@neurynae/toolcairn-mcp 0.10.3 → 0.10.4

package/dist/index.js

@@ -4931,7 +4931,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 +4980,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(" ");
 }