token-pilot 0.42.2 → 0.43.0

package/dist/cli/install-statusline.js

@@ -24,70 +24,73 @@
 import { readFile, writeFile, mkdir, access } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-/** The version-agnostic chain command (auto-picks the newest plugin dir). */
+/** TP-only badge command (DEFAULT — just token-pilot's [TP] badge). */
+export const TP_ONLY_COMMAND = 'bash "$(ls -t ~/.claude/plugins/cache/token-pilot/token-pilot/*/hooks/tp-statusline.sh 2>/dev/null | head -1)"';
+/**
+ * Chain command — renders token-pilot's badge AND any other ecosystem
+ * badge (caveman) side by side. Opt-in via `--chain`.
+ */
 export const CHAIN_COMMAND = 'bash "$(ls -t ~/.claude/plugins/cache/token-pilot/token-pilot/*/hooks/statusline-chain.sh 2>/dev/null | head -1)"';
 /**
- * Pure decision: given the current statusline status, what should the
- * installer do? Separated from I/O for unit tests.
+ * Pure decision: given the current statusline status + options, what
+ * should the installer do and which command should it write?
+ *
+ * v0.42.3 — DEFAULT is now the TP-only badge. The previous default
+ * silently installed the chain wrapper, which also rendered caveman's
+ * badge — presumptuous (we install OUR badge, we don't decide that a
+ * third-party tool's badge belongs in your status bar). `--chain`
+ * opts into the combined view. token-pilot's own previous choices
+ * (tp-only ↔ chain) are switched freely; a non-token-pilot statusLine
+ * (caveman-only, custom) is never clobbered without `--force`.
  */
