@neurynae/toolcairn-mcp 0.10.3 → 0.10.5

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
@@ -1165,6 +1165,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 +4484,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 +4552,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 +4583,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 +4599,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" });
@@ -4931,7 +5053,45 @@ async function runPostAuthInit(options = {}) {
       });
     }
   }
-  const unknownTotal = projects.reduce((sum, p) => sum + (p.unknown_tools?.length ?? 0), 0);
+  if (!options.disableAutoSubmit) {
+    for (const project of projects) {
+      if (project.status !== "initialized") continue;
+      const pending = (project.unknown_tools ?? []).filter((t) => !!t.github_url);
+      if (pending.length === 0) continue;
+      try {
+        const outcome = await submitUnknownsToEngine(remote, pending);
+        project.auto_submitted = outcome;
+        const toMark = [...outcome.staged, ...outcome.already_staged, ...outcome.already_indexed];
+        if (toMark.length > 0) {
+          await markSuggestedInConfig(project.project_root, toMark).catch(
+            (err) => logger22.warn(
+              { err, projectRoot: project.project_root },
+              "Failed to flip suggested flags after auto-submit"
+            )
+          );
+        }
+        logger22.info(
+          {
+            projectRoot: project.project_root,
+            staged: outcome.staged.length,
+            already_staged: outcome.already_staged.length,
+            already_indexed: outcome.already_indexed.length,
+            rejected: outcome.rejected.length
+          },
+          "Auto-push to suggest_graph_update complete"
+        );
+      } catch (err) {
+        logger22.warn(
+          { err, projectRoot: project.project_root },
+          "Auto-push to suggest_graph_update failed \u2014 agent directive remains as fallback"
+        );
+      }
+    }
+  }
+  const unknownTotal = projects.reduce(
+    (sum, p) => sum + (p.unknown_tools ?? []).filter((t) => !t.suggested).length,
+    0
+  );
   const directive = buildFirstTurnDirective(projects, unknownTotal);
   return {
     cwd,
@@ -4942,19 +5102,87 @@ async function runPostAuthInit(options = {}) {
     first_turn_directive: directive
   };
 }
+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 }))
+    },
+    confidence: 0.5
+  });
+  const textBlock = res.content?.[0];
+  const outcome = {
+    staged: [],
+    already_staged: [],
+    already_indexed: [],
+    rejected: []
+  };
+  if (!textBlock || textBlock.type !== "text") return outcome;
+  let envelope;
+  try {
+    envelope = JSON.parse(textBlock.text ?? "{}");
+  } catch {
+    return outcome;
+  }
+  const items = envelope.data?.results ?? [];
+  for (const item of items) {
+    const name = item.tool_name ?? "";
+    if (!name) continue;
+    if (item.already_indexed) {
+      outcome.already_indexed.push(name);
+    } else if (item.already_staged) {
+      outcome.already_staged.push(name);
+    } else if (item.staged === true) {
+      outcome.staged.push(name);
+    } else {
+      outcome.rejected.push({ tool_name: name, reason: item.reason ?? "unknown" });
+    }
+  }
+  return outcome;
+}
+async function markSuggestedInConfig(projectRoot, toolNames) {
+  const wanted = new Set(toolNames);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let changed = 0;
+  await mutateConfig(
+    projectRoot,
+    (cfg) => {
+      const list = cfg.tools.unknown_in_graph ?? [];
+      for (const entry of list) {
+        if (wanted.has(entry.name) && !entry.suggested) {
+          entry.suggested = true;
+          entry.suggested_at = now;
+          changed++;
+        }
+      }
+      cfg.tools.unknown_in_graph = list;
+    },
+    {
+      action: "mark_suggestions_sent",
+      tool: `__auto_submit__:${toolNames.length}`,
+      reason: "Server auto-pushed unknown_in_graph tools to suggest_graph_update"
+    }
+  );
+  if (changed === 0) {
+    logger22.debug({ projectRoot, toolNames }, "No unknown_in_graph entries flipped");
+  }
+}
 function buildFirstTurnDirective(projects, unknownTotal) {
   if (unknownTotal === 0) return "";
-  const rootsWithUnknown = projects.filter((p) => (p.unknown_tools?.length ?? 0) > 0);
+  const rootsWithUnknown = projects.filter(
+    (p) => (p.unknown_tools ?? []).filter((t) => !t.suggested).length > 0
+  );
+  if (rootsWithUnknown.length === 0) return "";
   const roots = rootsWithUnknown.map((p) => p.project_root).join(", ");
   return [
     `The auto-init scan found ${unknownTotal} tool(s) not yet in the ToolCairn graph`,
     `across ${rootsWithUnknown.length} project root(s): ${roots}.`,
-    "BEFORE responding to the user, for EACH root with a non-empty `unknown_tools[]`:",
+    "The server has already auto-submitted these to the admin review queue,",
+    "but you MAY repeat the call below to confirm \u2014 engine-side dedup prevents duplicates:",
     '(1) call `suggest_graph_update` with suggestion_type="new_tool" and',
-    "    data.tools=<that root's unknown_tools array> \u2014 entries will be STAGED",
-    "    for admin review (no live-graph writes yet);",
+    "    data.tools=<that root's unknown_tools array>;",
     '(2) call `update_project_config` with action="mark_suggestions_sent",',
-    "    project_root, and data.tool_names=<names that staged successfully>."
+    "    project_root, and data.tool_names=<names that staged or were already_staged>."
   ].join(" ");
 }