@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.0

package/src/project/routes/directories.ts

@@ -0,0 +1,124 @@
+import { Hono } from "hono"
+import { describeRoute, resolver, validator } from "hono-openapi"
+import { z } from "zod"
+import { Scope } from "@ericsanchezok/synergy-harness/scope"
+import { ScopeContext } from "@ericsanchezok/synergy-harness/scope/context"
+import { ProjectWorktrees } from "../worktrees"
+import { WorkspaceAccess } from "@ericsanchezok/synergy-harness/workspace/access"
+import { Worktree } from "@ericsanchezok/synergy-local-runtime/workspace/worktree"
+import { ProjectDirectories } from "../directories"
+
+const params = z.object({ scopeID: z.string().min(1) })
+const response = (schema: z.ZodType) => ({
+  description: "Project folders",
+  content: { "application/json": { schema: resolver(schema) } },
+})
+const failures = {
+  400: response(ProjectDirectories.Invalid.Schema),
+  409: response(ProjectDirectories.Conflict.Schema),
+}
+async function result(c: import("hono").Context, action: () => Promise<unknown>) {
+  try {
+    return c.json(await action())
+  } catch (error) {
+    if (error instanceof ProjectDirectories.Invalid) return c.json(error.toObject(), 400)
+    if (error instanceof ProjectDirectories.Conflict) return c.json(error.toObject(), 409)
+    if (error instanceof WorkspaceAccess.BusyError)
+      return c.json(
+        {
+          name: "ProjectDirectoriesConflict",
+          data: { message: "Project folders are in use. Keep your changes and retry when tasks are idle." },
+        },
+        409,
+      )
+    throw error
+  }
+}
+export function ProjectDirectoriesRoute() {
+  return new Hono()
+    .post(
+      "/",
+      describeRoute({
+        summary: "Create a project from folders",
+        operationId: "project.create",
+        responses: { 200: response(ProjectDirectories.Created), ...failures },
+      }),
+      validator("json", ProjectDirectories.CreateInput),
+      (c) => result(c, () => ProjectDirectories.create(c.req.valid("json"))),
+    )
+    .get(
+      "/:scopeID/directories",
+      describeRoute({
+        summary: "Get project folders",
+        operationId: "project.directories",
+        responses: { 200: response(ProjectDirectories.Result) },
+      }),
+      validator("param", params),
+      (c) => result(c, () => ProjectDirectories.get(c.req.valid("param").scopeID)),
+    )
+    .patch(
+      "/:scopeID/directories",
+      describeRoute({
+        summary: "Save main and additional project folders",
+        operationId: "project.updateDirectories",
+        responses: { 200: response(ProjectDirectories.Result), ...failures },
+      }),
+      validator("param", params),
+      validator("json", ProjectDirectories.UpdateInput),
+      (c) => result(c, () => ProjectDirectories.update(c.req.valid("param").scopeID, c.req.valid("json"))),
+    )
+    .get(
+      "/:scopeID/worktree-inventory",
+      describeRoute({
+        summary: "List Worktree identities without computing status or disk usage",
+        operationId: "project.worktreeInventory",
+        responses: { 200: response(ProjectWorktrees.Inventory) },
+      }),
+      validator("param", params),
+      async (c) => {
+        const scope = await Scope.resolve(c.req.valid("param"))
+        const inventory = await ScopeContext.provide({
+          scope,
+          workspace: null,
+          fn: () => ProjectWorktrees.inventory(scope.id),
+        })
+        c.header("x-synergy-epoch", inventory.sync.epoch)
+        c.header("x-synergy-seq", String(inventory.sync.seq))
+        return c.json(inventory)
+      },
+    )
+    .get(
+      "/:scopeID/worktree-details",
+      describeRoute({
+        summary: "Compute status, disk usage and cleanup protection for one Worktree",
+        operationId: "project.worktreeDetails",
+        responses: { 200: response(Worktree.Details), ...failures },
+      }),
+      validator("param", params),
+      validator("query", z.object({ target: z.string().min(1), sourceWorkspaceID: z.string().optional() })),
+      async (c) => {
+        const scope = await Scope.resolve(c.req.valid("param"))
+        const input = c.req.valid("query")
+        return c.json(
+          await ScopeContext.provide({
+            scope,
+            workspace: null,
+            fn: () => Worktree.withSource(input.sourceWorkspaceID, () => Worktree.details(input)),
+          }),
+        )
+      },
+    )
+    .get(
+      "/:scopeID/worktrees",
+      describeRoute({
+        summary: "List project Worktrees with their original repositories",
+        operationId: "project.worktrees",
+        responses: { 200: response(Worktree.Info.array()) },
+      }),
+      validator("param", params),
+      async (c) => {
+        const scope = await Scope.resolve(c.req.valid("param"))
+        return c.json(await ScopeContext.provide({ scope, workspace: null, fn: () => ProjectWorktrees.list(scope.id) }))
+      },
+    )
+}

