@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.1

package/dist/project/git-health.js

@@ -0,0 +1,498 @@
+import { RuntimeContext } from "@ericsanchezok/synergy-harness/lifecycle/context";
+import path from "path";
+import fs from "fs";
+export var GitHealth;
+(function (GitHealth) {
+    // ---------------------------------------------------------------------------
+    // Cache — per-directory with 5-minute TTL
+    // ---------------------------------------------------------------------------
+    const runtimeState = RuntimeContext.state(() => ({
+        _cache: new Map(),
+        _refreshing: new Map(),
+        _aliases: new Map(),
+        _lastDir: undefined,
+        _generation: 0,
+        _revisions: new Map(),
+        _dirty: new Set(),
+        _failed: new Set(),
+    }));
+    const CACHE_TTL_MS = 5 * 60 * 1000;
+    const GIT_COMMAND_TIMEOUT_MS = 2_000;
+    const SCAN_TIMEOUT_MS = 3_000;
+    const LARGE_FILE_STAT_BATCH_SIZE = 64;
+    const DEFAULT_GC_AUTO = 6700;
+    // ---------------------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------------------
+    function normalizeDir(cwd) {
+        return path.resolve(cwd);
+    }
+    function cacheKey(cwd) {
+        const instanceState = runtimeState();
+        const dir = normalizeDir(cwd);
+        return instanceState._aliases.get(dir) ?? dir;
+    }
+    function remainingMs(deadline) {
+        return Math.max(0, deadline - Date.now());
+    }
+    async function withDeadline(promise, ms) {
+        let timer;
+        const fallback = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => reject(new Error("Git health scan timed out")), ms);
+        });
+        return Promise.race([promise, fallback]).finally(() => {
+            if (timer)
+                clearTimeout(timer);
+        });
+    }
+    async function gitText(cwd, args, options) {
+        const proc = Bun.spawn(["git", ...args], {
+            cwd,
+            stdout: "pipe",
+            stderr: "pipe",
+            signal: AbortSignal.timeout(GIT_COMMAND_TIMEOUT_MS),
+        });
+        const stdout = new Response(proc.stdout).text();
+        const stderr = new Response(proc.stderr).text().catch(() => "");
+        const [output, exitCode] = await Promise.all([stdout, proc.exited]);
+        const errorText = await stderr;
+        if (exitCode !== 0) {
+            if (options?.allowedExit?.includes(exitCode) || (options?.notRepo && /not a git repository/i.test(errorText)))
+                return undefined;
+            throw new Error(`Git health probe failed (${args[0]}, exit ${exitCode})`);
+        }
+        return output;
+    }
+    async function resolveRepo(cwd) {
+        const dir = normalizeDir(cwd);
+        const inside = await gitText(dir, ["rev-parse", "--is-inside-work-tree"], { notRepo: true });
+        if (inside?.trim() !== "true")
+            return undefined;
+        const [rootText, gitDirText] = await Promise.all([
+            gitText(dir, ["rev-parse", "--show-toplevel"]),
+            gitText(dir, ["rev-parse", "--git-dir"]),
+        ]);
+        const root = rootText?.trim();
+        const gitDir = gitDirText?.trim();
+        if (!root || !gitDir)
+            return undefined;
+        const resolvedRoot = normalizeDir(root);
+        return {
+            root: resolvedRoot,
+            gitDir: path.isAbsolute(gitDir) ? gitDir : path.resolve(dir, gitDir),
+        };
+    }
+    function render(issues) {
+        const active = issues.filter((i) => i.level === "warn" || i.level === "critical");
+        if (active.length === 0)
+            return undefined;
+        const lines = [
+            "<git-health>",
+            "Latest completed diagnostic check; this is a bounded historical observation, not a live guarantee of repository state.",
+        ];
+        for (const issue of active) {
+            const label = issue.level === "critical" ? "Critical" : "Warning";
+            lines.push(`${label}: ${issue.message}`);
+        }
+        lines.push("</git-health>");
+        return lines.join("\n");
+    }
+    function parseNumstat(text) {
+        let additions = 0;
+        let deletions = 0;
+        const files = new Set();
+        for (const line of text.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const parts = trimmed.split("\t");
+            const add = parseInt(parts[0]);
+            const del = parseInt(parts[1]);
+            if (!isNaN(add))
+                additions += add;
+            if (!isNaN(del))
+                deletions += del;
+            if (parts.length >= 3 && parts[2])
+                files.add(parts[2]);
+        }
+        return { additions, deletions, files };
+    }
+    function countLooseObjectsOnDisk(gitDir) {
+        const objectsDir = path.join(gitDir, "objects");
+        let count = 0;
+        try {
+            for (const entry of fs.readdirSync(objectsDir)) {
+                if (entry === "pack" || entry === "info")
+                    continue;
+                const subDir = path.join(objectsDir, entry);
+                const subStat = fs.statSync(subDir, { throwIfNoEntry: false });
+                if (subStat?.isDirectory()) {
+                    count += fs.readdirSync(subDir).length;
+                }
+            }
+        }
+        catch { }
+        return count;
+    }
+    // ---------------------------------------------------------------------------
+    // Dimensions 1+2: diff_lines and diff_files (single pass)
+    // diff_lines thresholds: 200→warn, 800→critical
+    // diff_files thresholds: 10→warn, 25→critical
+    // ---------------------------------------------------------------------------
+    async function checkDiff(cwd) {
+        const head = await gitText(cwd, ["rev-parse", "--verify", "--quiet", "HEAD"], { allowedExit: [1] });
+        const reference = head ? ["HEAD"] : [];
+        const [unstaged, staged] = await Promise.all([
+            gitText(cwd, ["diff", "--numstat", ...reference]).then((x) => x ?? ""),
+            gitText(cwd, ["diff", "--cached", "--numstat", ...reference]).then((x) => x ?? ""),
+        ]);
+        const unstagedParsed = parseNumstat(unstaged);
+        const stagedParsed = parseNumstat(staged);
+        const issues = [];
+        // diff_lines
+        const unstagedLines = unstagedParsed.additions + unstagedParsed.deletions;
+        const stagedLines = stagedParsed.additions + stagedParsed.deletions;
+        const total = unstagedLines + stagedLines;
+        if (total >= 200) {
+            issues.push({
+                dimension: "diff_lines",
+                level: total >= 800 ? "critical" : "warn",
+                message: `${total} lines of uncommitted changes — commit now to avoid losing work`,
+                detail: { lines: total, staged: stagedLines, unstaged: unstagedLines },
+            });
+        }
+        // diff_files
+        const allFiles = new Set([...unstagedParsed.files, ...stagedParsed.files]);
+        const count = allFiles.size;
+        if (count >= 10) {
+            issues.push({
+                dimension: "diff_files",
+                level: count >= 25 ? "critical" : "warn",
+                message: `${count} files modified but not committed — split into focused commits while intent is fresh`,
+                detail: { files: count },
+            });
+        }
+        return issues;
+    }
+    // ---------------------------------------------------------------------------
+    // Dimension 3: untracked
+    // Thresholds: 15→warn, 80→critical
+    // ---------------------------------------------------------------------------
+    async function checkUntracked(cwd) {
+        const result = (await gitText(cwd, ["ls-files", "--others", "--exclude-standard"])) ?? "";
+        const trimmed = result.trim();
+        const count = trimmed ? trimmed.split("\n").length : 0;
+        if (count < 15)
+            return undefined;
+        const level = count >= 80 ? "critical" : "warn";
+        return {
+            dimension: "untracked",
+            level,
+            message: `${count} untracked files — review with git status: add, ignore, or clean up`,
+            detail: { count },
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Dimension 4: large_files
+    // Thresholds: >10MB→warn, >50MB→critical
+    // ---------------------------------------------------------------------------
+    async function checkLargeFiles(cwd, deadline) {
+        const result = (await gitText(cwd, ["ls-files", "-z"])) ?? "";
+        const fileNames = result.split("\0").filter(Boolean);
+        if (fileNames.length === 0)
+            return undefined;
+        // Cap to avoid dominating check time on repos with hundreds of thousands of files.
+        const cappedNames = fileNames.length > 10000 ? fileNames.slice(0, 10000) : fileNames;
+        if (cappedNames.length === 0)
+            return undefined;
+        const large = [];
+        for (let i = 0; i < cappedNames.length; i += LARGE_FILE_STAT_BATCH_SIZE) {
+            if (Date.now() >= deadline)
+                throw new Error("Git health file scan timed out");
+            const batch = cappedNames.slice(i, i + LARGE_FILE_STAT_BATCH_SIZE);
+            const stats = await withDeadline(Promise.all(batch.map(async (fileName) => {
+                const filePath = path.join(cwd, fileName);
+                const stat = await fs.promises.lstat(filePath).catch((error) => {
+                    if (error.code === "ENOENT")
+                        return undefined;
+                    throw error;
+                });
+                if (!stat || stat.isSymbolicLink())
+                    return undefined;
+                return { fileName, stat };
+            })), remainingMs(deadline));
+            for (const result of stats) {
+                if (result && result.stat.size > 10 * 1024 * 1024) {
+                    large.push({ path: result.fileName, size: result.stat.size });
+                }
+            }
+        }
+        if (large.length === 0)
+            return undefined;
+        large.sort((a, b) => b.size - a.size);
+        const largest = large[0];
+        const level = largest.size >= 50 * 1024 * 1024 ? "critical" : "warn";
+        return {
+            dimension: "large_files",
+            level,
+            message: `${large.length} large file(s) tracked — largest is ${largest.path} (${Math.round(largest.size / (1024 * 1024))}MB). If committed by accident, add to .gitignore and remove from tracking`,
+            detail: {
+                count: large.length,
+                largest: largest.path,
+                largestSize: largest.size,
+                files: large.slice(0, 5).map((f) => f.path),
+            },
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Dimension 5: extra_branches
+    // Thresholds: 10→warn, 40→critical
+    // ---------------------------------------------------------------------------
+    async function checkExtraBranches(cwd) {
+        const [headBranch, branchesText] = await Promise.all([
+            gitText(cwd, ["symbolic-ref", "--quiet", "--short", "HEAD"], { allowedExit: [1] }).then((x) => x?.trim() ?? ""),
+            gitText(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/heads/"]).then((x) => x ?? ""),
+        ]);
+        const branches = branchesText.trim().split("\n").filter(Boolean);
+        if (branches.length === 0)
+            return undefined;
+        const count = branches.filter((b) => b !== headBranch).length;
+        if (count < 10)
+            return undefined;
+        const level = count >= 40 ? "critical" : "warn";
+        return {
+            dimension: "extra_branches",
+            level,
+            message: `${count} non-current branches — archive or remove them via the worktree cleanup path; deleting is deferred there because squash- or rebase-merged branches are not detected as merged by ancestry alone, which needs content comparison`,
+            detail: { count },
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Dimension 6: detached_head
+    // ---------------------------------------------------------------------------
+    async function checkDetachedHead(cwd) {
+        const symRef = await gitText(cwd, ["symbolic-ref", "--quiet", "HEAD"], { allowedExit: [1] });
+        if (symRef !== undefined)
+            return undefined;
+        const headCommit = (await gitText(cwd, ["rev-parse", "HEAD"]))?.trim() ?? "";
+        if (!headCommit)
+            return undefined;
+        return {
+            dimension: "detached_head",
+            level: "critical",
+            message: "Detached HEAD — commits will be lost unless you create a branch",
+            detail: { headCommit },
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Dimension 7: gc_needed
+    // Thresholds derive from the repo's effective gc.auto (git's documented
+    // default is 6700): git auto-gcs once loose objects exceed gc.auto, so warn at
+    // a quarter of that. Uses both git count-objects and filesystem count (max of
+    // the two); git count-objects only counts valid objects, while the filesystem
+    // fallback catches hand-crafted test fixture objects.
+    // ---------------------------------------------------------------------------
+    async function checkGcNeeded(cwd, gitDir, deadline) {
+        const [output, gcAutoText] = await Promise.all([
+            gitText(cwd, ["count-objects", "-v"]).then((x) => x ?? ""),
+            gitText(cwd, ["config", "--get", "gc.auto"], { allowedExit: [1] }),
+        ]);
+        const countMatch = output.match(/count:\s*(\d+)/);
+        const sizeMatch = output.match(/size:\s*(\d+)/);
+        const gitCount = countMatch ? parseInt(countMatch[1]) : 0;
+        const diskCount = Date.now() >= deadline ? 0 : countLooseObjectsOnDisk(gitDir);
+        const looseObjects = Math.max(gitCount, diskCount);
+        const size = sizeMatch ? parseInt(sizeMatch[1]) : 0;
+        // gc.auto <= 0 disables auto-gc, so treat it as absent rather than as a threshold.
+        const configuredGcAuto = parseInt(gcAutoText?.trim() ?? "");
+        const gcAuto = Number.isFinite(configuredGcAuto) && configuredGcAuto > 0 ? configuredGcAuto : DEFAULT_GC_AUTO;
+        if (looseObjects < Math.floor(gcAuto / 4))
+            return undefined;
+        const level = looseObjects >= gcAuto ? "critical" : "warn";
+        return {
+            dimension: "gc_needed",
+            level,
+            message: `Git gc recommended — ${looseObjects} loose objects (gc.auto ${gcAuto}). Run git gc to reclaim space`,
+            detail: { looseObjects, size },
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Dimension 8: unpushed
+    // ---------------------------------------------------------------------------
+    async function checkUnpushed(cwd) {
+        // With no remote-tracking refs `--not --remotes` subtracts nothing and the
+        // count degenerates to the entire local history, so only report when the
+        // repo actually tracks a remote.
+        const remoteRefs = await gitText(cwd, ["for-each-ref", "--count=1", "--format=%(refname)", "refs/remotes/"]);
+        if (!remoteRefs?.trim())
+            return undefined;
+        if (!(await gitText(cwd, ["rev-parse", "--verify", "--quiet", "HEAD"], { allowedExit: [1] })))
+            return undefined;
+        const output = await gitText(cwd, ["rev-list", "--count", "HEAD", "--not", "--remotes"]);
+        const count = parseInt(output?.trim() ?? "");
+        if (!Number.isFinite(count) || count <= 0)
+            return undefined;
+        return {
+            dimension: "unpushed",
+            level: "warn",
+            message: `${count} commit(s) not on any remote — push to preserve this work`,
+            detail: { unpushed: count },
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Public API
+    // ---------------------------------------------------------------------------
+    async function scan(cwd) {
+        const fallbackDir = normalizeDir(cwd);
+        const deadline = Date.now() + SCAN_TIMEOUT_MS;
+        const repo = await resolveRepo(fallbackDir);
+        if (!repo)
+            return { dir: fallbackDir, issues: [] };
+        const remaining = remainingMs(deadline);
+        if (remaining === 0)
+            throw new Error("Git health repository probe timed out");
+        const checks = [
+            checkDiff(repo.root),
+            checkUntracked(repo.root),
+            checkLargeFiles(repo.root, deadline),
+            checkExtraBranches(repo.root),
+            checkDetachedHead(repo.root),
+            checkGcNeeded(repo.root, repo.gitDir, deadline),
+            checkUnpushed(repo.root),
+        ];
+        const results = await withDeadline(Promise.all(checks), remaining);
+        const issues = results.flat().filter((i) => i !== undefined);
+        return { dir: repo.root, issues };
+    }
+    /**
+     * Live repository probe shared with the env prompt block. Deliberately
+     * bypasses the scan cache: callers (per-turn env assembly) need the current
+     * answer, and a stale repo probe is exactly the bug this replaces.
+     */
+    async function isGitRepo(cwd) {
+        const repo = await resolveRepo(normalizeDir(cwd ?? process.cwd())).catch(() => undefined);
+        return repo !== undefined;
+    }
+    GitHealth.isGitRepo = isGitRepo;
+    function refresh(cwd) {
+        const instanceState = runtimeState();
+        const inputDir = normalizeDir(cwd ?? process.cwd());
+        const key = cacheKey(inputDir);
+        const existing = instanceState._refreshing.get(key) ?? instanceState._refreshing.get(inputDir);
+        if (existing)
+            return existing;
+        const generation = instanceState._generation;
+        const revisions = new Map(instanceState._revisions);
+        const unchanged = (dir) => (revisions.get(dir) ?? 0) === (instanceState._revisions.get(dir) ?? 0);
+        let promise;
+        promise = scan(inputDir)
+            .then((result) => {
+            const instanceState = runtimeState();
+            if (generation === instanceState._generation)
+                instanceState._aliases.set(inputDir, result.dir);
+            if (generation === instanceState._generation && unchanged(key) && unchanged(result.dir)) {
+                instanceState._cache.set(result.dir, { issues: result.issues, ts: Date.now() });
+                instanceState._lastDir = result.dir;
+                instanceState._dirty.delete(key);
+                instanceState._dirty.delete(result.dir);
+                instanceState._dirty.delete(inputDir);
+                instanceState._failed.delete(key);
+                instanceState._failed.delete(result.dir);
+            }
+            return result.issues;
+        })
+            .catch(() => {
+            if (generation === instanceState._generation && unchanged(key)) {
+                instanceState._failed.add(key);
+                instanceState._dirty.delete(key);
+            }
+            return instanceState._cache.get(key)?.issues ?? [];
+        })
+            .finally(() => {
+            const instanceState = runtimeState();
+            if (instanceState._refreshing.get(key) === promise)
+                instanceState._refreshing.delete(key);
+            if (instanceState._refreshing.get(inputDir) === promise)
+                instanceState._refreshing.delete(inputDir);
+        })
+            .then((issues) => generation === instanceState._generation && (!unchanged(key) || !unchanged(cacheKey(inputDir)))
+            ? refresh(inputDir)
+            : issues);
+        instanceState._refreshing.set(key, promise);
+        if (key !== inputDir)
+            instanceState._refreshing.set(inputDir, promise);
+        return promise;
+    }
+    GitHealth.refresh = refresh;
+    async function check(cwd) {
+        const instanceState = runtimeState();
+        const dir = normalizeDir(cwd ?? process.cwd());
+        const key = cacheKey(dir);
+        const cached = instanceState._cache.get(key);
+        if (cached &&
+            !instanceState._dirty.has(key) &&
+            !instanceState._failed.has(key) &&
+            Date.now() - cached.ts < CACHE_TTL_MS) {
+            instanceState._lastDir = key;
+            return cached.issues;
+        }
+        return refresh(dir);
+    }
+    GitHealth.check = check;
+    async function inject(cwd) {
+        return render(await check(cwd));
+    }
+    GitHealth.inject = inject;
+    function injectCached(cwd) {
+        const observation = observeCached(cwd);
+        return observation.state === "present" ? observation.text : undefined;
+    }
+    GitHealth.injectCached = injectCached;
+    function observeCached(cwd) {
+        const instanceState = runtimeState();
+        const dir = normalizeDir(cwd ?? process.cwd());
+        const key = cacheKey(dir);
+        const cached = instanceState._cache.get(key);
+        if (!cached ||
+            instanceState._dirty.has(key) ||
+            instanceState._failed.has(key) ||
+            Date.now() - cached.ts >= CACHE_TTL_MS) {
+            refresh(dir).catch(() => { });
+        }
+        if (instanceState._failed.has(key))
+            return { state: "unavailable" };
+        if (!cached || instanceState._dirty.has(key) || Date.now() - cached.ts >= CACHE_TTL_MS)
+            return { state: "pending" };
+        instanceState._lastDir = key;
+        const text = render(cached.issues);
+        return text ? { state: "present", text } : { state: "cleared" };
+    }
+    GitHealth.observeCached = observeCached;
+    function lastReport() {
+        const instanceState = runtimeState();
+        if (!instanceState._lastDir)
+            return undefined;
+        const cached = instanceState._cache.get(instanceState._lastDir);
+        return cached?.issues.length ? cached.issues : undefined;
+    }
+    GitHealth.lastReport = lastReport;
+    function invalidate(cwd) {
+        const instanceState = runtimeState();
+        if (cwd === undefined) {
+            instanceState._generation++;
+            instanceState._refreshing.clear();
+            instanceState._cache.clear();
+            instanceState._aliases.clear();
+            instanceState._lastDir = undefined;
+            instanceState._revisions.clear();
+            instanceState._dirty.clear();
+            instanceState._failed.clear();
+            return;
+        }
+        const dir = normalizeDir(cwd);
+        const key = cacheKey(dir);
+        instanceState._revisions.set(key, (instanceState._revisions.get(key) ?? 0) + 1);
+        instanceState._dirty.add(key);
+    }
+    GitHealth.invalidate = invalidate;
+})(GitHealth || (GitHealth = {}));

package/dist/project/ide.js

@@ -0,0 +1,66 @@
+import { RuntimeContext } from "@ericsanchezok/synergy-harness/lifecycle/context";
+import { BusEvent } from "@ericsanchezok/synergy-harness/bus/bus-event";
+import { spawn } from "bun";
+import z from "zod";
+import { NamedError } from "@ericsanchezok/synergy-util/error";
+import { Log } from "@ericsanchezok/synergy-harness/util/log";
+const SUPPORTED_IDES = [
+    { name: "Windsurf", cmd: "windsurf" },
+    { name: "Visual Studio Code - Insiders", cmd: "code-insiders" },
+    { name: "Visual Studio Code", cmd: "code" },
+    { name: "Cursor", cmd: "cursor" },
+    { name: "VSCodium", cmd: "codium" },
+];
+export var Ide;
+(function (Ide) {
+    const log = Log.create({ service: "ide" });
+    Ide.Event = {
+        Installed: BusEvent.define("ide.installed", z.object({
+            ide: z.string(),
+        })),
+    };
+    Ide.AlreadyInstalledError = NamedError.create("AlreadyInstalledError", z.object({}));
+    Ide.InstallFailedError = NamedError.create("InstallFailedError", z.object({
+        stderr: z.string(),
+    }));
+    function ide() {
+        if (RuntimeContext.current().host.env["TERM_PROGRAM"] === "vscode") {
+            const v = RuntimeContext.current().host.env["GIT_ASKPASS"];
+            for (const ide of SUPPORTED_IDES) {
+                if (v?.includes(ide.name))
+                    return ide.name;
+            }
+        }
+        return "unknown";
+    }
+    Ide.ide = ide;
+    function alreadyInstalled() {
+        return (RuntimeContext.current().host.env["SYNERGY_CALLER"] === "vscode" ||
+            RuntimeContext.current().host.env["SYNERGY_CALLER"] === "vscode-insiders");
+    }
+    Ide.alreadyInstalled = alreadyInstalled;
+    async function install(ide) {
+        const cmd = SUPPORTED_IDES.find((i) => i.name === ide)?.cmd;
+        if (!cmd)
+            throw new Error(`Unknown IDE: ${ide}`);
+        const p = spawn([cmd, "--install-extension", "ericsanchezok.synergy"], {
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        await p.exited;
+        const stdout = await new Response(p.stdout).text();
+        const stderr = await new Response(p.stderr).text();
+        log.info("installed", {
+            ide,
+            stdout,
+            stderr,
+        });
+        if (p.exitCode !== 0) {
+            throw new Ide.InstallFailedError({ stderr });
+        }
+        if (stdout.includes("already installed")) {
+            throw new Ide.AlreadyInstalledError({});
+        }
+    }
+    Ide.install = install;
+})(Ide || (Ide = {}));

package/dist/project/migration.js

@@ -0,0 +1,22 @@
+import { MigrationRegistry } from "@ericsanchezok/synergy-harness/migration/registry";
+import { Scope } from "@ericsanchezok/synergy-harness/scope";
+import { ProjectDirectories } from "./directories.js";
+export const projectMigrations = [
+    {
+        id: "20260929-project-directories",
+        scope: "global",
+        execution: "startup",
+        description: "Separate project folders from historical Worktrees without changing Scope identity",
+        async up(progress) {
+            const projects = await Scope.list();
+            progress(0, projects.length);
+            for (const [index, project] of projects.entries()) {
+                await ProjectDirectories.migrateProject(project);
+                progress(index + 1, projects.length);
+            }
+        },
+    },
+];
+export function registerProjectMigrations() {
+    MigrationRegistry.register("workbench-projects", projectMigrations);
+}

package/dist/project/routes/directories.js

@@ -0,0 +1,89 @@
+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.js";
+import { WorkspaceAccess } from "@ericsanchezok/synergy-harness/workspace/access";
+import { Worktree } from "@ericsanchezok/synergy-local-runtime/workspace/worktree";
+import { ProjectDirectories } from "../directories.js";
+const params = z.object({ scopeID: z.string().min(1) });
+const response = (schema) => ({
+    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, action) {
+    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) }));
+    });
+}