@cachly-dev/mcp-server 0.8.2 → 0.9.0

package/dist/index.js

@@ -47,7 +47,7 @@ import { Redis } from 'ioredis';
 const API_URL = process.env.CACHLY_API_URL ?? 'https://api.cachly.dev';
 const JWT = process.env.CACHLY_JWT ?? '';
 const EMBED_MODEL = process.env.CACHLY_EMBED_MODEL ?? '';
-const CURRENT_VERSION = '0.8.2';
+const CURRENT_VERSION = '0.8.3';
 /**
  * ┌──────────────────────────────────────────────────────────────────────┐
  * │  EMBEDDING PROVIDER — pluggable, client-side first                  │
@@ -3465,6 +3465,60 @@ const TOOLS = [
             required: [],
         },
     },
+    // ── v0.9 — compact_recover ─────────────────────────────────────────────────
+    {
+        name: 'compact_recover',
+        description: 'FAST context recovery after Claude/Cursor/Copilot context window compaction. ' +
+            'Call this as the FIRST tool call after any context limit hit or window restart — before reading any files. ' +
+            'Returns: last checkpoint (task + files + next_step), session handoff if any, last 5 recalled lessons, open TODOs. ' +
+            'Unlike session_start, this is instant — no full brain scan, no streak logic, just the critical recovery data. ' +
+            'Typical use in CLAUDE.md: "If context is compacted, call compact_recover immediately."',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instance_id: { type: 'string', description: 'UUID of the cache instance' },
+                focus: {
+                    type: 'string',
+                    description: 'What you are trying to recover context for — used to surface relevant lessons (optional)',
+                },
+            },
+            required: ['instance_id'],
+        },
+    },
+    // ── v0.9 — brain_from_git ─────────────────────────────────────────────────
+    {
+        name: 'brain_from_git',
+        description: 'Bootstrap the AI Brain from git history — reads commit messages and automatically stores lessons. ' +
+            'Scans the last N days of commits, extracts actionable knowledge (fixes, reverts, deploys, migrations), ' +
+            'and bulk-loads them into the Brain as lessons. ' +
+            'Run once to pre-load months of team knowledge before the first session_start. ' +
+            'Skips commits already in the Brain (safe to re-run). ' +
+            'Example: brain_from_git(instance_id="...", workspace_path="/home/you/project", days=180) ' +
+            '→ "📊 Scanned 342 commits · ✅ 28 lessons stored · ❌ 9 failure lessons · 0 duplicates skipped"',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instance_id: { type: 'string', description: 'UUID of the cache instance' },
+                workspace_path: {
+                    type: 'string',
+                    description: 'Absolute path to the git repository root (e.g. "/home/you/myproject")',
+                },
+                days: {
+                    type: 'number',
+                    description: 'How many days of history to scan (default: 180, max: 365)',
+                },
+                max_commits: {
+                    type: 'number',
+                    description: 'Maximum number of commits to process (default: 200, max: 500)',
+                },
+                author: {
+                    type: 'string',
+                    description: 'Filter to commits by this git author email or name (optional — omit to scan all authors)',
+                },
+            },
+            required: ['instance_id', 'workspace_path'],
+        },
+    },
 ];
 // ── Handlers ──────────────────────────────────────────────────────────────────
 function formatInstance(inst) {
@@ -7214,6 +7268,173 @@ smart_recall(
             lines.push(`---`, `**Confirm** (if this helped you): \`syndicate(topic="${res.results[0]?.topic ?? '...'}", what_worked="...")\` → auto-deduped, trust +1`, `**All trending:** \`syndicate_trending(limit=50)\`  |  **Search:** \`syndicate_search(q="...")\``);
             return lines.filter(l => l !== '').join('\n');
         }
+        // ── v0.9 compact_recover — fast context recovery ──────────────────────────
+        case 'compact_recover': {
+            const { instance_id, focus = '' } = args;
+            const redis = await getConnection(instance_id);
+            const lines = ['⚡ **Context Recovered**', ''];
+            // 1. Latest checkpoint
+            const checkpointRaw = await redis.get('cachly:session:checkpoint');
+            if (checkpointRaw) {
+                try {
+                    const cp = JSON.parse(checkpointRaw);
+                    const ago = Math.round((Date.now() - new Date(cp.ts).getTime()) / 60000);
+                    const agoStr = ago < 60 ? `${ago}m ago` : `${Math.round(ago / 60)}h ago`;
+                    lines.push(`📌 **Last checkpoint** (${agoStr}): ${cp.task}`);
+                    if (cp.files_touched && cp.files_touched.length > 0) {
+                        lines.push(`   Files: ${cp.files_touched.slice(0, 5).join(', ')}${cp.files_touched.length > 5 ? '…' : ''}`);
+                    }
+                    if (cp.next_step)
+                        lines.push(`📍 **Resume with:** ${cp.next_step}`);
+                    lines.push('');
+                }
+                catch { /* ignore corrupt */ }
+            }
+            // 2. Handoff (if any, from a different window)
+            const handoffRaw = await redis.get('cachly:session:handoff');
+            if (handoffRaw) {
+                try {
+                    const hf = JSON.parse(handoffRaw);
+                    const remaining = hf.remaining_tasks ?? [];
+                    if (remaining.length > 0) {
+                        lines.push(`⏳ **Remaining tasks:**`);
+                        remaining.slice(0, 5).forEach(t => lines.push(`  - ${t}`));
+                        if (remaining.length > 5)
+                            lines.push(`  …and ${remaining.length - 5} more`);
+                        lines.push('');
+                    }
+                    if (hf.blocked_on) {
+                        lines.push(`🚫 **Blocked on:** ${hf.blocked_on}`, '');
+                    }
+                }
+                catch { /* ignore */ }
+            }
+            // 3. Top recently recalled lessons (BM25 if focus, else recency)
+            const lessonKeys = [];
+            const lStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
+            await new Promise((resolve, reject) => {
+                lStream.on('data', (batch) => lessonKeys.push(...batch));
+                lStream.on('end', resolve);
+                lStream.on('error', reject);
+            });
+            const allLessons = [];
+            for (const k of lessonKeys) {
+                const raw = await redis.get(k);
+                if (!raw)
+                    continue;
+                try {
+                    allLessons.push(JSON.parse(raw));
+                }
+                catch { /* skip */ }
+            }
+            const focusTerms = focus.toLowerCase().split(/\s+/).filter(Boolean);
+            let topLessons = focusTerms.length > 0
+                ? allLessons.filter(l => focusTerms.some(t => l.topic.toLowerCase().includes(t) || (l.tags ?? []).some((tag) => tag.toLowerCase().includes(t)))).slice(0, 5)
+                : allLessons.sort((a, b) => (b.recall_count ?? 0) - (a.recall_count ?? 0)).slice(0, 5);
+            if (topLessons.length > 0) {
+                lines.push(`🧠 **Top lessons${focus ? ` for "${focus}"` : ''}:**`);
+                for (const l of topLessons) {
+                    const icon = l.outcome === 'success' ? '✅' : l.outcome === 'failure' ? '❌' : '⚠️';
+                    lines.push(`  ${icon} \`${l.topic}\` — ${l.what_worked.slice(0, 120)}${l.what_worked.length > 120 ? '…' : ''}`);
+                }
+                lines.push('');
+            }
+            lines.push(`💡 Call \`session_start\` for the full briefing, or resume work directly.`);
+            return lines.filter(l => l !== '').join('\n');
+        }
+        // ── v0.9 brain_from_git — bulk-load git history as lessons ───────────────
+        case 'brain_from_git': {
+            const { instance_id, workspace_path, days = 180, max_commits = 200, author = '', } = args;
+            const redis = await getConnection(instance_id);
+            const { execSync } = await import('node:child_process');
+            const clampedDays = Math.min(Math.max(1, days), 365);
+            const clampedMax = Math.min(Math.max(1, max_commits), 500);
+            const authorArg = author ? `--author="${author}"` : '';
+            let gitRaw = '';
+            try {
+                gitRaw = execSync(`git -C "${workspace_path}" log --since="${clampedDays} days ago" ${authorArg} --oneline --format="%H|||%s|||%ai|||%ae" -n ${clampedMax}`, { timeout: 15000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+            }
+            catch {
+                return `❌ **brain_from_git failed**: Could not read git log from \`${workspace_path}\`.\nMake sure the path exists and is a git repository.`;
+            }
+            if (!gitRaw) {
+                return `📭 **No commits found** in the last ${clampedDays} days${author ? ` by "${author}"` : ''}.\nTry increasing \`days\` or removing the \`author\` filter.`;
+            }
+            const commitLines = gitRaw.split('\n');
+            const now = new Date();
+            const actionRe = /\b(fix|add|remove|refactor|migrate|update|resolve|implement|improve|optimize|configure|create|delete|disable|enable|debug|patch|upgrade|rewrite|deploy|feat|revert|break|merge|bump)\b/i;
+            const failRe = /\b(revert|broken|broke|breaking|rollback|undo|hotfix|crash|oops|wrong|mistake|bad)\b/i;
+            let stored = 0;
+            let skipped = 0;
+            let failures = 0;
+            const topLessons = [];
+            for (const line of commitLines) {
+                const parts = line.split('|||');
+                if (parts.length < 2)
+                    continue;
+                const [hash, msg, dateStr] = parts;
+                if (!msg || !actionRe.test(msg))
+                    continue;
+                const isFail = failRe.test(msg);
+                const cleanMsg = msg
+                    .replace(/^(fix|feat|chore|docs|test|ci|perf|refactor|build|revert|hotfix|bump)[:(\s!]+/i, '')
+                    .trim();
+                if (!cleanMsg || cleanMsg.length < 5)
+                    continue;
+                const slug = cleanMsg
+                    .toLowerCase()
+                    .replace(/[^a-z0-9]+/g, '-')
+                    .replace(/^-+|-+$/g, '')
+                    .slice(0, 40);
+                if (!slug)
+                    continue;
+                const topic = `git:${slug}`;
+                const key = `cachly:lesson:best:${topic}`;
+                const existing = await redis.get(key);
+                if (existing) {
+                    skipped++;
+                    continue;
+                }
+                const lesson = {
+                    topic,
+                    outcome: isFail ? 'failure' : 'success',
+                    what_worked: isFail ? '' : cleanMsg.slice(0, 300),
+                    what_failed: isFail ? cleanMsg.slice(0, 300) : undefined,
+                    context: `Auto-learned from git commit ${(hash ?? '').slice(0, 7)}${dateStr ? ` at ${dateStr}` : ''} in ${workspace_path}${author ? ` (author: ${author})` : ''}`,
+                    severity: 'minor',
+                    ts: dateStr ? new Date(dateStr).toISOString() : now.toISOString(),
+                    recall_count: 0,
+                    auto_learned: true,
+                    source: 'brain_from_git',
+                    version: 3,
+                };
+                await redis.set(key, JSON.stringify(lesson));
+                await redis.expire(key, 90 * 86400); // 90-day TTL for git-sourced lessons
+                stored++;
+                if (isFail)
+                    failures++;
+                if (topLessons.length < 5)
+                    topLessons.push(`  ${isFail ? '❌' : '✅'} \`${topic}\` — ${cleanMsg.slice(0, 80)}`);
+            }
+            const lines = [
+                `🧠 **Brain bootstrapped from git history**`,
+                ``,
+                `📊 **Scanned:** ${commitLines.filter(l => l.trim()).length} commits over last ${clampedDays} days`,
+                `✅ **Success lessons stored:** ${stored - failures}`,
+                `❌ **Failure/revert lessons:** ${failures}`,
+                skipped > 0 ? `⏭️  **Already in brain (skipped):** ${skipped}` : '',
+                ``,
+            ];
+            if (topLessons.length > 0) {
+                lines.push(`**Top lessons extracted:**`);
+                lines.push(...topLessons);
+                if (stored > 5)
+                    lines.push(`  …and ${stored - 5} more`);
+                lines.push('');
+            }
+            lines.push(`💡 **Next step:** Call \`session_start(focus="...")\` to see these lessons in your briefing.`, `🔄 **Re-run anytime** — duplicates are safely skipped.`);
+            return lines.filter(l => l !== '').join('\n');
+        }
         default:
             return null;
     }
@@ -7475,9 +7696,17 @@ if (process.argv[2] === 'setup') {
     const { existsSync } = await import('node:fs');
     const { resolve, dirname } = await import('node:path');
     const { createInterface } = await import('node:readline');
+    // --yes / -y → non-interactive mode (skips all prompts, picks defaults)
+    const nonInteractive = process.argv.includes('--yes') || process.argv.includes('-y');
     const rl = createInterface({ input: process.stdin, output: process.stdout });
-    const ask = (q) => new Promise(res => rl.question(q, ans => res(ans.trim())));
-    console.log('\n🧠  cachly AI Brain — Interactive Setup');
+    const ask = (q, defaultVal = '') => {
+        if (nonInteractive) {
+            console.log(`${q}${defaultVal}`);
+            return Promise.resolve(defaultVal);
+        }
+        return new Promise(res => rl.question(q, ans => res(ans.trim() || defaultVal)));
+    };
+    console.log('\n🧠  cachly AI Brain — Setup');
     console.log('────────────────────────────────────────\n');
     // ── Step 1: Authenticate via OAuth Device Flow ────────────────────────────
     let token = process.env.CACHLY_JWT ?? '';
@@ -7672,13 +7901,11 @@ if (process.argv[2] === 'setup') {
             process.exit(1);
         }
     }
-    let instance = instances[0];
+    // Auto-pick the most recently created running instance — no prompt.
+    const instance = instances[0];
     if (instances.length > 1) {
-        console.log('Step 2: Pick your Brain instance:\n');
-        instances.forEach((inst, idx) => console.log(`   ${idx + 1}. ${inst.name.padEnd(24)} ${inst.tier.padEnd(10)} ${inst.region}`));
-        const raw = await ask(`\n   Pick [1-${instances.length}] (Enter = 1): `);
-        const idx = parseInt(raw || '1', 10) - 1;
-        instance = instances[Math.max(0, Math.min(instances.length - 1, idx))];
+        console.log(`ℹ️  Multiple instances found — using most recent: ${instance.name}`);
+        console.log(`   (Run with --instance-id <id> to use a different one)\n`);
     }
     console.log(`✓  Instance: ${instance.name} (${instance.id.slice(0, 8)}…)\n`);
     // ── Step 3: Detect editors ────────────────────────────────────────────────
@@ -7711,32 +7938,10 @@ if (process.argv[2] === 'setup') {
     if (existsSync(zedDir))
         detected.push('zed');
     const editorLabel = (e) => ({ claude: 'Claude Code', cursor: 'Cursor', windsurf: 'Windsurf', copilot: 'GitHub Copilot', continue: 'Continue.dev', cline: 'Cline (VSCode)', zed: 'Zed' })[e] ?? e;
-    console.log(`Step 3: Detected editors: ${detected.map(editorLabel).join(', ')}`);
-    const editorsRaw = await ask(`   Configure for which? [all / ${detected.join('/')}] (Enter = all): `);
-    const editorsToSetup = !editorsRaw || editorsRaw.toLowerCase() === 'all'
-        ? detected
-        : editorsRaw.split(/[,\s]+/).map(s => s.toLowerCase()).filter(s => EDITOR_FILES[s]);
-    console.log('');
-    // ── Step 4: Email opt-in ──────────────────────────────────────────────────
-    console.log('Step 4: Stay in the loop (optional)');
-    const email = await ask('   Email for release notes & tips? [Enter to skip]: ');
-    if (email && email.includes('@')) {
-        try {
-            await fetch(`${API_URL}/api/newsletter/subscribe`, {
-                method: 'POST', headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ email: email.trim().toLowerCase(), source: 'mcp-setup' }),
-                signal: AbortSignal.timeout(5000),
-            });
-            console.log('✅ Subscribed — you\'ll only hear from us when it matters.\n');
-        }
-        catch {
-            console.log('⚠️  Could not subscribe (no internet?). Continuing...\n');
-        }
-    }
-    else {
-        console.log('   Skipped.\n');
-    }
-    // ── Step 5: Write editor configs ──────────────────────────────────────────
+    // Auto-configure all detected editors — no prompt needed.
+    const editorsToSetup = detected;
+    console.log(`Step 3: Configuring for: ${editorsToSetup.map(editorLabel).join(', ')}\n`);
+    // ── Step 4: Write editor configs ──────────────────────────────────────────
     for (const editor of editorsToSetup) {
         const configFile = EDITOR_FILES[editor] ?? '.mcp.json';
         const configPath = resolve(cwd, configFile);
@@ -7744,14 +7949,11 @@ if (process.argv[2] === 'setup') {
         await writeFile(configPath, buildMcpConfig(token, instance.id, editor), 'utf-8');
         console.log(`✅ Written: ${configFile}`);
     }
-    // ── Step 6: CLAUDE.md (always — idempotent) ───────────────────────────────
+    // ── Step 5: CLAUDE.md (always — idempotent) ───────────────────────────────
     const mdResult = await writeClaudeMd(cwd, instance.id);
     const mdLabel = mdResult === 'updated' ? '✅ Updated' : mdResult === 'appended' ? '✅ Appended to' : '✅ Written';
-    console.log(`${mdLabel}: CLAUDE.md`);
-    rl.close();
-    console.log(`\n🧠  Done! Restart your editor — the \`cachly\` MCP tools will appear.`);
-    console.log(`    Your AI now has persistent memory across every session.\n`);
-    // ── Step 7: Show first session_start preview (Aha moment) ────────────────
+    console.log(`${mdLabel}: CLAUDE.md\n`);
+    // ── Step 6: Show Brain health (Aha moment) ────────────────────────────────
     // Fetch brain health from the API to show the user what their agent will see.
     process.stdout.write('\n⏳ Fetching your Brain health preview...');
     try {
@@ -7792,8 +7994,25 @@ if (process.argv[2] === 'setup') {
     catch {
         console.log(' (skipped)');
     }
-    console.log(`\n   Your AI will call session_start automatically when it uses the first tool.`);
-    console.log(`   To see your Brain at any time: https://cachly.dev/instances/${instance.id}\n`);
+    console.log(`\n🧠  Done! Restart your editor — the \`cachly\` MCP tools will appear.`);
+    console.log(`   Your AI now has persistent memory across every session.\n`);
+    console.log(`   Dashboard: https://cachly.dev/instances/${instance.id}\n`);
+    // ── Step 7: Email opt-in (non-blocking — at the very end) ────────────────
+    if (!nonInteractive) {
+        const email = await ask('   📬 Stay in the loop? Email for release notes [Enter to skip]: ');
+        if (email && email.includes('@')) {
+            try {
+                await fetch(`${API_URL}/api/newsletter/subscribe`, {
+                    method: 'POST', headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ email: email.trim().toLowerCase(), source: 'mcp-setup' }),
+                    signal: AbortSignal.timeout(5000),
+                });
+                console.log('   ✅ Subscribed — you\'ll only hear from us when it matters.\n');
+            }
+            catch { /* fire and forget */ }
+        }
+    }
+    rl.close();
     process.exit(0);
 }
 // ── CLI: cachly index <dir> ───────────────────────────────────────────────────