package/src/project/routes/git.ts

@@ -0,0 +1,42 @@
+import { Hono } from "hono"
+import { describeRoute, validator } from "hono-openapi"
+import { resolver } from "hono-openapi"
+import z from "zod"
+import { Vcs } from "@ericsanchezok/synergy-workbench/project/vcs"
+import { errors } from "@ericsanchezok/synergy-server/server/error"
+
+export const GitRoute = () =>
+  new Hono().post(
+    "/init",
+    describeRoute({
+      summary: "Initialize git repository",
+      description: "Initialize a git repository in the specified directory if one does not already exist.",
+      operationId: "global.git.init",
+      responses: {
+        200: {
+          description: "Git initialization result",
+          content: {
+            "application/json": {
+              schema: resolver(
+                z.object({
+                  initialized: z.boolean().meta({ description: "Whether a new git repository was initialized" }),
+                }),
+              ),
+            },
+          },
+        },
+        ...errors(400),
+      },
+    }),
+    validator(
+      "json",
+      z.object({
+        directory: z.string().meta({ description: "Directory path to initialize git in" }),
+      }),
+    ),
+    async (c) => {
+      const { directory } = c.req.valid("json")
+      const initialized = await Vcs.initIfNeeded(directory)
+      return c.json({ initialized })
+    },
+  )

package/src/project/routes/task-defaults.ts

@@ -0,0 +1,50 @@
+import { Hono } from "hono"
+import { describeRoute, resolver, validator } from "hono-openapi"
+import { ProjectTaskDefaults } from "../task-defaults"
+
+export function ProjectTaskDefaultsRoute() {
+  const success = {
+    description: "Project task defaults",
+    content: { "application/json": { schema: resolver(ProjectTaskDefaults.Result) } },
+  }
+  return new Hono()
+    .get(
+      "/",
+      describeRoute({
+        summary: "Get project new-task defaults",
+        operationId: "project.taskDefaults.get",
+        responses: { 200: success },
+      }),
+      async (c) => c.json(await ProjectTaskDefaults.get()),
+    )
+    .patch(
+      "/",
+      describeRoute({
+        summary: "Save project new-task defaults",
+        description:
+          "Updates only Web and Desktop new-task defaults. Existing sessions and runtime creation rules are unchanged.",
+        operationId: "project.taskDefaults.update",
+        responses: {
+          200: success,
+          400: {
+            description: "Invalid defaults",
+            content: { "application/json": { schema: resolver(ProjectTaskDefaults.Invalid.Schema) } },
+          },
+          409: {
+            description: "Concurrent project edit",
+            content: { "application/json": { schema: resolver(ProjectTaskDefaults.Conflict.Schema) } },
+          },
+        },
+      }),
+      validator("json", ProjectTaskDefaults.Input),
+      async (c) => {
+        try {
+          return c.json(await ProjectTaskDefaults.update(c.req.valid("json")))
+        } catch (error) {
+          if (error instanceof ProjectTaskDefaults.Conflict) return c.json(error.toObject(), 409)
+          if (error instanceof ProjectTaskDefaults.Invalid) return c.json(error.toObject(), 400)
+          throw error
+        }
+      },
+    )
+}

package/src/project/session-health.ts

@@ -0,0 +1,10 @@
+import { SessionProjectHealth } from "@ericsanchezok/synergy-harness/session/project-health"
+import { GitHealth } from "./git-health"
+
+export function registerProjectSessionHealth() {
+  SessionProjectHealth.register({
+    isGitRepo: (cwd) => GitHealth.isGitRepo(cwd),
+    observeGitHealth: (cwd) => GitHealth.observeCached(cwd),
+    invalidateGitHealth: (cwd) => GitHealth.invalidate(cwd),
+  })
+}

package/src/project/startup.ts

