wyrm-mcp 3.3.0 → 3.4.0

package/dist/index.js

@@ -32,6 +32,9 @@ import { IndexingPipeline } from "./indexer.js";
 import { KnowledgeGraph } from "./knowledge-graph.js";
 import { MemoryArtifacts } from "./memory-artifacts.js";
 import { GroundTruths, ReasoningScaffolds } from "./intelligence.js";
+import { classifyCapture } from "./capture.js";
+import { injectSystemPrompt } from "./autoconfig.js";
+export { classifyCapture } from "./capture.js";
 import { initializeLicense, getLicenseInfo, hasFeature, getTier, activateLicense } from "./license.js";
 import { WyrmAnalytics } from "./analytics.js";
 import { WyrmCloudBackup } from "./cloud-backup.js";
@@ -223,6 +226,7 @@ const READ_ONLY_TOOLS = new Set([
     "wyrm_context_build",
     "wyrm_truth_get",
     "wyrm_scaffold_get",
+    "wyrm_session_prime",
 ]);
 /** Tools that mutate data — invalidate relevant caches */
 const WRITE_TOOLS = new Set([
@@ -252,10 +256,15 @@ const WRITE_TOOLS = new Set([
     "wyrm_scaffold_save",
     "wyrm_distill",
     "wyrm_review",
+    "wyrm_capture",
+    "wyrm_import_git",
+    "wyrm_import_pr",
+    "wyrm_import_rules",
+    "wyrm_inject_prompt",
 ]);
 const server = new Server({
     name: "wyrm",
-    version: "3.2.0",
+    version: "3.4.0",
 }, {
     capabilities: {
         tools: {},
@@ -983,6 +992,101 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["artifactId", "approved"],
             },
         },
+        // ==================== v3.4.0 TOOLS ====================
+        {
+            name: "wyrm_capture",
+            description: "Unified capture with auto-classification. Detects whether content is a quest, ground truth, or memory artifact and stores it automatically. Use this for any quick thought, decision, task, or lesson you want to preserve.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    content: { type: "string", description: "The text to classify and store" },
+                    project_id: { type: "number", description: "Project ID to associate with (optional)" },
+                    tags: { type: "array", items: { type: "string" }, description: "Optional tags" },
+                    mode: { type: "string", enum: ["auto", "quest", "truth", "memory"], description: "Override auto-classification mode" },
+                },
+                required: ["content"],
+            },
+        },
+        {
+            name: "wyrm_session_prime",
+            description: "Assemble a rich session context brief — ground truths, reasoning scaffold, memory artifacts, and active quests — in a single call. Use at the start of any complex conversation to load all relevant project knowledge.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_id: { type: "number", description: "Project ID to prime for" },
+                    project_name: { type: "string", description: "Project name (used if project_id not given)" },
+                    task: { type: "string", description: "Current task — used to find best scaffold and relevant memories" },
+                    log_session: { type: "boolean", description: "If true, also create a session log entry (default: false)" },
+                },
+            },
+        },
+        {
+            name: "wyrm_import_git",
+            description: "Import a list of commits into the Wyrm memory review queue. Useful for onboarding a project's history or capturing recent work.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_id: { type: "number", description: "Project ID" },
+                    commits: {
+                        type: "array",
+                        description: "Array of commit objects",
+                        items: {
+                            type: "object",
+                            properties: {
+                                message: { type: "string" },
+                                diff_summary: { type: "string" },
+                                author: { type: "string" },
+                                date: { type: "string" },
+                            },
+                            required: ["message"],
+                        },
+                    },
+                    auto_approve: { type: "boolean", description: "Skip review queue and activate immediately (default: false)" },
+                },
+                required: ["project_id", "commits"],
+            },
+        },
+        {
+            name: "wyrm_import_pr",
+            description: "Import a pull request (title, body, review comments) into the Wyrm memory review queue to extract patterns and heuristics.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_id: { type: "number", description: "Project ID" },
+                    title: { type: "string", description: "PR title" },
+                    body: { type: "string", description: "PR description / body" },
+                    review_comments: { type: "array", items: { type: "string" }, description: "Review comment strings" },
+                    auto_approve: { type: "boolean", description: "Skip review queue (default: false)" },
+                },
+                required: ["project_id", "title", "body"],
+            },
+        },
+        {
+            name: "wyrm_import_rules",
+            description: "Import a .cursorrules / copilot-instructions file into Wyrm. Parses by section and creates ground truths (for constraint/rule language) or memory artifacts (for general guidelines).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_id: { type: "number", description: "Project ID" },
+                    content: { type: "string", description: "Full text of the rules file" },
+                    format: { type: "string", enum: ["cursorrules", "copilot", "plain"], description: "Source format (default: plain)" },
+                    source_file: { type: "string", description: "Filename for provenance (optional)" },
+                },
+                required: ["project_id", "content"],
+            },
+        },
+        {
+            name: "wyrm_inject_prompt",
+            description: "Opt-in: inject a Wyrm session-prime instruction block into .github/copilot-instructions.md and/or .cursor/rules for a project. Uses managed markers so re-runs are safe.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_path: { type: "string", description: "Absolute path to the project root" },
+                    clients: { type: "array", items: { type: "string" }, description: "Clients to inject into: 'copilot', 'cursor' (default: both detected)" },
+                },
+                required: ["project_path"],
+            },
+        },
     ],
 }));
 // Tool implementations
