@neurynae/toolcairn-mcp 0.9.0 → 0.9.2

package/dist/index.js

@@ -1424,7 +1424,8 @@ var initProjectConfigSchema = {
   framework: z.string().optional(),
   detected_tools: z.array(z.object({
     name: z.string(),
-    source: z.enum(["toolpilot", "manual", "non_oss"]),
+    // 'toolcairn' is the current canonical source; 'toolpilot' kept for pre-rename configs
+    source: z.enum(["toolcairn", "toolpilot", "manual", "non_oss"]),
     version: z.string().optional()
   })).optional()
 };
@@ -1512,7 +1513,7 @@ ${args.prompt}
 """${projectToolsContext}
 
 Your response (one category name only):`;
-    const needs_tool_search_prompt = `Based on this classification, determine if ToolPilot tool search should be invoked.
+    const needs_tool_search_prompt = `Based on this classification, determine if ToolCairn tool search should be invoked.
 Respond with 1 if the classification is one of: tool_discovery, stack_building, tool_comparison
 Respond with 0 if the classification is: tool_configuration, debugging, general_coding
 Respond with ONLY 0 or 1.`;
@@ -1528,7 +1529,7 @@ Respond with ONLY 0 or 1.`;
         "general_coding"
       ],
       tool_required_if: TOOL_REQUIRED_CLASSIFICATIONS,
-      instructions: "Step 1: Send classification_prompt to the LLM and get a classification. Step 2: If classification is in tool_required_if, call refine_requirement with the classification. Otherwise, proceed without ToolPilot search."
+      instructions: "Step 1: Send classification_prompt to the LLM and get a classification. Step 2: If classification is in tool_required_if, call refine_requirement with the classification. Otherwise, proceed without ToolCairn search."
     });
   } catch (e) {
     logger2.error({ err: e }, "classify_prompt failed");
@@ -1542,29 +1543,35 @@ var import_errors5 = __toESM(require_dist2(), 1);
 
 // ../../packages/tools-local/dist/templates/agent-instructions.js
 init_esm_shims();
-var TOOLPILOT_MCP_ENTRY = {
-  toolpilot: {
+var IS_WINDOWS = process.platform === "win32";
+var TOOLCAIRN_MCP_ENTRY = IS_WINDOWS ? {
+  toolcairn: {
+    command: "cmd",
+    args: ["/c", "npx", "-y", "@neurynae/toolcairn-mcp"]
+  }
+} : {
+  toolcairn: {
     command: "npx",
-    args: ["-y", "@toolcairn/mcp@latest"]
+    args: ["-y", "@neurynae/toolcairn-mcp"]
   }
 };
 var CORE_RULES = `
-## ToolPilot \u2014 Tool Intelligence MCP
+## ToolCairn \u2014 Tool Intelligence MCP
 
-ToolPilot is your tool intelligence co-pilot. It has a graph database of 500+ indexed tools with health signals, compatibility data, and known issue tracking. Always use it before recommending any tool, library, or framework.
+ToolCairn is your tool intelligence co-pilot. It has a graph database of 500+ indexed tools with health signals, compatibility data, and known issue tracking. Always use it before recommending any tool, library, or framework.
 
 ### Workflow for Tool Selection
 
 1. **Before recommending any tool**: Always call \`search_tools\` first. Never recommend from training data alone.
 2. **When user describes a use case**: Call \`classify_prompt\` first, then \`refine_requirement\` if tool selection is needed.
-3. **When starting a new project**: Call \`toolpilot_init\` to set up .toolpilot/config.json.
-4. **When resuming work on a project**: Read .toolpilot/config.json via \`read_project_config\` to see confirmed tools.
+3. **When starting a new project**: Call \`toolcairn_init\` to set up .toolcairn/config.json.
+4. **When resuming work on a project**: Read .toolcairn/config.json via \`read_project_config\` to see confirmed tools.
 5. **When a tool is selected**: Call \`update_project_config\` to persist the choice.
 6. **When encountering an error with a tool**: Call \`check_issue\` before debugging \u2014 it may be a known issue with an open GitHub ticket.
 7. **When user asks to compare tools**: Call \`compare_tools\` for a structured comparison with health data.
 8. **When user chooses a non-indexed/proprietary tool**: Add it to config with source: "non_oss" via \`update_project_config\`.
 
-### Available ToolPilot MCP Tools
+### Available ToolCairn MCP Tools
 
 | Tool | When to use |
 |------|------------|
@@ -1577,17 +1584,17 @@ ToolPilot is your tool intelligence co-pilot. It has a graph database of 500+ in
 | \`check_compatibility\` | Check if two tools work well together |
 | \`compare_tools\` | Compare two tools with health and graph data |
 | \`report_outcome\` | Report whether a recommended tool worked (improves future results) |
-| \`toolpilot_init\` | Set up ToolPilot for a new project |
-| \`init_project_config\` | Initialize .toolpilot/config.json |
-| \`read_project_config\` | Parse .toolpilot/config.json to get confirmed tools |
-| \`update_project_config\` | Add/remove/update tools in .toolpilot/config.json |
-| \`suggest_graph_update\` | Suggest a new tool or relationship for the ToolPilot graph |
+| \`toolcairn_init\` | Set up ToolCairn for a new project |
+| \`init_project_config\` | Initialize .toolcairn/config.json |
+| \`read_project_config\` | Parse .toolcairn/config.json to get confirmed tools |
+| \`update_project_config\` | Add/remove/update tools in .toolcairn/config.json |
+| \`suggest_graph_update\` | Suggest a new tool or relationship for the ToolCairn graph |
 
 ### Rules
 
-- NEVER recommend a tool without first checking ToolPilot unless the tool is already in .toolpilot/config.json
-- Always check .toolpilot/config.json at the start of a session if it exists
-- Prefer open-source tools from ToolPilot index; flag proprietary alternatives clearly
+- NEVER recommend a tool without first checking ToolCairn unless the tool is already in .toolcairn/config.json
+- Always check .toolcairn/config.json at the start of a session if it exists
+- Prefer open-source tools from ToolCairn index; flag proprietary alternatives clearly
 - After selecting a tool, always call \`update_project_config\` to persist it
 - After using a tool successfully/unsuccessfully, call \`report_outcome\`
 `;
@@ -1663,20 +1670,29 @@ function getInstructionsForAgent(agent) {
 function getMcpConfigEntry(serverPath) {
   if (serverPath) {
     return {
-      toolpilot: {
+      toolcairn: {
         command: "node",
         args: [serverPath]
       }
     };
   }
-  return TOOLPILOT_MCP_ENTRY;
+  return TOOLCAIRN_MCP_ENTRY;
 }
 function getOpenCodeMcpEntry(serverPath) {
-  const resolvedPath = serverPath;
+  if (serverPath) {
+    return {
+      toolcairn: {
+        type: "local",
+        command: ["node", serverPath],
+        enabled: true
+      }
+    };
+  }
+  const command = IS_WINDOWS ? ["cmd", "/c", "npx", "-y", "@neurynae/toolcairn-mcp"] : ["npx", "-y", "@neurynae/toolcairn-mcp"];
   return {
-    toolpilot: {
+    toolcairn: {
       type: "local",
-      command: resolvedPath ? ["node", resolvedPath] : ["npx", "-y", "@toolcairn/mcp@latest"],
+      command,
       enabled: true
     }
   };
@@ -1690,7 +1706,7 @@ function generateTrackerHtml2(eventsPath) {
 <head>
 <meta charset="UTF-8" />
 <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-<title>ToolPilot Tracker</title>
+<title>ToolCairn Tracker</title>
 <style>
   :root {
     --bg: #0a0a0f;
@@ -1787,7 +1803,7 @@ function generateTrackerHtml2(eventsPath) {
     <circle cx="10" cy="10" r="9" stroke="#7c5cfc" stroke-width="1.5"/>
     <path d="M6 10h8M10 6v8" stroke="#7c5cfc" stroke-width="1.5" stroke-linecap="round"/>
   </svg>
-  <h1><span>Tool</span>Pilot Tracker</h1>
+  <h1><span>Tool</span>Cairn Tracker</h1>
   <div id="statusText" style="font-size:12px; color:var(--muted);">Loading...</div>
   <div id="statusDot" class="status-dot paused"></div>
 </header>
@@ -1816,7 +1832,7 @@ function generateTrackerHtml2(eventsPath) {
     <div class="empty" id="emptyState">
       <svg width="40" height="40" viewBox="0 0 40 40"><circle cx="20" cy="20" r="18" stroke="currentColor" stroke-width="1.5" fill="none"/><path d="M13 20h14M20 13v14" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/></svg>
       <p>Waiting for MCP tool calls...</p>
-      <code>Set TOOLPILOT_EVENTS_PATH in your MCP server env</code>
+      <code>Set TOOLCAIRN_EVENTS_PATH in your MCP server env</code>
     </div>
   </div>
   <div class="sidebar">
@@ -2078,7 +2094,7 @@ function renderAll() {
 // \u2500\u2500\u2500 Boot \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
 if (!EVENTS_PATH || EVENTS_PATH === 'null') {
   document.getElementById('statusText').textContent = 'No events path configured';
-  document.getElementById('emptyState').querySelector('p').textContent = 'TOOLPILOT_EVENTS_PATH not set in MCP server environment';
+  document.getElementById('emptyState').querySelector('p').textContent = 'TOOLCAIRN_EVENTS_PATH not set in MCP server environment';
 } else {
   startPolling();
 }
@@ -2088,19 +2104,19 @@ if (!EVENTS_PATH || EVENTS_PATH === 'null') {
 }
 
 // ../../packages/tools-local/dist/handlers/toolcairn-init.js
-var logger3 = (0, import_errors5.createMcpLogger)({ name: "@toolcairn/tools:toolpilot-init" });
+var logger3 = (0, import_errors5.createMcpLogger)({ name: "@toolcairn/tools:toolcairn-init" });
 async function handleToolcairnInit(args) {
   try {
-    logger3.info({ agent: args.agent, project_root: args.project_root }, "toolpilot_init called");
+    logger3.info({ agent: args.agent, project_root: args.project_root }, "toolcairn_init called");
     const instructions = getInstructionsForAgent(args.agent);
     const isOpenCode = args.agent === "opencode";
     const mcpConfigEntry = isOpenCode ? getOpenCodeMcpEntry(args.server_path) : getMcpConfigEntry(args.server_path);
     const mcpConfigFile = isOpenCode ? "opencode.json" : ".mcp.json";
     const hasMcpJson = args.detected_files?.some((f) => f === mcpConfigFile || f.endsWith(`/${mcpConfigFile}`));
     const hasInstructionFile = args.detected_files?.some((f) => f.endsWith(instructions.file_path));
-    const hasToolpilotConfig = args.detected_files?.some((f) => f.includes(".toolpilot/config.json"));
-    const hasTrackerHtml = args.detected_files?.some((f) => f.includes(".toolpilot/tracker.html"));
-    const eventsPath = `${args.project_root}/.toolpilot/events.jsonl`;
+    const hasToolcairnConfig = args.detected_files?.some((f) => f.includes(".toolcairn/config.json"));
+    const hasTrackerHtml = args.detected_files?.some((f) => f.includes(".toolcairn/tracker.html"));
+    const eventsPath = `${args.project_root}/.toolcairn/events.jsonl`;
     const setupSteps = [];
     let step = 1;
     setupSteps.push({
@@ -2111,7 +2127,7 @@ async function handleToolcairnInit(args) {
       note: hasInstructionFile ? `Append the content to your existing ${instructions.file_path}` : `Create ${instructions.file_path} with the content`
     });
     const mcpContent = isOpenCode ? JSON.stringify({ mcp: mcpConfigEntry }, null, 2) : JSON.stringify({ mcpServers: mcpConfigEntry }, null, 2);
-    const mcpMergeNote = isOpenCode ? `Merge the toolpilot entry into your existing ${mcpConfigFile} under "mcp"` : `Merge the toolpilot entry into your existing ${mcpConfigFile} under "mcpServers"`;
+    const mcpMergeNote = isOpenCode ? `Merge the toolcairn entry into your existing ${mcpConfigFile} under "mcp"` : `Merge the toolcairn entry into your existing ${mcpConfigFile} under "mcpServers"`;
     const mcpCreateNote = isOpenCode ? `Create ${mcpConfigFile} with this content (OpenCode MCP config format)` : `Create ${mcpConfigFile} with this content`;
     setupSteps.push({
       step: step++,
@@ -2120,29 +2136,29 @@ async function handleToolcairnInit(args) {
       content: mcpContent,
       note: hasMcpJson ? mcpMergeNote : mcpCreateNote
     });
-    if (!hasToolpilotConfig) {
+    if (!hasToolcairnConfig) {
       setupSteps.push({
         step: step++,
         action: "create",
-        file: ".toolpilot/config.json",
-        note: "Call init_project_config to generate the config content, then write to .toolpilot/config.json"
+        file: ".toolcairn/config.json",
+        note: "Call init_project_config to generate the config content, then write to .toolcairn/config.json"
       });
     }
     if (!hasTrackerHtml) {
       setupSteps.push({
         step: step++,
         action: "create",
-        file: ".toolpilot/tracker.html",
+        file: ".toolcairn/tracker.html",
         content: generateTrackerHtml2(eventsPath),
-        note: `Open .toolpilot/tracker.html in your browser to monitor MCP tool calls in real time. Set TOOLPILOT_EVENTS_PATH=${eventsPath} in your MCP server environment to enable event logging.`
+        note: `Open .toolcairn/tracker.html in your browser to monitor MCP tool calls in real time. Set TOOLCAIRN_EVENTS_PATH=${eventsPath} in your MCP server environment to enable event logging.`
       });
     }
     setupSteps.push({
       step: step++,
       action: "append",
       file: ".gitignore",
-      content: "\n# ToolPilot\n.toolpilot/events.jsonl\n",
-      note: "Add .toolpilot/events.jsonl to .gitignore (the tracker event log)"
+      content: "\n# ToolCairn\n.toolcairn/events.jsonl\n",
+      note: "Add .toolcairn/events.jsonl to .gitignore (the tracker event log)"
     });
     const agentFileLabel = {
       claude: "CLAUDE.md",
@@ -2160,16 +2176,16 @@ async function handleToolcairnInit(args) {
       mcp_config_entry: mcpConfigEntry,
       events_path: eventsPath,
       summary: [
-        `ToolPilot setup for ${args.agent} agent in ${args.project_root}`,
+        `ToolCairn setup for ${args.agent} agent in ${args.project_root}`,
         `Instructions will be added to: ${instructions.file_path}`,
-        `MCP server entry: toolpilot \u2192 ${mcpConfigFile}`,
-        hasToolpilotConfig ? ".toolpilot/config.json already exists \u2014 skipping init" : "Run init_project_config next to generate .toolpilot/config.json",
-        hasTrackerHtml ? ".toolpilot/tracker.html already exists \u2014 skipping" : "Tracker dashboard: open .toolpilot/tracker.html in browser"
+        `MCP server entry: toolcairn \u2192 ${mcpConfigFile}`,
+        hasToolcairnConfig ? ".toolcairn/config.json already exists \u2014 skipping init" : "Run init_project_config next to generate .toolcairn/config.json",
+        hasTrackerHtml ? ".toolcairn/tracker.html already exists \u2014 skipping" : "Tracker dashboard: open .toolcairn/tracker.html in browser"
       ].join("\n"),
-      next_steps: hasToolpilotConfig ? "Setup complete. Open .toolpilot/tracker.html to monitor tool calls." : "After completing setup steps, call init_project_config to initialize .toolpilot/config.json."
+      next_steps: hasToolcairnConfig ? "Setup complete. Open .toolcairn/tracker.html to monitor tool calls." : "After completing setup steps, call init_project_config to initialize .toolcairn/config.json."
     });
   } catch (e) {
-    logger3.error({ err: e }, "toolpilot_init failed");
+    logger3.error({ err: e }, "toolcairn_init failed");
     return errResult("init_error", e instanceof Error ? e.message : String(e));
   }
 }
@@ -2187,7 +2203,7 @@ async function handleInitProjectConfig(args) {
       source: t.source,
       version: t.version,
       chosen_at: now,
-      chosen_reason: "Auto-detected from project files during toolpilot_init",
+      chosen_reason: "Auto-detected from project files during toolcairn_init",
       alternatives_considered: []
     }));
     const config5 = {
@@ -2213,8 +2229,8 @@ async function handleInitProjectConfig(args) {
     const config_json = JSON.stringify(config5, null, 2);
     return okResult({
       config_json,
-      file_path: ".toolpilot/config.json",
-      instructions: "Create the directory .toolpilot/ in your project root (if it does not exist), then write this config_json content to .toolpilot/config.json. Also add .toolpilot/ to .gitignore if not already present.",
+      file_path: ".toolcairn/config.json",
+      instructions: "Create the directory .toolcairn/ in your project root (if it does not exist), then write this config_json content to .toolcairn/config.json. Also add .toolcairn/ to .gitignore if not already present.",
       confirmed_count: confirmedTools.length,
       next_step: confirmedTools.length > 0 ? "Config initialized with auto-detected tools. Use search_tools to find any additional tools you need." : "Config initialized. Use classify_prompt \u2192 refine_requirement \u2192 search_tools to discover tools for your project."
     });
@@ -2260,13 +2276,13 @@ async function handleReadProjectConfig(args) {
       };
     });
     const non_oss_tools = config5.tools.confirmed.filter((t) => t.source === "non_oss").map((t) => t.name);
-    const toolpilot_indexed_tools = config5.tools.confirmed.filter((t) => t.source === "toolpilot").map((t) => t.name);
+    const toolcairn_indexed_tools = config5.tools.confirmed.filter((t) => t.source === "toolcairn" || t.source === "toolpilot").map((t) => t.name);
     return okResult({
       project: config5.project,
       confirmed_tools: confirmedToolNames,
       pending_tools: pendingToolNames,
       non_oss_tools,
-      toolpilot_indexed_tools,
+      toolcairn_indexed_tools,
       stale_tools: staleTools,
       total_confirmed: confirmedToolNames.length,
       total_pending: pendingToolNames.length,
@@ -2306,11 +2322,11 @@ async function handleUpdateProjectConfig(args) {
         if (!config5.tools.confirmed.some((t) => t.name === args.tool_name)) {
           const newTool = {
             name: args.tool_name,
-            source: data.source ?? "toolpilot",
+            source: data.source ?? "toolcairn",
             github_url: data.github_url,
             version: data.version,
             chosen_at: now,
-            chosen_reason: data.chosen_reason ?? "Selected via ToolPilot",
+            chosen_reason: data.chosen_reason ?? "Selected via ToolCairn",
             alternatives_considered: data.alternatives_considered ?? [],
             query_id: data.query_id,
             notes: data.notes
@@ -2321,7 +2337,7 @@ async function handleUpdateProjectConfig(args) {
           action: "add_tool",
           tool: args.tool_name,
           timestamp: now,
-          reason: data.chosen_reason ?? "Added via ToolPilot recommendation"
+          reason: data.chosen_reason ?? "Added via ToolCairn recommendation"
         });
         break;
       }
@@ -2381,12 +2397,12 @@ async function handleUpdateProjectConfig(args) {
     const updated_config_json = JSON.stringify(config5, null, 2);
     return okResult({
       updated_config_json,
-      file_path: ".toolpilot/config.json",
+      file_path: ".toolcairn/config.json",
       action_applied: args.action,
       tool_name: args.tool_name,
       confirmed_count: config5.tools.confirmed.length,
       pending_count: config5.tools.pending_evaluation.length,
-      instructions: "Write updated_config_json to .toolpilot/config.json to persist this change."
+      instructions: "Write updated_config_json to .toolcairn/config.json to persist this change."
     });
   } catch (e) {
     logger6.error({ err: e }, "update_project_config failed");
@@ -2642,7 +2658,7 @@ async function addToolsToServer(server) {
   server.registerTool(
     "get_stack",
     {
-      description: 'Build a complementary tool stack for a project use case. For best results, call refine_requirement first with classification "stack_building", evaluate its decomposition_prompt to get sub-needs, then pass each {sub_need_type, keyword_sentence} object as a sub_needs entry. This lets get_stack keyword-match per layer (e.g. "web-framework", "database", "auth") instead of one broad search. Falls back to balanced search when sub_needs is omitted.',
+      description: 'Build a complementary tool stack for a project use case. For best results, call refine_requirement first with classification "stack_building", evaluate its decomposition_prompt to get sub-needs, then pass each {sub_need_type, keyword_sentence} object as a sub_needs entry. This lets get_stack keyword-match per layer (e.g. "web-framework", "database", "auth") instead of one broad search. Falls back to balanced search when sub_needs is omitted. Each tool in the returned stack also carries a `version` object with the recommended version that is cross-compatible with the rest of the stack (downgraded from latest if needed to satisfy peer constraints), plus a top-level `compatibility_matrix` + `stack_compatibility` summarising cross-tool version fit.',
       inputSchema: getStackSchema
     },
     wrap("get_stack", async (args) => remote.getStack(args))