-export function decideStatuslineAction(status, force) {
+export function decideStatuslineAction(status, opts) {
+    const command = opts.chain ? CHAIN_COMMAND : TP_ONLY_COMMAND;
+    const badgeDesc = opts.chain ? "caveman + [TP] badges" : "[TP] badge";
+    const noWrite = (action, message) => ({
+        write: false,
+        command,
+        result: { action, message },
+    });
+    const doWrite = (action, message) => ({
+        write: true,
+        command,
+        result: { action, message },
+    });
     switch (status) {
         case "not-configured":
-            return {
-                write: true,
-                result: {
-                    action: "installed",
-                    message: "statusLine configured — the [TP] badge will show in your status bar (restart Claude Code).",
-                },
-            };
-        case "configured-caveman-only":
+            return doWrite("installed", `statusLine configured — the ${badgeDesc} will show in your status bar (restart Claude Code).`);
         case "configured-tp-only":
-            return {
-                write: true,
-                result: {
-                    action: "upgraded",
-                    message: "statusLine upgraded to the chain wrapper — both caveman and [TP] badges now render side by side.",
-                },
-            };
+            // Already ours. Switch only if the user asked for the chain.
+            return opts.chain
+                ? doWrite("upgraded", "statusLine upgraded to the chain wrapper — caveman + [TP] now render side by side.")
+                : noWrite("noop", "statusLine already shows the [TP] badge. Nothing to do.");
         case "configured-chain":
-            return {
-                write: false,
-                result: {
-                    action: "noop",
-                    message: "statusLine already uses the token-pilot chain wrapper. Nothing to do.",
-                },
-            };
+            // Also ours. Switch to tp-only unless the user wants the chain.
+            return opts.chain
+                ? noWrite("noop", "statusLine already uses the chain wrapper. Nothing to do.")
+                : doWrite("installed", "statusLine switched to the [TP]-only badge (caveman badge removed from the status bar).");
+        case "configured-caveman-only":
+            // Caveman's own statusline — NOT ours. Don't replace it silently.
+            if (opts.chain) {
+                return doWrite("upgraded", "statusLine upgraded to the chain wrapper — keeps caveman and adds [TP].");
+            }
+            if (opts.force) {
+                return doWrite("installed", "Replaced caveman's statusLine with the [TP]-only badge (--force).");
+            }
+            return noWrite("skipped", "Your statusLine is caveman's. Left untouched. Run with --chain to show " +
+                "both badges, or --force to replace it with [TP] only.");
         case "configured-other":
-            if (force) {
-                return {
-                    write: true,
-                    result: {
-                        action: "installed",
-                        message: "Replaced your custom statusLine with the token-pilot chain wrapper (--force).",
-                    },
-                };
+            if (opts.force) {
+                return doWrite("installed", `Replaced your custom statusLine with the ${badgeDesc} (--force).`);
             }
-            return {
-                write: false,
-                result: {
-                    action: "skipped",
-                    message: "You already have a custom statusLine — left untouched. " +
-                        "To show the [TP] badge too, set statusLine.command to:\n  " +
-                        CHAIN_COMMAND +
-                        "\nor re-run with --force to replace it.",
-                },
-            };
+            return noWrite("skipped", "You already have a custom statusLine — left untouched. To use the " +
+                `${badgeDesc}, re-run with --force, or set statusLine.command to:\n  ` +
+                command);
         case "unknown":
         default:
-            return {
-                write: false,
-                result: {
-                    action: "skipped",
-                    message: "Could not read ~/.claude/settings.json as JSON — not modifying it. " +
-                        "Add this manually under \"statusLine\":\n  " +
-                        CHAIN_COMMAND,
-                },
-            };
+            return noWrite("skipped", 'Could not read ~/.claude/settings.json as JSON — not modifying it. ' +
+                'Add this manually under "statusLine":\n  ' +
+                command);
     }
 }
 /**
@@ -126,9 +129,13 @@ export async function classifyStatuslineAt(settingsPath) {
  */
 export async function handleInstallStatusline(argv, opts) {
     const force = argv.includes("--force");
+    const chain = argv.includes("--chain");
     const settingsPath = opts?.settingsPath ?? join(homedir(), ".claude", "settings.json");
     const status = await classifyStatuslineAt(settingsPath);
-    const { write, result } = decideStatuslineAction(status, force);
+    const { write, command, result } = decideStatuslineAction(status, {
+        force,
+        chain,
+    });
     if (!write) {
         process.stdout.write(`[token-pilot] ${result.message}\n`);
         return 0;
@@ -145,7 +152,7 @@ export async function handleInstallStatusline(argv, opts) {
     catch {
         /* fresh file — start clean (only reached when status was safe) */
     }
-    settings.statusLine = { type: "command", command: CHAIN_COMMAND };
+    settings.statusLine = { type: "command", command };
     try {
         await mkdir(dirname(settingsPath), { recursive: true });
         await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n");

package/dist/core/validation.d.ts

@@ -145,6 +145,23 @@ export interface ModuleInfoArgs {
     check?: "deps" | "dependents" | "api" | "unused-deps" | "all";
 }
 export declare function validateModuleInfoArgs(args: unknown): ModuleInfoArgs;
+/**
+ * Validate module_route arguments.
+ *
+ * Wraps ast-index 3.44 `module-route` — the transitive dependency path
+ * between two modules. `from`/`to` are required; everything else mirrors
+ * the CLI flags with sane caps.
+ */
+export interface ModuleRouteArgs {
+    from: string;
+    to: string;
+    all?: boolean;
+    maxPaths?: number;
+    maxDepth?: number;
+    viaKind?: "api" | "implementation" | "all";
+    format?: "text" | "json" | "mermaid" | "dot";
+}
+export declare function validateModuleRouteArgs(args: unknown): ModuleRouteArgs;
 /**
  * Validate smart_diff arguments.
  */

package/dist/core/validation.js

@@ -428,6 +428,60 @@ export function validateModuleInfoArgs(args) {
         check: check ?? "all",
     };
 }
+export function validateModuleRouteArgs(args) {
+    if (!args || typeof args !== "object") {
+        throw new Error('Arguments must be an object with "from" and "to" parameters.');
+    }
+    const a = args;
+    if (typeof a.from !== "string" || a.from.length === 0) {
+        throw new Error('Required parameter "from" must be a non-empty string.');
+    }
+    if (typeof a.to !== "string" || a.to.length === 0) {
+        throw new Error('Required parameter "to" must be a non-empty string.');
+    }
+    let viaKind;
+    if (a.viaKind !== undefined && a.viaKind !== null) {
+        const valid = ["api", "implementation", "all"];
+        if (typeof a.viaKind !== "string" || !valid.includes(a.viaKind)) {
+            throw new Error(`"viaKind" must be one of: ${valid.join(", ")}`);
+        }
+        viaKind = a.viaKind;
+    }
+    let format;
+    if (a.format !== undefined && a.format !== null) {
+        const valid = ["text", "json", "mermaid", "dot"];
+        if (typeof a.format !== "string" || !valid.includes(a.format)) {
+            throw new Error(`"format" must be one of: ${valid.join(", ")}`);
+        }
+        format = a.format;
+    }
+    // Clamp numeric caps to safe ranges — never trust the caller blindly.
+    let maxPaths;
+    if (a.maxPaths !== undefined && a.maxPaths !== null) {
+        const n = Number(a.maxPaths);
+        if (!Number.isFinite(n) || n < 1) {
+            throw new Error('"maxPaths" must be a positive number.');
+        }
+        maxPaths = Math.min(Math.floor(n), 200);
+    }
+    let maxDepth;
+    if (a.maxDepth !== undefined && a.maxDepth !== null) {
+        const n = Number(a.maxDepth);
+        if (!Number.isFinite(n) || n < 1) {
+            throw new Error('"maxDepth" must be a positive number.');
+        }
+        maxDepth = Math.min(Math.floor(n), 50);
+    }
+    return {
+        from: a.from,
+        to: a.to,
+        all: a.all === true,
+        maxPaths,
+        maxDepth,
+        viaKind,
+        format,
+    };
+}
 export function validateSmartDiffArgs(args) {
     if (!args || typeof args !== "object")
         return { scope: "unstaged" };

package/dist/handlers/module-route.d.ts

@@ -0,0 +1,20 @@
+import type { AstIndexClient } from "../ast-index/client.js";
+import type { ModuleRouteArgs } from "../core/validation.js";
+/**
+ * module_route — transitive dependency path(s) between two modules.
+ *
+ * Thin wrapper over ast-index 3.44 `module-route`. The CLI already
+ * produces compact, purpose-built output (a path listing, or
+ * mermaid/dot/json for diagramming), so the handler only frames it and
+ * handles the empty / degraded cases — it does not re-parse the graph.
+ */
+export declare function handleModuleRoute(args: ModuleRouteArgs, _projectRoot: string, astIndex: AstIndexClient): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    meta: {
+        files: string[];
+    };
+}>;
+//# sourceMappingURL=module-route.d.ts.map

package/dist/handlers/module-route.js

@@ -0,0 +1,73 @@
+/**
+ * module_route — transitive dependency path(s) between two modules.
+ *
+ * Thin wrapper over ast-index 3.44 `module-route`. The CLI already
+ * produces compact, purpose-built output (a path listing, or
+ * mermaid/dot/json for diagramming), so the handler only frames it and
+ * handles the empty / degraded cases — it does not re-parse the graph.
+ */
+export async function handleModuleRoute(args, _projectRoot, astIndex) {
+    // Degradation check — same contract as module_info.
+    if (astIndex.isDisabled() || astIndex.isOversized()) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "⚠ ast-index unavailable — module_route requires ast-index.\n" +
+                        "DEGRADED: Use module_info() on each module + related_files() to trace dependencies manually.",
+                },
+            ],
+            meta: { files: [] },
+        };
+    }
+    const output = await astIndex.moduleRoute({
+        from: args.from,
+        to: args.to,
+        all: args.all,
+        maxPaths: args.maxPaths,
+        maxDepth: args.maxDepth,
+        viaKind: args.viaKind,
+        format: args.format,
+    });
+    const header = `MODULE ROUTE: ${args.from} → ${args.to}`;
+    if (output == null) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${header}\n\n` +
+                        "⚠ module-route failed (index unavailable or command error).\n" +
+                        "HINT: run `npx token-pilot doctor` to check ast-index, or fall back to module_info().",
+                },
+            ],
+            meta: { files: [] },
+        };
+    }
+    const body = output.trim();
+    if (body.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${header}\n\n` +
+                        `No dependency path returned from "${args.from}" to "${args.to}" ` +
+                        `(within ${args.maxDepth ?? 20} hops).\n` +
+                        "This means one of:\n" +
+                        "  • the modules are genuinely unrelated, or\n" +
+                        "  • the module-dependency graph isn't indexed yet — run `ast-index rebuild`.\n" +
+                        'HINT: also try a higher "maxDepth" / wider "viaKind", or module_info() to confirm each module resolves.',
+                },
+            ],
+            meta: { files: [] },
+        };
+    }
+    // For machine formats (json/mermaid/dot) pass the payload through clean —
+    // a header would corrupt a diagram/parse. Text format gets the header.
+    const isMachineFormat = args.format === "json" || args.format === "mermaid" || args.format === "dot";
+    const text = isMachineFormat ? body : `${header}\n\n${body}`;
+    return {
+        content: [{ type: "text", text }],
+        meta: { files: [] },
+    };
+}
+//# sourceMappingURL=module-route.js.map

package/dist/index.js

@@ -1625,12 +1625,12 @@ Usage:
 Quick start:
   npx token-pilot init              Setup .mcp.json (token-pilot + context-mode)
 
-MCP Tools (22):
+MCP Tools (23):
   smart_read, read_symbol, read_symbols, read_range, read_section, read_diff,
   read_for_edit, smart_read_many, find_usages, find_unused, related_files,
   outline, project_overview, session_analytics, code_audit, module_info,
-  smart_diff, explore_area, smart_log, test_summary, session_snapshot,
-  session_budget
+  module_route, smart_diff, explore_area, smart_log, test_summary,
+  session_snapshot, session_budget
 `);
     process.exit(0);
 }