@@ -0,0 +1,28 @@
+import { ScopeStartup } from "@ericsanchezok/synergy-harness/scope/startup"
+import { Vcs } from "./vcs"
+import { startWorktreeJanitor, stopWorktreeJanitor } from "./worktree-janitor"
+
+/**
+ * H5 project startup contribution: Vcs.init moves out of scope/runtime.ts.
+ * It runs after the file watcher, matching the historical startup sequence.
+ */
+export function registerProjectStartup() {
+  ScopeStartup.register({
+    name: "vcs-init",
+    owner: "workspace",
+    phase: "surface",
+    after: ["file-watcher"],
+    init: () => Vcs.init().then(() => {}),
+  })
+  // The janitor only schedules itself here; its first scan is deferred with an
+  // unref'd timer so neither startup latency nor process lifetime depends on it.
+  ScopeStartup.register({
+    name: "worktree-janitor",
+    phase: "surface",
+    after: ["command-watcher"],
+    init: (scope) => {
+      if (scope.type === "project") startWorktreeJanitor(scope)
+    },
+    dispose: (scopeID) => stopWorktreeJanitor(scopeID),
+  })
+}

package/src/project/task-defaults.ts

@@ -0,0 +1,70 @@
+import { ProjectDirectories } from "./directories"
+import path from "node:path"
+import { z } from "zod"
+import { NamedError } from "@ericsanchezok/synergy-util/error"
+import { Config } from "@ericsanchezok/synergy-harness/config/config"
+import { GlobalBus } from "@ericsanchezok/synergy-harness/bus/global"
+import { ScopeContext } from "@ericsanchezok/synergy-harness/scope/context"
+import { ResourceProfiles } from "@ericsanchezok/synergy-local-runtime/environment/profiles"
+
+export namespace ProjectTaskDefaults {
+  export const Defaults = z
+    .object({
+      defaultSessionWorkspace: z.enum(["main", "worktree"]).optional(),
+      defaultSessionEnvironmentProfile: z.string().min(1).nullable().optional(),
+    })
+    .meta({ ref: "ProjectTaskDefaults" })
+  export const Result = z
+    .object({ defaults: Defaults, effective: Defaults, editable: z.boolean() })
+    .meta({ ref: "ProjectTaskDefaultsResult" })
+  export const Input = z.object({ defaults: Defaults, expected: Defaults }).meta({ ref: "ProjectTaskDefaultsInput" })
+  export const Conflict = NamedError.create("ProjectTaskDefaultsConflict", z.object({ message: z.string() }))
+  export const Invalid = NamedError.create("ProjectTaskDefaultsInvalid", z.object({ message: z.string() }))
+  function root() {
+    const scope = ScopeContext.current.scope
+    return scope.type === "project" && scope.local ? path.join(scope.local.directory, ".synergy") : undefined
+  }
+  export async function get(): Promise<z.infer<typeof Result>> {
+    const directory = root()
+    return {
+      defaults: directory ? Defaults.parse(await Config.domainGet("general", directory)) : {},
+      effective: Defaults.parse(await Config.current()),
+      editable: !!directory,
+    }
+  }
+  export async function update(input: z.infer<typeof Input>) {
+    const parsed = Input.parse(input)
+    const directory = root()
+    if (!directory)
+      throw new Invalid({
+        message: "This project inherits global settings because it has no project configuration directory.",
+      })
+    if (parsed.defaults.defaultSessionWorkspace === "worktree") {
+      const folders = await ProjectDirectories.get(ScopeContext.current.scope.id)
+      if (!folders.folders.some((folder) => folder.workspaceID === folders.mainWorkspaceID && folder.git))
+        throw new Invalid({ message: "Worktree requires a Git main folder." })
+    }
+    const profile = parsed.defaults.defaultSessionEnvironmentProfile
+    if (profile && !(await ResourceProfiles.list()).environments.some((item) => item.name === profile))
+      throw new Invalid({ message: "The selected execution profile is unavailable. Choose a configured location." })
+    const { change } = await Config.domainMutateWithChange(
+      "general",
+      (current) => {
+        if (JSON.stringify(Defaults.parse(current)) !== JSON.stringify(parsed.expected))
+          throw new Conflict({ message: "Project defaults changed. Reload them before saving again." })
+        delete current.defaultSessionWorkspace
+        delete current.defaultSessionEnvironmentProfile
+        return { ...current, ...parsed.defaults }
+      },
+      { root: directory, mode: "replace-domain" },
+    )
+    GlobalBus().emit("event", {
+      scopeID: ScopeContext.current.scope.id,
+      payload: {
+        type: Config.Event.Updated.type,
+        properties: { scope: "project", changedFields: change.changedFields },
+      },
+    })
+    return get()
+  }
+}