tachibot-mcp 2.23.3 → 2.24.0

package/README.md

@@ -4,18 +4,18 @@
 
 ### Multi-Model AI Orchestration Platform
 
-[![Version](https://img.shields.io/badge/version-2.23.2-blue.svg)](https://www.npmjs.com/package/tachibot-mcp)
-[![Tools](https://img.shields.io/badge/tools-57_active-brightgreen.svg)](#-tool-ecosystem-57-tools)
+[![Version](https://img.shields.io/badge/version-2.24.0-blue.svg)](https://www.npmjs.com/package/tachibot-mcp)
+[![Tools](https://img.shields.io/badge/tools-61_active-brightgreen.svg)](#-tool-ecosystem-61-tools)
 [![License](https://img.shields.io/badge/license-AGPL--3.0-green.svg)](LICENSE)
-[![Node](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org)
+[![Node](https://img.shields.io/badge/node-%3E%3D22.0.0-brightgreen.svg)](https://nodejs.org)
 [![MCP](https://img.shields.io/badge/MCP-Compatible-purple.svg)](https://modelcontextprotocol.io)
 
-**57 AI tools. 12 providers. One protocol.**
+**61 AI tools. 12 providers. One protocol.**
 
 Orchestrate Perplexity, Grok, GPT-5.5, Gemini, Qwen, Kimi K2.7-Code, and MiniMax M3
 from Claude Code, Claude Desktop, Cursor, or any MCP client.
 
-[Get Started](#-quick-start) · [View Tools](#-tool-ecosystem-57-tools) · [Documentation](https://tachibot.com/docs)
+[Get Started](#-quick-start) · [View Tools](#-tool-ecosystem-61-tools) · [Documentation](https://tachibot.com/docs)
 
 <br>
 
@@ -70,7 +70,7 @@ Techniques are embedded directly in tool system prompts for automatic applicatio
 
 ## Skills (Claude Code)
 
-TachiBot ships with 12 slash commands for Claude Code. These orchestrate the tools into powerful workflows:
+TachiBot ships with 14 slash commands for Claude Code. These orchestrate the tools into powerful workflows:
 
 | Skill | What it does | Example |
 |-------|-------------|---------|
@@ -85,6 +85,8 @@ TachiBot ships with 12 slash commands for Claude Code. These orchestrate the too
 | `/lens` | Long-context analysis over Kimi's 256K window | `/lens find inconsistencies in this spec` |
 | `/reflect` | Grounded reflexion loop — critique vs external evidence | `/reflect harden this auth middleware` |
 | `/tot` | Tree-of-Thought: branch → jury-prune → synthesize | `/tot design a rate limiter` |
+| `/review` | Multi-model diff review — panel + Gemini judge verdict | `/review` (or paste a diff) |
+| `/redteam` | Adversarial plan red-team — pre-mortem, risks, plan edits | `/redteam <paste plan>` |
 | `/tachi` | Help - see available skills, tools, key status | `/tachi` |
 
 Skills automatically adapt to your configured API keys. Even with just 1-2 providers, all skills work.
@@ -96,7 +98,7 @@ Skills automatically adapt to your configured API keys. Even with just 1-2 provi
 ## Key Features
 
 ### Multi-Model Intelligence
-- **57 AI Tools** across 12 providers &mdash; Perplexity, Grok, GPT-5, Gemini, Qwen, Kimi, MiniMax, DeepSeek, GLM (Zhipu), StepFun, ERNIE (Baidu), plus free local models (Ollama / LM Studio / llama.cpp / vLLM)
+- **61 AI Tools** across 12 providers &mdash; Perplexity, Grok, GPT-5, Gemini, Qwen, Kimi, MiniMax, DeepSeek, GLM (Zhipu), StepFun, ERNIE (Baidu), plus free local models (Ollama / LM Studio / llama.cpp / vLLM)
 - **Gemini 3.5 Flash** (`gemini-3.5-flash`, GA May 19 2026) &mdash; Flash/search tier; reasoning default stays `gemini-3.1-pro-preview`
 - **Multi-Model Council** &mdash; planner_maker synthesizes plans from 5+ models into bite-sized TDD steps
 - **Smart Routing** &mdash; Automatic model selection for optimal results
@@ -111,12 +113,12 @@ Skills automatically adapt to your configured API keys. Even with just 1-2 provi
 ### Tool Profiles
 | Profile | Tools | Best For |
 |---------|-------|----------|
-| **Minimal** | 12 | Quick tasks, low token budget |
+| **Minimal** | 13 | Quick tasks, low token budget |
 | **Research Power** | 35 | Deep investigation, multi-source |
-| **Code Focus** | 34 | Software development, SWE tasks |
-| **Balanced** | 45 | General-purpose, mixed workflows |
-| **Heavy Coding** (default) | 50 | Max code tools + agentic workflows |
-| **Full** | 57 | Everything enabled |
+| **Code Focus** | 39 | Software development, SWE tasks |
+| **Balanced** | 50 | General-purpose, mixed workflows |
+| **Heavy Coding** | 54 | Max code tools + agentic workflows |
+| **Full** (default) | 61 | Everything enabled |
 
 ### Developer Experience
 - **Claude Code** &mdash; First-class support
@@ -134,7 +136,15 @@ Skills automatically adapt to your configured API keys. Even with just 1-2 provi
 npm install -g tachibot-mcp
 ```
 
-### Setup
+### Claude Code (one-liner)
+
+```bash
+claude mcp add tachibot -- npx -y -p tachibot-mcp tachibot
+```
+
+Then verify with `/mcp`. Add API keys with `--env`, e.g. `--env OPENROUTER_API_KEY=sk-or-xxx --env PERPLEXITY_API_KEY=pplx-xxx`.
+
+### Setup (Claude Desktop)
 
 **Gateway Mode (Recommended)** &mdash; 2 keys, all providers:
 
@@ -178,22 +188,22 @@ See [Installation Guide](docs/INSTALLATION_BOTH.md) for detailed instructions.
 
 ---
 
-## Tool Ecosystem (57 Tools)
+## Tool Ecosystem (61 Tools)
 
-### Research & Search (6)
-`perplexity_ask` &#183; `perplexity_research` &#183; `perplexity_reason` &#183; `grok_search` &#183; `openai_search` &#183; `gemini_search`
+### Research & Search (5)
+`perplexity_ask` &#183; `perplexity_reason` &#183; `grok_search` &#183; `openai_search` &#183; `gemini_search`
 
 ### Reasoning & Planning (13)
 `grok_reason` &#183; `openai_reason` &#183; `qwen_reason` &#183; `qwq_reason` &#183; `kimi_thinking` &#183; `kimi_decompose` &#183; `deepseek_reason` &#183; `glm_reason` &#183; `stepfun_reason` &#183; `ernie_reason` &#183; `planner_maker` &#183; `planner_runner` &#183; `list_plans`
 
-### Code Intelligence (9)
-`kimi_code` &#183; `grok_code` &#183; `grok_debug` &#183; `qwen_coder` &#183; `qwen_algo` &#183; `qwen_competitive` &#183; `deepseek_algo` &#183; `minimax_code` &#183; `minimax_agent`
+### Code Intelligence (10)
+`kimi_code` &#183; `grok_code` &#183; `grok_debug` &#183; `qwen_coder` &#183; `qwen_algo` &#183; `qwen_competitive` &#183; `deepseek_algo` &#183; `minimax_code` &#183; `minimax_agent` &#183; `testgen`
 
-### Analysis & Judgment (11)
-`gemini_analyze_text` &#183; `gemini_analyze_code` &#183; `gemini_judge` &#183; `jury` &#183; `gemini_brainstorm` &#183; `openai_brainstorm` &#183; `openai_code_review` &#183; `openai_explain` &#183; `grok_brainstorm` &#183; `grok_architect` &#183; `kimi_long_context`
+### Analysis & Judgment (14)
+`gemini_analyze_text` &#183; `gemini_analyze_code` &#183; `gemini_judge` &#183; `jury` &#183; `diff_review` &#183; `plan_critique` &#183; `gemini_brainstorm` &#183; `openai_brainstorm` &#183; `openai_code_review` &#183; `openai_explain` &#183; `grok_brainstorm` &#183; `grok_architect` &#183; `security_review` &#183; `kimi_long_context`
 
-### Meta & Orchestration (5)
-`think` &#183; `nextThought` &#183; `focus` &#183; `tachi` &#183; `usage_stats`
+### Meta & Orchestration (6)
+`think` &#183; `nextThought` &#183; `focus` &#183; `tachi` &#183; `doctor` &#183; `usage_stats`
 
 ### Workflows (9)
 `workflow` &#183; `workflow_start` &#183; `continue_workflow` &#183; `list_workflows` &#183; `create_workflow` &#183; `visualize_workflow` &#183; `workflow_status` &#183; `validate_workflow` &#183; `validate_workflow_file`

package/dist/src/config/timeout-config.js

@@ -77,14 +77,19 @@ export function formatTimeout(ms) {
     return `${minutes}m ${remainingSeconds}s`;
 }
 /**
- * Create timeout promise for use with Promise.race()
+ * Create timeout promise for use with Promise.race(), plus a cancel handle.
+ * The race's loser leaves its timer scheduled unless the caller cancels it —
+ * without that, a fast-resolving `promise` still leaves this setTimeout alive
+ * for the full `ms`, holding the event loop open.
  */
 export function createTimeoutPromise(ms, message) {
-    return new Promise((_, reject) => {
-        setTimeout(() => {
+    let timer;
+    const promise = new Promise((_, reject) => {
+        timer = setTimeout(() => {
             reject(new Error(message || `Operation timed out after ${formatTimeout(ms)}`));
         }, ms);
     });
+    return { promise, cancel: () => clearTimeout(timer) };
 }
 /**
  * Wrap promise with timeout
@@ -93,10 +98,13 @@ export async function withTimeout(promise, timeoutMs, toolName) {
     const timeoutMessage = toolName
         ? `${toolName} operation timed out after ${formatTimeout(timeoutMs)}`
         : `Operation timed out after ${formatTimeout(timeoutMs)}`;
-    return Promise.race([
-        promise,
-        createTimeoutPromise(timeoutMs, timeoutMessage)
-    ]);
+    const raceTimeout = createTimeoutPromise(timeoutMs, timeoutMessage);
+    try {
+        return await Promise.race([promise, raceTimeout.promise]);
+    }
+    finally {
+        raceTimeout.cancel();
+    }
 }
 /**
  * Check if we should show progress (operation exceeds threshold)
@@ -127,7 +135,9 @@ export const SMART_TIMEOUT_DEFAULTS = {
         },
         openai: {
             base: 60000, // 60 seconds - GPT-5.4 reasoning needs more time
-            max: 180000 // 3 minutes - high/xhigh reasoning effort
+            max: 600000 // 10 minutes - GPT-5.5 high/xhigh effort can exceed the
+            // OpenAI SDK's 900s default; 180s was cutting off real
+            // reasoning runs (verified 2026-07 deep-research)
         },
         anthropic: {
             base: 20000, // 20 seconds

package/dist/src/profiles/balanced.js

@@ -1,14 +1,14 @@
 export const balancedProfile = {
-    description: "Balanced set for general use (~Xk tokens, 18 tools)",
+    description: "Balanced set for general use (50 tools)",
     tools: {
         think: true,
         focus: true,
         tachi: true,
+        doctor: true,
         nextThought: true,
         usage_stats: true,
         perplexity_ask: true,
         perplexity_reason: true,
-        perplexity_research: false,
         grok_reason: true,
         grok_code: true,
         grok_debug: false,
@@ -59,5 +59,13 @@ export const balancedProfile = {
         planner_maker: true,
         planner_runner: true,
         list_plans: true,
+        // Test generation
+        testgen: true,
+        // Security audit
+        security_review: true,
+        // Diff-aware code review
+        diff_review: true,
+        // Adversarial plan red-team
+        plan_critique: true,
     }
 };

package/dist/src/profiles/code_focus.js

@@ -1,14 +1,14 @@
 export const codeFocusProfile = {
-    description: "Code-heavy work with debugging and analysis (~Xk tokens, 15 tools)",
+    description: "Code-heavy work with debugging and analysis (39 tools)",
     tools: {
         think: true,
         focus: true,
         tachi: true,
+        doctor: true,
         nextThought: true,
         usage_stats: true,
         perplexity_ask: true,
         perplexity_reason: false,
-        perplexity_research: false,
         grok_reason: true,
         grok_code: true,
         grok_debug: true,
@@ -59,5 +59,13 @@ export const codeFocusProfile = {
         planner_maker: true,
         planner_runner: true,
         list_plans: true,
+        // Test generation
+        testgen: true,
+        // Security audit
+        security_review: true,
+        // Diff-aware code review
+        diff_review: true,
+        // Adversarial plan red-team
+        plan_critique: true,
     }
 };

package/dist/src/profiles/full.js

@@ -1,14 +1,14 @@
 export const fullProfile = {
-    description: "All tools enabled for maximum capability (57 tools)",
+    description: "Default profile — all tools enabled for maximum capability (61 tools)",
     tools: {
         think: true,
         focus: true,
         tachi: true,
+        doctor: true,
         nextThought: true,
         usage_stats: true,
         perplexity_ask: true,
         perplexity_reason: true,
-        perplexity_research: true,
         grok_reason: true,
         grok_code: true,
         grok_debug: true,
@@ -59,5 +59,13 @@ export const fullProfile = {
         planner_maker: true,
         planner_runner: true,
         list_plans: true,
+        // Test generation
+        testgen: true,
+        // Security audit
+        security_review: true,
+        // Diff-aware code review
+        diff_review: true,
+        // Adversarial plan red-team
+        plan_critique: true,
     }
 };

package/dist/src/profiles/heavy_coding.js

@@ -1,16 +1,16 @@
 export const heavyCodingProfile = {
-    description: "Default profile — heavy coding with all reasoning & code tools (40 tools)",
+    description: "Heavy coding with all reasoning & code tools (54 tools)",
     tools: {
         // Core reasoning - all enabled
         think: true,
         focus: true,
         tachi: true,
+        doctor: true,
         nextThought: true,
         usage_stats: true,
         // Perplexity - all enabled for research
         perplexity_ask: true,
         perplexity_reason: true,
-        perplexity_research: true,
         // Grok - all enabled for heavy coding
         grok_reason: true,
         grok_code: true,
@@ -66,5 +66,13 @@ export const heavyCodingProfile = {
         planner_maker: true,
         planner_runner: true,
         list_plans: true,
+        // Test generation
+        testgen: true,
+        // Security audit
+        security_review: true,
+        // Diff-aware code review
+        diff_review: true,
+        // Adversarial plan red-team
+        plan_critique: true,
     }
 };

package/dist/src/profiles/minimal.js

@@ -1,14 +1,14 @@
 export const minimalProfile = {
-    description: "Minimal essential tools for basic tasks (~Xk tokens, 8 tools)",
+    description: "Minimal essential tools for basic tasks (13 tools)",
     tools: {
         think: true,
         focus: true,
         tachi: true,
+        doctor: true,
         nextThought: true,
         usage_stats: true,
         perplexity_ask: true,
         perplexity_reason: false,
-        perplexity_research: false,
         grok_reason: true,
         grok_code: false,
         grok_debug: false,
@@ -59,5 +59,13 @@ export const minimalProfile = {
         planner_maker: false,
         planner_runner: false,
         list_plans: false,
+        // Test generation
+        testgen: false,
+        // Security audit
+        security_review: false,
+        // Diff-aware code review
+        diff_review: false,
+        // Adversarial plan red-team
+        plan_critique: false,
     }
 };

package/dist/src/profiles/research_power.js

@@ -1,14 +1,14 @@
 export const researchPowerProfile = {
-    description: "Research-focused with Grok search + all Perplexity + brainstorming (~Xk tokens, 13 tools)",
+    description: "Research-focused with Grok search + all Perplexity + brainstorming (35 tools)",
     tools: {
         think: true,
         focus: true,
         tachi: true,
+        doctor: true,
         nextThought: true,
         usage_stats: true,
         perplexity_ask: true,
         perplexity_reason: true,
-        perplexity_research: true,
         grok_reason: true,
         grok_code: false,
         grok_debug: false,
@@ -59,5 +59,13 @@ export const researchPowerProfile = {
         planner_maker: true,
         planner_runner: true,
         list_plans: true,
+        // Test generation
+        testgen: false,
+        // Security audit
+        security_review: false,
+        // Diff-aware code review
+        diff_review: false,
+        // Adversarial plan red-team
+        plan_critique: false,
     }
 };

package/dist/src/server.js

@@ -616,12 +616,17 @@ async function initializeServer() {
         console.error("✅ Server.start() called successfully");
         // Keep the process alive with a heartbeat
         // This ensures the server doesn't exit prematurely
+        // .unref() so this timer is never itself the reason the process stays up —
+        // real MCP runs already stay alive via process.stdin.resume() and the
+        // active transport; this only logs a liveness ping while that's true.
+        // Without unref, importing this module (e.g. test/golden/emit-schema.ts
+        // reading tool schemas) leaks the interval past test teardown.
         setInterval(() => {
             // Heartbeat to keep process alive
             // Log every 30 seconds to show we're still alive
             const now = new Date().toISOString();
             console.error(`💓 Heartbeat: Server still alive at ${now}`);
-        }, 30000); // Every 30 seconds
+        }, 30000).unref(); // Every 30 seconds
         console.error("✅ Heartbeat interval established");
         console.error("✅ Server started successfully and listening for MCP commands");
     }

package/dist/src/tools/diff-review-tool.js

@@ -0,0 +1,120 @@
+/**
+ * diff_review — multi-model, diff-AWARE code review.
+ * Differs from openai_code_review (whole-file, single model) and jury (free-
+ * text, no code structure): reviewers are scoped to the changed lines, then a
+ * Gemini judge dedupes and severity-ranks into ONE actionable list.
+ * Gated on Gemini (judge); panelists self-drop when their key is missing.
+ */
+import { z } from "zod";
+import { defineModelTool } from "./factory/define-model-tool.js";
+import { callOpenRouter, OpenRouterModel } from "./openrouter-tools.js";
+import { callOpenAI } from "./openai-tools.js";
+import { callGemini } from "./gemini-tools.js";
+import { hasOpenAIApiKey, hasOpenRouterApiKey } from "../utils/api-keys.js";
+import { OPENAI_MODELS } from "../config/model-constants.js";
+import { readFilesIntoContext } from "../utils/file-reader.js";
+import { FORMAT_INSTRUCTION } from "../utils/format-constants.js";
+import { withHeartbeat } from "../utils/streaming-helper.js";
+import { runPanel } from "./panel.js";
+const PANELIST_MAX_TOKENS = 8000; // same rationale as JUROR_MAX_TOKENS (jury-tool.ts)
+export function buildDiffReviewerPrompt(args) {
+    const focus = args.focus || "all";
+    const fileContext = args.files?.length
+        ? `\n\nSURROUNDING CODE (context only — do NOT review unchanged code):\n${readFilesIntoContext(args.files)}`
+        : "";
+    return `Review this diff. Flag issues ONLY on changed lines and lines directly adjacent to/affected by the change — do not review the rest of the file.
+
+${args.intent ? `STATED INTENT OF THE CHANGE: ${args.intent}\nAlso flag any way the diff does NOT accomplish this intent.\n` : ""}FOCUS: ${focus} (security | perf | correctness | style | all).
+
+FOR EACH ISSUE: severity (blocker | major | minor | nit), file:line from the diff hunks, what breaks and the concrete input/state that triggers it, suggested fix (one line).
+Look specifically for: regressions the change introduces, missed edge cases in the new logic, security implications of new data flows, and behavior the intent implies but the diff doesn't implement.
+If you find nothing at a severity, say so explicitly.
+
+DIFF:
+${args.diff}${fileContext}`;
+}
+export function buildDiffJudgePrompt(perspectives, args) {
+    const floor = args.severityFloor || "nit";
+    const body = perspectives
+        .map((p, i) => `=== REVIEWER ${i + 1}: ${p.label} ===\n${p.text}`)
+        .join("\n\n");
+    return `You are the presiding reviewer. Below are independent reviews of the SAME diff.
+
+MERGE THEM INTO ONE LIST:
+1. Deduplicate findings that describe the same underlying issue (keep the clearest wording; note "flagged by N/${perspectives.length} reviewers").
+2. Discard findings that misread the diff (verify each against the DIFF below).
+3. Rank by severity: blocker > major > minor > nit. OMIT everything below severity floor: ${floor}.
+4. Every finding keeps its file:line anchor and one-line fix.
+
+END WITH: verdict line — "MERGEABLE", "MERGEABLE WITH FIXES", or "DO NOT MERGE", plus the single most important fix.
+
+DIFF:
+${args.diff}
+
+${body}`;
+}
+function buildPanel() {
+    const panel = [];
+    if (hasOpenRouterApiKey()) {
+        panel.push({
+            key: "kimi",
+            label: "Kimi K2.7-Code (SWE regressions)",
+            call: (q) => callOpenRouter([
+                { role: "system", content: `You are Kimi K2.7-Code, an SWE-specialized reviewer. Hunt regressions and missed edge cases in diffs. ${FORMAT_INSTRUCTION}` },
+                { role: "user", content: q },
+            ], OpenRouterModel.KIMI_K2_7_CODE, 0.3, PANELIST_MAX_TOKENS),
+        });
+        panel.push({
+            key: "deepseek",
+            label: "DeepSeek V4 Pro (correctness & security)",
+            call: (q) => callOpenRouter([
+                { role: "system", content: `You are DeepSeek V4 Pro reviewing a diff. Rigorously verify correctness of the new logic and security of new data flows. ${FORMAT_INSTRUCTION}` },
+                { role: "user", content: q },
+            ], OpenRouterModel.DEEPSEEK_V4_PRO, 0.2, PANELIST_MAX_TOKENS),
+        });
+    }
+    if (hasOpenAIApiKey()) {
+        panel.push({
+            key: "gpt",
+            label: "GPT-5.5 (intent & API-contract)",
+            call: (q) => callOpenAI([
+                { role: "system", content: `You review diffs for intent mismatches and API-contract breaks (types, error paths, backward compatibility). ${FORMAT_INSTRUCTION}` },
+                { role: "user", content: q },
+            ], OPENAI_MODELS.DEFAULT, // explicit: undefined falls back to INSTANT (gpt-5.4-mini), contradicting the GPT-5.5 label
+            0.3, PANELIST_MAX_TOKENS, "high"),
+        });
+    }
+    return panel;
+}
+export const diffReviewTool = defineModelTool({
+    name: "diff_review",
+    description: "Multi-model diff-aware code review: 2-3 lab-diverse reviewers (Kimi K2.7-Code, DeepSeek V4 Pro, GPT-5.5) scoped to the changed lines, deduplicated and severity-ranked by a Gemini judge. Provide the unified diff in 'diff'.",
+    parameters: z.object({
+        diff: z.string().describe("Unified diff to review (git diff output) — REQUIRED"),
+        intent: z.string().optional().describe("What the change is SUPPOSED to do (enables intent-mismatch detection)"),
+        files: z.array(z.string()).optional().describe("File paths for surrounding context. Supports line ranges: 'src/foo.ts:100-200'."),
+        focus: z.enum(["security", "perf", "correctness", "style", "all"]).optional().default("all").describe("Review focus"),
+        severityFloor: z.enum(["blocker", "major", "minor", "nit"]).optional().default("nit").describe("Omit findings below this severity"),
+    }),
+    execute: async (args, { reportProgress }) => {
+        if (!args.diff?.trim()) {
+            return "Error: 'diff' is required — paste the unified diff (e.g. `git diff` output).";
+        }
+        const panel = buildPanel();
+        if (panel.length === 0) {
+            return "Error: no reviewers available — diff_review needs OPENROUTER_API_KEY and/or OPENAI_API_KEY in addition to the Gemini key. Run `doctor` for setup status.";
+        }
+        const reviewerPrompt = buildDiffReviewerPrompt(args);
+        const perspectives = await withHeartbeat(() => runPanel(panel, reviewerPrompt), reportProgress, 10000);
+        if (perspectives.length === 0) {
+            return "Error: all reviewers failed (provider outage or quota). Try again or run `doctor`.";
+        }
+        const judgePrompt = buildDiffJudgePrompt(perspectives, args);
+        const verdict = await withHeartbeat(() => callGemini(judgePrompt, undefined, `You are Gemini 3 Pro, the presiding code reviewer synthesizing a panel review of one diff. Be decisive; keep only verified findings. ${FORMAT_INSTRUCTION}`, 0.3), reportProgress, 10000);
+        const roster = perspectives.map((p) => p.label).join(", ");
+        return `DIFF REVIEW (${perspectives.length} reviewers: ${roster})\n\n${verdict}`;
+    },
+});
+export function getAllDiffReviewTools() {
+    return [diffReviewTool];
+}

package/dist/src/tools/doctor-tool.js

@@ -0,0 +1,143 @@
+/**
+ * Doctor Tool — zero-cost diagnostic for "why am I only seeing N tools?"
+ *
+ * Tools self-gate registration on API keys (src/tools/registry.ts), so a user
+ * with one key silently sees a fraction of the full set with no explanation.
+ * `doctor` makes the gating legible: detected keys, which tools are hidden and
+ * why, the active profile and where it came from, and a concrete first step.
+ *
+ * Registers UNCONDITIONALLY (no API-key gate) — it costs nothing and is most
+ * useful precisely when no keys are set.
+ */
+import { z } from "zod";
+import { defineModelTool } from "./factory/define-model-tool.js";
+import { hasGrokApiKey, hasOpenAIApiKey, hasPerplexityApiKey, hasGeminiApiKey, hasOpenRouterApiKey, hasLocalLLM, } from "../utils/api-keys.js";
+import { getActiveProfile, getProfileSource } from "../utils/tool-config.js";
+import { toolRouter } from "./tool-router.js";
+import { PROVIDER_GROUPS } from "./provider-catalog.js";
+const RULE = "─".repeat(48);
+/** One line per key provider: ✓/✗ plus the env var(s) that set it. */
+function renderKeyStatus() {
+    const rows = PROVIDER_GROUPS.map((g) => {
+        const ok = g.available();
+        const mark = ok ? "✓" : "✗";
+        const label = g.label.padEnd(16);
+        const hint = ok ? g.envHint : `set ${g.envHint}`;
+        const note = g.note ? `  — ${g.note}` : "";
+        return `  ${mark} ${label} (${hint})${note}`;
+    });
+    return rows.join("\n");
+}
+/**
+ * "Try this first" — pick a concrete entry point from the keys that ARE set,
+ * so the suggestion always actually works for this user.
+ */
+function suggestFirstStep() {
+    const gemini = hasGeminiApiKey();
+    const openrouter = hasOpenRouterApiKey();
+    const grok = hasGrokApiKey();
+    const perplexity = hasPerplexityApiKey();
+    const openai = hasOpenAIApiKey();
+    const local = hasLocalLLM();
+    const anyKey = gemini || openrouter || grok || perplexity || openai || local;
+    if (!anyKey) {
+        return [
+            "  No API keys detected — external tools can't run yet.",
+            "  Add ONE key to your .env, then restart the MCP server:",
+            "    • OPENROUTER_API_KEY unlocks the most tools (Qwen/Kimi/DeepSeek/GLM/…)",
+            "    • or GOOGLE_API_KEY / XAI_API_KEY / OPENAI_API_KEY / PERPLEXITY_API_KEY",
+            "  (think, focus, nextThought, tachi and doctor work with no key.)",
+        ].join("\n");
+    }
+    // A Gemini judge + at least one juror-capable key = the jury is the best demo.
+    if (gemini && (openrouter || grok || openai || perplexity)) {
+        return '  jury  question="What\'s the best way to X?"   (parallel panel → Gemini synthesis)';
+    }
+    if (grok) {
+        return '  tachi  query="how does X work?"   (auto-routes to Grok live search)';
+    }
+    if (perplexity) {
+        return '  perplexity_ask  query="..."   (web-grounded answer with sources)';
+    }
+    if (openrouter) {
+        return '  deepseek_reason  query="..."   (frontier open-weight reasoning)';
+    }
+    if (openai) {
+        return '  openai_reason  query="..."   (GPT-5.5 deep reasoning)';
+    }
+    if (gemini) {
+        return '  gemini_brainstorm  query="..."   (fast ideation)';
+    }
+    // local only
+    return '  local_query  query="..."   (offline, zero-cost via your local server)';
+}
+export const doctorTool = defineModelTool({
+    name: "doctor",
+    description: "Diagnose your TachiBot setup: which API keys are detected, which tools are available vs hidden (and why), the active profile, and a suggested first step. Zero-cost, needs no API key. Call it when tools seem missing.",
+    parameters: z.object({}),
+    execute: async (_args, context) => {
+        context?.log?.info?.("Running TachiBot doctor diagnostic");
+        // (a) API keys
+        const keys = renderKeyStatus();
+        // (b) Tool availability report from the router (available vs hidden + why)
+        const routerStatus = toolRouter.getStatus();
+        // Also summarize the key-gated tool count across ALL providers (the router
+        // only covers a subset of categories), so the "hidden" story is complete.
+        let gatedTotal = 0;
+        let gatedHidden = 0;
+        const hiddenByProvider = [];
+        for (const g of PROVIDER_GROUPS) {
+            gatedTotal += g.tools.length;
+            if (!g.available()) {
+                gatedHidden += g.tools.length;
+                hiddenByProvider.push(`  ✗ ${g.label}: ${g.tools.length} tool(s) hidden (set ${g.envHint})`);
+            }
+        }
+        const gatedVisible = gatedTotal - gatedHidden;
+        const hiddenSummary = hiddenByProvider.length > 0
+            ? hiddenByProvider.join("\n")
+            : "  All key-gated providers are configured — nothing hidden by missing keys.";
+        // (c) Active profile + where it was resolved from
+        const profile = getActiveProfile();
+        const profileName = profile?.name ?? "default";
+        const profileDesc = profile?.description ? `\n  ${profile.description}` : "";
+        const profileFrom = getProfileSource();
+        // (d) Try-this-first suggestion, tailored to available keys
+        const suggestion = suggestFirstStep();
+        return [
+            "TACHIBOT DOCTOR",
+            "═".repeat(48),
+            "",
+            "API KEYS DETECTED",
+            RULE,
+            keys,
+            "",
+            "KEY-GATED TOOLS",
+            RULE,
+            `  Visible: ${gatedVisible}/${gatedTotal}  (${gatedHidden} hidden by missing keys)`,
+            hiddenSummary,
+            "  Note: think, focus, nextThought, tachi, doctor + workflow/prompt tools",
+            "  are always on (no key needed); profile membership still applies.",
+            "",
+            "ACTIVE PROFILE",
+            RULE,
+            `  Profile: ${profileName}   (source: ${profileFrom})${profileDesc}`,
+            "  Switch with TACHIBOT_PROFILE=<name> or activeProfile in tools.config.json.",
+            "  Profiles: minimal, code_focus, research_power, balanced, heavy_coding, full.",
+            "",
+            "TOOL ROUTER STATUS",
+            RULE,
+            routerStatus,
+            "",
+            "TRY THIS FIRST",
+            RULE,
+            suggestion,
+            "",
+            "Run tachi (no query) for the full tool + skill catalog.",
+        ].join("\n");
+    },
+});
+/** Export for central registry (mirrors getTachiTools). */
+export function getDoctorTools() {
+    return [doctorTool];
+}