@voybio/ace-swarm 0.1.0

package/dist/store/bootstrap-store.js

@@ -0,0 +1,242 @@
+/**
+ * bootstrap-store.ts — Phase 8
+ *
+ * New bootstrapAceWorkspace() using the Zarrita-backed store.
+ *
+ * Replaces the old copyTree()-based bootstrap with:
+ *   1. Create minimal directories
+ *   2. Initialize AcePackedStore at .agents/ACE/ace-state.zarr
+ *   3. Bake core knowledge (agents, modules, kernel)
+ *   4. Write topology records
+ *   5. Write initial runtime state seeds
+ *   6. Write meta (codebooks, schema version)
+ *   7. Compact the store
+ *   8. Optionally materialize host integration files
+ *   9. Materialize hook context snapshot
+ *  10. Write tasks/todo.md starter
+ */
+import { mkdirSync, existsSync } from "fs";
+import { join, dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { openStore } from "./ace-packed-store.js";
+import { bakeAllCoreKnowledge } from "./knowledge-bake.js";
+import { bakeTopology } from "./topology-bake.js";
+import { buildCatalog } from "./catalog-builder.js";
+import { HookContextMaterializer } from "./materializers/hook-context-materializer.js";
+import { HostFileMaterializer } from "./materializers/host-file-materializer.js";
+import { TodoSyncer } from "./materializers/todo-syncer.js";
+import { OPERATIONAL_ARTIFACT_REL_PATHS, operationalArtifactKey, } from "./store-artifacts.js";
+import { STORE_VERSION } from "./types.js";
+import { DEFAULT_LLAMA_CPP_MODEL, DEFAULT_OLLAMA_MODEL, } from "../tui/provider-discovery.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getAssetsRoot() {
+    // Resolve relative to this file's location in the installed package
+    const candidate = resolve(__dirname, "..", "..", "assets");
+    if (existsSync(candidate))
+        return candidate;
+    // Fallback for dev (dist/store/ → ../../assets/)
+    return resolve(__dirname, "..", "..", "..", "assets");
+}
+async function applyLlmRuntimeConfig(store, opts) {
+    if (!opts.llm)
+        return;
+    const configuredModel = opts.model ?? (opts.llm === "llama.cpp" ? DEFAULT_LLAMA_CPP_MODEL : DEFAULT_OLLAMA_MODEL);
+    const profilePayload = {
+        provider: opts.llm,
+        model: configuredModel,
+        generated_at: new Date().toISOString(),
+    };
+    if (opts.ollamaUrl) {
+        profilePayload.base_url = opts.ollamaUrl;
+        if (opts.llm === "ollama") {
+            profilePayload.api_compat_base_url = opts.ollamaUrl.endsWith("/v1")
+                ? opts.ollamaUrl
+                : `${opts.ollamaUrl}/v1`;
+            profilePayload.default_api_key = "ollama";
+        }
+    }
+    await store.setJSON("state/runtime/llm_profile", profilePayload);
+    const doctorCommands = opts.llm === "ollama"
+        ? [
+            "ollama serve",
+            `ollama pull ${configuredModel}`,
+            ...(opts.ollamaUrl ? [`curl -s ${opts.ollamaUrl}/api/tags`] : []),
+        ]
+        : [
+            "# Start llama-server separately, for example:",
+            "# llama-server -m /path/to/model.gguf --port 8080",
+            ...(opts.ollamaUrl
+                ? [`curl -s ${opts.ollamaUrl.endsWith("/v1") ? opts.ollamaUrl : `${opts.ollamaUrl}/v1`}/models`]
+                : []),
+        ];
+    await store.setBlob("state/runtime/doctor_checks.md", [
+        `# ACE + ${opts.llm} Doctor Checks`,
+        "",
+        "Run these commands to verify local-model readiness:",
+        "",
+        "```bash",
+        ...doctorCommands,
+        opts.ollamaUrl
+            ? `ace doctor --llm ${opts.llm} --model ${configuredModel} --base-url ${opts.ollamaUrl}`
+            : `ace doctor --llm ${opts.llm} --model ${configuredModel} --scan`,
+        "```",
+        "",
+    ].join("\n"));
+}
+async function materializeStoreSurfaces(store, workspaceRoot, opts) {
+    const materialized = [];
+    await store.setJSON("meta/host_materialization", {
+        include_mcp_config: opts.includeMcpConfig ?? false,
+        include_client_config_bundle: opts.includeClientConfigBundle ?? false,
+    });
+    await applyLlmRuntimeConfig(store, opts);
+    const hostMat = new HostFileMaterializer(store, workspaceRoot);
+    await hostMat.seedStorePayload();
+    if ((opts.includeMcpConfig ?? false) || (opts.includeClientConfigBundle ?? false)) {
+        materialized.push(...(await hostMat.materializeAll({
+            mcpServerPath: opts.mcpServerPath,
+            includeMcpConfig: opts.includeMcpConfig ?? false,
+            includeClientConfigBundle: opts.includeClientConfigBundle ?? false,
+        })));
+    }
+    const hookCtx = new HookContextMaterializer(store, workspaceRoot);
+    await hookCtx.materialize();
+    materialized.push(join(workspaceRoot, ".agents", "ACE", "ace-hook-context.json"));
+    const todoSyncer = new TodoSyncer(store, workspaceRoot);
+    await todoSyncer.initStarter();
+    materialized.push(join(workspaceRoot, ".agents", "ACE", "tasks", "todo.md"));
+    await store.commit();
+    return [...new Set(materialized)];
+}
+async function seedOperationalArtifacts(store) {
+    for (const relPath of OPERATIONAL_ARTIFACT_REL_PATHS) {
+        const knowledgeKey = `knowledge/agent-state/${relPath.replace(/^agent-state\//, "")}`;
+        const content = relPath.endsWith("-archive.ndjson")
+            ? ""
+            : (await store.getBlob(knowledgeKey)) ?? "";
+        await store.setBlob(operationalArtifactKey(relPath), content);
+    }
+}
+export async function bootstrapStoreWorkspace(opts) {
+    const { workspaceRoot, force = false } = opts;
+    const warnings = [];
+    const materialized = [];
+    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.zarr");
+    if (existsSync(storePath) && !force) {
+        if (!(opts.includeMcpConfig ?? false) && !(opts.includeClientConfigBundle ?? false) && !opts.llm) {
+            warnings.push(`Store already exists at ${storePath}. Use --force to reinitialize, or run 'ace migrate' to import existing state.`);
+            return { storePath, agents: 0, modules: { gates: 0, roles: 0, schemas: 0 }, materialized, warnings };
+        }
+        const existingStore = await openStore(storePath);
+        try {
+            await seedOperationalArtifacts(existingStore);
+            materialized.push(...(await materializeStoreSurfaces(existingStore, workspaceRoot, opts)));
+            const agents = (await existingStore.listAgents()).length;
+            warnings.push(`Reused existing store at ${storePath} and refreshed host materializations.`);
+            return { storePath, agents, modules: { gates: 0, roles: 0, schemas: 0 }, materialized, warnings };
+        }
+        finally {
+            await existingStore.close();
+        }
+    }
+    // 1. Create minimal directories under .agents/ACE/ (canonical ACE namespace)
+    for (const dir of [
+        join(workspaceRoot, ".agents", "ACE"),
+        join(workspaceRoot, ".agents", "ACE", "tasks"),
+    ]) {
+        mkdirSync(dir, { recursive: true });
+    }
+    // 2. Initialize store
+    const store = await openStore(storePath);
+    try {
+        // 3. Write meta
+        await store.setJSON("meta/schema_version", STORE_VERSION);
+        await store.setJSON("meta/created_at", Date.now());
+        await store.setJSON("meta/project_name", opts.projectName ?? "ACE Workspace");
+        await store.setJSON("meta/host_materialization", {
+            include_mcp_config: opts.includeMcpConfig ?? false,
+            include_client_config_bundle: opts.includeClientConfigBundle ?? false,
+        });
+        // 4. Bake core knowledge
+        const assetsRoot = getAssetsRoot();
+        const knowledge = await bakeAllCoreKnowledge(store, assetsRoot);
+        // 5. Write topology
+        await bakeTopology(store, assetsRoot);
+        // 6. Write initial empty runtime seeds
+        await store.setJSON("state/handoffs/__index", []);
+        await store.setJSON("state/todo/index", []);
+        await store.setJSON("state/ledger/seq", 0);
+        await store.setJSON("state/scheduler/queue", []);
+        await store.setJSON("state/scheduler/locks", []);
+        await store.setJSON("state/runtime/sessions/index", []);
+        await store.setJSON("state/discovery/index", []);
+        await store.setJSON("state/vericify/posts/index", []);
+        await applyLlmRuntimeConfig(store, opts);
+        await seedOperationalArtifacts(store);
+        // 7. Build catalog
+        await buildCatalog(store);
+        // 8. Commit + compact
+        await store.commit();
+        await store.compact();
+        materialized.push(...(await materializeStoreSurfaces(store, workspaceRoot, opts)));
+        const agents = (await store.listAgents()).length;
+        return {
+            storePath,
+            agents,
+            modules: knowledge.modules,
+            materialized,
+            warnings,
+        };
+    }
+    finally {
+        await store.close();
+    }
+}
+// ── ace repair ────────────────────────────────────────────────────────────────
+export async function repairWorkspace(workspaceRoot) {
+    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.zarr");
+    if (!existsSync(storePath)) {
+        return [`No store found at ${storePath}. Run 'ace init' first.`];
+    }
+    const warnings = [];
+    const store = await openStore(storePath);
+    try {
+        const hostPolicy = (await store.getJSON("meta/host_materialization")) ?? {};
+        // Re-materialize host files
+        const hostMat = new HostFileMaterializer(store, workspaceRoot);
+        await hostMat.materializeAll({
+            includeMcpConfig: hostPolicy.include_mcp_config ?? false,
+            includeClientConfigBundle: hostPolicy.include_client_config_bundle ?? false,
+        });
+        // Re-materialize hook context
+        const hookCtx = new HookContextMaterializer(store, workspaceRoot);
+        await hookCtx.materialize();
+        await store.commit();
+    }
+    catch (e) {
+        warnings.push(`repair error: ${e.message}`);
+    }
+    finally {
+        await store.close();
+    }
+    return warnings;
+}
+// ── ace compact ───────────────────────────────────────────────────────────────
+export async function compactWorkspace(workspaceRoot) {
+    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.zarr");
+    if (!existsSync(storePath)) {
+        throw new Error(`No store found at ${storePath}. Run 'ace init' first.`);
+    }
+    const { statSync } = await import("fs");
+    const before = statSync(storePath).size;
+    const store = await openStore(storePath);
+    try {
+        await store.compact();
+    }
+    finally {
+        await store.close();
+    }
+    const after = statSync(storePath).size;
+    return { before, after };
+}
+//# sourceMappingURL=bootstrap-store.js.map

