@voybio/ace-swarm 0.1.0

package/dist/index-store.d.ts

@@ -0,0 +1,51 @@
+export interface IndexedFileEntry {
+    size: number;
+    mtime_ms: number;
+    fingerprint: string;
+}
+export interface IndexSnapshot {
+    version: 1;
+    root: string;
+    generated_at: string;
+    discovery: {
+        mode: "ast_grep_commands";
+        command_pack: string;
+        subagent: string;
+        skill: string;
+        fingerprint_store: string;
+    };
+    options: {
+        depth: number;
+        max_files: number;
+        include_hidden: boolean;
+        exclude: string[];
+        file_entry_cap: number;
+    };
+    file_count: number;
+    stored_file_count: number;
+    directories: Record<string, number>;
+    extensions: Record<string, number>;
+    files: Record<string, IndexedFileEntry>;
+}
+export interface DeltaScanResult {
+    index_path: string;
+    fingerprint_path: string;
+    snapshot: IndexSnapshot;
+    changed: string[];
+    unchanged: string[];
+    deleted: string[];
+    truncated: boolean;
+    scanned_count: number;
+}
+export interface ScanWorkspaceDeltaInput {
+    path?: string;
+    depth?: number;
+    max_files?: number;
+    include_hidden?: boolean;
+    exclude?: string[];
+    file_entry_cap?: number;
+    index_path?: string;
+}
+export declare function scanWorkspaceDelta(input?: ScanWorkspaceDeltaInput): DeltaScanResult;
+export declare function getDefaultIndexPath(): string;
+//# sourceMappingURL=index-store.d.ts.map

package/dist/index-store.js

