@voybio/ace-swarm 0.1.0

package/dist/store/materializers/host-file-materializer.js

@@ -0,0 +1,271 @@
+/**
+ * HostFileMaterializer
+ *
+ * Writes the minimal host-facing shim files that must remain on disk because
+ * external tools do not read the ACE store directly.
+ *
+ * The store remains authoritative. These files are projections only.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildHostInstructionText } from "../../ace-server-instructions.js";
+import { ALL_MCP_CLIENTS, getAllMcpServerConfigSnippets, getMcpClientInstallHint, getMcpServerConfigSnippet, } from "../../helpers.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HOOK_COMMAND = "node ./.agents/ACE/scripts/ace/ace-hook-dispatch.mjs";
+const HOST_KNOWLEDGE_PREFIX = "knowledge/host";
+function ensureDir(path) {
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+function write(path, content) {
+    ensureDir(path);
+    writeFileSync(path, content, "utf8");
+    return path;
+}
+function buildCopilotHookSettings() {
+    const hook = {
+        type: "command",
+        command: HOOK_COMMAND,
+        windows: "node .\\\\.agents\\\\ACE\\\\scripts\\\\ace\\\\ace-hook-dispatch.mjs",
+        timeout: 10,
+    };
+    return JSON.stringify({
+        hooks: {
+            SessionStart: [hook],
+            UserPromptSubmit: [hook],
+            PreToolUse: [hook],
+            PostToolUse: [hook],
+            PreCompact: [hook],
+            SubagentStart: [hook],
+            SubagentStop: [hook],
+            Stop: [hook],
+        },
+    }, null, 2);
+}
+function buildClaudeHookSettings() {
+    const hook = {
+        type: "command",
+        command: HOOK_COMMAND,
+    };
+    return JSON.stringify({
+        hooks: {
+            SessionStart: [{ matcher: "", hooks: [hook] }],
+            UserPromptSubmit: [{ matcher: "", hooks: [hook] }],
+            PreToolUse: [{ matcher: "", hooks: [hook] }],
+            PostToolUse: [{ matcher: "", hooks: [hook] }],
+            PreCompact: [{ matcher: "", hooks: [hook] }],
+            SubagentStart: [{ matcher: "", hooks: [hook] }],
+            SubagentStop: [{ matcher: "", hooks: [hook] }],
+            Stop: [{ matcher: "", hooks: [hook] }],
+        },
+    }, null, 2);
+}
+function buildCodexHookSettings() {
+    return [
+        "# ACE lifecycle hook scaffold for Codex-compatible runtimes.",
+        "# Merge or source these entries in the host hook config that supports SessionStart/SubagentStart hooks.",
+        "",
+        ...["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PreCompact", "SubagentStart", "SubagentStop", "Stop"].flatMap((event) => ["[[hooks]]", `event = "${event}"`, `command = "${HOOK_COMMAND}"`, ""]),
+    ].join("\n");
+}
+function getAssetsScriptsRoot() {
+    const packaged = resolve(__dirname, "..", "..", "..", "assets", "scripts");
+    if (existsSync(packaged))
+        return packaged;
+    return resolve(__dirname, "..", "..", "..", "..", "assets", "scripts");
+}
+export class HostFileMaterializer {
+    store;
+    workspaceRoot;
+    packageName;
+    constructor(store, workspaceRoot, packageName = "@voybio/ace-swarm") {
+        this.store = store;
+        this.workspaceRoot = workspaceRoot;
+        this.packageName = packageName;
+    }
+    ace(...parts) {
+        return join(this.workspaceRoot, ".agents", "ACE", ...parts);
+    }
+    root(...parts) {
+        return join(this.workspaceRoot, ...parts);
+    }
+    hostKey(...parts) {
+        return `${HOST_KNOWLEDGE_PREFIX}/${parts.join("/")}`;
+    }
+    async materializeProjectedText(absPath, keyParts, fallbackContent) {
+        const key = this.hostKey(...keyParts);
+        const existing = await this.store.getBlob(key);
+        const content = existing ?? fallbackContent;
+        if (existing === undefined) {
+            await this.store.setBlob(key, fallbackContent);
+        }
+        return write(absPath, content);
+    }
+    async seedProjectedText(entry) {
+        const key = this.hostKey(...entry.keyParts);
+        const existing = await this.store.getBlob(key);
+        if (existing === undefined) {
+            await this.store.setBlob(key, entry.fallbackContent);
+        }
+    }
+    async materializeEntry(entry) {
+        return this.materializeProjectedText(entry.absPath, entry.keyParts, entry.fallbackContent);
+    }
+    buildInstructionShimEntries() {
+        return [
+            {
+                absPath: this.root("AGENTS.md"),
+                keyParts: ["AGENTS.md"],
+                fallbackContent: buildHostInstructionText("codex", this.workspaceRoot),
+            },
+            {
+                absPath: this.root("CLAUDE.md"),
+                keyParts: ["CLAUDE.md"],
+                fallbackContent: buildHostInstructionText("claude", this.workspaceRoot),
+            },
+            {
+                absPath: this.root(".cursorrules"),
+                keyParts: [".cursorrules"],
+                fallbackContent: buildHostInstructionText("cursor", this.workspaceRoot),
+            },
+            {
+                absPath: this.root(".github", "copilot-instructions.md"),
+                keyParts: [".github", "copilot-instructions.md"],
+                fallbackContent: buildHostInstructionText("copilot", this.workspaceRoot),
+            },
+        ];
+    }
+    buildHookFileEntries() {
+        return [
+            {
+                absPath: this.root(".claude", "settings.json"),
+                keyParts: [".claude", "settings.json"],
+                fallbackContent: JSON.stringify(JSON.parse(buildClaudeHookSettings()), null, 2),
+            },
+            {
+                absPath: this.root(".github", "hooks", "ace-copilot.json"),
+                keyParts: [".github", "hooks", "ace-copilot.json"],
+                fallbackContent: JSON.stringify(JSON.parse(buildCopilotHookSettings()), null, 2),
+            },
+            {
+                absPath: this.root(".cursor", "hooks.json"),
+                keyParts: [".cursor", "hooks.json"],
+                fallbackContent: JSON.stringify(JSON.parse(buildCopilotHookSettings()), null, 2),
+            },
+        ];
+    }
+    buildOptionalHookBundleEntries() {
+        return [
+            {
+                absPath: this.root(".vscode", "ace-hooks.json"),
+                keyParts: [".vscode", "ace-hooks.json"],
+                fallbackContent: JSON.stringify(JSON.parse(buildCopilotHookSettings()), null, 2),
+            },
+            {
+                absPath: this.root(".mcp-config", "codex.hooks.toml"),
+                keyParts: [".mcp-config", "codex.hooks.toml"],
+                fallbackContent: buildCodexHookSettings(),
+            },
+            {
+                absPath: this.root(".mcp-config", "gemini.hooks.json"),
+                keyParts: [".mcp-config", "gemini.hooks.json"],
+                fallbackContent: buildCopilotHookSettings(),
+            },
+            {
+                absPath: this.root(".mcp-config", "antigravity.hooks.json"),
+                keyParts: [".mcp-config", "antigravity.hooks.json"],
+                fallbackContent: buildCopilotHookSettings(),
+            },
+        ];
+    }
+    buildScriptEntries() {
+        return ["ace-hook-dispatch.mjs", "copilot-hook-dispatch.mjs"].map((scriptName) => {
+            const src = join(getAssetsScriptsRoot(), scriptName);
+            return {
+                absPath: this.ace("scripts", "ace", scriptName),
+                keyParts: [".agents", "ACE", "scripts", "ace", scriptName],
+                fallbackContent: readFileSync(src, "utf8"),
+            };
+        });
+    }
+    buildWorkspaceScriptEntries() {
+        return this.buildScriptEntries().filter((entry) => entry.keyParts.at(-1) === "ace-hook-dispatch.mjs");
+    }
+    buildMcpBundleEntries() {
+        const snippets = getAllMcpServerConfigSnippets();
+        const fileNames = {
+            codex: "codex.config.toml",
+            vscode: "vscode.mcp.json",
+            claude: "claude_desktop_config.json",
+            cursor: "cursor.mcp.json",
+            antigravity: "antigravity.mcp.json",
+        };
+        const entries = [];
+        for (const client of ALL_MCP_CLIENTS) {
+            entries.push({
+                absPath: this.root(".mcp-config", fileNames[client]),
+                keyParts: [".mcp-config", fileNames[client]],
+                fallbackContent: snippets[client],
+            });
+        }
+        entries.push({
+            absPath: this.root(".mcp-config", "README.md"),
+            keyParts: [".mcp-config", "README.md"],
+            fallbackContent: [
+                "# ACE MCP Client Config Bundle",
+                "",
+                `Generated for ${this.packageName}. Prefer global or user-level MCP installs; this bundle is stored in ace-state.zarr for export and repair.`,
+                "",
+                "## Files",
+                ...ALL_MCP_CLIENTS.map((client) => `- ${client}: ${fileNames[client]}`),
+                "",
+                "## Install Hints",
+                ...ALL_MCP_CLIENTS.map((client) => `- ${client}: ${getMcpClientInstallHint(client)}`),
+            ].join("\n"),
+        });
+        return entries;
+    }
+    buildVsCodeMcpEntry() {
+        return {
+            absPath: this.root(".vscode", "mcp.json"),
+            keyParts: [".vscode", "mcp.json"],
+            fallbackContent: getMcpServerConfigSnippet("vscode"),
+        };
+    }
+    buildAllProjectedEntries() {
+        return [
+            ...this.buildInstructionShimEntries(),
+            ...this.buildHookFileEntries(),
+            ...this.buildOptionalHookBundleEntries(),
+            ...this.buildScriptEntries(),
+            ...this.buildMcpBundleEntries(),
+            this.buildVsCodeMcpEntry(),
+        ];
+    }
+    async seedStorePayload() {
+        for (const entry of this.buildAllProjectedEntries()) {
+            await this.seedProjectedText(entry);
+        }
+    }
+    async materializeAll(opts = {}) {
+        const paths = [];
+        const includeMcpConfig = opts.includeMcpConfig ?? false;
+        const includeClientConfigBundle = opts.includeClientConfigBundle ?? false;
+        await this.seedStorePayload();
+        if (!includeMcpConfig && !includeClientConfigBundle) {
+            return paths;
+        }
+        if (includeMcpConfig) {
+            paths.push(await this.materializeEntry(this.buildVsCodeMcpEntry()));
+        }
+        if (includeClientConfigBundle) {
+            for (const entry of this.buildInstructionShimEntries()) {
+                paths.push(await this.materializeEntry(entry));
+            }
+        }
+        return paths;
+    }
+}
+//# sourceMappingURL=host-file-materializer.js.map

package/dist/store/materializers/todo-syncer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * TodoSyncer
+ *
+ * Bidirectional sync between tasks/todo.md (human-editable) and the store.
+ *
+ * - On write: store → tasks/todo.md (ACE writes todo state from store)
+ * - On read: tasks/todo.md → store (if externally modified by mtime + hash)
+ *
+ * tasks/todo.md format:
+ *   - [ ] Todo item title (id: todo-001)
+ *   - [x] Completed item (id: todo-002)
+ *   - [~] In progress (id: todo-003)
+ *   - [!] Blocked (id: todo-004)
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export declare class TodoSyncer {
+    private store;
+    private workspaceRoot;
+    private repo;
+    private lastHash;
+    private todoMdPath;
+    constructor(store: AcePackedStore, workspaceRoot: string);
+    /** Write store todo state → tasks/todo.md */
+    writeToFile(): Promise<void>;
+    /** Check if tasks/todo.md was modified externally, and if so ingest changes */
+    syncFromFile(): Promise<boolean>;
+    /** Initialize todo.md with starter content if it doesn't exist */
+    initStarter(): Promise<void>;
+}
+//# sourceMappingURL=todo-syncer.d.ts.map

