wyrm-mcp 5.2.2 → 5.4.0

package/dist/index.js

@@ -58,6 +58,177 @@ import { Goals } from "./goals.js";
 import { OutboundMcpClient } from "./mcp-client.js";
 import { AgentLoop } from "./agent-loop.js";
 import { AgentDaemon } from "./agent-daemon.js";
+import { getUpdateStatus, emitStartupVersionBanner } from "./version-check.js";
+import { getCapabilities, renderCapabilityBriefing } from "./capabilities.js";
+import { spawn as cpSpawn } from "child_process";
+import { makeEstimator, applyBudget, resolveBudget } from "./token-budget.js";
+import { loadWeightsFromEnv, score as rankScore } from "./context-ranking.js";
+import { SessionSeen } from "./session-seen.js";
+import { fileURLToPath as _versionFileURLToPath } from "url";
+import { dirname as _versionDirname, join as _versionJoin } from "path";
+import { readFileSync as _versionReadFile, existsSync as _versionExists } from "fs";
+// Update when adding/removing MCP tools so wyrm_capabilities reports accurately.
+// The ListToolsRequestSchema handler is the single source of truth at runtime —
+// this constant is just for the self-description and the postinstall pitch.
+const WYRM_TOOL_COUNT = 114;
+// Spec 014 — token budgeting subsystem. Lazy-init on first use.
+const tokenEstimator = makeEstimator();
+const rankWeights = loadWeightsFromEnv();
+let _sessionSeen = null;
+function sessionSeen() {
+    if (!_sessionSeen)
+        _sessionSeen = new SessionSeen(db.getDatabase());
+    return _sessionSeen;
+}
+/**
+ * Spec 014 budgeted wyrm_context_build path.
+ *
+ * Renders a stable preamble (ground truths) + dynamic body (memory
+ * artifacts, scaffold). Items below the token-budget cutoff elide to
+ * one-line stubs the AI can recall via wyrm_recall.
+ */
+function runBudgetedContextBuild(opts) {
+    // Resolve effective budget per spec 014 D1 precedence: call > env > fallback.
+    const budget = resolveBudget({
+        callArg: opts.maxTokens,
+        envValue: process.env.WYRM_CONTEXT_TOKEN_BUDGET,
+        clientName: null, // clientInfo wiring is a follow-up; env override is the lever today
+    });
+    const seen = opts.sessionId ? sessionSeen().getSeen(opts.sessionId) : new Set();
+    // --- Stable preamble (ground truths) ---
+    const truthsText = groundTruths.formatForContext(opts.project.id);
+    const truthsTokens = tokenEstimator.count(truthsText ?? '');
+    // Strict budget mode (D3) elides truths if even the preamble overflows;
+    // default behavior is to warn-and-overflow per spec 014.
+    let preambleText = truthsText ?? '';
+    let preambleEmitted = truthsTokens;
+    if (truthsTokens > budget * 0.5 && !opts.strictBudget) {
+        process.stderr.write(`[wyrm_context_build] ground truths consume ${truthsTokens} of ${budget}-token budget — body will be heavily elided. Pass strict_budget:true to elide truths too.\n`);
+    }
+    if (opts.strictBudget && truthsTokens > budget * 0.5) {
+        // Strict mode: keep truths brief
+        preambleText = (truthsText ?? '').slice(0, budget * 2); // 2 chars/token rough cap on chars
+        preambleEmitted = tokenEstimator.count(preambleText);
+    }
+    // --- Build candidate body items: best scaffold + memory artifacts ---
+    const items = [];
+    // Scaffold (treated as a single candidate)
+    const scaffoldMatch = scaffoldLib.findBest(opts.task, opts.project.id);
+    if (scaffoldMatch) {
+        const sText = scaffoldLib.formatForContext(scaffoldMatch);
+        const sId = scaffoldMatch.scaffold.id;
+        items.push({
+            item: { kind: 'scaffold', id: sId, title: scaffoldMatch.scaffold.problem_type, body: sText },
+            key: `scaffold:${sId}`,
+            inlineCost: tokenEstimator.count(sText),
+            stubCost: 20,
+            // Scaffold is high-relevance by definition; assign generous score.
+            score: rankScore({ confidence: 0.9, relevance: 0.9, updatedAt: new Date().toISOString() }, rankWeights),
+        });
+    }
+    // Memory artifacts via recall (which returns id-level results with relevance scores)
+    const recalled = memory.recall(opts.project.id, opts.task, {
+        limit: 20,
+        minConfidence: opts.minConfidence ?? 0.2,
+    });
+    for (const r of recalled) {
+        const a = r.artifact;
+        // Skip kind filter mismatches if caller specified one
+        if (opts.kinds && opts.kinds.length > 0 && !opts.kinds.includes(a.kind))
+            continue;
+        const body = [
+            `**${a.kind.toUpperCase()}** · ${a.problem}`,
+            a.constraints ? `Constraints: ${a.constraints}` : '',
+            a.validated_fix ? `Fix: ${a.validated_fix}` : '',
+            a.why_it_worked ? `Why: ${a.why_it_worked}` : '',
+        ].filter(Boolean).join('\n');
+        items.push({
+            item: { kind: 'memory', id: a.id, title: a.problem.slice(0, 60), body },
+            key: `memory:${a.id}`,
+            inlineCost: tokenEstimator.count(body),
+            stubCost: 25,
+            score: rankScore({
+                confidence: a.confidence,
+                relevance: r.relevance_score,
+                updatedAt: a.updated_at,
+            }, rankWeights),
+        });
+    }
+    // --- Apply budget ---
+    const result = applyBudget(items, {
+        budget,
+        alreadySeen: seen,
+        reserved: opts.strictBudget ? 0 : preambleEmitted,
+    });
+    // --- Mark inlined items as seen for this session ---
+    if (opts.sessionId) {
+        sessionSeen().markBulk(opts.sessionId, result.inline.map((it) => ({ id: it.id, kind: it.kind, mode: 'inline' })));
+        sessionSeen().markBulk(opts.sessionId, result.elided.map((e) => ({ id: e.item.id, kind: e.item.kind, mode: 'stub' })));
+    }
+    // --- Render output ---
+    const lines = [];
+    lines.push(`🐉 **Context Brief** — "${opts.task}"`);
+    lines.push('');
+    lines.push('## Ground truths (stable preamble)');
+    lines.push('');
+    lines.push(preambleText || '_no ground truths set for this project yet_');
+    lines.push('');
+    lines.push('## Task-relevant memory');
+    lines.push('');
+    for (const it of result.inline) {
+        lines.push(`### [${it.kind}:${it.id}] ${it.title}`);
+        lines.push(it.body);
+        lines.push('');
+    }
+    if (result.elided.length > 0) {
+        lines.push('## Elided to stubs');
+        lines.push('');
+        lines.push('_Below the budget cutoff or already seen this session. Recall with `wyrm_recall(id)`:_');
+        lines.push('');
+        for (const e of result.elided) {
+            const tag = e.reason === 'seen' ? 'shown earlier in session' : `~${e.stubCost} tokens`;
+            lines.push(`- [${e.item.kind}:${e.item.id}] ${e.item.title} · ${tag}`);
+        }
+        lines.push('');
+    }
+    lines.push('---');
+    lines.push(`_Budget: ${result.tokensInline}/${budget} tokens inline · ${result.elided.length} stub${result.elided.length === 1 ? '' : 's'} · estimator: ${tokenEstimator.source}_`);
+    const text = lines.join('\n');
+    // Telemetry — fire-and-forget via the existing tool_call_log surface.
+    try {
+        toolAnalytics.log({
+            tool_name: 'wyrm_context_build',
+            project_id: opts.project.id,
+            args: {
+                budget,
+                items_total: items.length,
+                items_inline: result.inline.length,
+                items_elided: result.elided.length,
+                tokens_inline: result.tokensInline,
+                tokens_stubs: result.tokensStubs,
+            },
+            success: true,
+            latency_ms: 0,
+        });
+    }
+    catch { /* never fail context_build on telemetry */ }
+    return { content: [{ type: 'text', text }] };
+}
+// Resolve our own package.json once so wyrm_check_update knows what version we are.
+const WYRM_PACKAGE_VERSION = (() => {
+    try {
+        const here = _versionDirname(_versionFileURLToPath(import.meta.url));
+        for (const p of [_versionJoin(here, '..', 'package.json'), _versionJoin(here, '..', '..', 'package.json')]) {
+            if (_versionExists(p)) {
+                const v = JSON.parse(_versionReadFile(p, 'utf-8')).version;
+                if (typeof v === 'string')
+                    return v;
+            }
+        }
+    }
+    catch { /* fall through */ }
+    return 'unknown';
+})();
 const db = new WyrmDB();
 const sync = new WyrmSync(db);
 const graph = new KnowledgeGraph(db.getDatabase());