@@ -0,0 +1,328 @@
+import { readdirSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { safeRead, safeWrite, WORKSPACE_ROOT, wsPath } from "./helpers.js";
+import { isReadError, isInside, normalizeRelPath } from "./shared.js";
+const DEFAULT_INDEX_REL = "agent-state/index.json";
+const DEFAULT_FINGERPRINT_INDEX_REL = "agent-state/index-fingerprints.json";
+const DEFAULT_EXCLUDES = [
+    ".git",
+    "node_modules",
+    "dist",
+    "target",
+    ".venv",
+    "__pycache__",
+    ".DS_Store",
+];
+const DEFAULT_FILE_ENTRY_CAP = 0;
+const DEFAULT_DISCOVERY = {
+    mode: "ast_grep_commands",
+    command_pack: "agent-state/AST_GREP_COMMANDS.md",
+    subagent: "astgrep",
+    skill: "astgrep-index",
+    fingerprint_store: DEFAULT_FINGERPRINT_INDEX_REL,
+};
+function parseSnapshot(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.root !== "string" ||
+            typeof candidate.generated_at !== "string" ||
+            typeof candidate.file_count !== "number" ||
+            !candidate.files ||
+            typeof candidate.files !== "object") {
+            return undefined;
+        }
+        const files = {};
+        for (const [filePath, value] of Object.entries(candidate.files)) {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                continue;
+            const row = value;
+            if (typeof row.size !== "number" ||
+                typeof row.mtime_ms !== "number" ||
+                typeof row.fingerprint !== "string") {
+                continue;
+            }
+            files[filePath] = {
+                size: row.size,
+                mtime_ms: row.mtime_ms,
+                fingerprint: row.fingerprint,
+            };
+        }
+        const parseCounts = (value) => {
+            if (!value || typeof value !== "object" || Array.isArray(value)) {
+                return {};
+            }
+            const output = {};
+            for (const [key, count] of Object.entries(value)) {
+                if (typeof count === "number" && Number.isFinite(count) && count >= 0) {
+                    output[key] = count;
+                }
+            }
+            return output;
+        };
+        const directories = parseCounts(candidate.directories);
+        const extensions = parseCounts(candidate.extensions);
+        const storedFileCount = (() => {
+            if (typeof candidate.stored_file_count === "number" &&
+                Number.isFinite(candidate.stored_file_count) &&
+                candidate.stored_file_count >= 0) {
+                return candidate.stored_file_count;
+            }
+            return Object.keys(files).length;
+        })();
+        return {
+            version: 1,
+            root: candidate.root,
+            generated_at: candidate.generated_at,
+            discovery: {
+                ...DEFAULT_DISCOVERY,
+                fingerprint_store: typeof candidate.discovery?.fingerprint_store === "string"
+                    ? candidate.discovery.fingerprint_store
+                    : DEFAULT_DISCOVERY.fingerprint_store,
+            },
+            options: {
+                depth: candidate.options?.depth ?? 6,
+                max_files: candidate.options?.max_files ?? 10000,
+                include_hidden: candidate.options?.include_hidden ?? false,
+                exclude: Array.isArray(candidate.options?.exclude)
+                    ? candidate.options?.exclude.filter((name) => typeof name === "string")
+                    : DEFAULT_EXCLUDES,
+                file_entry_cap: candidate.options?.file_entry_cap ?? DEFAULT_FILE_ENTRY_CAP,
+            },
+            file_count: candidate.file_count,
+            stored_file_count: storedFileCount,
+            directories,
+            extensions,
+            files,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseFingerprintSnapshot(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.root !== "string" ||
+            typeof candidate.generated_at !== "string" ||
+            typeof candidate.file_count !== "number" ||
+            !candidate.fingerprints ||
+            typeof candidate.fingerprints !== "object" ||
+            Array.isArray(candidate.fingerprints)) {
+            return undefined;
+        }
+        const fingerprints = {};
+        for (const [path, fingerprint] of Object.entries(candidate.fingerprints)) {
+            if (typeof fingerprint === "string") {
+                fingerprints[path] = fingerprint;
+            }
+        }
+        return {
+            version: 1,
+            root: candidate.root,
+            generated_at: candidate.generated_at,
+            file_count: candidate.file_count,
+            fingerprints,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function fileFingerprint(size, mtimeMs) {
+    return `${size}:${Math.floor(mtimeMs)}`;
+}
+function fileExtension(name) {
+    const dot = name.lastIndexOf(".");
+    if (dot <= 0 || dot === name.length - 1)
+        return "[no_ext]";
+    return name.slice(dot + 1).toLowerCase();
+}
+function sortCountMap(input) {
+    return Object.fromEntries(Object.entries(input).sort((a, b) => a[0].localeCompare(b[0])));
+}
+function shouldSkipName(name, includeHidden, excludeSet) {
+    if (!includeHidden && name.startsWith(".")) {
+        return true;
+    }
+    return excludeSet.has(name);
+}
+function readPriorIndex(indexPath) {
+    const raw = safeRead(indexPath);
+    if (isReadError(raw)) {
+        return undefined;
+    }
+    return parseSnapshot(raw);
+}
+function readPriorFingerprints(fingerprintPath) {
+    const raw = safeRead(fingerprintPath);
+    if (isReadError(raw))
+        return undefined;
+    return parseFingerprintSnapshot(raw)?.fingerprints;
+}
+function buildSnapshot(input) {
+    const depth = input.depth ?? 6;
+    const maxFiles = input.max_files ?? 10000;
+    const includeHidden = input.include_hidden ?? false;
+    const fileEntryCap = input.file_entry_cap ?? DEFAULT_FILE_ENTRY_CAP;
+    const exclude = input.exclude?.length ? input.exclude : DEFAULT_EXCLUDES;
+    const excludeSet = new Set(exclude);
+    const requestedRoot = normalizeRelPath(input.path ?? ".");
+    const rootRel = requestedRoot === "" ? "." : requestedRoot;
+    const rootAbs = resolve(WORKSPACE_ROOT, rootRel);
+    if (!isInside(WORKSPACE_ROOT, rootAbs)) {
+        throw new Error(`Path escapes workspace root: ${rootRel}`);
+    }
+    const files = {};
+    const fingerprints = {};
+    const directories = {};
+    const extensions = {};
+    let scanned = 0;
+    let stored = 0;
+    let truncated = false;
+    function walk(currentAbs, currentRel, remainingDepth) {
+        if (truncated || remainingDepth < 0)
+            return;
+        const entries = readdirSync(currentAbs, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (truncated)
+                return;
+            if (shouldSkipName(entry.name, includeHidden, excludeSet))
+                continue;
+            const entryAbs = resolve(currentAbs, entry.name);
+            const entryRel = currentRel ? `${currentRel}/${entry.name}` : entry.name;
+            const normalized = normalizeRelPath(entryRel);
+            if (entry.isDirectory()) {
+                walk(entryAbs, normalized, remainingDepth - 1);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            if (scanned >= maxFiles) {
+                truncated = true;
+                return;
+            }
+            const stats = statSync(entryAbs);
+            const fingerprint = fileFingerprint(stats.size, stats.mtimeMs);
+            const topLevel = normalized.includes("/") ? normalized.split("/")[0] : normalized;
+            directories[topLevel] = (directories[topLevel] ?? 0) + 1;
+            const ext = fileExtension(entry.name);
+            extensions[ext] = (extensions[ext] ?? 0) + 1;
+            fingerprints[normalized] = fingerprint;
+            if (stored < fileEntryCap) {
+                files[normalized] = {
+                    size: stats.size,
+                    mtime_ms: stats.mtimeMs,
+                    fingerprint,
+                };
+                stored += 1;
+            }
+            scanned += 1;
+        }
+    }
+    walk(rootAbs, rootRel === "." ? "" : rootRel, depth);
+    const snapshot = {
+        version: 1,
+        root: rootRel,
+        generated_at: new Date().toISOString(),
+        discovery: {
+            ...DEFAULT_DISCOVERY,
+            // Use the actual fingerprint store path so custom indexes report
+            // accurate metadata instead of always claiming the default store.
+            fingerprint_store: input.index_path
+                ? (/\.json$/.test(normalizeRelPath(input.index_path))
+                    ? normalizeRelPath(input.index_path).replace(/\.json$/, "-fingerprints.json")
+                    : `${normalizeRelPath(input.index_path)}-fingerprints.json`)
+                : DEFAULT_DISCOVERY.fingerprint_store,
+        },
+        options: {
+            depth,
+            max_files: maxFiles,
+            include_hidden: includeHidden,
+            exclude,
+            file_entry_cap: fileEntryCap,
+        },
+        file_count: scanned,
+        stored_file_count: stored,
+        directories: sortCountMap(directories),
+        extensions: sortCountMap(extensions),
+        files,
+    };
+    return { snapshot, fingerprints, truncated, scanned_count: scanned };
+}
+export function scanWorkspaceDelta(input = {}) {
+    const indexRel = normalizeRelPath(input.index_path ?? DEFAULT_INDEX_REL);
+    // Derive fingerprint path from the index path to avoid cross-scope contamination.
+    // If a custom index_path is provided (e.g. "agent-state/index-src.json"), the
+    // fingerprint store becomes "agent-state/index-src-fingerprints.json".
+    // Guard: if the path has no .json extension, append "-fingerprints.json" to
+    // avoid index and fingerprint paths colliding (which would overwrite the index).
+    const fingerprintRel = indexRel === normalizeRelPath(DEFAULT_INDEX_REL)
+        ? DEFAULT_DISCOVERY.fingerprint_store
+        : /\.json$/.test(indexRel)
+            ? indexRel.replace(/\.json$/, "-fingerprints.json")
+            : `${indexRel}-fingerprints.json`;
+    const previous = readPriorIndex(indexRel);
+    const previousFingerprints = readPriorFingerprints(fingerprintRel) ??
+        (() => {
+            const fallback = {};
+            const previousFiles = previous?.files ?? {};
+            for (const [path, row] of Object.entries(previousFiles)) {
+                fallback[path] = row.fingerprint;
+            }
+            return fallback;
+        })();
+    const { snapshot, fingerprints, truncated, scanned_count } = buildSnapshot(input);
+    const changed = [];
+    const unchanged = [];
+    const deleted = [];
+    for (const [path, nextFingerprint] of Object.entries(fingerprints)) {
+        const oldFingerprint = previousFingerprints[path];
+        if (!oldFingerprint || oldFingerprint !== nextFingerprint) {
+            changed.push(path);
+        }
+        else {
+            unchanged.push(path);
+        }
+    }
+    for (const oldPath of Object.keys(previousFingerprints)) {
+        if (!fingerprints[oldPath]) {
+            deleted.push(oldPath);
+        }
+    }
+    changed.sort((a, b) => a.localeCompare(b));
+    unchanged.sort((a, b) => a.localeCompare(b));
+    deleted.sort((a, b) => a.localeCompare(b));
+    const indexPath = safeWrite(indexRel, JSON.stringify(snapshot, null, 2));
+    const fingerprintPath = safeWrite(fingerprintRel, JSON.stringify({
+        version: 1,
+        root: snapshot.root,
+        generated_at: snapshot.generated_at,
+        file_count: snapshot.file_count,
+        fingerprints,
+    }, null, 2));
+    return {
+        index_path: indexPath,
+        fingerprint_path: fingerprintPath,
+        snapshot,
+        changed,
+        unchanged,
+        deleted,
+        truncated,
+        scanned_count,
+    };
+}
+export function getDefaultIndexPath() {
+    return wsPath(DEFAULT_INDEX_REL);
+}
+//# sourceMappingURL=index-store.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { startStdioServer } from "./server.js";
+startStdioServer().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/internal-tool-runtime.d.ts

@@ -0,0 +1,21 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export interface InternalToolDescriptor {
+    name: string;
+    description: string;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+}
+export interface InternalToolExecutionContext {
+    sessionId?: string;
+}
+export interface InternalToolExecutionResult {
+    ok: boolean;
+    name: string;
+    summary: string;
+    result?: CallToolResult;
+    error?: string;
+}
+export declare function listInternalTools(toolScope?: string[]): InternalToolDescriptor[];
+export declare function executeInternalTool(name: string, args?: Record<string, unknown>, context?: InternalToolExecutionContext): Promise<InternalToolExecutionResult>;
+export declare function resetInternalToolRuntime(): void;
+//# sourceMappingURL=internal-tool-runtime.d.ts.map

package/dist/internal-tool-runtime.js

@@ -0,0 +1,136 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { createAceServer } from "./server.js";
+function isPlainObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isZodSchema(value) {
+    return Boolean(value) && typeof value === "object" && "safeParseAsync" in value;
+}
+function buildZodObject(shape) {
+    if (!isPlainObject(shape))
+        return undefined;
+    const values = Object.values(shape);
+    if (!values.every((value) => isZodSchema(value)))
+        return undefined;
+    return z.object(shape);
+}
+function describeSchema(schema) {
+    if (isPlainObject(schema)) {
+        const properties = Object.fromEntries(Object.entries(schema).map(([key, value]) => [
+            key,
+            {
+                description: isZodSchema(value)
+                    ? value.description ?? value._def?.typeName ?? "input"
+                    : "input",
+            },
+        ]));
+        return { type: "object", properties };
+    }
+    if (isZodSchema(schema)) {
+        return {
+            type: schema._def?.typeName ?? "schema",
+            description: schema.description ?? "tool input",
+        };
+    }
+    return undefined;
+}
+function summarizeResult(name, result) {
+    const textBlocks = Array.isArray(result.content)
+        ? result.content
+            .filter((entry) => {
+            return isPlainObject(entry) && entry.type === "text" && typeof entry.text === "string";
+        })
+            .map((entry) => entry.text.trim())
+            .filter(Boolean)
+        : [];
+    const summary = textBlocks[0] ?? `${name} completed`;
+    return summary.length <= 240 ? summary : `${summary.slice(0, 239).trimEnd()}…`;
+}
+let cachedTools;
+function getRegisteredTools() {
+    if (cachedTools)
+        return cachedTools;
+    const server = createAceServer({ toolGovernance: false });
+    const registry = server
+        ._registeredTools;
+    cachedTools = new Map(Object.entries(registry ?? {}).filter(([, tool]) => tool.enabled !== false));
+    return cachedTools;
+}
+export function listInternalTools(toolScope) {
+    const allowed = toolScope ? new Set(toolScope) : undefined;
+    return [...getRegisteredTools().entries()]
+        .filter(([name]) => !allowed || allowed.has(name))
+        .map(([name, tool]) => ({
+        name,
+        description: tool.description ?? tool.title ?? "ACE MCP tool",
+        inputSchema: describeSchema(tool.inputSchema),
+        outputSchema: describeSchema(tool.outputSchema),
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+export async function executeInternalTool(name, args = {}, context = {}) {
+    const tool = getRegisteredTools().get(name);
+    if (!tool) {
+        return {
+            ok: false,
+            name,
+            summary: `Unknown tool: ${name}`,
+            error: `Unknown tool: ${name}`,
+        };
+    }
+    let validatedArgs = args;
+    try {
+        if (tool.inputSchema) {
+            const schema = isZodSchema(tool.inputSchema) ? tool.inputSchema : buildZodObject(tool.inputSchema);
+            if (schema) {
+                const parsed = await schema.safeParseAsync(args);
+                if (!parsed.success) {
+                    const message = parsed.error.issues.map((issue) => issue.message).join("; ");
+                    return {
+                        ok: false,
+                        name,
+                        summary: `Input validation failed for ${name}`,
+                        error: message,
+                    };
+                }
+                if (isPlainObject(parsed.data)) {
+                    validatedArgs = parsed.data;
+                }
+            }
+        }
+        const extra = {
+            signal: new AbortController().signal,
+            sessionId: context.sessionId ?? `internal-${randomUUID()}`,
+            requestId: `internal-${randomUUID()}`,
+            sendNotification: async () => undefined,
+            sendRequest: async () => {
+                throw new Error("Internal tool runtime does not support nested MCP requests.");
+            },
+        };
+        const raw = tool.inputSchema
+            ? await tool.handler(validatedArgs, extra)
+            : await tool.handler(extra);
+        const result = raw;
+        return {
+            ok: !Boolean(result?.isError),
+            name,
+            summary: summarizeResult(name, result),
+            result,
+            error: result.isError ? summarizeResult(name, result) : undefined,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            name,
+            summary: `${name} failed`,
+            error: message,
+        };
+    }
+}
+export function resetInternalToolRuntime() {
+    cachedTools = undefined;
+}
+//# sourceMappingURL=internal-tool-runtime.js.map