@@ -2454,6 +2558,317 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             return { content: [{ type: "text", text: `Unknown encrypt action: ${encAction}. Use: status, enable, test` }], isError: true };
                     }
                 }
+                // ==================== v3.4.0 TOOLS ====================
+                case "wyrm_capture": {
+                    const { content: capContent, project_id: capProjId, tags: capTags, mode: capMode } = args;
+                    // Determine classification
+                    let classified = classifyCapture(capContent);
+                    if (capMode && capMode !== 'auto') {
+                        const subtypeMap = { quest: 'quest', truth: 'decision', memory: 'pattern' };
+                        classified = {
+                            type: capMode,
+                            subtype: subtypeMap[capMode] ?? capMode,
+                            confidence: 100,
+                            reasoning: `Mode override: ${capMode}`,
+                        };
+                    }
+                    const { type: capType, subtype: capSubtype, confidence: capConf, reasoning: capReasoning } = classified;
+                    const effectiveProjId = capProjId ?? null;
+                    let storedId = 0;
+                    let typeShort = '';
+                    let needsReviewNote = '';
+                    if (capType === 'quest') {
+                        if (effectiveProjId === null) {
+                            return { content: [{ type: "text", text: `🧠 Cannot capture quest without project_id. Please provide project_id.` }], isError: true };
+                        }
+                        const quest = db.addQuest(effectiveProjId, capContent.slice(0, 200), '', 'medium', capTags?.join(','));
+                        storedId = quest.id;
+                        typeShort = 'quest';
+                        cache.invalidate('wyrm_all_quests');
+                        cache.invalidate('wyrm_stats');
+                    }
+                    else if (capType === 'truth') {
+                        if (effectiveProjId === null) {
+                            return { content: [{ type: "text", text: `🧠 Cannot capture truth without project_id. Please provide project_id.` }], isError: true };
+                        }
+                        if (capMode !== 'truth' && capConf < 100) {
+                            // Store as artifact pending review
+                            const artifact = memory.add(effectiveProjId, {
+                                kind: 'pattern',
+                                problem: capContent,
+                                validatedFix: '',
+                                whyItWorked: '',
+                                tags: capTags ?? [],
+                                confidence: capConf / 100,
+                                needsReview: 1,
+                            });
+                            storedId = artifact.id;
+                            typeShort = 'mem';
+                            needsReviewNote = `\n⚠️ Stored for review — run \`wyrm_review\` to activate`;
+                        }
+                        else {
+                            const truth = groundTruths.set(effectiveProjId, {
+                                category: 'decision',
+                                key: capContent.slice(0, 60),
+                                value: capContent,
+                            });
+                            storedId = truth.id;
+                            typeShort = 'truth';
+                            cache.invalidate('wyrm_truth_get');
+                            cache.invalidate('wyrm_context_build');
+                        }
+                    }
+                    else {
+                        // memory
+                        if (effectiveProjId === null) {
+                            return { content: [{ type: "text", text: `🧠 Cannot capture memory without project_id. Please provide project_id.` }], isError: true };
+                        }
+                        const shouldAutoCreate = capConf >= 75;
+                        const artifact = memory.add(effectiveProjId, {
+                            kind: capSubtype,
+                            problem: capContent,
+                            validatedFix: '',
+                            whyItWorked: '',
+                            tags: capTags ?? [],
+                            confidence: capConf / 100,
+                            needsReview: shouldAutoCreate ? 0 : 1,
+                        });
+                        storedId = artifact.id;
+                        typeShort = 'mem';
+                        if (!shouldAutoCreate) {
+                            needsReviewNote = `\n⚠️ Stored for review — run \`wyrm_review\` to activate`;
+                        }
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `🧠 Captured as ${capType}: ${capSubtype}\nConfidence: ${capConf}%  |  ${capReasoning}\nID: ${typeShort}:${storedId}${needsReviewNote}`,
+                            }],
+                    };
+                }
+                case "wyrm_session_prime": {
+                    const { project_id: spId, project_name: spName, task: spTask, log_session: spLog } = args;
+                    // Project resolution
+                    let spProject;
+                    if (spId) {
+                        spProject = db.getProjectById(spId);
+                    }
+                    else if (spName) {
+                        const rawDb = db.getDatabase();
+                        spProject = rawDb.prepare('SELECT * FROM projects WHERE LOWER(name) LIKE LOWER(?) LIMIT 1').get(`%${spName}%`);
+                    }
+                    else {
+                        const rawDb = db.getDatabase();
+                        spProject = rawDb.prepare(`
+            SELECT p.* FROM projects p
+            JOIN sessions s ON s.project_id = p.id
+            ORDER BY s.created_at DESC LIMIT 1
+          `).get();
+                    }
+                    if (!spProject) {
+                        const allProjects = db.getAllProjects(20);
+                        if (allProjects.length === 0) {
+                            return { content: [{ type: "text", text: `🐉 No projects found. Run \`wyrm_scan_projects\` first.` }] };
+                        }
+                        const candidates = allProjects.map(p => `- ${p.name} (ID: ${p.id})`).join('\n');
+                        return { content: [{ type: "text", text: `🐉 Project not found. Available projects:\n${candidates}` }] };
+                    }
+                    const sections = [];
+                    // Section 1 — Ground Truths (up to 1200 chars)
+                    const truthsText = groundTruths.formatForContext(spProject.id, 1200);
+                    if (truthsText)
+                        sections.push(truthsText);
+                    // Section 2 — Reasoning Scaffold (up to 1500 chars)
+                    if (spTask) {
+                        const scaffoldMatchSP = scaffoldLib.findBest(spTask, spProject.id, 0.3);
+                        if (scaffoldMatchSP) {
+                            sections.push(scaffoldLib.formatForContext(scaffoldMatchSP, 1500));
+                        }
+                    }
+                    // Section 3 — Memory Brief (up to 2000 chars)
+                    const spBrief = memory.buildContextBrief(spProject.id, spTask ?? 'general', { maxItems: 10, minConfidence: 0.3 });
+                    if (spBrief.text)
+                        sections.push(spBrief.text.slice(0, 2000));
+                    // Section 4 — Active Quests (up to 800 chars)
+                    const spRawDb = db.getDatabase();
+                    const spActiveQuests = spRawDb.prepare(`
+          SELECT * FROM quests
+          WHERE project_id = ? AND status = 'pending'
+          ORDER BY
+            CASE priority WHEN 'critical' THEN 1 WHEN 'high' THEN 2 WHEN 'medium' THEN 3 ELSE 4 END
+          LIMIT 5
+        `).all(spProject.id);
+                    if (spActiveQuests.length > 0) {
+                        const priorityEmoji = { critical: '🔴', high: '🟠', medium: '🟡', low: '🟢' };
+                        let questsBlock = '### 🎯 Active Quests\n';
+                        for (const q of spActiveQuests) {
+                            questsBlock += `- ${priorityEmoji[q.priority] ?? '•'} #${q.id}: ${q.title}\n`;
+                        }
+                        sections.push(questsBlock.slice(0, 800));
+                    }
+                    // Optionally log session
+                    let sessionNote = '';
+                    if (spLog) {
+                        const session = db.createSession(spProject.id, {
+                            objectives: spTask ?? 'Session started via wyrm_session_prime',
+                            summary: '',
+                        });
+                        sessionNote = `\nSession logged: #${session.id}`;
+                    }
+                    const spTruthStats = groundTruths.getStats(spProject.id);
+                    const spMemStats = memory.getStats(spProject.id);
+                    const summaryLine = `🐉 Wyrm primed for **${spProject.name}** | ${spTruthStats.current} truth${spTruthStats.current !== 1 ? 's' : ''} · ${spActiveQuests.length} quest${spActiveQuests.length !== 1 ? 's' : ''} · ${spMemStats.total} memor${spMemStats.total !== 1 ? 'ies' : 'y'}${sessionNote}`;
+                    const spContext = sections.length > 0
+                        ? sections.join('\n\n---\n\n') + '\n\n' + summaryLine
+                        : summaryLine + '\n\n_No memory stored yet — start working and Wyrm will learn._';
+                    const spResponse = cachedResponse(spContext);
+                    if (cacheKey)
+                        cache.set(cacheKey, spResponse, 30000);
+                    return spResponse;
+                }
+                case "wyrm_import_git": {
+                    const { project_id: gitProjId, commits: gitCommits, auto_approve: gitAutoApprove } = args;
+                    const gitProject = db.getProjectById(gitProjId);
+                    if (!gitProject)
+                        return { content: [{ type: "text", text: `Project ID ${gitProjId} not found.` }], isError: true };
+                    let captured = 0, skippedCount = 0;
+                    for (const commit of gitCommits) {
+                        const msg = commit.message ?? '';
+                        if (/^Merge /i.test(msg)) {
+                            skippedCount++;
+                            continue;
+                        }
+                        if (/^(chore|bump|release|version)/i.test(msg)) {
+                            skippedCount++;
+                            continue;
+                        }
+                        let artifactKind = 'pattern';
+                        if (/^fix(\(.+\))?:/i.test(msg))
+                            artifactKind = 'lesson';
+                        else if (/^feat(\(.+\))?:/i.test(msg))
+                            artifactKind = 'pattern';
+                        else if (/^refactor(\(.+\))?:/i.test(msg))
+                            artifactKind = 'heuristic';
+                        const typePrefix = msg.split(':')[0] ?? 'commit';
+                        memory.add(gitProjId, {
+                            kind: artifactKind,
+                            problem: msg,
+                            validatedFix: commit.diff_summary ?? '',
+                            whyItWorked: `Committed by ${commit.author ?? 'unknown'} on ${commit.date ?? 'unknown'}`,
+                            tags: ['git', 'commit', typePrefix.toLowerCase()],
+                            confidence: 0.6,
+                            needsReview: gitAutoApprove ? 0 : 1,
+                        });
+                        captured++;
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `🐉 **Git Import Complete**\n\n- **Captured:** ${captured}\n- **Skipped:** ${skippedCount} (merges/chores)\n- **Review needed:** ${gitAutoApprove ? 'No (auto-approved)' : `Yes — run \`wyrm_review\` to activate ${captured} artifact${captured !== 1 ? 's' : ''}`}`,
+                            }],
+                    };
+                }
+                case "wyrm_import_pr": {
+                    const { project_id: prProjId, title: prTitle, body: prBody, review_comments: prComments, auto_approve: prAutoApprove } = args;
+                    const prProject = db.getProjectById(prProjId);
+                    if (!prProject)
+                        return { content: [{ type: "text", text: `Project ID ${prProjId} not found.` }], isError: true };
+                    let prCreated = 0;
+                    const prNeedsReview = prAutoApprove ? 0 : 1;
+                    memory.add(prProjId, {
+                        kind: 'pattern',
+                        problem: `${prTitle}\n\n${prBody}`,
+                        validatedFix: '',
+                        whyItWorked: '',
+                        tags: ['git', 'pr'],
+                        confidence: 0.65,
+                        needsReview: prNeedsReview,
+                    });
+                    prCreated++;
+                    for (const comment of (prComments ?? [])) {
+                        if (/\b(should|must|always|never|prefer|avoid|use|don't)\b/i.test(comment)) {
+                            memory.add(prProjId, {
+                                kind: 'heuristic',
+                                problem: comment,
+                                validatedFix: '',
+                                whyItWorked: '',
+                                tags: ['git', 'pr', 'review'],
+                                confidence: 0.65,
+                                needsReview: prNeedsReview,
+                            });
+                            prCreated++;
+                        }
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `🐉 **PR Import Complete**\n\n- **Artifacts created:** ${prCreated}\n- **Review needed:** ${prAutoApprove ? 'No (auto-approved)' : `Yes — run \`wyrm_review\` to activate`}`,
+                            }],
+                    };
+                }
+                case "wyrm_import_rules": {
+                    const { project_id: ruleProjId, content: ruleContent, format: ruleFormat, source_file: ruleSrc } = args;
+                    const rulesProject = db.getProjectById(ruleProjId);
+                    if (!rulesProject)
+                        return { content: [{ type: "text", text: `Project ID ${ruleProjId} not found.` }], isError: true };
+                    const fmt = ruleFormat ?? 'plain';
+                    const src = ruleSrc ?? 'rules';
+                    const baseTags = ['imported', fmt, src];
+                    // Section-based parsing: prefer markdown headings, fall back to paragraph breaks
+                    const byHeadings = ruleContent.split(/\n(?=#)/);
+                    const byParagraphs = ruleContent.split(/\n\n+/);
+                    const chunks = (byHeadings.length >= byParagraphs.length ? byHeadings : byParagraphs)
+                        .map((c) => c.trim())
+                        .filter((c) => c.length >= 15);
+                    let ruleTruthsCreated = 0, ruleArtifactsCreated = 0;
+                    for (const chunk of chunks) {
+                        if (/\b(always|never|must|use|don't|avoid|prefer)\b/i.test(chunk)) {
+                            groundTruths.set(ruleProjId, {
+                                category: 'constraint',
+                                key: chunk.slice(0, 50).replace(/\n/g, ' '),
+                                value: chunk,
+                                source: src,
+                            });
+                            ruleTruthsCreated++;
+                        }
+                        else {
+                            memory.add(ruleProjId, {
+                                kind: 'heuristic',
+                                problem: chunk,
+                                validatedFix: '',
+                                whyItWorked: '',
+                                tags: baseTags,
+                                confidence: 0.7,
+                                needsReview: 1,
+                            });
+                            ruleArtifactsCreated++;
+                        }
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `🐉 **Rules Import Complete** (${fmt})\n\n- **Ground truths created:** ${ruleTruthsCreated} (active immediately)\n- **Memory artifacts created:** ${ruleArtifactsCreated} (pending review)\n- **Source:** ${src}\n\nRun \`wyrm_review\` to approve the memory artifacts.`,
+                            }],
+                    };
+                }
+                case "wyrm_inject_prompt": {
+                    const { project_path: injPath, clients: injClients } = args;
+                    const injectResult = injectSystemPrompt(injPath, injClients ?? []);
+                    let injText = `🐉 **System Prompt Injection**\n\n`;
+                    if (injectResult.injected.length > 0) {
+                        injText += `✅ Injected into:\n${injectResult.injected.map((f) => `- ${f}`).join('\n')}\n\n`;
+                    }
+                    if (injectResult.skipped.length > 0) {
+                        injText += `○ Skipped (unknown client): ${injectResult.skipped.join(', ')}\n\n`;
+                    }
+                    if (injectResult.errors.length > 0) {
+                        injText += `❌ Errors:\n${injectResult.errors.map((e) => `- ${e}`).join('\n')}\n\n`;
+                    }
+                    if (injectResult.injected.length > 0) {
+                        injText += `AI models in this project will now call \`wyrm_session_prime\` at the start of each conversation.`;
+                    }
+                    return { content: [{ type: "text", text: injText }] };
+                }
                 default:
                     return {
                         content: [{ type: "text", text: `Unknown tool: ${name}` }],