@@ -1094,19 +1265,22 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: "wyrm_context_build",
-            description: "Assemble an optimized memory brief for the current task — a formatted block of relevant patterns, lessons, reasoning traces, and anti-patterns from past sessions. Inject this at the start of complex tasks to give AI models the right context without bloating the whole conversation.",
+            description: "Assemble an optimized memory brief for the current task — a formatted block of relevant patterns, lessons, reasoning traces, and anti-patterns from past sessions. Inject this at the start of complex tasks to give AI models the right context without bloating the whole conversation. Pass max_tokens for budget-aware delivery (low-score items elide to recallable stubs); omit max_tokens for legacy unbounded behaviour.",
             inputSchema: {
                 type: "object",
                 properties: {
                     projectPath: { type: "string", description: "Project to build context from" },
                     task: { type: "string", description: "Describe the current task in detail — the more specific, the better the recall" },
-                    maxItems: { type: "number", description: "Max knowledge items to include (default: 10, max: 20)" },
+                    maxItems: { type: "number", description: "Max knowledge items to include (default: 10, max: 20). Ignored when max_tokens is set." },
                     kinds: {
                         type: "array",
                         items: { type: "string", enum: ["reasoning_trace", "lesson", "pattern", "anti_pattern", "heuristic"] },
                         description: "Limit to specific artifact kinds (default: all)",
                     },
                     minConfidence: { type: "number", description: "Minimum confidence threshold (default: 0.3)" },
+                    max_tokens: { type: "number", description: "Spec 014: token budget. Default per model tier auto-detected (Opus 4096 / Sonnet 8192 / Haiku 12288), env WYRM_CONTEXT_TOKEN_BUDGET, fallback 4096. Items below budget cutoff elide to stubs the AI can deref with wyrm_recall." },
+                    session_id: { type: "number", description: "Spec 014: session id for already-seen dedup. Items already shown in this session render as one-line references." },
+                    strict_budget: { type: "boolean", description: "Spec 014: if true, elide ground truths too when preamble exceeds budget. Default false — ground truths are foundation and never elided unless explicitly requested." },
                 },
                 required: ["projectPath", "task"],
             },
