@specship/specship-win32-arm64 0.16.0 → 0.18.0

package/lib/dist/mcp/tools.js

@@ -17,6 +17,8 @@ exports.getStaticTools = getStaticTools;
 const directory_1 = require("../directory");
 const statusline_1 = require("../statusline");
 const model_context_1 = require("./model-context");
+const miner_1 = require("../reflect/miner");
+const session_outcomes_1 = require("../reflect/session-outcomes");
 // Lazy-load the heavy SpecShip chain off the MCP startup path — see the same
 // helper in engine.ts. ToolHandler must load to answer tools/list (static
 // schemas), but it must NOT drag in sqlite/query layers before the daemon binds;
@@ -641,6 +643,22 @@ class ToolHandler {
                 // economics that justify trimming don't apply, so they always survive.
                 visible = visible.filter(t => TINY_REPO_CORE_TOOLS.has(t.name) || t.name.startsWith('designer_'));
             }
+            // Haiku-tier menu trim (LOWMODEL-DOC, REQ-LOWMODEL-004): small-model
+            // tool choice degrades with menu size, so the code-graph group trims
+            // to the core three; spec/link tools and enabled integrations are
+            // untouched. Composes with the tiny-repo gate as an intersection.
+            // Schemas never vary — only the list; `execute()` still answers a
+            // trimmed-away tool for clients that cached the full list (A2).
+            if ((0, model_context_1.detectModelTier)(this.cg.getProjectRoot()) === 'haiku') {
+                const HAIKU_CORE = new Set(['specship_explore', 'specship_search', 'specship_node']);
+                const CODE_GRAPH_GROUP = new Set([
+                    'specship_explore', 'specship_search', 'specship_node',
+                    'specship_callers', 'specship_callees', 'specship_impact',
+                    'specship_files', 'specship_status',
+                    'specship_maintainability', 'specship_fitness',
+                ]);
+                visible = visible.filter(t => !CODE_GRAPH_GROUP.has(t.name) || HAIKU_CORE.has(t.name));
+            }
             return visible.map(tool => {
                 if (tool.name === 'specship_explore') {
                     return {
@@ -831,6 +849,30 @@ class ToolHandler {
      * disables) and, on haiku/sonnet, compresses the response's prose
      * scaffolding — fenced code stays byte-verbatim. Full tier is identity.
      */
+    /**
+     * Tier-change listeners (LOWMODEL-DOC, REQ-LOWMODEL-004.A3): the haiku
+     * menu trim changes `tools/list`, so a mid-session /model switch must ride
+     * an MCP `notifications/tools/list_changed`. Sessions subscribe here; the
+     * change is detected on the next code-graph call (the same funnel that
+     * reads the tier for compaction).
+     */
+    tierListeners = new Set();
+    lastTier = null;
+    addTierChangeListener(cb) {
+        this.tierListeners.add(cb);
+        return () => this.tierListeners.delete(cb);
+    }
+    noteTier(tier) {
+        if (this.lastTier !== null && tier !== this.lastTier) {
+            for (const cb of this.tierListeners) {
+                try {
+                    cb(tier);
+                }
+                catch { /* a listener must never break a tool call */ }
+            }
+        }
+        this.lastTier = tier;
+    }
     withModelCompaction(result) {
         if (result.isError)
             return result;
@@ -842,6 +884,7 @@ class ToolHandler {
             root = null;
         }
         const tier = (0, model_context_1.detectModelTier)(root);
+        this.noteTier(tier);
         if (tier === 'full')
             return result;
         const first = result.content?.[0];
@@ -1106,7 +1149,7 @@ class ToolHandler {
             kinds: kind ? [kind] : undefined,
         });
         if (results.length === 0) {
-            return this.textResult(`No results found for "${query}"`);
+            return this.missWithSuggestions(cg, 'Query', query);
         }
         // Down-rank generated files within the FTS-returned set so a search
         // for "Send" surfaces the hand-written keeper before .pb.go stubs
@@ -1119,6 +1162,47 @@ class ToolHandler {
         const formatted = this.formatSearchResults(ranked);
         return this.textResult(this.truncateOutput(formatted));
     }
+    /**
+     * Anti-flounder miss template (LOWMODEL-DOC, REQ-LOWMODEL-001): a "not
+     * found" that just says "not found" leaves the agent — small models
+     * especially — to guess its next move, and the guess is usually grep/Read.
+     * Instead: name the nearest REAL symbols (token-level lookup, since the
+     * full query already failed FTS+LIKE) and end with a copy-pasteable next
+     * call. Applies at every tier.
+     */
+    missWithSuggestions(cg, kindLabel, query) {
+        // Split on separators AND camelCase so "AuthServic.logn" still yields
+        // useful probes ("Auth", "Servic", "logn" → LIKE finds AuthService/login).
+        const tokens = [...new Set(query
+                .split(/[\s._:\->#/\\]+/)
+                .flatMap((t) => t.split(/(?=[A-Z])/))
+                .map((t) => t.trim())
+                .filter((t) => t.length >= 3))].slice(0, 6);
+        const seen = new Set();
+        const suggestions = [];
+        for (const token of tokens) {
+            for (const r of cg.searchNodes(token, { limit: 3 })) {
+                const key = r.node.qualifiedName;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                suggestions.push({ name: key, where: `${r.node.filePath}:${r.node.startLine}` });
+                if (suggestions.length >= 4)
+                    break;
+            }
+            if (suggestions.length >= 4)
+                break;
+        }
+        const lines = [`${kindLabel} "${query}" not found in the index.`];
+        if (suggestions.length > 0) {
+            lines.push(`Closest indexed symbols: ${suggestions.map((s) => `${s.name} (${s.where})`).join(' · ')}`);
+            lines.push(`Next: specship_explore "${suggestions.map((s) => s.name).join(' ')}"`);
+        }
+        else {
+            lines.push('Nothing close in the index either. Next: specship_explore with broader words from the question — it also matches file names and doc text.');
+        }
+        return this.textResult(lines.join('\n'));
+    }
     /**
      * Handle specship_callers
      */
@@ -1130,7 +1214,7 @@ class ToolHandler {
         const limit = (0, utils_1.clamp)(args.limit || 20, 1, 100);
         const allMatches = this.findAllSymbols(cg, symbol);
         if (allMatches.nodes.length === 0) {
-            return this.textResult(`Symbol "${symbol}" not found in the codebase`);
+            return this.missWithSuggestions(cg, 'Symbol', symbol);
         }
         // Aggregate callers across all matching symbols
         const seen = new Set();
@@ -1160,7 +1244,7 @@ class ToolHandler {
         const limit = (0, utils_1.clamp)(args.limit || 20, 1, 100);
         const allMatches = this.findAllSymbols(cg, symbol);
         if (allMatches.nodes.length === 0) {
-            return this.textResult(`Symbol "${symbol}" not found in the codebase`);
+            return this.missWithSuggestions(cg, 'Symbol', symbol);
         }
         // Aggregate callees across all matching symbols
         const seen = new Set();
@@ -1190,7 +1274,7 @@ class ToolHandler {
         const depth = (0, utils_1.clamp)(args.depth || 2, 1, 10);
         const allMatches = this.findAllSymbols(cg, symbol);
         if (allMatches.nodes.length === 0) {
-            return this.textResult(`Symbol "${symbol}" not found in the codebase`);
+            return this.missWithSuggestions(cg, 'Symbol', symbol);
         }
         // Aggregate impact across all matching symbols
         const mergedNodes = new Map();
@@ -1333,7 +1417,7 @@ class ToolHandler {
      * whose qualifiedName contains another named token (`PmsProductServiceImpl::list`),
      * dropping unrelated `OmsOrderService::list`.
      */
-    buildFlowFromNamedSymbols(cg, query) {
+    buildFlowFromNamedSymbols(cg, query, tier = 'full') {
         const EMPTY = { text: '', pathNodeIds: new Set(), namedNodeIds: new Set(), uniqueNamedNodeIds: new Set() };
         try {
             const CALLABLE = new Set(['method', 'function', 'component', 'constructor']);
@@ -1468,11 +1552,23 @@ class ToolHandler {
                 out.push('## Flow (call path among the symbols you queried)', '');
                 for (let i = 0; i < best.length; i++) {
                     const step = best[i];
-                    if (step.edge) {
-                        const sy = this.synthEdgeNote(step.edge);
-                        out.push(`   ↓ ${sy ? sy.compact : step.edge.kind}`);
+                    if (tier === 'haiku') {
+                        // LOWMODEL-DOC REQ-LOWMODEL-003: small models don't synthesize
+                        // the flow from evidence — render each hop as ONE explicit line
+                        // with its mechanism inline. Additive formatting only; the code
+                        // bodies below are identical to the full tier's (A2).
+                        const mech = step.edge
+                            ? ` — via ${(this.synthEdgeNote(step.edge)?.compact ?? step.edge.kind)}`
+                            : '';
+                        out.push(`${i + 1}. ${i > 0 ? '→ ' : ''}${step.node.name} (${step.node.filePath}:${step.node.startLine})${mech}`);
+                    }
+                    else {
+                        if (step.edge) {
+                            const sy = this.synthEdgeNote(step.edge);
+                            out.push(`   ↓ ${sy ? sy.compact : step.edge.kind}`);
+                        }
+                        out.push(`${i + 1}. ${step.node.name} (${step.node.filePath}:${step.node.startLine})`);
                     }
-                    out.push(`${i + 1}. ${step.node.name} (${step.node.filePath}:${step.node.startLine})`);
                 }
                 out.push('');
             }
@@ -1511,6 +1607,43 @@ class ToolHandler {
      * CLAUDE.md). Facts are few and human-authored, so a linear scan + token
      * match is cheap and precise enough.
      */
+    /**
+     * Prior-work recall (LEARN-DOC, REQ-LEARN-003): sessions from this
+     * project's ingested task history that EDITED the files this exploration
+     * touches — date, opening prompt, files, overlapping workflow runs.
+     * Deterministic join over `claude_*` + `workflow_runs`; scoped to this
+     * project in both path forms; silent when the tables are absent (ingest
+     * never ran) or nothing matches. Capped tiny so the hot path stays lean.
+     */
+    buildPriorWorkSection(cg, subgraph) {
+        try {
+            const db = cg.getSpecQueries()['db'];
+            const files = [...new Set([...subgraph.nodes.values()].map((n) => n.filePath))].slice(0, 12);
+            const forms = (0, miner_1.projectPathForms)(cg.getProjectRoot());
+            const sessions = (0, session_outcomes_1.sessionsTouchingFiles)(db, forms, files);
+            if (sessions.length === 0)
+                return '';
+            const linesOut = ['## Prior work', '_Past sessions that edited these files (local task history — deterministic, from ingested transcripts)._', ''];
+            for (const id of sessions) {
+                const o = (0, session_outcomes_1.sessionOutcome)(db, id);
+                if (!o)
+                    continue;
+                const date = o.startedAt ? new Date(o.startedAt).toISOString().slice(0, 10) : '—';
+                const runs = o.workflowRuns.length
+                    ? ` · runs in window: ${o.workflowRuns.map((r) => `${r.name} (${r.status})`).join(', ')}`
+                    : '';
+                const links = o.linksAsserted > 0 ? ` · ${o.linksAsserted} spec link(s) asserted` : '';
+                linesOut.push(`- ${date} · session ${o.sessionId.slice(0, 8)} · "${o.firstPrompt || '(no prompt text)'}" · edited: ${o.filesEdited.slice(0, 5).map((f) => f.split('/').pop()).join(', ')}${o.filesEdited.length > 5 ? ` +${o.filesEdited.length - 5}` : ''}${runs}${links}`);
+            }
+            if (linesOut.length <= 3)
+                return '';
+            linesOut.push('');
+            return linesOut.join('\n');
+        }
+        catch {
+            return ''; // recall must never break an exploration
+        }
+    }
     buildDomainFactsSection(cg, query) {
         let facts;
         try {
@@ -2042,6 +2175,13 @@ class ToolHandler {
         const domainFacts = this.buildDomainFactsSection(cg, query);
         if (domainFacts)
             lines.push(domainFacts);
+        // Prior work (LEARN-DOC, REQ-LEARN-003): if past sessions edited the
+        // files this exploration resolves to, surface them inline — the tier-3
+        // task-history recall, riding the same additive/silent pattern as domain
+        // facts (no new tool; one indexed query; nothing on no-match).
+        const priorWork = this.buildPriorWorkSection(cg, subgraph);
+        if (priorWork)
+            lines.push(priorWork);
         // Blast radius (always-on, compact): for the entry symbols, who depends on
         // them + which tests cover them — locations only, no source — so the agent
         // knows what to update/verify before editing without a separate call.
@@ -2082,7 +2222,7 @@ class ToolHandler {
         // Compute the flow spine once — used both to prepend the Flow section (below)
         // and to gate adaptive source sizing: files on the spine get full source,
         // off-spine peers skeletonize.
-        const flow = this.buildFlowFromNamedSymbols(cg, query);
+        const flow = this.buildFlowFromNamedSymbols(cg, query, (0, model_context_1.detectModelTier)(cg.getProjectRoot()));
         // Polymorphic-sibling detector for adaptive sizing. A class that implements/
         // extends a supertype shared by >= MIN_SIBLINGS classes is one of many
         // INTERCHANGEABLE implementations (OkHttp's 14 `: Interceptor` classes —
@@ -2663,7 +2803,7 @@ class ToolHandler {
         const lineHint = typeof args.line === 'number' && args.line > 0 ? args.line : undefined;
         let matches = this.findSymbolMatches(cg, symbol);
         if (matches.length === 0) {
-            return this.textResult(`Symbol "${symbol}" not found in the codebase`);
+            return this.missWithSuggestions(cg, 'Symbol', symbol);
         }
         // Disambiguate a heavily-overloaded name to a specific definition the caller
         // pinned by file/line (the `file:line` a trail or another tool showed it) —