@voybio/ace-swarm 0.1.0

package/dist/todo-state.js

@@ -0,0 +1,399 @@
+import { existsSync } from "node:fs";
+import { ACE_TASKS_ROOT_REL, resolveWorkspaceRoot, safeRead, safeWrite, wsPath } from "./helpers.js";
+import { openStore } from "./store/ace-packed-store.js";
+import { VericifyProjector } from "./store/materializers/vericify-projector.js";
+import { getWorkspaceStorePath } from "./store/store-snapshot.js";
+import { withStoreWriteQueue } from "./store/write-queue.js";
+import { isReadError, slugify } from "./shared.js";
+const TODO_MARKDOWN_REL = `${ACE_TASKS_ROOT_REL}/todo.md`;
+const TODO_STATE_REL = "agent-state/todo-state.json";
+let todoMirrorChain = Promise.resolve();
+function workspaceRoot() {
+    return resolveWorkspaceRoot();
+}
+const TRANSITIONS = {
+    backlog: ["in_progress", "blocked"],
+    in_progress: ["blocked", "gated", "done"],
+    blocked: ["backlog", "in_progress"],
+    gated: ["in_progress", "blocked", "done"],
+    done: ["in_progress", "blocked"],
+};
+function defaultState() {
+    return {
+        version: 1,
+        updated_at: new Date().toISOString(),
+        source_todo_path: TODO_MARKDOWN_REL,
+        order: [],
+        nodes: {},
+    };
+}
+function isTodoNodeStatus(value) {
+    return (value === "backlog" ||
+        value === "in_progress" ||
+        value === "blocked" ||
+        value === "gated" ||
+        value === "done");
+}
+function parseMeta(rawTitle) {
+    const metaMatch = rawTitle.match(/<!--\s*ace:(.*?)\s*-->/i);
+    const config = {};
+    const applyMetaChunks = (rawMeta) => {
+        for (const chunk of rawMeta.split(";")) {
+            const match = chunk.match(/^\s*([A-Za-z0-9_\- ]+)\s*[:=]\s*(.+?)\s*$/);
+            if (!match)
+                continue;
+            const rawKey = match[1]?.trim() ?? "";
+            const rawValue = match[2]?.trim() ?? "";
+            if (!rawKey || !rawValue)
+                continue;
+            config[rawKey.toLowerCase().replace(/\s+/g, "_")] = rawValue;
+        }
+    };
+    let cleanTitle = rawTitle.trim();
+    if (metaMatch?.[1]) {
+        applyMetaChunks(metaMatch[1]);
+        cleanTitle = cleanTitle.replace(metaMatch[0], "").trim();
+    }
+    while (true) {
+        const inlineMatch = cleanTitle.match(/\s+\(([^()]*[:=][^()]*)\)\s*$/);
+        if (!inlineMatch?.[1])
+            break;
+        const before = cleanTitle.slice(0, cleanTitle.length - inlineMatch[0].length).trimEnd();
+        const priorConfigSize = Object.keys(config).length;
+        applyMetaChunks(inlineMatch[1]);
+        if (Object.keys(config).length === priorConfigSize)
+            break;
+        cleanTitle = before;
+    }
+    const dependsOn = (config.depends_on ?? config.depends ?? "")
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return {
+        cleanTitle: cleanTitle.trim(),
+        id: config.id,
+        depends_on: dependsOn,
+    };
+}
+function defaultStatusFor(section, checked) {
+    if (checked)
+        return "done";
+    const lower = section.toLowerCase();
+    if (lower.includes("verification"))
+        return "gated";
+    if (lower.includes("active"))
+        return "in_progress";
+    return "backlog";
+}
+function parseTodoMarkdown(todoRaw) {
+    const entries = [];
+    const activeIds = [];
+    const verificationIndexes = [];
+    let section = "General";
+    for (const [idx, line] of todoRaw.split(/\r?\n/).entries()) {
+        const header = line.match(/^##\s+(.+)$/);
+        if (header?.[1]) {
+            section = header[1].trim();
+            continue;
+        }
+        const item = line.match(/^- \[( |x|X)\]\s+(.+)$/);
+        if (!item?.[2])
+            continue;
+        const checked = item[1]?.toLowerCase() === "x";
+        const rawTitle = item[2].trim();
+        const meta = parseMeta(rawTitle);
+        const lineNumber = idx + 1;
+        const id = (meta.id && meta.id.trim()) || `todo-${lineNumber}-${slugify(meta.cleanTitle)}`;
+        const row = {
+            id,
+            title: meta.cleanTitle || "Untitled task",
+            section,
+            line: lineNumber,
+            checked,
+            default_status: defaultStatusFor(section, checked),
+            depends_on: meta.depends_on,
+        };
+        if (section.toLowerCase().includes("active work")) {
+            activeIds.push(id);
+        }
+        if (section.toLowerCase().includes("verification") && row.depends_on.length === 0) {
+            verificationIndexes.push(entries.length);
+        }
+        entries.push(row);
+    }
+    for (const idx of verificationIndexes) {
+        const node = entries[idx];
+        if (!node)
+            continue;
+        node.depends_on = [...activeIds];
+    }
+    return entries;
+}
+function parseTodoState(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return undefined;
+        }
+        const candidate = parsed;
+        if (candidate.version !== 1 ||
+            typeof candidate.source_todo_path !== "string" ||
+            !Array.isArray(candidate.order) ||
+            !candidate.nodes ||
+            typeof candidate.nodes !== "object") {
+            return undefined;
+        }
+        const nodes = {};
+        for (const [key, value] of Object.entries(candidate.nodes)) {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                continue;
+            const row = value;
+            if (typeof row.id !== "string" ||
+                typeof row.title !== "string" ||
+                typeof row.section !== "string" ||
+                typeof row.source_line !== "number" ||
+                !Array.isArray(row.depends_on) ||
+                typeof row.status !== "string" ||
+                !isTodoNodeStatus(row.status)) {
+                continue;
+            }
+            nodes[key] = {
+                id: row.id,
+                title: row.title,
+                section: row.section,
+                source_line: row.source_line,
+                depends_on: row.depends_on.filter((dep) => typeof dep === "string"),
+                status: row.status,
+            };
+        }
+        return {
+            version: 1,
+            updated_at: typeof candidate.updated_at === "string"
+                ? candidate.updated_at
+                : new Date().toISOString(),
+            source_todo_path: candidate.source_todo_path,
+            order: candidate.order.filter((id) => typeof id === "string"),
+            nodes,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function readPersistedState() {
+    const raw = safeRead(TODO_STATE_REL);
+    if (isReadError(raw))
+        return defaultState();
+    return parseTodoState(raw) ?? defaultState();
+}
+function mapStoreStatus(status) {
+    switch (status) {
+        case "in_progress":
+            return "in_progress";
+        case "blocked":
+            return "blocked";
+        case "done":
+            return "done";
+        case "gated":
+        case "backlog":
+        default:
+            return "pending";
+    }
+}
+async function mirrorTodoStateToStore(state) {
+    const root = workspaceRoot();
+    const storePath = getWorkspaceStorePath(root);
+    if (!existsSync(storePath))
+        return;
+    await withStoreWriteQueue(storePath, async () => {
+        const store = await openStore(storePath);
+        try {
+            const nextIds = state.order.filter((id) => Boolean(state.nodes[id]));
+            const previousIds = (await store.getJSON("state/todo/index")) ?? [];
+            for (const staleId of previousIds.filter((id) => !nextIds.includes(id))) {
+                await store.delete(`state/todo/${staleId}`);
+            }
+            for (const id of nextIds) {
+                const node = state.nodes[id];
+                if (!node)
+                    continue;
+                const existing = await store.getJSON(`state/todo/${id}`);
+                await store.setJSON(`state/todo/${id}`, {
+                    id: node.id,
+                    title: node.title,
+                    status: mapStoreStatus(node.status),
+                    depends_on: node.depends_on,
+                    created_at: existing?.created_at ?? Date.now(),
+                    updated_at: Date.now(),
+                    notes: node.section ? `section: ${node.section}` : undefined,
+                });
+            }
+            await store.setJSON("state/todo/index", nextIds);
+            await store.commit();
+            const projector = new VericifyProjector(store, root);
+            await projector.projectTodos();
+            await store.commit();
+        }
+        finally {
+            await store.close();
+        }
+    });
+}
+function scheduleTodoMirror(state) {
+    const snapshot = JSON.parse(JSON.stringify(state));
+    todoMirrorChain = todoMirrorChain
+        .catch(() => { })
+        .then(() => mirrorTodoStateToStore(snapshot))
+        .catch(() => { });
+}
+export async function waitForTodoStoreMirror() {
+    await todoMirrorChain.catch(() => { });
+}
+function writeState(state) {
+    state.updated_at = new Date().toISOString();
+    const path = safeWrite(TODO_STATE_REL, JSON.stringify(state, null, 2));
+    scheduleTodoMirror(state);
+    return path;
+}
+function syncStateWithTodo(todoRaw, previous) {
+    const parsed = parseTodoMarkdown(todoRaw);
+    const nodes = {};
+    const order = [];
+    for (const row of parsed) {
+        const prev = previous.nodes[row.id];
+        let status;
+        if (row.checked) {
+            status = "done";
+        }
+        else if (prev && prev.status !== "done") {
+            status = prev.status;
+        }
+        else {
+            status = row.default_status;
+        }
+        nodes[row.id] = {
+            id: row.id,
+            title: row.title,
+            section: row.section,
+            source_line: row.line,
+            depends_on: row.depends_on.filter((dep) => dep !== row.id),
+            status,
+        };
+        order.push(row.id);
+    }
+    return {
+        version: 1,
+        updated_at: new Date().toISOString(),
+        source_todo_path: TODO_MARKDOWN_REL,
+        order,
+        nodes,
+    };
+}
+function setTodoCheckbox(todoRaw, line, checked) {
+    const lines = todoRaw.split(/\r?\n/);
+    const target = lines[line - 1];
+    if (!target)
+        return todoRaw;
+    lines[line - 1] = target.replace(/^- \[( |x|X)\]/, `- [${checked ? "x" : " "}]`);
+    return lines.join("\n");
+}
+function getTodoPath() {
+    return wsPath(TODO_MARKDOWN_REL);
+}
+export function getTodoStatePath() {
+    return wsPath(TODO_STATE_REL);
+}
+export function syncTodoState(todoContent) {
+    const todoRaw = typeof todoContent === "string" ? todoContent : safeRead(TODO_MARKDOWN_REL);
+    if (isReadError(todoRaw)) {
+        const path = writeState(defaultState());
+        return { state: defaultState(), path };
+    }
+    const state = syncStateWithTodo(todoRaw, readPersistedState());
+    const path = writeState(state);
+    return { state, path };
+}
+export async function syncTodoStateSafe(todoContent) {
+    const result = syncTodoState(todoContent);
+    await waitForTodoStoreMirror();
+    return result;
+}
+export function readTodoState() {
+    const todoRaw = safeRead(TODO_MARKDOWN_REL);
+    if (isReadError(todoRaw))
+        return readPersistedState();
+    const previous = readPersistedState();
+    return syncStateWithTodo(todoRaw, previous);
+}
+export function transitionTodoNode(nodeId, targetStatus) {
+    const todoRaw = safeRead(TODO_MARKDOWN_REL);
+    if (isReadError(todoRaw)) {
+        return {
+            ok: false,
+            path: getTodoStatePath(),
+            todo_path: getTodoPath(),
+            error: `${TODO_MARKDOWN_REL} not found; cannot apply transition.`,
+        };
+    }
+    const synced = syncStateWithTodo(todoRaw, readPersistedState());
+    const node = synced.nodes[nodeId];
+    if (!node) {
+        return {
+            ok: false,
+            path: getTodoStatePath(),
+            todo_path: getTodoPath(),
+            error: `Unknown node_id: ${nodeId}`,
+        };
+    }
+    const from = node.status;
+    if (from !== targetStatus) {
+        const allowed = TRANSITIONS[from];
+        if (!allowed.includes(targetStatus)) {
+            return {
+                ok: false,
+                path: getTodoStatePath(),
+                todo_path: getTodoPath(),
+                node_id: nodeId,
+                from,
+                to: targetStatus,
+                allowed,
+                error: `Invalid transition ${from} -> ${targetStatus}`,
+            };
+        }
+    }
+    if (targetStatus === "in_progress" ||
+        targetStatus === "gated" ||
+        targetStatus === "done") {
+        const unresolved = node.depends_on.filter((depId) => synced.nodes[depId]?.status !== "done");
+        if (unresolved.length > 0) {
+            return {
+                ok: false,
+                path: getTodoStatePath(),
+                todo_path: getTodoPath(),
+                node_id: nodeId,
+                from,
+                to: targetStatus,
+                unresolved_dependencies: unresolved,
+                error: `Dependencies not satisfied for ${nodeId}`,
+            };
+        }
+    }
+    node.status = targetStatus;
+    const statePath = writeState(synced);
+    const updatedTodo = setTodoCheckbox(todoRaw, node.source_line, targetStatus === "done");
+    safeWrite(TODO_MARKDOWN_REL, updatedTodo);
+    return {
+        ok: true,
+        path: statePath,
+        todo_path: getTodoPath(),
+        node_id: nodeId,
+        from,
+        to: targetStatus,
+    };
+}
+export async function transitionTodoNodeSafe(nodeId, targetStatus) {
+    const result = transitionTodoNode(nodeId, targetStatus);
+    await waitForTodoStoreMirror();
+    return result;
+}
+//# sourceMappingURL=todo-state.js.map

package/dist/tools-agent.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Agent, skill, kernel, and task-pack tool registrations.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export type { TaskPlan, TaskStep } from "./orchestrator-supervisor.js";
+export declare function registerAgentTools(server: McpServer): void;
+//# sourceMappingURL=tools-agent.d.ts.map