@@ -1346,6 +1520,37 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["project_path"],
             },
         },
+        {
+            name: "wyrm_capabilities",
+            description: "Return Wyrm's self-description: feature inventory, why-it-matters per feature, runtime state (vector provider, encryption, agent), and the canonical pitch. Call this at session start so you know exactly which tool to reach for instead of re-discovering the surface.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    format: { type: "string", enum: ["json", "markdown"], description: "Response shape: 'json' (structured) or 'markdown' (rendered briefing). Default: markdown." },
+                },
+            },
+        },
+        {
+            name: "wyrm_check_update",
+            description: "Check whether a newer wyrm-mcp is available on npm. Cached 24h by default; pass force:true to bypass cache.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    force: { type: "boolean", description: "Bypass the 24-hour cache and re-query the registry." },
+                },
+            },
+        },
+        {
+            name: "wyrm_self_update",
+            description: "Run `npm install -g wyrm-mcp@latest` to upgrade. Returns the install transcript. Requires the operator to have write access to the global npm prefix.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    confirm: { type: "boolean", description: "Must be true to actually run the upgrade (safety guard)." },
+                },
+                required: ["confirm"],
+            },
+        },
         // ============================================================
         // v3.9.0 — Counter-pattern detection (failure_patterns)
         // ============================================================
@@ -2854,10 +3059,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     return { content: [{ type: "text", text: `🐉 Feedback recorded ${icon}\n\n- Artifact #${artifactId}: "${artifact.problem.slice(0, 60)}"\n- New confidence: ${(updated.confidence * 100).toFixed(0)}%\n- Total uses: ${updated.reuse_count} (✅ ${updated.reuse_success_count} / ❌ ${updated.reuse_failure_count})` }] };
                 }
                 case "wyrm_context_build": {
-                    const { projectPath: cbPath, task: cbTask, maxItems: cbMax, kinds: cbKinds, minConfidence: cbMinConf } = args;
+                    const { projectPath: cbPath, task: cbTask, maxItems: cbMax, kinds: cbKinds, minConfidence: cbMinConf, max_tokens: cbMaxTokens, session_id: cbSessionId, strict_budget: cbStrictBudget, } = args;
                     const cbProject = db.getProject(cbPath);
                     if (!cbProject)
                         return { content: [{ type: "text", text: `Project not found: ${cbPath}` }], isError: true };
+                    // Spec 014 budgeted path — only when max_tokens is supplied (backwards compat: criterion 7).
+                    // Kill switch: WYRM_DISABLE_TOKEN_BUDGET=1 routes everything to legacy.
+                    const wantsBudget = cbMaxTokens != null && !process.env.WYRM_DISABLE_TOKEN_BUDGET;
+                    if (wantsBudget) {
+                        return runBudgetedContextBuild({
+                            project: cbProject,
+                            task: cbTask,
+                            maxTokens: cbMaxTokens,
+                            sessionId: cbSessionId,
+                            strictBudget: cbStrictBudget === true,
+                            kinds: cbKinds,
+                            minConfidence: cbMinConf,
+                        });
+                    }
                     const sections = [];
                     // Section 1: Ground truths (~1200 char budget)
                     const truthsText = groundTruths.formatForContext(cbProject.id);
@@ -3250,6 +3469,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         db.vacuum();
                         text += `- Vacuumed database\n`;
                     }
