feat(api): implement project routes with mock manager/store

[Vaibhaav-Tiwari]

Summary

Implements the Phase 3 /api/v1/projects API surface
on top of PR #24 route shell by replacing 501 Not Implemented stubs with working handlers backed by a
mock in-memory project manager/store.

What Changed

• Implemented project route handlers in backend/ internal/httpd/controllers/projects.go:
  • GET /api/v1/projects
  • POST /api/v1/projects
  • GET /api/v1/projects/{id}
  • PATCH /api/v1/projects/{id}
  • DELETE /api/v1/projects/{id}
  • POST /api/v1/projects/{id}/repair
  • POST /api/v1/projects/reload
• Added mock project service layer:
  • backend/internal/project/manager.go
  • backend/internal/project/memory_store.go
  • backend/internal/project/errors.go
• Wired default mock manager in backend/internal/ httpd/api.go when project deps are not provided.
• Replaced route-shell 501 tests with behavior tests
  in backend/internal/httpd/controllers/ projects_test.go.
• Fixed Windows compile issue in backend/internal/ runfile/rename_windows.go (MoveFileExW via
  kernel32.dll) so backend tests run on Windows.

Behavior / Validation

• Returns structured API errors (INVALID_JSON,
  PATH_REQUIRED, NOT_A_GIT_REPO,
  INVALID_PROJECT_ID, PROJECT_NOT_FOUND,
  IDENTITY_FROZEN, PATH_ALREADY_REGISTERED,
  ID_ALREADY_REGISTERED, REPAIR_NOT_AVAILABLE).
• Enforces identity freeze for PATCH on: projectId,
  path, repo, defaultBranch.
• Mock DB is in-memory only (no durable persistence
  yet).

Testing

Ran locally:

cd backend
go test ./...
go vet ./...

All passing.

## Scope Notes

- This PR intentionally uses mocked project storage
  as assigned for Phase 3.

- Follow-up work will wire real persistence (SQLite
  store) and implement real repair/reload/delete side
  effects (session/workspace cleanup).

[Vaibhaav-Tiwari]

@copilot resolve the merge conflicts in this pull request

[Copilot]

Pull request overview

Implements the /api/v1/projects REST surface in the Go daemon by replacing route-shell stubs with working handlers backed by an in-memory (mock) project manager/store, and rounds out the backend daemon skeleton (config, server lifecycle, run-file handshake, OpenAPI serving) with tests.

Changes:

• Implemented full projects API handlers (list/add/get/update/delete/repair/reload) backed by a mock project.Manager + MemoryStore.
• Added daemon lifecycle infrastructure: loopback bind config, graceful Server.Run, and atomic running.json run-file handshake (incl. Windows support).
• Embedded/served OpenAPI YAML and updated/added unit tests for API behavior, server lifecycle, and spec helpers.

Reviewed changes

Copilot reviewed 29 out of 30 changed files in this pull request and generated 10 comments.

Show a summary per file

