@voybio/ace-swarm 0.1.0

package/dist/cli.js

@@ -0,0 +1,591 @@
+#!/usr/bin/env node
+import { ACE_ROOT_REL, ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_LLM_PROVIDERS, DEFAULTS_ROOT, PACKAGE_ROOT, WORKSPACE_ROOT, fileExists, getAllMcpServerConfigSnippets, getMcpClientInstallHint, getMcpServerConfigSnippet, wsPath, } from "./helpers.js";
+import { refreshAstgrepIndex } from "./astgrep-index.js";
+import { scanWorkspaceDelta } from "./index-store.js";
+import { startStdioServer } from "./server.js";
+import { appendRunLedgerEntrySafe } from "./run-ledger.js";
+import { waitForPendingStatusEventMirrors } from "./status-events.js";
+import { bootstrapStoreWorkspace } from "./store/bootstrap-store.js";
+import { openStore } from "./store/ace-packed-store.js";
+import { withStoreWriteQueue } from "./store/write-queue.js";
+import { getWorkspaceStorePath, readStoreBlobSync, readStoreJsonSync, } from "./store/store-snapshot.js";
+import { readFileSync } from "node:fs";
+import { runTui } from "./tui/index.js";
+import { buildOpenAiCompatibleBaseUrl, DEFAULT_LLAMA_CPP_MODEL, DEFAULT_OLLAMA_MODEL, discoverProviderContext, normalizeLocalBaseUrl, scanLocalModelRuntimes, } from "./tui/provider-discovery.js";
+function printHelp() {
+    console.log(`ACE Swarm CLI
+
+Usage:
+  ace mcp                      Start MCP server over stdio
+  ace serve                    Alias for mcp
+  ace tui [options]            Launch interactive TUI dashboard
+  ace init [options]           Bootstrap the ACE store into current workspace
+  ace turnkey [options]        Project minimal workspace bootstrap stubs from the ACE store
+  ace doctor [options]         Validate local LLM + MCP readiness
+  ace mcp-config [options]     Print global/client MCP config snippet(s) from store
+  ace paths                    Show resolved package/workspace paths
+  ace help                     Show help
+
+Options for tui:
+  --provider <name>            Provider override (ollama|llama.cpp|codex|gemini|claude|copilot|...)
+  --model <name>               Model name override (defaults from profile/settings discovery)
+  --base-url <url>             Local runtime base URL override
+  --ollama-url <url>           Legacy alias for --base-url
+
+Options for init:
+  --project <name>             Project name stored in ${ACE_ROOT_REL}/ace-state.zarr metadata
+  --force                      Overwrite scaffolded files if they already exist
+  --mcp-config                 Also write .vscode/mcp.json workspace bridge
+  --client-config-bundle       Also write minimal workspace host stubs (AGENTS.md, CLAUDE.md, .cursorrules, .github/copilot-instructions.md)
+  --llm <provider>             ollama|llama.cpp
+  --model <name>               Model name for local provider
+  --base-url <url>             Local runtime base URL override
+  --ollama-url <url>           Legacy alias for --base-url
+
+Options for doctor:
+  --llm <provider>             ollama|llama.cpp (default: auto from ${ACE_ROOT_REL}/ace-state.zarr)
+  --model <name>               Model name override
+  --base-url <url>             Local runtime base URL override
+  --ollama-url <url>           Legacy alias for --base-url
+  --scan                       Probe common local Ollama + llama.cpp endpoints when URL is unset
+
+Options for mcp-config:
+  --client <name>              codex|vscode|claude|cursor|antigravity
+  --all                        Print all client snippets for optional global install
+`);
+}
+function readFlagValue(args, flag) {
+    const exact = args.find((arg) => arg.startsWith(`${flag}=`));
+    if (exact)
+        return exact.slice(flag.length + 1);
+    const index = args.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return args[index + 1];
+}
+function readLlmProfile() {
+    const storeProfile = readStoreJsonSync(WORKSPACE_ROOT, "state/runtime/llm_profile") ??
+        readStoreJsonSync(WORKSPACE_ROOT, "state/runtime/llm-profile");
+    if (storeProfile && typeof storeProfile === "object") {
+        return storeProfile;
+    }
+    const profilePath = wsPath(".ace", "llm-profile.json");
+    if (!fileExists(profilePath))
+        return undefined;
+    try {
+        const raw = readFileSync(profilePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readBaseUrlFlag(args) {
+    return normalizeLocalBaseUrl(readFlagValue(args, "--base-url") ?? readFlagValue(args, "--ollama-url"));
+}
+function parseLlmOptions(args) {
+    const profile = readLlmProfile();
+    const selected = readFlagValue(args, "--llm")?.trim().toLowerCase() ?? profile?.provider?.trim().toLowerCase();
+    if (!selected)
+        return {};
+    if (!ALL_LLM_PROVIDERS.includes(selected)) {
+        throw new Error(`Unsupported LLM provider: ${selected}`);
+    }
+    const provider = selected;
+    const defaultModel = provider === "llama.cpp" ? DEFAULT_LLAMA_CPP_MODEL : DEFAULT_OLLAMA_MODEL;
+    const llmModel = readFlagValue(args, "--model")?.trim() || profile?.model || defaultModel;
+    const llmBaseUrl = readBaseUrlFlag(args) ?? normalizeLocalBaseUrl(profile?.base_url);
+    return {
+        llmProvider: provider,
+        llmModel,
+        llmBaseUrl,
+    };
+}
+async function writeLlmProfile(profile) {
+    const storePath = getWorkspaceStorePath(WORKSPACE_ROOT);
+    await withStoreWriteQueue(storePath, async () => {
+        const payload = {
+            provider: profile.provider,
+            model: profile.model,
+            generated_at: new Date().toISOString(),
+        };
+        if (profile.baseUrl) {
+            payload.base_url = profile.baseUrl;
+            if (profile.provider === "ollama") {
+                payload.api_compat_base_url = buildOpenAiCompatibleBaseUrl(profile.baseUrl);
+                payload.default_api_key = "ollama";
+            }
+        }
+        const doctorCommands = profile.provider === "ollama"
+            ? [
+                "ollama serve",
+                `ollama pull ${profile.model}`,
+                ...(profile.baseUrl ? [`curl -s ${profile.baseUrl}/api/tags`] : []),
+            ]
+            : [
+                "# Start llama-server separately, for example:",
+                "# llama-server -m /path/to/model.gguf --port 8080",
+                ...(profile.baseUrl ? [`curl -s ${buildOpenAiCompatibleBaseUrl(profile.baseUrl)}/models`] : []),
+            ];
+        const store = await openStore(storePath);
+        try {
+            await store.setJSON("state/runtime/llm_profile", payload);
+            await store.setBlob("state/runtime/doctor_checks.md", [
+                `# ACE + ${profile.provider} Doctor Checks`,
+                "",
+                "Run these commands to verify local-model readiness:",
+                "",
+                "```bash",
+                ...doctorCommands,
+                profile.baseUrl
+                    ? `ace doctor --llm ${profile.provider} --model ${profile.model} --base-url ${profile.baseUrl}`
+                    : `ace doctor --llm ${profile.provider} --model ${profile.model} --scan`,
+                "```",
+                "",
+            ].join("\n"));
+            await store.commit();
+        }
+        finally {
+            await store.close();
+        }
+    });
+    return `${storePath}#state/runtime/llm_profile`;
+}
+async function runInit(args, mode = "init") {
+    const projectName = readFlagValue(args, "--project");
+    const force = args.includes("--force");
+    const includeMcpConfig = args.includes("--mcp-config");
+    const includeClientConfigBundle = mode === "turnkey"
+        ? !args.includes("--no-client-config-bundle")
+        : args.includes("--client-config-bundle");
+    const llm = parseLlmOptions(args);
+    // Store-first bootstrap — init stays minimal, turnkey adds host-facing shims.
+    const storeResult = await bootstrapStoreWorkspace({
+        workspaceRoot: WORKSPACE_ROOT,
+        projectName: projectName ?? undefined,
+        force,
+        includeMcpConfig,
+        includeClientConfigBundle,
+        llm: llm.llmProvider ?? undefined,
+        model: llm.llmModel ?? undefined,
+        ollamaUrl: llm.llmBaseUrl ?? undefined,
+    });
+    const astIndex = refreshAstgrepIndex({
+        scope: ".",
+        append_evidence: true,
+        emit_event: true,
+        include_rep_corpus: true,
+    });
+    const delta = scanWorkspaceDelta({
+        path: ".",
+        depth: 8,
+        max_files: 25000,
+        include_hidden: false,
+        exclude: [".git", "node_modules", "dist", "target", ".venv", "__pycache__", ".DS_Store"],
+        file_entry_cap: 0,
+    });
+    if (storeResult.warnings.length) {
+        for (const w of storeResult.warnings)
+            console.warn(`  [store] ${w}`);
+    }
+    console.log("ACE bootstrap complete");
+    console.log(`Workspace: ${WORKSPACE_ROOT}`);
+    console.log(`Store: ${storeResult.storePath}`);
+    console.log(`Agents baked: ${storeResult.agents}`);
+    console.log(`Materialized files: ${storeResult.materialized.length}`);
+    console.log(`Indexed files: ${delta.snapshot.file_count}`);
+    console.log(`Stored index entries: ${delta.snapshot.stored_file_count}`);
+    console.log(`Index entry cap: ${delta.snapshot.options.file_entry_cap}`);
+    console.log(`Index path: ${delta.index_path}`);
+    console.log(`Fingerprint path: ${delta.fingerprint_path}`);
+    console.log(`AST index path: ${astIndex.output_json_path}`);
+    console.log(`AST index generated: ${astIndex.generated_at}`);
+    if (llm.llmProvider) {
+        console.log(`LLM provider: ${llm.llmProvider}`);
+        console.log(`Model: ${llm.llmModel}`);
+        console.log(`Base URL: ${llm.llmBaseUrl ?? "(not set; run ace doctor --scan or pass --base-url)"}`);
+        console.log(`LLM profile path: ${storeResult.storePath}#state/runtime/llm_profile`);
+    }
+    if (storeResult.materialized.length > 0) {
+        console.log("\nMaterialized files:");
+        for (const path of storeResult.materialized)
+            console.log(`- ${path}`);
+    }
+    // refreshAstgrepIndex() emits a status event via a background store mirror.
+    // Drain that queue before appending the init run-ledger entry so init/turnkey
+    // never race two packed-store writers in the same process.
+    await waitForPendingStatusEventMirrors();
+    // Record CLI execution in run-ledger for observability
+    try {
+        await appendRunLedgerEntrySafe({
+            tool: "cli:init",
+            category: "major_update",
+            message: `ace ${mode} completed: ${storeResult.materialized.length} bootstrap files materialized`,
+            artifacts: [
+                `${ACE_TASKS_ROOT_REL}/`,
+                `${ACE_ROOT_REL}/ace-state.zarr`,
+                delta.index_path,
+                astIndex.output_json_path,
+            ],
+            metadata: {
+                materialized_count: storeResult.materialized.length,
+                indexed_files: delta.snapshot.file_count,
+                force,
+                mode,
+                llm_provider: llm.llmProvider ?? null,
+                llm_model: llm.llmModel ?? null,
+                llm_base_url: llm.llmBaseUrl ?? null,
+            },
+        });
+    }
+    catch {
+        // Run-ledger write may fail on first bootstrap before dirs exist
+    }
+    await waitForPendingStatusEventMirrors();
+}
+function getStoredMcpConfigKey(client) {
+    if (client === "codex")
+        return "knowledge/host/.mcp-config/codex.config.toml";
+    if (client === "vscode")
+        return "knowledge/host/.vscode/mcp.json";
+    if (client === "claude")
+        return "knowledge/host/.mcp-config/claude_desktop_config.json";
+    if (client === "cursor")
+        return "knowledge/host/.mcp-config/cursor.mcp.json";
+    return "knowledge/host/.mcp-config/antigravity.mcp.json";
+}
+function readStoredMcpSnippet(client) {
+    return readStoreBlobSync(WORKSPACE_ROOT, getStoredMcpConfigKey(client));
+}
+async function listLocalRuntimeModels(provider, baseUrl) {
+    if (provider === "ollama") {
+        const response = await fetch(`${baseUrl}/api/tags`, {
+            method: "GET",
+            headers: { Accept: "application/json" },
+        });
+        if (!response.ok) {
+            throw new Error(`${response.status} ${response.statusText}`);
+        }
+        const payload = (await response.json().catch(() => ({})));
+        return Array.isArray(payload.models)
+            ? payload.models
+                .map((item) => item?.name?.trim())
+                .filter((name) => Boolean(name))
+            : [];
+    }
+    const response = await fetch(`${buildOpenAiCompatibleBaseUrl(baseUrl)}/models`, {
+        method: "GET",
+        headers: { Accept: "application/json" },
+    });
+    if (!response.ok) {
+        throw new Error(`${response.status} ${response.statusText}`);
+    }
+    const payload = (await response.json().catch(() => ({})));
+    return Array.isArray(payload.data)
+        ? payload.data
+            .map((item) => item?.id?.trim())
+            .filter((name) => Boolean(name))
+        : [];
+}
+async function runDoctor(args) {
+    const llm = parseLlmOptions(args);
+    const checks = [];
+    const shouldScan = args.includes("--scan") || !llm.llmBaseUrl;
+    const mcpConfigPaths = [wsPath(".vscode", "mcp.json")];
+    const hasWorkspaceMcpConfig = mcpConfigPaths.some((path) => fileExists(path));
+    const hasStoredMcpConfig = ALL_MCP_CLIENTS.some((client) => typeof readStoredMcpSnippet(client) === "string");
+    const hasMcpConfig = hasWorkspaceMcpConfig || hasStoredMcpConfig;
+    checks.push({
+        name: "MCP config present",
+        ok: hasMcpConfig,
+        detail: hasMcpConfig
+            ? hasWorkspaceMcpConfig
+                ? "Found one or more workspace MCP bridge files."
+                : "Store-backed MCP snippets are baked into ace-state.zarr. Run `ace mcp-config --all` for global install."
+            : "No MCP bridge or baked snippets found. Run `ace init` first.",
+    });
+    const profilePath = `${getWorkspaceStorePath(WORKSPACE_ROOT)}#state/runtime/llm_profile`;
+    const hasProfile = Boolean(readLlmProfile());
+    checks.push({
+        name: "LLM profile present",
+        ok: hasProfile,
+        detail: hasProfile
+            ? profilePath
+            : `Missing ${ACE_ROOT_REL}/ace-state.zarr#state/runtime/llm_profile. Run \`ace init --llm ollama\` or \`ace doctor --scan\`.`,
+    });
+    let provider = llm.llmProvider;
+    let model = llm.llmModel;
+    let baseUrl = llm.llmBaseUrl;
+    if (shouldScan) {
+        const scanned = await scanLocalModelRuntimes({
+            workspaceRoot: WORKSPACE_ROOT,
+            preferredProvider: provider,
+            explicitBaseUrl: baseUrl,
+        });
+        const chosen = scanned.candidates.find((candidate) => !provider || candidate.provider === provider) ??
+            scanned.candidates[0];
+        if (chosen) {
+            provider = chosen.provider ?? provider;
+            baseUrl = baseUrl ?? chosen.baseUrl;
+            model = model || chosen.models[0] || (provider === "llama.cpp" ? DEFAULT_LLAMA_CPP_MODEL : DEFAULT_OLLAMA_MODEL);
+            checks.push({
+                name: "Runtime endpoint discovered",
+                ok: true,
+                detail: `Picked ${chosen.provider} at ${chosen.baseUrl} (${chosen.source})`,
+            });
+            const writtenProfilePath = await writeLlmProfile({
+                provider: provider ?? chosen.provider,
+                model: model ?? (provider === "llama.cpp" ? DEFAULT_LLAMA_CPP_MODEL : DEFAULT_OLLAMA_MODEL),
+                baseUrl,
+            });
+            checks.push({
+                name: "LLM profile refreshed",
+                ok: true,
+                detail: `Updated ${writtenProfilePath} from discovered runtime settings.`,
+            });
+        }
+        else {
+            checks.push({
+                name: "Runtime endpoint discovered",
+                ok: false,
+                detail: "No reachable local Ollama or llama.cpp runtime was found. Provide --base-url or start one before rerunning doctor.",
+            });
+        }
+    }
+    if (!provider) {
+        throw new Error(`No local runtime provider configured. Use --llm <provider>, bootstrap one into ${ACE_ROOT_REL}/ace-state.zarr#state/runtime/llm_profile, or run \`ace doctor --scan\`.`);
+    }
+    if (!model) {
+        model = provider === "llama.cpp" ? DEFAULT_LLAMA_CPP_MODEL : DEFAULT_OLLAMA_MODEL;
+    }
+    if (!baseUrl) {
+        checks.push({
+            name: "Base URL configured",
+            ok: false,
+            detail: "No local runtime base URL is configured. Pass --base-url or run `ace doctor --scan` to discover one.",
+        });
+        const failed = checks.filter((check) => !check.ok);
+        console.log("ACE Doctor Report (local runtime)");
+        console.log(`Workspace: ${WORKSPACE_ROOT}`);
+        console.log(`Provider: ${provider}`);
+        console.log(`Model: ${model}`);
+        console.log(`Base URL: (not set)`);
+        console.log("");
+        for (const check of checks) {
+            const status = check.ok ? "PASS" : "FAIL";
+            console.log(`- [${status}] ${check.name}: ${check.detail}`);
+        }
+        if (failed.length > 0) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    let modelNames = [];
+    try {
+        modelNames = await listLocalRuntimeModels(provider, baseUrl);
+        checks.push({
+            name: "Runtime endpoint reachable",
+            ok: true,
+            detail: provider === "ollama"
+                ? `${baseUrl}/api/tags responded with ${modelNames.length} models`
+                : `${buildOpenAiCompatibleBaseUrl(baseUrl)}/models responded with ${modelNames.length} models`,
+        });
+    }
+    catch (error) {
+        checks.push({
+            name: "Runtime endpoint reachable",
+            ok: false,
+            detail: `${baseUrl} request failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+    const hasModel = modelNames.includes(model);
+    checks.push({
+        name: provider === "ollama" ? "Requested model installed" : "Requested model served",
+        ok: hasModel,
+        detail: provider === "ollama"
+            ? hasModel
+                ? `${model} found`
+                : `${model} missing (run: ollama pull ${model})`
+            : hasModel
+                ? `${model} found`
+                : `${model} not reported by llama.cpp (available: ${modelNames.join(", ") || "none"})`,
+    });
+    const failed = checks.filter((check) => !check.ok);
+    console.log("ACE Doctor Report (local runtime)");
+    console.log(`Workspace: ${WORKSPACE_ROOT}`);
+    console.log(`Provider: ${provider}`);
+    console.log(`Model: ${model}`);
+    console.log(`Base URL: ${baseUrl}`);
+    console.log("");
+    for (const check of checks) {
+        const status = check.ok ? "PASS" : "FAIL";
+        console.log(`- [${status}] ${check.name}: ${check.detail}`);
+    }
+    if (failed.length > 0) {
+        process.exitCode = 1;
+    }
+}
+function parseClientFlag(args) {
+    const client = readFlagValue(args, "--client");
+    if (!client)
+        return undefined;
+    const normalized = client.trim().toLowerCase();
+    const match = ALL_MCP_CLIENTS.find((candidate) => candidate === normalized);
+    if (!match) {
+        throw new Error(`Unsupported MCP client: ${client}`);
+    }
+    return match;
+}
+async function runMcpConfig(args) {
+    const all = args.includes("--all");
+    const explicitClient = parseClientFlag(args);
+    if (all) {
+        for (const client of ALL_MCP_CLIENTS) {
+            const body = readStoredMcpSnippet(client) ?? getAllMcpServerConfigSnippets()[client];
+            const fence = client === "codex" ? "toml" : "json";
+            console.log(`# ${client}`);
+            console.log(`\`\`\`${fence}`);
+            console.log(body);
+            console.log("```");
+            console.log(`Install hint: ${getMcpClientInstallHint(client)}`);
+            console.log("");
+        }
+        return;
+    }
+    const client = explicitClient ?? "vscode";
+    const body = readStoredMcpSnippet(client) ?? getMcpServerConfigSnippet(client);
+    console.log(body);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = (args[0] ?? "mcp").toLowerCase();
+    if (command === "mcp" || command === "serve") {
+        await startStdioServer();
+        return;
+    }
+    if (command === "tui") {
+        const tuiArgs = args.slice(1);
+        const cliProvider = readFlagValue(tuiArgs, "--provider")?.trim() ||
+            readFlagValue(tuiArgs, "--llm")?.trim();
+        const cliModel = readFlagValue(tuiArgs, "--model")?.trim();
+        const cliBaseUrl = readBaseUrlFlag(tuiArgs);
+        const discovered = discoverProviderContext({
+            workspaceRoot: WORKSPACE_ROOT,
+            cliProvider,
+            cliModel,
+            cliBaseUrl,
+        });
+        await runTui({
+            provider: discovered.provider,
+            model: discovered.model,
+            providers: discovered.providers,
+            modelsByProvider: discovered.modelsByProvider,
+            baseUrl: discovered.baseUrl,
+            ollamaUrl: discovered.ollamaUrl,
+            providerBaseUrls: discovered.providerBaseUrls,
+            workspaceRoot: WORKSPACE_ROOT,
+        });
+        return;
+    }
+    if (command === "init") {
+        await runInit(args.slice(1), "init");
+        return;
+    }
+    if (command === "turnkey") {
+        await runInit(args.slice(1), "turnkey");
+        return;
+    }
+    if (command === "doctor") {
+        await runDoctor(args.slice(1));
+        return;
+    }
+    if (command === "mcp-config") {
+        await runMcpConfig(args.slice(1));
+        return;
+    }
+    if (command === "paths") {
+        console.log(`PACKAGE_ROOT=${PACKAGE_ROOT}`);
+        console.log(`DEFAULTS_ROOT=${DEFAULTS_ROOT}`);
+        console.log(`WORKSPACE_ROOT=${WORKSPACE_ROOT}`);
+        return;
+    }
+    if (command === "add") {
+        const subcommand = args[1]?.toLowerCase();
+        if (subcommand === "skills") {
+            const { installSkillPack, installAllSkills, listAvailableSkillPacks } = await import("./store/skills-install.js");
+            const skillName = args[2];
+            if (!skillName || skillName === "all") {
+                const packs = await listAvailableSkillPacks(WORKSPACE_ROOT);
+                if (!packs.available.length) {
+                    console.log("No skill packs available in assets/.");
+                    return;
+                }
+                console.log(`Installing all ${packs.available.length} available skill packs...`);
+                const results = await installAllSkills(WORKSPACE_ROOT);
+                for (const r of results) {
+                    console.log(`  ✓ ${r.skill} (${r.files} files${r.compacted ? ", compacted" : ""})`);
+                }
+            }
+            else {
+                console.log(`Installing skill pack: ${skillName}`);
+                const result = await installSkillPack(WORKSPACE_ROOT, skillName);
+                console.log(`  ✓ ${result.skill} (${result.files} files${result.compacted ? ", compacted" : ""})`);
+            }
+            return;
+        }
+        console.error(`Unknown subcommand: ace add ${subcommand ?? "(missing)"}`);
+        console.error("Usage: ace add skills [skill-name|all]");
+        process.exit(1);
+    }
+    if (command === "migrate") {
+        const { importFromFileWorkspace } = await import("./store/importer.js");
+        const storePath = args[1] ?? `${WORKSPACE_ROOT}/.agents/ACE/ace-state.zarr`;
+        console.log(`Migrating file workspace at ${WORKSPACE_ROOT} to store at ${storePath}...`);
+        const result = await importFromFileWorkspace(WORKSPACE_ROOT, storePath);
+        console.log(`Migration complete:`);
+        console.log(`  handoffs: ${result.handoffs}`);
+        console.log(`  todos: ${result.todos}`);
+        console.log(`  ledger events: ${result.ledger_events}`);
+        console.log(`  status events: ${result.status_events}`);
+        console.log(`  vericify posts: ${result.vericify_posts}`);
+        if (result.warnings.length) {
+            console.warn(`Warnings (${result.warnings.length}):`);
+            for (const w of result.warnings)
+                console.warn(`  ! ${w}`);
+        }
+        return;
+    }
+    if (command === "repair") {
+        const { repairWorkspace } = await import("./store/bootstrap-store.js");
+        console.log(`Repairing workspace at ${WORKSPACE_ROOT}...`);
+        const warnings = await repairWorkspace(WORKSPACE_ROOT);
+        if (warnings.length) {
+            for (const w of warnings)
+                console.warn(`  ! ${w}`);
+        }
+        else {
+            console.log("  ✓ All host files re-materialized.");
+        }
+        return;
+    }
+    if (command === "compact") {
+        const { compactWorkspace } = await import("./store/bootstrap-store.js");
+        const result = await compactWorkspace(WORKSPACE_ROOT);
+        const savedKb = Math.round((result.before - result.after) / 1024);
+        console.log(`Store compacted: ${result.before} → ${result.after} bytes (saved ${savedKb}KB)`);
+        return;
+    }
+    if (command === "help" || command === "--help" || command === "-h") {
+        printHelp();
+        return;
+    }
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/git-ops.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Git operations module – wraps git CLI for rollback, audit trail,
+ * and workspace state management.
+ */
+export interface GitStatusResult {
+    ok: boolean;
+    is_repo: boolean;
+    clean: boolean;
+    staged: string[];
+    unstaged: string[];
+    untracked: string[];
+    branch: string;
+    output: string;
+    error?: string;
+}
+export interface GitCommitResult {
+    ok: boolean;
+    hash?: string;
+    message: string;
+    files_committed: number;
+    output: string;
+    error?: string;
+}
+export interface GitDiffResult {
+    ok: boolean;
+    diff: string;
+    files_changed: number;
+    insertions: number;
+    deletions: number;
+    stat: string;
+    error?: string;
+}
+export interface GitLogEntry {
+    hash: string;
+    date: string;
+    message: string;
+}
+export interface GitLogResult {
+    ok: boolean;
+    entries: GitLogEntry[];
+    error?: string;
+}
+export declare function isGitRepo(): boolean;
+export declare function gitStatus(): GitStatusResult;
+export declare function gitCommit(message: string, paths?: string[]): GitCommitResult;
+export declare function gitDiff(path?: string, staged?: boolean): GitDiffResult;
+export declare function gitLog(limit?: number): GitLogResult;
+export declare function gitInitIfNeeded(): {
+    ok: boolean;
+    initialized: boolean;
+    error?: string;
+};
+//# sourceMappingURL=git-ops.d.ts.map