package/dist/store/materializers/todo-syncer.js

@@ -0,0 +1,140 @@
+/**
+ * TodoSyncer
+ *
+ * Bidirectional sync between tasks/todo.md (human-editable) and the store.
+ *
+ * - On write: store → tasks/todo.md (ACE writes todo state from store)
+ * - On read: tasks/todo.md → store (if externally modified by mtime + hash)
+ *
+ * tasks/todo.md format:
+ *   - [ ] Todo item title (id: todo-001)
+ *   - [x] Completed item (id: todo-002)
+ *   - [~] In progress (id: todo-003)
+ *   - [!] Blocked (id: todo-004)
+ */
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { createHash } from "crypto";
+import { TodoRepository } from "../repositories/todo-repository.js";
+const STATUS_ICONS = {
+    pending: " ",
+    in_progress: "~",
+    done: "x",
+    blocked: "!",
+    cancelled: "-",
+};
+const ICON_STATUS = {
+    " ": "pending",
+    "~": "in_progress",
+    x: "done",
+    "!": "blocked",
+    "-": "cancelled",
+};
+function sha256(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function renderTodoMd(todos) {
+    const lines = ["# Tasks\n"];
+    const byStatus = {};
+    for (const t of todos) {
+        (byStatus[t.status] ??= []).push(t);
+    }
+    const order = ["in_progress", "pending", "blocked", "done", "cancelled"];
+    for (const status of order) {
+        const group = byStatus[status];
+        if (!group?.length)
+            continue;
+        const icon = STATUS_ICONS[status];
+        for (const t of group) {
+            const priority = t.priority ? ` [${t.priority}]` : "";
+            const assignee = t.assigned_to ? ` @${t.assigned_to}` : "";
+            lines.push(`- [${icon}] ${t.title}${priority}${assignee} (id: ${t.id})`);
+            if (t.notes)
+                lines.push(`  > ${t.notes}`);
+        }
+    }
+    return lines.join("\n") + "\n";
+}
+function parseTodoMd(content) {
+    const results = [];
+    for (const line of content.split("\n")) {
+        const match = line.match(/^- \[(.)\] (.+)/);
+        if (!match)
+            continue;
+        const [, iconChar, rest] = match;
+        const status = ICON_STATUS[iconChar] ?? "pending";
+        // Extract id if present
+        const idMatch = rest.match(/\(id: ([^)]+)\)/);
+        const id = idMatch?.[1];
+        const title = rest.replace(/\s*\(id: [^)]+\)/, "").replace(/\s*\[[^\]]+\]/, "").replace(/\s*@\S+/, "").trim();
+        results.push({ id, title, status });
+    }
+    return results;
+}
+export class TodoSyncer {
+    store;
+    workspaceRoot;
+    repo;
+    lastHash = "";
+    todoMdPath;
+    constructor(store, workspaceRoot) {
+        this.store = store;
+        this.workspaceRoot = workspaceRoot;
+        this.repo = new TodoRepository(store);
+        // Canonical ACE path: .agents/ACE/tasks/todo.md (mirrors ACE_TASKS_ROOT_REL in helpers.ts)
+        this.todoMdPath = join(workspaceRoot, ".agents", "ACE", "tasks", "todo.md");
+    }
+    /** Write store todo state → tasks/todo.md */
+    async writeToFile() {
+        const todos = await this.repo.getAll();
+        const content = renderTodoMd(todos);
+        const dir = dirname(this.todoMdPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(this.todoMdPath, content, "utf8");
+        this.lastHash = sha256(content);
+    }
+    /** Check if tasks/todo.md was modified externally, and if so ingest changes */
+    async syncFromFile() {
+        if (!existsSync(this.todoMdPath))
+            return false;
+        const content = readFileSync(this.todoMdPath, "utf8");
+        const currentHash = sha256(content);
+        if (currentHash === this.lastHash)
+            return false; // not modified
+        const parsed = parseTodoMd(content);
+        let changed = false;
+        for (const item of parsed) {
+            if (!item.id)
+                continue; // can't sync without id
+            const existing = await this.repo.get(item.id);
+            if (!existing)
+                continue;
+            if (existing.status !== item.status || existing.title !== item.title) {
+                await this.repo.update(item.id, { title: item.title, status: item.status });
+                changed = true;
+            }
+        }
+        this.lastHash = currentHash;
+        return changed;
+    }
+    /** Initialize todo.md with starter content if it doesn't exist */
+    async initStarter() {
+        if (existsSync(this.todoMdPath))
+            return;
+        const dir = dirname(this.todoMdPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const starter = `# Tasks\n\n- [ ] Initiate ACE (id: todo-001)\n`;
+        writeFileSync(this.todoMdPath, starter, "utf8");
+        this.lastHash = sha256(starter);
+        // Seed into store
+        await this.repo.create({
+            id: "todo-001",
+            title: "Initiate ACE",
+            status: "pending",
+            priority: "high",
+        });
+    }
+}
+//# sourceMappingURL=todo-syncer.js.map

package/dist/store/materializers/vericify-projector.d.ts

@@ -0,0 +1,38 @@
+/**
+ * VericifyProjector
+ *
+ * Writes 5 Vericify-facing files from store state on every relevant mutation.
+ * These are MIRRORS only — the store is source of truth.
+ *
+ * All files live under .agents/ACE/ (the canonical ACE namespace as defined
+ * by ACE_ROOT_REL in helpers.ts and remapped via ACE_MANAGED_PREFIXES).
+ *
+ * Files projected:
+ *   .agents/ACE/agent-state/handoff-registry.json
+ *   .agents/ACE/agent-state/todo-state.json       ← schema: { version, updated_at, order[], nodes{} }
+ *   .agents/ACE/agent-state/run-ledger.json        ← schema: { version, updated_at, entries[] }
+ *   .agents/ACE/agent-state/STATUS_EVENTS.ndjson   ← schema: StatusEventRecord per line
+ *   .agents/ACE/agent-state/vericify/process-posts.json
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export declare class VericifyProjector {
+    private store;
+    private workspaceRoot;
+    private handoffs;
+    private todos;
+    private ledger;
+    private tracker;
+    private vericify;
+    constructor(store: AcePackedStore, workspaceRoot: string);
+    private operationalRel;
+    projectAll(): Promise<void>;
+    projectHandoffs(): Promise<void>;
+    projectTodos(): Promise<void>;
+    projectLedger(): Promise<void>;
+    projectStatusEvents(): Promise<void>;
+    projectVericifyPosts(): Promise<void>;
+    private _write;
+    private _trackChecksum;
+    checkExternalModification(relPath: string, currentContent: string): Promise<boolean>;
+}
+//# sourceMappingURL=vericify-projector.d.ts.map