File	Description
README.md	Documents how to run/test the backend daemon and its env configuration.
backend/main.go	Turns main into a real daemon entrypoint (config, logger, run-file check, server run).
backend/internal/runfile/runfile.go	Implements atomic run-file write/read/remove + stale PID detection.
backend/internal/runfile/runfile_test.go	Adds run-file unit tests (round trip, overwrite, stale/live PID behavior).
backend/internal/runfile/rename_windows.go	Implements atomic replace on Windows via MoveFileExW.
backend/internal/runfile/rename_unix.go	Implements atomic replace on Unix via os.Rename.
backend/internal/runfile/process_windows.go	Windows PID liveness check via OpenProcess.
backend/internal/runfile/process_unix.go	Unix PID liveness check via kill(pid, 0) semantics.
backend/internal/project/types.go	Defines project entities and behavior-config DTO shapes exposed via API.
backend/internal/project/project.go	Introduces the project.Manager interface (service contract).
backend/internal/project/memory_store.go	Adds concurrency-safe in-memory project store implementing Store.
backend/internal/project/manager.go	Implements mock Manager behavior over the store (validation/conflicts/reload).
backend/internal/project/errors.go	Adds typed manager errors for controller translation to API envelopes.
backend/internal/project/dto.go	Adds manager request/response DTOs used by controllers.
backend/internal/httpd/server.go	Implements daemon HTTP server lifecycle (bind, serve, graceful shutdown, run-file).
backend/internal/httpd/server_test.go	Tests health probes, server lifecycle + run-file behavior, and port conflict.
backend/internal/httpd/router.go	Builds router + middleware stack, mounts health, mounts API surface.
backend/internal/httpd/log.go	Adds slog-based structured access logging middleware.
backend/internal/httpd/json.go	Adds shared JSON response writer helper for the httpd package.
backend/internal/httpd/errors.go	Defines the locked APIError envelope and writer for router-level errors.
backend/internal/httpd/controllers/projects.go	Implements /api/v1/projects handlers and error translation for projects routes.
backend/internal/httpd/controllers/projects_test.go	Replaces route-shell 501 tests with behavior tests for the projects API + OpenAPI serving.
backend/internal/httpd/apispec/openapi.yaml	Adds embedded OpenAPI 3.1 spec describing the /api/v1/projects surface.
backend/internal/httpd/apispec/apispec.go	Embeds/parses OpenAPI YAML and serves operation slices in 501 stubs + YAML serving.
backend/internal/httpd/apispec/apispec_test.go	Tests embedded spec loading, operation lookup behavior, and YAML serving.
backend/internal/httpd/api.go	Wires API surface and defaults missing deps to a memory project.Manager; mounts OpenAPI route.
backend/internal/config/config.go	Adds env-based daemon config with loopback-only binding and default timeouts/run-file path.
backend/internal/config/config_test.go	Adds config unit tests for defaults, overrides, and invalid env values.
backend/go.mod	Adds module requirements for chi and yaml.
backend/go.sum	Adds sums for new Go module dependencies.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

@copilot resolve the merge conflicts in this pull request

Resolved and pushed. I merged origin/main into this PR branch, fixed all merge conflicts, and validated backend tests. Addressed in commit b438925.

[greptile-apps]

Greptile Summary

This PR implements the Phase 3 /api/v1/projects REST surface, replacing 501 stubs with working handlers backed by a mock in-memory manager and store. The HTTP wiring, error mapping, OpenAPI spec embedding, and identity-freeze guard are all well-structured; the Windows MoveFileExW fix is correct.

• Mock store bugs (already flagged): Archive never removes entries from the paths index, so deleted projects permanently poison their path and ID slots; double-DELETE succeeds instead of 404; Get returns archived rows, creating a list/get inconsistency.
• Silent PATCH drop (already flagged): UpdateConfig discards all fields in patch (the parameter is _) and immediately returns 501, giving callers no indication their supplied values were ignored.
• New P2 findings: isGitRepo contains dead code (return top == path is always false after the strings.EqualFold guard); projectFromRow hardcodes DefaultBranch: "main" with no corresponding ProjectRow field, leaving no column for the real default branch when persistence lands.

Confidence Score: 3/5

Not safe to merge without addressing the store mutation bugs: deleted projects permanently block re-registration at both the same path and the same ID, double-deletes silently succeed, and every PATCH request discards all supplied config fields.

The HTTP wiring, routing, and error envelope layers are solid, but the in-memory store and manager that back every write operation carry four confirmed defects on the mutation paths: the paths index is never cleaned on archive (making path slots unrecoverable), archived entries still pass the id-conflict check (making id slots unrecoverable), Archive is idempotent (second delete returns 200 instead of 404), and UpdateConfig silently discards all patch fields. These are all exercised by the handlers added in this PR and will persist into the SQLite implementation if not corrected in the Store/Manager contract now.