package/dist/store/catalog-builder.d.ts

@@ -0,0 +1,21 @@
+/**
+ * catalog-builder.ts
+ *
+ * Builds catalog_entry records after knowledge and topology are baked.
+ * Provides a queryable index of what's available in the store.
+ */
+import { AcePackedStore } from "./ace-packed-store.js";
+export interface CatalogEntry {
+    kind: "agent" | "skill" | "gate" | "role" | "schema" | "kernel";
+    name: string;
+    group?: string;
+    files?: string[];
+    skills?: string[];
+    description?: string;
+}
+export declare function buildCatalog(store: AcePackedStore): Promise<CatalogEntry[]>;
+export declare function queryCatalog(store: AcePackedStore, filter?: {
+    kind?: CatalogEntry["kind"];
+    group?: string;
+}): Promise<CatalogEntry[]>;
+//# sourceMappingURL=catalog-builder.d.ts.map

package/dist/store/catalog-builder.js

@@ -0,0 +1,68 @@
+/**
+ * catalog-builder.ts
+ *
+ * Builds catalog_entry records after knowledge and topology are baked.
+ * Provides a queryable index of what's available in the store.
+ */
+import { ContentSource, EntityKind } from "./types.js";
+export async function buildCatalog(store) {
+    const catalog = [];
+    // Agents
+    const agents = await store.listAgents();
+    const swarmRegistry = await store.getTopology("swarm_registry");
+    const skillBindings = await store.getTopology("skill_bindings");
+    for (const agentName of agents) {
+        const registryEntry = swarmRegistry.find((e) => e.key === agentName);
+        const skillsEntry = skillBindings.find((e) => e.key === agentName);
+        catalog.push({
+            kind: "agent",
+            name: agentName,
+            group: registryEntry ? registryEntry.value.group : undefined,
+            description: registryEntry ? registryEntry.value.objective : undefined,
+            skills: skillsEntry ? skillsEntry.value.skills : [],
+        });
+    }
+    // Skills
+    const skills = await store.listSkills();
+    for (const skillName of skills) {
+        catalog.push({ kind: "skill", name: skillName });
+    }
+    // Gates
+    for (const key of collectKeysByPrefix(store, "knowledge/gates/")) {
+        catalog.push({ kind: "gate", name: key.split("/").pop() });
+    }
+    // Write catalog to store
+    const catalogKey = "knowledge/catalog";
+    await store.setJSON(catalogKey, catalog);
+    await store.appendEntry({
+        kind: EntityKind.CatalogEntry,
+        content_source: ContentSource.Package,
+        key: catalogKey,
+        payload: { count: catalog.length },
+    });
+    console.log(`[catalog-builder] ${catalog.length} catalog entries written`);
+    return catalog;
+}
+function collectKeysByPrefix(store, prefix) {
+    // Access internal index synchronously — only call after store is opened
+    const keys = [];
+    // @ts-ignore — accessing private index for catalog building
+    for (const key of store["index"].keys()) {
+        if (key.startsWith(prefix))
+            keys.push(key);
+    }
+    return keys;
+}
+export async function queryCatalog(store, filter) {
+    const catalog = await store.getJSON("knowledge/catalog");
+    if (!catalog)
+        return [];
+    return catalog.filter((entry) => {
+        if (filter?.kind && entry.kind !== filter.kind)
+            return false;
+        if (filter?.group && entry.group !== filter.group)
+            return false;
+        return true;
+    });
+}
+//# sourceMappingURL=catalog-builder.js.map

