@mcoda/mswarm 0.1.57 → 0.1.61

package/dist/vendor/codali/tools/docdex/DocdexTools.js

@@ -0,0 +1,490 @@
+const toOutput = (payload) => ({
+    output: typeof payload === "string" ? payload : JSON.stringify(payload, null, 2),
+    data: payload,
+});
+export const createDocdexTools = (client) => [
+    {
+        name: "docdex_health",
+        description: "Check docdex healthz endpoint.",
+        inputSchema: { type: "object", properties: {} },
+        handler: async () => {
+            const ok = await client.healthCheck();
+            return toOutput({ ok });
+        },
+    },
+    {
+        name: "docdex_initialize",
+        description: "Initialize docdex repo binding.",
+        inputSchema: {
+            type: "object",
+            required: ["rootUri"],
+            properties: {
+                rootUri: { type: "string" },
+            },
+        },
+        handler: async (args) => {
+            const { rootUri } = args;
+            const result = await client.initialize(rootUri);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_search",
+        description: "Search docdex index.",
+        inputSchema: {
+            type: "object",
+            required: ["query"],
+            properties: {
+                query: { type: "string" },
+                limit: { type: "number" },
+            },
+        },
+        handler: async (args) => {
+            const { query, limit } = args;
+            const result = await client.search(query, { limit });
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_open",
+        description: "Open a file by path or fetch a snippet by doc id.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                docId: { type: "string" },
+                path: { type: "string" },
+                window: { type: "number" },
+                textOnly: { type: "boolean" },
+                startLine: { type: "number" },
+                endLine: { type: "number" },
+                head: { type: "number" },
+                clamp: { type: "boolean" },
+            },
+        },
+        handler: async (args) => {
+            const { docId, path, window, textOnly, startLine, endLine, head, clamp } = args;
+            if (path) {
+                const result = await client.openFile(path, { startLine, endLine, head, clamp });
+                return toOutput(result);
+            }
+            if (!docId) {
+                throw new Error("docdex_open requires either docId or path");
+            }
+            const result = await client.openSnippet(docId, { window, textOnly });
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_symbols",
+        description: "Fetch docdex symbols for a file.",
+        inputSchema: {
+            type: "object",
+            required: ["path"],
+            properties: {
+                path: { type: "string" },
+            },
+        },
+        handler: async (args) => {
+            const { path } = args;
+            const result = await client.symbols(path);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_ast",
+        description: "Fetch docdex AST nodes for a file.",
+        inputSchema: {
+            type: "object",
+            required: ["path"],
+            properties: {
+                path: { type: "string" },
+                maxNodes: { type: "number" },
+            },
+        },
+        handler: async (args) => {
+            const { path, maxNodes } = args;
+            const result = await client.ast(path, maxNodes);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_impact_graph",
+        description: "Fetch docdex impact graph for a file.",
+        inputSchema: {
+            type: "object",
+            required: ["file"],
+            properties: {
+                file: { type: "string" },
+                maxDepth: { type: "number" },
+                maxEdges: { type: "number" },
+                edgeTypes: { type: "array", items: { type: "string" } },
+            },
+        },
+        handler: async (args) => {
+            const { file, maxDepth, maxEdges, edgeTypes } = args;
+            const result = await client.impactGraph(file, { maxDepth, maxEdges, edgeTypes });
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_impact_diagnostics",
+        description: "Fetch docdex impact diagnostics (dynamic imports).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                file: { type: "string" },
+                limit: { type: "number" },
+                offset: { type: "number" },
+            },
+        },
+        handler: async (args) => {
+            const { file, limit, offset } = args;
+            const result = await client.impactDiagnostics({ file, limit, offset });
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_dag_export",
+        description: "Export docdex DAG for a session.",
+        inputSchema: {
+            type: "object",
+            required: ["sessionId"],
+            properties: {
+                sessionId: { type: "string" },
+                format: { type: "string" },
+                maxNodes: { type: "number" },
+            },
+        },
+        handler: async (args) => {
+            const { sessionId, format, maxNodes } = args;
+            const result = await client.dagExport(sessionId, { format, maxNodes });
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_tree",
+        description: "Render a folder tree from docdex.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string" },
+                maxDepth: { type: "number" },
+                dirsOnly: { type: "boolean" },
+                includeHidden: { type: "boolean" },
+                extraExcludes: { type: "array", items: { type: "string" } },
+            },
+        },
+        handler: async (args) => {
+            const { path, maxDepth, dirsOnly, includeHidden, extraExcludes } = args;
+            const result = await client.tree({ path, maxDepth, dirsOnly, includeHidden, extraExcludes });
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_open_file",
+        description: "Open a file by path via docdex (MCP).",
+        inputSchema: {
+            type: "object",
+            required: ["path"],
+            properties: {
+                path: { type: "string" },
+                startLine: { type: "number" },
+                endLine: { type: "number" },
+                head: { type: "number" },
+                clamp: { type: "boolean" },
+            },
+        },
+        handler: async (args) => {
+            const { path, startLine, endLine, head, clamp } = args;
+            const result = await client.openFile(path, { startLine, endLine, head, clamp });
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_memory_save",
+        description: "Store repo memory in docdex.",
+        inputSchema: {
+            type: "object",
+            required: ["text"],
+            properties: {
+                text: { type: "string" },
+            },
+        },
+        handler: async (args) => {
+            const { text } = args;
+            const result = await client.memorySave(text);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_get_profile",
+        description: "Fetch docdex profile preferences.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agentId: { type: "string" },
+            },
+        },
+        handler: async (args) => {
+            const { agentId } = args;
+            const result = await client.getProfile(agentId);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_save_preference",
+        description: "Save a docdex profile preference.",
+        inputSchema: {
+            type: "object",
+            required: ["agentId", "category", "content"],
+            properties: {
+                agentId: { type: "string" },
+                category: { type: "string" },
+                content: { type: "string" },
+            },
+        },
+        handler: async (args) => {
+            const { agentId, category, content } = args;
+            const result = await client.savePreference(agentId, category, content);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_memory_recall",
+        description: "Recall repo memory from docdex.",
+        inputSchema: {
+            type: "object",
+            required: ["query"],
+            properties: {
+                query: { type: "string" },
+                topK: { type: "number" },
+            },
+        },
+        handler: async (args) => {
+            const { query, topK } = args;
+            const result = await client.memoryRecall(query, topK);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_web_research",
+        description: "Run docdex web research (requires DOCDEX_WEB_ENABLED=1).",
+        inputSchema: {
+            type: "object",
+            required: ["query"],
+            properties: {
+                query: { type: "string" },
+                forceWeb: { type: "boolean" },
+                skipLocalSearch: { type: "boolean" },
+                webLimit: { type: "number" },
+                noCache: { type: "boolean" },
+            },
+        },
+        handler: async (args) => {
+            const { query, forceWeb, skipLocalSearch, webLimit, noCache } = args;
+            const result = await client.webResearch(query, { forceWeb, skipLocalSearch, webLimit, noCache });
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_chat_context",
+        description: "Ask docdex OpenAI-compatible chat with repo/profile/wake-up context.",
+        inputSchema: {
+            type: "object",
+            required: ["messages"],
+            properties: {
+                messages: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        required: ["role", "content"],
+                        properties: {
+                            role: { type: "string" },
+                            content: {
+                                anyOf: [
+                                    { type: "string" },
+                                    { type: "array", items: { type: "object" } },
+                                ],
+                            },
+                            name: { type: "string" },
+                            tool_call_id: { type: "string" },
+                        },
+                    },
+                },
+                model: { type: "string" },
+                maxTokens: { type: "number" },
+                temperature: { type: "number" },
+                docdex: { type: "object" },
+            },
+        },
+        handler: async (args) => {
+            const { messages, model, maxTokens, temperature, docdex } = args;
+            const result = await client.chatContext(messages, { model, maxTokens, temperature, docdex });
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_rerank",
+        description: "Rerank candidate hits using docdex optional rerank flow.",
+        inputSchema: {
+            type: "object",
+            required: ["query", "candidates"],
+            properties: {
+                query: { type: "string" },
+                candidates: { type: "array", items: { type: "object" } },
+                limit: { type: "number" },
+            },
+        },
+        handler: async (args) => {
+            const { query, candidates, limit } = args;
+            const result = await client.rerank(query, candidates, limit);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_batch_search",
+        description: "Run batched docdex search queries via optional batch endpoint/tool.",
+        inputSchema: {
+            type: "object",
+            required: ["queries"],
+            properties: {
+                queries: { type: "array", items: { type: "string" } },
+                limit: { type: "number" },
+                includeLibs: { type: "boolean" },
+            },
+        },
+        handler: async (args) => {
+            const { queries, limit, includeLibs } = args;
+            const result = await client.batchSearch(queries, { limit, includeLibs });
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_capabilities",
+        description: "Probe optional docdex retrieval capability support and cache per run.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                forceRefresh: { type: "boolean" },
+            },
+        },
+        handler: async (args) => {
+            const { forceRefresh } = args ?? {};
+            const result = await client.getCapabilities(forceRefresh ?? false);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_stats",
+        description: "Fetch docdex index stats.",
+        inputSchema: { type: "object", properties: {} },
+        handler: async () => {
+            const result = await client.stats();
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_files",
+        description: "List docdex indexed files.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: { type: "number" },
+                offset: { type: "number" },
+            },
+        },
+        handler: async (args) => {
+            const { limit, offset } = args ?? {};
+            const result = await client.files(limit, offset);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_repo_inspect",
+        description: "Inspect docdex repo mapping.",
+        inputSchema: { type: "object", properties: {} },
+        handler: async () => {
+            const result = await client.repoInspect();
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_index_rebuild",
+        description: "Rebuild docdex index.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                libsSources: { type: "string" },
+            },
+        },
+        handler: async (args) => {
+            const { libsSources } = args;
+            const result = await client.indexRebuild(libsSources);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_index_ingest",
+        description: "Ingest a single file into the docdex index.",
+        inputSchema: {
+            type: "object",
+            required: ["file"],
+            properties: {
+                file: { type: "string" },
+            },
+        },
+        handler: async (args) => {
+            const { file } = args;
+            const result = await client.indexIngest(file);
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_delegate",
+        description: "Run a local completion via docdex delegation.",
+        inputSchema: {
+            type: "object",
+            required: ["taskType", "instruction", "context"],
+            properties: {
+                taskType: { type: "string" },
+                instruction: { type: "string" },
+                context: { type: "string" },
+                agent: { type: "string" },
+                maxTokens: { type: "number" },
+                timeoutMs: { type: "number" },
+                mode: { type: "string" },
+                maxContextChars: { type: "number" },
+            },
+        },
+        handler: async (args) => {
+            const { taskType, instruction, context, agent, maxTokens, timeoutMs, mode, maxContextChars, } = args;
+            const result = await client.delegate({
+                task_type: taskType,
+                instruction,
+                context,
+                agent,
+                max_tokens: maxTokens,
+                timeout_ms: timeoutMs,
+                mode,
+                max_context_chars: maxContextChars,
+            });
+            return toOutput(result);
+        },
+    },
+    {
+        name: "docdex_hooks_validate",
+        description: "Run docdex validation hooks for a list of files.",
+        inputSchema: {
+            type: "object",
+            required: ["files"],
+            properties: {
+                files: { type: "array", items: { type: "string" } },
+            },
+        },
+        handler: async (args) => {
+            const { files } = args;
+            const result = await client.hooksValidate(files);
+            return toOutput(result);
+        },
+    },
+];

package/dist/vendor/codali/tools/filesystem/FileTools.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "../ToolTypes.js";
+export declare const createFileTools: () => ToolDefinition[];
+//# sourceMappingURL=FileTools.d.ts.map

package/dist/vendor/codali/tools/filesystem/FileTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileTools.d.ts","sourceRoot":"","sources":["../../../src/tools/filesystem/FileTools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAgEnE,eAAO,MAAM,eAAe,QAAO,cAAc,EAwFhD,CAAC"}

package/dist/vendor/codali/tools/filesystem/FileTools.js

@@ -0,0 +1,141 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const resolveWorkspacePath = (context, targetPath) => {
+    const resolved = path.resolve(context.workspaceRoot, targetPath);
+    if (context.allowOutsideWorkspace) {
+        return resolved;
+    }
+    const relative = path.relative(context.workspaceRoot, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("Path is outside the workspace root");
+    }
+    return resolved;
+};
+const toRelative = (context, targetPath) => {
+    return path.relative(context.workspaceRoot, targetPath) || ".";
+};
+const normalizeScope = (value) => {
+    const normalized = path.posix.normalize(value.replace(/\\/g, "/")).replace(/^\/+/, "");
+    if (!normalized || normalized === ".")
+        return ".";
+    if (normalized === ".." || normalized.startsWith("../")) {
+        throw new Error("Path scope is outside the workspace root");
+    }
+    return normalized;
+};
+const isWithinScope = (relativePath, scope) => {
+    if (scope === ".")
+        return true;
+    return relativePath === scope || relativePath.startsWith(`${scope}/`);
+};
+const assertPathScope = (context, resolvedPath, scopes, action) => {
+    if (!scopes?.length)
+        return;
+    const relativePath = normalizeScope(toRelative(context, resolvedPath));
+    const normalizedScopes = scopes.map(normalizeScope);
+    if (!normalizedScopes.some((scope) => isWithinScope(relativePath, scope))) {
+        throw new Error(`Path is outside allowed ${action} scopes`);
+    }
+};
+const listFilesRecursive = async (basePath, maxDepth, currentDepth = 0, entries = []) => {
+    if (currentDepth > maxDepth)
+        return entries;
+    const dirEntries = await fs.readdir(basePath, { withFileTypes: true });
+    for (const entry of dirEntries) {
+        const fullPath = path.join(basePath, entry.name);
+        entries.push(fullPath);
+        if (entry.isDirectory()) {
+            await listFilesRecursive(fullPath, maxDepth, currentDepth + 1, entries);
+        }
+    }
+    return entries;
+};
+export const createFileTools = () => {
+    return [
+        {
+            name: "read_file",
+            description: "Read a text file from the workspace.",
+            inputSchema: {
+                type: "object",
+                required: ["path"],
+                properties: {
+                    path: { type: "string" },
+                },
+            },
+            handler: async (args, context) => {
+                const { path: target } = args;
+                const resolved = resolveWorkspacePath(context, target);
+                assertPathScope(context, resolved, context.allowedReadPaths, "read");
+                const content = await fs.readFile(resolved, "utf8");
+                return { output: content };
+            },
+        },
+        {
+            name: "write_file",
+            description: "Write content to a file inside the workspace.",
+            inputSchema: {
+                type: "object",
+                required: ["path", "content"],
+                properties: {
+                    path: { type: "string" },
+                    content: { type: "string" },
+                },
+            },
+            handler: async (args, context) => {
+                const { path: target, content } = args;
+                const resolved = resolveWorkspacePath(context, target);
+                assertPathScope(context, resolved, context.allowedWritePaths, "write");
+                await fs.mkdir(path.dirname(resolved), { recursive: true });
+                await fs.writeFile(resolved, content, "utf8");
+                if (context.recordTouchedFile) {
+                    context.recordTouchedFile(toRelative(context, resolved));
+                }
+                return { output: `Wrote ${toRelative(context, resolved)}` };
+            },
+        },
+        {
+            name: "list_files",
+            description: "List files under a directory within the workspace.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string" },
+                    maxDepth: { type: "number" },
+                },
+            },
+            handler: async (args, context) => {
+                const { path: target = ".", maxDepth = 2 } = args ?? {};
+                const resolved = resolveWorkspacePath(context, target);
+                assertPathScope(context, resolved, context.allowedReadPaths, "read");
+                const entries = await listFilesRecursive(resolved, maxDepth);
+                const relativeEntries = entries.map((entry) => toRelative(context, entry));
+                return { output: relativeEntries.join("\n"), data: { entries: relativeEntries } };
+            },
+        },
+        {
+            name: "stat_path",
+            description: "Get stat info for a file or directory.",
+            inputSchema: {
+                type: "object",
+                required: ["path"],
+                properties: {
+                    path: { type: "string" },
+                },
+            },
+            handler: async (args, context) => {
+                const { path: target } = args;
+                const resolved = resolveWorkspacePath(context, target);
+                assertPathScope(context, resolved, context.allowedReadPaths, "read");
+                const stats = await fs.stat(resolved);
+                const info = {
+                    path: toRelative(context, resolved),
+                    isFile: stats.isFile(),
+                    isDirectory: stats.isDirectory(),
+                    size: stats.size,
+                    mtimeMs: stats.mtimeMs,
+                };
+                return { output: JSON.stringify(info, null, 2), data: info };
+            },
+        },
+    ];
+};

package/dist/vendor/codali/tools/search/SearchTool.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "../ToolTypes.js";
+export declare const createSearchTool: () => ToolDefinition;
+//# sourceMappingURL=SearchTool.d.ts.map

package/dist/vendor/codali/tools/search/SearchTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SearchTool.d.ts","sourceRoot":"","sources":["../../../src/tools/search/SearchTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,iBAAiB,CAAC;AA0BnE,eAAO,MAAM,gBAAgB,QAAO,cAwBlC,CAAC"}

package/dist/vendor/codali/tools/search/SearchTool.js

@@ -0,0 +1,46 @@
+import { spawnSync } from "node:child_process";
+const runCommand = (cmd, args, cwd) => {
+    const result = spawnSync(cmd, args, { cwd, encoding: "utf8" });
+    if (result.error) {
+        return { ok: false, output: "", error: result.error.message };
+    }
+    if (result.status !== 0 && result.status !== 1) {
+        return { ok: false, output: result.stdout ?? "", error: result.stderr ?? "" };
+    }
+    return { ok: true, output: result.stdout ?? "" };
+};
+const runRipgrep = (query, glob, cwd) => {
+    const args = ["--line-number", "--column", "--no-heading", "--color", "never"];
+    if (glob) {
+        args.push("--glob", glob);
+    }
+    args.push(query, ".");
+    return runCommand("rg", args, cwd);
+};
+const runGrepFallback = (query, cwd) => {
+    return runCommand("grep", ["-R", "-n", query, "."], cwd);
+};
+export const createSearchTool = () => ({
+    name: "search_repo",
+    description: "Search for text in the workspace using rg when available.",
+    inputSchema: {
+        type: "object",
+        required: ["query"],
+        properties: {
+            query: { type: "string" },
+            glob: { type: "string" },
+        },
+    },
+    handler: async (args, context) => {
+        const { query, glob } = args;
+        let result = runRipgrep(query, glob, context.workspaceRoot);
+        if (!result.ok) {
+            const fallback = runGrepFallback(query, context.workspaceRoot);
+            if (fallback.ok) {
+                result = fallback;
+            }
+        }
+        const lines = result.output.split("\n").filter(Boolean).slice(0, 200);
+        return { output: lines.join("\n"), data: { count: lines.length } };
+    },
+});