backend/internal/project/memory_store.go and backend/internal/project/manager.go — the archive/re-registration and silent-patch bugs live here and affect every project mutation route.

Important Files Changed

Filename	Overview
backend/internal/project/manager.go	New mock manager implementing the project.Manager interface; contains previously flagged P1 bugs (UpdateConfig silently drops patch, archived IDs block re-registration) plus a dead-code branch in isGitRepo.
backend/internal/project/memory_store.go	New in-memory Store implementation; previously flagged P1 bugs: Archive never clears paths index (path poisoned forever) and double-DELETE succeeds instead of 404.
backend/internal/httpd/controllers/projects.go	Implements all 7 project route handlers; correctly reads body twice for frozen-field guard with proper reset, maps project.Error kinds to HTTP status codes, and falls back to 501 stubs when Mgr is nil.
backend/internal/httpd/controllers/projects_test.go	Good behavioural test coverage for list/add/get/reload, validation errors, conflicts, delete and repair; explicitly validates the archived-project visibility asymmetry between GET list and GET by-id.
backend/internal/httpd/apispec/apispec.go	Parses embedded OpenAPI YAML once via sync.Once, serves per-operation slices in 501 responses; previously flagged P2: YAML() ignores the receiver and always returns the global embedded bytes.
backend/internal/runfile/rename_windows.go	Replaces syscall.MoveFileEx with a lazy-loaded kernel32.dll call to fix a Windows build issue; unsafe.Pointer/uintptr usage follows the standard Windows syscall pattern and is safe within a single Call invocation.

Sequence Diagram

sequenceDiagram
    participant C as HTTP Client
    participant R as chi Router
    participant PC as ProjectsController
    participant M as manager (Manager)
    participant S as MemoryStore (Store)

    C->>R: POST /api/v1/projects
    R->>PC: add()
    PC->>M: Add(ctx, AddInput)
    M->>S: FindByPath(ctx, path)
    S-->>M: (row, ok, err)
    M->>S: Get(ctx, id)
    S-->>M: (row, ok, err)
    M->>S: Upsert(ctx, ProjectRow)
    S-->>M: nil
    M-->>PC: "Project{}"
    PC-->>C: "201 {project}"

    C->>R: "GET /api/v1/projects/{id}"
    R->>PC: get()
    PC->>M: Get(ctx, id)
    M->>S: Get(ctx, id)
    Note over S: Returns archived rows too
    S-->>M: (row, true, nil)
    M-->>PC: "GetResult{Status:ok}"
    PC-->>C: "200 {status, project}"

    C->>R: "DELETE /api/v1/projects/{id}"
    R->>PC: remove()
    PC->>M: Remove(ctx, id)
    M->>S: Archive(ctx, id, now)
    Note over S: paths index not cleared
    Note over S: re-archive succeeds
    S-->>M: (true, nil)
    M-->>PC: "RemoveResult{}"
    PC-->>C: "200 {projectId, removedStorageDir}"

    C->>R: "PATCH /api/v1/projects/{id}"
    R->>PC: updateConfig()
    PC->>PC: containsFrozenIdentityField()
    PC->>M: UpdateConfig(ctx, id, patch)
    Note over M: patch arg ignored
    M-->>PC: notImplemented error
    PC-->>C: 501 PROJECT_CONFIG_NOT_IMPLEMENTED

Loading

_{Reviews (4): Last reviewed commit: "style(project): gofmt git repo validatio..." | Re-trigger Greptile}

[illegalcall]

We have 2 PRs that recommend the backend architecture and library choices:

• Architecture / code structure: #41
• Technical stack / libraries: #25

Let’s try to follow those.

If you disagree with any part of those recommendations, let’s comment/contribute there and keep those PRs as the source of truth.

Based on that, I recommend these changes here:

