@neurynae/toolcairn-mcp 0.10.4 → 0.10.6

package/dist/index.js

@@ -923,7 +923,7 @@ async function pollForToken(apiUrl, deviceCode, intervalSec) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
 // src/index.prod.ts
@@ -1001,8 +1001,10 @@ var suggestGraphUpdateSchema = {
     tools: z.array(z.object({
       tool_name: z.string().min(1),
       github_url: z.string().url().optional(),
-      description: z.string().optional()
-    })).min(1).max(200).optional().describe('Batch of tools to stage for admin review. Use with suggestion_type="new_tool". Overrides single-tool fields when present.'),
+      description: z.string().optional(),
+      ecosystem: z.string().min(1).optional()
+    })).min(1).max(200).optional().describe('Batch of tools to stage for admin review. Use with suggestion_type="new_tool". Each entry may include `ecosystem` (npm/pypi/cargo/\u2026) so the engine can cross-check the authoritative github_url from the package registry. Overrides single-tool fields when present.'),
+    ecosystem: z.string().min(1).optional(),
     relationship: z.object({
       source_tool: z.string(),
       target_tool: z.string(),
@@ -1165,6 +1167,9 @@ var import_errors21 = __toESM(require_dist2(), 1);
 // ../../packages/tools-local/dist/auto-init.js
 init_esm_shims();
 var import_errors20 = __toESM(require_dist2(), 1);
+import { readFile as readFile28 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+import writeFileAtomic3 from "write-file-atomic";
 
 // ../../packages/tools-local/dist/config-store/index.js
 init_esm_shims();
@@ -4481,6 +4486,9 @@ function getOpenCodeMcpEntry(serverPath) {
 
 // ../../packages/tools-local/dist/auto-init.js
 var logger18 = (0, import_errors20.createMcpLogger)({ name: "@toolcairn/tools:auto-init" });
+var INSTRUCTION_SENTINEL = "## ToolCairn \u2014 Tool Intelligence MCP";
+var GITIGNORE_SENTINEL = "# ToolCairn";
+var GITIGNORE_BLOCK = "\n# ToolCairn\n.toolcairn/events.jsonl\n.toolcairn/audit-log.jsonl\n.toolcairn/audit-log.archive.jsonl\n.toolcairn/config.lock\n";
 async function autoInitProject(input) {
   const { projectRoot, agent, batchResolve, serverPath, reason } = input;
   logger18.info({ projectRoot, agent }, "autoInitProject starting");
@@ -4546,10 +4554,23 @@ async function autoInitProject(input) {
       step: 3,
       action: "append",
       file: ".gitignore",
-      content: "\n# ToolCairn\n.toolcairn/events.jsonl\n.toolcairn/audit-log.jsonl\n.toolcairn/audit-log.archive.jsonl\n.toolcairn/config.lock\n",
+      content: GITIGNORE_BLOCK,
       note: "Ignore runtime/audit files. config.json should be committed so teammates share tool intelligence."
     }
   ];
+  const applied_steps = input.skipSetupFileWrites ? setupSteps.map((s) => ({
+    file: s.file,
+    action: s.action,
+    applied: false,
+    reason: "skipSetupFileWrites=true"
+  })) : await applySetupFiles(projectRoot, {
+    agent,
+    instructionFile: instructions.file_path,
+    instructionContent: instructions.content,
+    mcpConfigFile,
+    mcpConfigEntry,
+    isOpenCode
+  });
   const tool_counts = {
     total: config5.tools.confirmed.length,
     indexed: config5.tools.confirmed.filter((t) => t.source === "toolcairn").length,
@@ -4564,6 +4585,7 @@ async function autoInitProject(input) {
     events_path: ".toolcairn/events.jsonl",
     mcp_config_entry: mcpConfigEntry,
     setup_steps: setupSteps,
+    applied_steps,
     scan_summary: {
       project_name: scan.name,
       languages: scan.languages.map((l) => ({ name: l.name, file_count: l.file_count })),
@@ -4579,6 +4601,108 @@ async function autoInitProject(input) {
     unknown_tools: undrained
   };
 }
+async function applySetupFiles(projectRoot, args) {
+  const results = [];
+  results.push(await applyInstructionFile(resolve3(projectRoot, args.instructionFile), args.instructionFile, args.instructionContent));
+  results.push(await applyMcpConfig(resolve3(projectRoot, args.mcpConfigFile), args.mcpConfigFile, args.mcpConfigEntry, args.isOpenCode));
+  results.push(await applyGitignore(resolve3(projectRoot, ".gitignore")));
+  return results;
+}
+async function applyInstructionFile(abs, relPath, content) {
+  try {
+    const exists = await fileExists(abs);
+    if (exists) {
+      const current = await readFile28(abs, "utf-8");
+      if (current.includes(INSTRUCTION_SENTINEL)) {
+        return {
+          file: relPath,
+          action: "append-or-create",
+          applied: false,
+          reason: "ToolCairn rules block already present"
+        };
+      }
+      const separator = current.endsWith("\n") ? "" : "\n";
+      await writeFileAtomic3(abs, `${current}${separator}${content}`, "utf-8");
+      return { file: relPath, action: "append-or-create", applied: true };
+    }
+    await writeFileAtomic3(abs, content, "utf-8");
+    return { file: relPath, action: "append-or-create", applied: true };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    logger18.warn({ err, file: relPath }, "Failed to write instruction file");
+    return { file: relPath, action: "append-or-create", applied: false, reason };
+  }
+}
+async function applyMcpConfig(abs, relPath, entry, isOpenCode) {
+  try {
+    const exists = await fileExists(abs);
+    const topKey = isOpenCode ? "mcp" : "mcpServers";
+    if (!exists) {
+      const payload = { [topKey]: entry };
+      await writeFileAtomic3(abs, `${JSON.stringify(payload, null, 2)}
+`, "utf-8");
+      return { file: relPath, action: "merge-or-create", applied: true };
+    }
+    const raw = await readFile28(abs, "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return {
+        file: relPath,
+        action: "merge-or-create",
+        applied: false,
+        reason: "existing file is not valid JSON \u2014 refusing to overwrite; fix manually"
+      };
+    }
+    const existingServers = parsed[topKey] && typeof parsed[topKey] === "object" && !Array.isArray(parsed[topKey]) ? parsed[topKey] : {};
+    if (existingServers.toolcairn !== void 0) {
+      return {
+        file: relPath,
+        action: "merge-or-create",
+        applied: false,
+        reason: `${topKey}.toolcairn already present`
+      };
+    }
+    const merged = {
+      ...parsed,
+      [topKey]: { ...existingServers, ...entry }
+    };
+    await writeFileAtomic3(abs, `${JSON.stringify(merged, null, 2)}
+`, "utf-8");
+    return { file: relPath, action: "merge-or-create", applied: true };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    logger18.warn({ err, file: relPath }, "Failed to write MCP config");
+    return { file: relPath, action: "merge-or-create", applied: false, reason };
+  }
+}
+async function applyGitignore(abs) {
+  const relPath = ".gitignore";
+  try {
+    const exists = await fileExists(abs);
+    if (!exists) {
+      await writeFileAtomic3(abs, GITIGNORE_BLOCK.replace(/^\n/, ""), "utf-8");
+      return { file: relPath, action: "append", applied: true };
+    }
+    const current = await readFile28(abs, "utf-8");
+    if (current.includes(GITIGNORE_SENTINEL)) {
+      return {
+        file: relPath,
+        action: "append",
+        applied: false,
+        reason: "ToolCairn gitignore block already present"
+      };
+    }
+    const separator = current.endsWith("\n") ? "" : "\n";
+    await writeFileAtomic3(abs, `${current}${separator}${GITIGNORE_BLOCK}`, "utf-8");
+    return { file: relPath, action: "append", applied: true };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    logger18.warn({ err, file: relPath }, "Failed to write .gitignore");
+    return { file: relPath, action: "append", applied: false, reason };
+  }
+}
 
 // ../../packages/tools-local/dist/handlers/toolcairn-init.js
 var logger19 = (0, import_errors21.createMcpLogger)({ name: "@toolcairn/tools:toolcairn-init" });
@@ -4984,7 +5108,11 @@ async function submitUnknownsToEngine(remote, pending) {
   const res = await remote.suggestGraphUpdate({
     suggestion_type: "new_tool",
     data: {
-      tools: pending.map((t) => ({ tool_name: t.name, github_url: t.github_url }))
+      tools: pending.map((t) => ({
+        tool_name: t.name,
+        github_url: t.github_url,
+        ecosystem: t.ecosystem
+      }))
     },
     confidence: 0.5
   });