@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.0

package/dist/project/routes/git.js

@@ -0,0 +1,30 @@
+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/dist/project/routes/task-defaults.js

@@ -0,0 +1,42 @@
+import { Hono } from "hono";
+import { describeRoute, resolver, validator } from "hono-openapi";
+import { ProjectTaskDefaults } from "../task-defaults.js";
+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/dist/project/session-health.js

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

package/dist/project/startup.js

@@ -0,0 +1,28 @@
+import { ScopeStartup } from "@ericsanchezok/synergy-harness/scope/startup";
+import { Vcs } from "./vcs.js";
+import { startWorktreeJanitor, stopWorktreeJanitor } from "./worktree-janitor.js";
+/**
+ * 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/dist/project/task-defaults.js

@@ -0,0 +1,68 @@
+import { ProjectDirectories } from "./directories.js";
+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 var ProjectTaskDefaults;
+(function (ProjectTaskDefaults) {
+    ProjectTaskDefaults.Defaults = z
+        .object({
+        defaultSessionWorkspace: z.enum(["main", "worktree"]).optional(),
+        defaultSessionEnvironmentProfile: z.string().min(1).nullable().optional(),
+    })
+        .meta({ ref: "ProjectTaskDefaults" });
+    ProjectTaskDefaults.Result = z
+        .object({ defaults: ProjectTaskDefaults.Defaults, effective: ProjectTaskDefaults.Defaults, editable: z.boolean() })
+        .meta({ ref: "ProjectTaskDefaultsResult" });
+    ProjectTaskDefaults.Input = z.object({ defaults: ProjectTaskDefaults.Defaults, expected: ProjectTaskDefaults.Defaults }).meta({ ref: "ProjectTaskDefaultsInput" });
+    ProjectTaskDefaults.Conflict = NamedError.create("ProjectTaskDefaultsConflict", z.object({ message: z.string() }));
+    ProjectTaskDefaults.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;
+    }
+    async function get() {
+        const directory = root();
+        return {
+            defaults: directory ? ProjectTaskDefaults.Defaults.parse(await Config.domainGet("general", directory)) : {},
+            effective: ProjectTaskDefaults.Defaults.parse(await Config.current()),
+            editable: !!directory,
+        };
+    }
+    ProjectTaskDefaults.get = get;
+    async function update(input) {
+        const parsed = ProjectTaskDefaults.Input.parse(input);
+        const directory = root();
+        if (!directory)
+            throw new ProjectTaskDefaults.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 ProjectTaskDefaults.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 ProjectTaskDefaults.Invalid({ message: "The selected execution profile is unavailable. Choose a configured location." });
+        const { change } = await Config.domainMutateWithChange("general", (current) => {
+            if (JSON.stringify(ProjectTaskDefaults.Defaults.parse(current)) !== JSON.stringify(parsed.expected))
+                throw new ProjectTaskDefaults.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();
+    }
+    ProjectTaskDefaults.update = update;
+})(ProjectTaskDefaults || (ProjectTaskDefaults = {}));