• Keep the internal/project feature-package direction, but make sure the mock store does not become the production source of truth by accident.
• Keep HTTP as the protocol adapter: controllers should call project.Manager, and storage/config/runtime side effects should stay behind the project feature layer.
• If project registration validates a real git repo, use the recommended Git CLI path instead of filesystem-only .git checks.
• Make PATCH/DELETE semantics honest: either persist the requested mock state consistently, or return a clear not-implemented/unsupported response until the real project store lands.
• Align the OpenAPI spec with actual behavior, especially around config passthrough and archived/deleted project visibility.

[illegalcall]

Defaulting nil deps to project.NewMemoryManager() makes the production router expose a successful but process-local project API whenever callers forget to wire a real manager. That makes POST /projects look durable even though the data disappears on restart. I think the mock manager should be injected explicitly by tests/dev wiring, or nil should keep the 501 behavior until a real project manager is available.

[illegalcall]

This returns 200 for PATCH while deliberately dropping every requested config field. That is worse than a stub because clients will believe agent, runtime, tracker, etc. were accepted. For the mock phase, can we either persist these fields in the in-memory row/read-model, or return a clear unsupported/not-implemented error until a config store exists?

[illegalcall]

Because Remove archives the row and Get does not check ArchivedAt, a project remains readable as status: ok after DELETE. That conflicts with the route contract’s “remove/unregister” semantics. Please either treat archived rows as not found/degraded at the API layer, or update the architecture/spec discussion to say deleted projects remain fetchable.

[illegalcall]

The stack PR recommends using the real git CLI for Git behavior. A filesystem .git check accepts fake repos and misses some edge cases that git -C <path> rev-parse --is-inside-work-tree would handle. If this endpoint is doing real validation, it should go through the Git CLI path; otherwise keep this explicitly mock-only.

[illegalcall]

This spec says extra config keys are preserved and re-emitted, but the Go DTOs do not carry an Extra/raw field and UpdateConfig currently drops the whole patch. Please align the spec with the implementation, or implement passthrough preservation before advertising it as part of the contract.

[illegalcall]

Rechecked latest head d46bf77. The earlier API semantics comments are partly addressed, but go test ./... now fails in backend/internal/httpd/controllers because valid git init fixtures are rejected as NOT_A_GIT_REPO on macOS.

Checked:

• gofmt -l . passes
• go vet ./... passes
• go test ./... fails in controllers

[illegalcall]

This equality check rejects valid repos on macOS when the input path is under /var/...: git rev-parse --show-toplevel returns the canonical /private/var/... path, while normalizePath keeps /var/..., so the same repo fails this comparison. That is why the latest git init fixtures fail with NOT_A_GIT_REPO. Please canonicalize both paths with filepath.EvalSymlinks before comparing, or treat a successful git -C path rev-parse --show-toplevel as sufficient for repo validation if nested worktrees are acceptable.

[Vaibhaav-Tiwari]

i'll canonicalize both paths with filepath.EvalSymlinks before comparing.

[Vaibhaav-Tiwari]

@copilot resolve the merge conflicts in this pull request

[illegalcall]

Rechecked latest head 0b0b136. The /var vs /private/var git repo fixture issue is fixed now: go test ./... and go vet ./... pass locally.

Still not ready to merge:

• GitHub currently marks this PR as CONFLICTING / DIRTY against latest main after PR #37 merged. Please rebase/merge latest main and resolve the backend/go.mod / backend/go.sum conflict.
• gofmt -l . returns backend/internal/project/manager.go.

After that, rerun the backend checks on the rebased branch.

[illegalcall]

This new block needs gofmt; gofmt -l . currently reports backend/internal/project/manager.go.

[Vaibhaav-Tiwari]

yep working on that only

[illegalcall]

Rechecked latest head 5046ea8. The previous merge conflict and gofmt issues are resolved.

Checked locally:

• gofmt -l . passes
• go vet ./... passes
• go test ./... passes
• go test -race ./... passes

GitHub now reports the PR as MERGEABLE / CLEAN.