+                    // Spec 014: prune session_seen_artifacts older than WYRM_SEEN_TTL_DAYS (default 7).
+                    try {
+                        const ttlDays = parseInt(process.env.WYRM_SEEN_TTL_DAYS ?? '7', 10);
+                        const pruned = sessionSeen().prune(Number.isFinite(ttlDays) && ttlDays > 0 ? ttlDays : 7);
+                        if (pruned > 0)
+                            text += `- Pruned ${pruned} session_seen_artifacts rows older than ${ttlDays}d\n`;
+                    }
+                    catch (e) { /* never fail maintenance on this */ }
                     db.checkpoint();
                     text += `- Checkpointed WAL\n`;
                     const stats = db.getStats();
@@ -4068,6 +4295,67 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     }
                     return { content: [{ type: "text", text: injText }] };
                 }
+                case "wyrm_capabilities": {
+                    const { format: capFmt = "markdown" } = args;
+                    const report = getCapabilities(db.getDatabase(), WYRM_TOOL_COUNT, {
+                        detectVectorProvider: () => {
+                            if (process.env.WYRM_VECTOR_PROVIDER === 'openai')
+                                return 'openai';
+                            return 'ollama';
+                        },
+                        hasEncryption: () => !!process.env.WYRM_ENCRYPTION_KEY,
+                        isFederationEnabled: () => true,
+                        isAgentRunning: () => {
+                            try {
+                                return agentDaemon.status().running;
+                            }
+                            catch {
+                                return null;
+                            }
+                        },
+                    });
+                    if (capFmt === 'json') {
+                        return { content: [{ type: 'text', text: JSON.stringify(report, null, 2) }] };
+                    }
+                    return { content: [{ type: 'text', text: renderCapabilityBriefing(report) }] };
+                }
+                case "wyrm_check_update": {
+                    const { force = false } = args;
+                    const status = await getUpdateStatus(db.getDatabase(), WYRM_PACKAGE_VERSION, { force });
+                    let text = `🐉 **Update check**\n\n- Current: ${status.current}\n- Latest: ${status.latest ?? 'unknown (offline?)'}\n- Update available: ${status.updateAvailable ? 'yes' : 'no'}\n- Checked: ${status.checkedAt} (${status.source})`;
+                    if (status.updateAvailable) {
+                        text += `\n\nRun \`wyrm_self_update\` with \`confirm: true\` to upgrade, or \`npm install -g wyrm-mcp@latest\` from your shell.`;
+                    }
+                    return { content: [{ type: 'text', text }] };
+                }
+                case "wyrm_self_update": {
+                    const { confirm: selfConfirm = false } = args;
+                    if (!selfConfirm) {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: '🐉 **Self-update declined**: call again with `confirm: true` to run `npm install -g wyrm-mcp@latest`. Note: requires write access to the global npm prefix.',
+                                }],
+                        };
+                    }
+                    const transcript = await new Promise((resolve) => {
+                        const proc = cpSpawn('npm', ['install', '-g', 'wyrm-mcp@latest'], { stdio: ['ignore', 'pipe', 'pipe'] });
+                        const chunks = [];
+                        proc.stdout.on('data', (b) => chunks.push(b.toString()));
+                        proc.stderr.on('data', (b) => chunks.push(b.toString()));
+                        proc.on('close', (code) => {
+                            chunks.push(`\n[exit ${code ?? 'unknown'}]`);
+                            resolve(chunks.join(''));
+                        });
+                        proc.on('error', (err) => resolve(`spawn failed: ${err.message}`));
+                    });
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `🐉 **Self-update transcript**\n\n\`\`\`\n${transcript}\n\`\`\`\n\nRestart your MCP client to pick up the new binary.`,
+                            }],
+                    };
+                }
                 // ==================== v3.5.0 TOOLS ====================
                 case "wyrm_prune": {
                     const { project_id: pruneProjectId, min_confidence: pruneMinConf = 0.3, older_than_days: pruneOlderDays = 90, types: pruneTypes, dry_run: pruneDryRun = true, confirm_ids: pruneConfirmIds, } = args;
@@ -4845,6 +5133,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
+    // Fire-and-forget: ping npm once a day for newer versions. Logs to stderr
+    // so it never interferes with the MCP stdio protocol.
+    emitStartupVersionBanner(db.getDatabase(), WYRM_PACKAGE_VERSION).catch(() => { });
     // Graceful shutdown — flush analytics buffer
     const shutdown = () => {
         try {