@voybio/ace-swarm 0.2.4 → 2.4.0

package/dist/internal-tool-runtime.js

@@ -1,136 +0,0 @@
-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

package/dist/store/workspace-snapshot.d.ts

@@ -1,26 +0,0 @@
-export interface WorkspaceSnapshotFileRecord {
-    path: string;
-    size: number;
-    mtime_ms: number;
-    encoding: "utf8" | "base64";
-    key: string;
-    virtual_path: string;
-}
-export interface WorkspaceSnapshotResult {
-    version: 1;
-    captured_at: string;
-    session_id: string;
-    source_workspace_path: string;
-    virtual_root: string;
-    manifest_key: string;
-    manifest_path: string;
-    file_count: number;
-    files: WorkspaceSnapshotFileRecord[];
-    skipped_paths: Array<{
-        path: string;
-        reason: string;
-    }>;
-}
-export declare function workspaceSnapshotVirtualRoot(workspaceRoot: string, sessionId: string): string;
-export declare function persistWorkspaceSnapshot(workspaceRoot: string, sessionId: string, sourceWorkspacePath: string): Promise<WorkspaceSnapshotResult>;
-//# sourceMappingURL=workspace-snapshot.d.ts.map

package/dist/store/workspace-snapshot.js

@@ -1,107 +0,0 @@
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { relative, resolve, sep } from "node:path";
-import { openStore } from "./ace-packed-store.js";
-import { getWorkspaceStorePath, toVirtualStorePath } from "./store-snapshot.js";
-import { withStoreWriteQueue } from "./write-queue.js";
-function normalizeRelPath(path) {
-    return path.split(sep).join("/");
-}
-function workspaceSnapshotPrefix(sessionId) {
-    return `state/runtime/executor/sessions/${sessionId}/workspace`;
-}
-function workspaceSnapshotFileKey(sessionId, relPath) {
-    return `${workspaceSnapshotPrefix(sessionId)}/files/${normalizeRelPath(relPath)}`;
-}
-function workspaceSnapshotManifestKey(sessionId) {
-    return `${workspaceSnapshotPrefix(sessionId)}/manifest.json`;
-}
-function encodeBuffer(content) {
-    const utf8 = content.toString("utf8");
-    if (Buffer.from(utf8, "utf8").equals(content)) {
-        return { encoding: "utf8", body: utf8 };
-    }
-    return { encoding: "base64", body: content.toString("base64") };
-}
-function collectWorkspaceFiles(rootPath, currentPath, output, skipped) {
-    const entries = readdirSync(currentPath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-        const absPath = resolve(currentPath, entry.name);
-        const relPath = normalizeRelPath(relative(rootPath, absPath));
-        if (entry.isSymbolicLink()) {
-            skipped.push({ path: relPath, reason: "symlink" });
-            continue;
-        }
-        if (entry.isDirectory()) {
-            collectWorkspaceFiles(rootPath, absPath, output, skipped);
-            continue;
-        }
-        if (entry.isFile()) {
-            output.push({ absPath, relPath });
-            continue;
-        }
-        skipped.push({ path: relPath, reason: "unsupported_entry_type" });
-    }
-}
-export function workspaceSnapshotVirtualRoot(workspaceRoot, sessionId) {
-    return toVirtualStorePath(getWorkspaceStorePath(workspaceRoot), workspaceSnapshotPrefix(sessionId));
-}
-export async function persistWorkspaceSnapshot(workspaceRoot, sessionId, sourceWorkspacePath) {
-    const files = [];
-    const skipped = [];
-    collectWorkspaceFiles(sourceWorkspacePath, sourceWorkspacePath, files, skipped);
-    const storePath = getWorkspaceStorePath(workspaceRoot);
-    const manifestKey = workspaceSnapshotManifestKey(sessionId);
-    const virtualRoot = workspaceSnapshotVirtualRoot(workspaceRoot, sessionId);
-    const capturedAt = new Date().toISOString();
-    const manifestFiles = [];
-    await withStoreWriteQueue(storePath, async () => {
-        const store = await openStore(storePath);
-        try {
-            for (const file of files) {
-                const content = readFileSync(file.absPath);
-                const stats = statSync(file.absPath);
-                const encoded = encodeBuffer(content);
-                const key = workspaceSnapshotFileKey(sessionId, file.relPath);
-                await store.setBlob(key, encoded.body);
-                manifestFiles.push({
-                    path: file.relPath,
-                    size: stats.size,
-                    mtime_ms: stats.mtimeMs,
-                    encoding: encoded.encoding,
-                    key,
-                    virtual_path: toVirtualStorePath(storePath, key),
-                });
-            }
-            const manifest = {
-                version: 1,
-                captured_at: capturedAt,
-                session_id: sessionId,
-                source_workspace_path: sourceWorkspacePath,
-                virtual_root: virtualRoot,
-                manifest_key: manifestKey,
-                manifest_path: toVirtualStorePath(storePath, manifestKey),
-                file_count: manifestFiles.length,
-                files: manifestFiles,
-                skipped_paths: skipped,
-            };
-            await store.setJSON(manifestKey, manifest);
-            await store.commit();
-        }
-        finally {
-            await store.close();
-        }
-    });
-    return {
-        version: 1,
-        captured_at: capturedAt,
-        session_id: sessionId,
-        source_workspace_path: sourceWorkspacePath,
-        virtual_root: virtualRoot,
-        manifest_key: manifestKey,
-        manifest_path: toVirtualStorePath(storePath, manifestKey),
-        file_count: manifestFiles.length,
-        files: manifestFiles,
-        skipped_paths: skipped,
-    };
-}
-//# sourceMappingURL=workspace-snapshot.js.map