package/dist/store/importer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Importer — Phase 7
+ *
+ * Reads all current files from an existing ACE workspace and creates a new
+ * ace-state.zarr with all content properly categorized.
+ *
+ * Used by `ace migrate` CLI command for one-time migration from file-backed
+ * workspaces to the Zarrita-backed store.
+ */
+export interface ImportResult {
+    handoffs: number;
+    todos: number;
+    ledger_events: number;
+    status_events: number;
+    vericify_posts: number;
+    warnings: string[];
+}
+export declare function importFromFileWorkspace(workspaceRoot: string, storePath: string): Promise<ImportResult>;
+//# sourceMappingURL=importer.d.ts.map

package/dist/store/importer.js

@@ -0,0 +1,157 @@
+/**
+ * Importer — Phase 7
+ *
+ * Reads all current files from an existing ACE workspace and creates a new
+ * ace-state.zarr with all content properly categorized.
+ *
+ * Used by `ace migrate` CLI command for one-time migration from file-backed
+ * workspaces to the Zarrita-backed store.
+ */
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { openStore } from "./ace-packed-store.js";
+import { HandoffRepository } from "./repositories/handoff-repository.js";
+import { TodoRepository } from "./repositories/todo-repository.js";
+import { LedgerRepository } from "./repositories/ledger-repository.js";
+import { TrackerRepository } from "./repositories/tracker-repository.js";
+import { VericifyRepository } from "./repositories/vericify-repository.js";
+function readJSON(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function readText(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function importFromFileWorkspace(workspaceRoot, storePath) {
+    const result = {
+        handoffs: 0,
+        todos: 0,
+        ledger_events: 0,
+        status_events: 0,
+        vericify_posts: 0,
+        warnings: [],
+    };
+    const store = await openStore(storePath);
+    try {
+        const handoffRepo = new HandoffRepository(store);
+        const todoRepo = new TodoRepository(store);
+        const ledgerRepo = new LedgerRepository(store);
+        const trackerRepo = new TrackerRepository(store);
+        const vericifyRepo = new VericifyRepository(store);
+        await ledgerRepo.init();
+        // ── Handoffs ──────────────────────────────────────────────────────────
+        const handoffReg = readJSON(join(workspaceRoot, "agent-state", "handoff-registry.json"));
+        if (handoffReg?.handoffs) {
+            for (const [id, data] of Object.entries(handoffReg.handoffs)) {
+                try {
+                    const h = data;
+                    await handoffRepo.create({
+                        id,
+                        from_agent: String(h.from_agent ?? h.from ?? "unknown"),
+                        to_agent: String(h.to_agent ?? h.to ?? "unknown"),
+                        status: h.status ?? "pending",
+                        summary: String(h.summary ?? h.task ?? ""),
+                        task: h.task ? String(h.task) : undefined,
+                    });
+                    result.handoffs++;
+                }
+                catch (e) {
+                    result.warnings.push(`handoff ${id}: ${e.message}`);
+                }
+            }
+        }
+        // ── Todos ─────────────────────────────────────────────────────────────
+        const todoState = readJSON(join(workspaceRoot, "agent-state", "todo-state.json"));
+        if (todoState?.todos) {
+            for (const item of todoState.todos) {
+                try {
+                    await todoRepo.create({
+                        id: String(item.id),
+                        title: String(item.title ?? item.content ?? ""),
+                        status: item.status ?? "pending",
+                        priority: item.priority,
+                        assigned_to: item.assigned_to ? String(item.assigned_to) : undefined,
+                    });
+                    result.todos++;
+                }
+                catch (e) {
+                    result.warnings.push(`todo ${item.id}: ${e.message}`);
+                }
+            }
+        }
+        // ── Run Ledger ────────────────────────────────────────────────────────
+        const ledger = readJSON(join(workspaceRoot, "agent-state", "run-ledger.json"));
+        if (ledger?.events) {
+            for (const ev of ledger.events) {
+                try {
+                    await ledgerRepo.append({
+                        kind: ev.kind ?? "note",
+                        summary: String(ev.summary ?? ev.message ?? ""),
+                        agent: ev.agent ? String(ev.agent) : undefined,
+                    });
+                    result.ledger_events++;
+                }
+                catch (e) {
+                    result.warnings.push(`ledger event: ${e.message}`);
+                }
+            }
+        }
+        // ── Status Events (NDJSON) ────────────────────────────────────────────
+        const ndjsonPath = join(workspaceRoot, "agent-state", "STATUS_EVENTS.ndjson");
+        const ndjsonContent = readText(ndjsonPath);
+        if (ndjsonContent) {
+            for (const line of ndjsonContent.split("\n").filter(Boolean)) {
+                try {
+                    const ev = JSON.parse(line);
+                    await trackerRepo.emit({
+                        kind: String(ev.kind ?? ev.type ?? "note"),
+                        summary: String(ev.summary ?? ev.message ?? ""),
+                        agent: ev.agent ? String(ev.agent) : undefined,
+                    });
+                    result.status_events++;
+                }
+                catch (e) {
+                    result.warnings.push(`status event: ${e.message}`);
+                }
+            }
+        }
+        // ── Vericify Posts ────────────────────────────────────────────────────
+        const postsFile = readJSON(join(workspaceRoot, "agent-state", "vericify", "process-posts.json"));
+        if (postsFile?.posts) {
+            for (const post of postsFile.posts) {
+                try {
+                    await vericifyRepo.appendPost({
+                        run_id: String(post.run_id ?? "migrated"),
+                        agent_id: String(post.agent_id ?? "unknown"),
+                        kind: post.kind ?? "completion",
+                        summary: String(post.summary ?? ""),
+                    });
+                    result.vericify_posts++;
+                }
+                catch (e) {
+                    result.warnings.push(`vericify post: ${e.message}`);
+                }
+            }
+        }
+        await store.commit();
+        await store.compact();
+    }
+    finally {
+        await store.close();
+    }
+    return result;
+}
+//# sourceMappingURL=importer.js.map

package/dist/store/knowledge-bake.d.ts

@@ -0,0 +1,59 @@
+/**
+ * knowledge-bake.ts
+ *
+ * Reads core assets from the npm package (assets/) and writes them into an
+ * open AcePackedStore. Called once at `ace init` time.
+ *
+ * Baked categories:
+ *   - Agent instructions (17 agents: 4 swarm + 13 composable)
+ *   - Module definitions (gates, roles, schemas)
+ *   - Kernel artifacts (DIRECTIVE_KERNEL, AGENT_REGISTRY)
+ *   - Static ACE state artifacts (TASK, STATUS, TEAL_CONFIG, runtime registries, etc.)
+ *   - Task artifacts (role packs, handoff templates, lessons seed, todo seed)
+ *   - Runtime profile seed (ACE_WORKFLOW.md)
+ *   - Skills (baked at init so the store is authoritative)
+ *   - Hook/bootstrap scripts used by turnkey materialization
+ */
+import { AcePackedStore } from "./ace-packed-store.js";
+export declare function bakeAgentInstructions(store: AcePackedStore, assetsRoot: string): Promise<{
+    agents: string[];
+    files: number;
+}>;
+export declare function bakeModules(store: AcePackedStore, assetsRoot: string): Promise<{
+    gates: number;
+    roles: number;
+    schemas: number;
+}>;
+export declare function bakeStaticStateArtifacts(store: AcePackedStore, assetsRoot: string): Promise<number>;
+export declare function bakeScripts(store: AcePackedStore, assetsRoot: string): Promise<number>;
+export declare function bakeTaskArtifacts(store: AcePackedStore, assetsRoot: string): Promise<{
+    state: number;
+    tasks: number;
+    runtime: number;
+}>;
+export declare function bakeSkillPack(store: AcePackedStore, assetsRoot: string, skillName: string): Promise<number>;
+export declare function listAvailableSkills(assetsRoot: string): Promise<string[]>;
+export declare function bakeAllCoreKnowledge(store: AcePackedStore, assetsRoot: string): Promise<{
+    agents: {
+        agents: string[];
+        files: number;
+    };
+    modules: {
+        gates: number;
+        roles: number;
+        schemas: number;
+    };
+    taskArtifacts: {
+        state: number;
+        tasks: number;
+        runtime: number;
+    };
+    skills: {
+        count: number;
+        files: number;
+    };
+    scripts: {
+        count: number;
+    };
+}>;
+//# sourceMappingURL=knowledge-bake.d.ts.map