@cachly-dev/mcp-server 0.5.34 → 0.5.36

package/README.md

@@ -1,6 +1,6 @@
 # 🧠 cachly AI Brain — MCP Server
 
-> **Persistent memory for Claude Code, Cursor, GitHub Copilot & Windsurf.**  
+> **Persistent memory for Claude Code, Cursor, GitHub Copilot, Windsurf, Cline & Zed.**  
 > Your AI remembers every lesson, every fix, every architecture decision — forever.
 
 <p align="center">
@@ -45,9 +45,15 @@ npx @cachly-dev/mcp-server@latest setup
 The interactive wizard:
 1. Signs you in (free, no credit card required)
 2. Picks or creates your AI Brain instance
-3. **Auto-detects** Cursor, Windsurf, VS Code, Claude Code, Continue.dev
+3. **Auto-detects** Cursor, Windsurf, VS Code, Claude Code, Continue.dev, **Cline & Zed**
 4. Writes the correct MCP config for every detected editor
 5. Creates `CLAUDE.md` with memory rules pre-filled
+6. Shows your Brain Health snapshot right in the terminal
+
+**Index your project** into the Brain for instant semantic search:
+```bash
+npx @cachly-dev/mcp-server@latest index .
+```
 
 **Result:** Your AI remembers everything. Always.
 

package/dist/index.d.ts

@@ -1,11 +1,16 @@
 #!/usr/bin/env node
 /**
  * Stopwords — filtered out during tokenization.
- * Covers: English, German, French, Spanish, Italian, Portuguese.
+ * Covers: English, German, French, Spanish, Italian, Portuguese,
+ *         Chinese (Simplified + Traditional), Japanese, Korean.
  * Keeps the index small and scores meaningful.
  */
 declare const STOPWORDS: Set<string>;
-/** Tokenize text into meaningful keywords. Handles unicode (accented chars). */
+/**
+ * Tokenize text into meaningful keywords.
+ * Handles accented Latin characters and CJK (Chinese, Japanese, Korean).
+ * CJK text is split into character bigrams (the standard for indexing logographic languages).
+ */
 declare function tokenize(text: string): string[];
 /**
  * Split a multi-topic query into sub-queries.

package/dist/index.js

@@ -288,12 +288,14 @@ function embedProviderHint() {
 //   • Recency boost — newer entries rank higher (exponential decay, 7-day half-life)
 //   • Multi-query splitting — numbered lists, semicolons, conjunctions
 //   • Fuzzy matching with Levenshtein distance ≤ 2
-//   • Multilingual stopwords (EN, DE, FR, ES, IT, PT)
+//   • Multilingual stopwords (EN, DE, FR, ES, IT, PT, ZH, JA, KO)
+//   • CJK character bigram extraction — handles Chinese, Japanese, Korean
 //   • Pipeline Redis reads for performance
 //
 /**
  * Stopwords — filtered out during tokenization.
- * Covers: English, German, French, Spanish, Italian, Portuguese.
+ * Covers: English, German, French, Spanish, Italian, Portuguese,
+ *         Chinese (Simplified + Traditional), Japanese, Korean.
  * Keeps the index small and scores meaningful.
  */
 const STOPWORDS = new Set([
@@ -367,14 +369,61 @@ const STOPWORDS = new Set([
     'eu', 'tu', 'ele', 'ela', 'nós', 'eles', 'elas', 'você', 'vocês',
     'não', 'já', 'sim', 'bem', 'muito', 'também', 'ainda', 'sempre',
     'todo', 'toda', 'todos', 'cada', 'outro', 'outra', 'quando', 'porque',
+    // ── Chinese (Simplified + Traditional) — high-frequency function characters ──
+    '的', '了', '是', '在', '不', '和', '我', '他', '这', '中', '大', '为',
+    '上', '个', '国', '以', '要', '就', '出', '说', '们', '有', '来', '到',
+    '时', '地', '年', '得', '着', '那', '过', '后', '还', '与', '也', '可',
+    '于', '从', '但', '而', '被', '把', '让', '使', '对', '很', '都', '一',
+    '会', '没', '人', '它', '这个', '那个', '什么', '如果', '因为', '所以',
+    '已经', '可以', '这些', '那些', '我们', '他们', '她们', '它们',
+    // ── Japanese — common hiragana particles and auxiliary verbs ──
+    'の', 'は', 'が', 'を', 'に', 'で', 'と', 'も', 'や', 'か', 'な', 'ね',
+    'よ', 'わ', 'て', 'い', 'う', 'え', 'お', 'き', 'く', 'け', 'こ', 'さ',
+    'し', 'す', 'せ', 'そ', 'た', 'ち', 'つ', 'ぬ', 'ん', 'から', 'まで',
+    'より', 'へ', 'です', 'ます', 'ない', 'ある', 'いる', 'する', 'こと',
+    'もの', 'ので', 'では', 'には', 'との', 'への', 'から', 'まで',
+    // ── Korean — common particles and auxiliary forms ──
+    '이', '가', '은', '는', '을', '를', '의', '에', '와', '과', '도',
+    '로', '에서', '한', '하', '있', '없', '것', '수', '않', '들',
+    '이다', '하다', '이고', '이며', '라고', '에게', '에서', '으로',
 ]);
-/** Tokenize text into meaningful keywords. Handles unicode (accented chars). */
+// CJK Unicode ranges used for bigram extraction
+const CJK_RE = /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uac00-\ud7af]/;
+const SEGMENT_RE = /([\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uac00-\ud7af]+|[^\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uac00-\ud7af]+)/g;
+/**
+ * Tokenize text into meaningful keywords.
+ * Handles accented Latin characters and CJK (Chinese, Japanese, Korean).
+ * CJK text is split into character bigrams (the standard for indexing logographic languages).
+ */
 function tokenize(text) {
-    return text
-        .toLowerCase()
-        .replace(/[^a-záàâãäåæçéèêëíìîïñóòôõöúùûüýÿßœ0-9:_\-./]/g, ' ')
-        .split(/\s+/)
-        .filter(w => w.length > 1 && !STOPWORDS.has(w));
+    const tokens = [];
+    const lower = text.toLowerCase();
+    for (const [seg] of lower.matchAll(SEGMENT_RE)) {
+        if (CJK_RE.test(seg)) {
+            // CJK segment — extract overlapping character bigrams
+            for (let i = 0; i < seg.length - 1; i++) {
+                const bigram = seg[i] + seg[i + 1];
+                if (!STOPWORDS.has(seg[i]) && !STOPWORDS.has(bigram)) {
+                    tokens.push(bigram);
+                }
+            }
+            // Trailing single character (for 1-char CJK terms)
+            if (seg.length >= 1) {
+                const last = seg[seg.length - 1];
+                if (!STOPWORDS.has(last))
+                    tokens.push(last);
+            }
+        }
+        else {
+            // Latin / other — existing logic
+            const words = seg
+                .replace(/[^a-záàâãäåæçéèêëíìîïñóòôõöúùûüýÿßœ0-9:_\-./]/g, ' ')
+                .split(/\s+/)
+                .filter(w => w.length > 1 && !STOPWORDS.has(w));
+            tokens.push(...words);
+        }
+    }
+    return tokens;
 }
 /**
  * Split a multi-topic query into sub-queries.
@@ -1485,6 +1534,100 @@ const TOOLS = [
             required: ['instance_id'],
         },
     },
+    // ── Roadmap — Persistent project plan tracker ───────────────────────────
+    {
+        name: 'roadmap_add',
+        description: 'Add a new item to the persistent project roadmap stored in the Brain. ' +
+            'Items survive across sessions and editors — the roadmap is always up to date. ' +
+            'Use for features, bugs, refactors, or any planned work. ' +
+            'Call roadmap_list to see all open items, roadmap_next to get the next actionable item.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instance_id: { type: 'string', description: 'UUID of the cache instance' },
+                title: { type: 'string', description: 'Short title of the task/feature (3–10 words)' },
+                description: { type: 'string', description: 'What needs to be done, acceptance criteria, context' },
+                priority: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low'],
+                    description: 'Priority level (default: medium)',
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Tags for filtering (e.g. ["api", "web", "sdk", "infra"])',
+                },
+                milestone: { type: 'string', description: 'Milestone/epic this belongs to (optional)' },
+            },
+            required: ['instance_id', 'title'],
+        },
+    },
+    {
+        name: 'roadmap_update',
+        description: 'Update the status, priority, or details of a roadmap item. ' +
+            'Use to move items through the lifecycle: planned → in-progress → done (or blocked/cancelled). ' +
+            'Also use to add notes/findings while working on an item.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instance_id: { type: 'string', description: 'UUID of the cache instance' },
+                id: { type: 'string', description: 'Item ID returned by roadmap_add or roadmap_list' },
+                status: {
+                    type: 'string',
+                    enum: ['planned', 'in-progress', 'done', 'blocked', 'cancelled'],
+                    description: 'New status for the item',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low'],
+                    description: 'Updated priority (optional)',
+                },
+                notes: { type: 'string', description: 'Progress notes, findings, or blockers (appended to existing notes)' },
+                title: { type: 'string', description: 'Updated title (optional)' },
+                description: { type: 'string', description: 'Updated description (optional)' },
+            },
+            required: ['instance_id', 'id'],
+        },
+    },
+    {
+        name: 'roadmap_list',
+        description: 'List all roadmap items, optionally filtered by status, priority, tag, or milestone. ' +
+            'Returns items sorted by priority then creation date. ' +
+            'Called automatically by session_start to show open work.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instance_id: { type: 'string', description: 'UUID of the cache instance' },
+                status: {
+                    type: 'string',
+                    enum: ['planned', 'in-progress', 'done', 'blocked', 'cancelled', 'open'],
+                    description: 'Filter by status. Use \'open\' to see planned+in-progress+blocked (default: open)',
+                },
+                tag: { type: 'string', description: 'Filter by tag (optional)' },
+                milestone: { type: 'string', description: 'Filter by milestone (optional)' },
+                priority: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low'],
+                    description: 'Filter by minimum priority (optional)',
+                },
+            },
+            required: ['instance_id'],
+        },
+    },
+    {
+        name: 'roadmap_next',
+        description: 'Get the single most important next actionable roadmap item. ' +
+            'Returns the highest-priority in-progress item first, then planned items, sorted by priority. ' +
+            'Call at session start to immediately know what to work on next.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instance_id: { type: 'string', description: 'UUID of the cache instance' },
+                tag: { type: 'string', description: 'Filter by tag (optional)' },
+            },
+            required: ['instance_id'],
+        },
+    },
     {
         name: 'brain_doctor',
         description: 'Check the health of your AI Brain and get actionable recommendations. ' +
@@ -3152,6 +3295,38 @@ async function handleTool(name, args) {
                 }
             }
             catch { /* non-critical */ }
+            // ── 🗺️ Roadmap — open items at session start ────────────────────────────
+            try {
+                const roadmapAll = await redis.hgetall(`cachly:roadmap:${instance_id}`);
+                if (roadmapAll && Object.keys(roadmapAll).length > 0) {
+                    const PRIORITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
+                    const PRIORITY_ICON = { critical: '🔴', high: '🟠', medium: '🟡', low: '🔵' };
+                    const openStatuses = new Set(['planned', 'in-progress', 'blocked']);
+                    const allItems = Object.values(roadmapAll).map(v => JSON.parse(v));
+                    const openItems = allItems
+                        .filter(i => openStatuses.has(i.status))
+                        .sort((a, b) => {
+                        if (a.status === 'in-progress' && b.status !== 'in-progress')
+                            return -1;
+                        if (b.status === 'in-progress' && a.status !== 'in-progress')
+                            return 1;
+                        return (PRIORITY_ORDER[a.priority] ?? 99) - (PRIORITY_ORDER[b.priority] ?? 99);
+                    });
+                    const doneCount = allItems.filter(i => i.status === 'done').length;
+                    if (openItems.length > 0) {
+                        lines.push(`🗺️ **Roadmap** (${openItems.length} open · ${doneCount} done):`);
+                        for (const it of openItems.slice(0, 5)) {
+                            const statusIcon = it.status === 'in-progress' ? '⚡' : it.status === 'blocked' ? '🚫' : '📋';
+                            lines.push(`  ${statusIcon} ${PRIORITY_ICON[it.priority] ?? '⚪'} \`${it.id}\` **${it.title}**`);
+                        }
+                        if (openItems.length > 5)
+                            lines.push(`  … and ${openItems.length - 5} more`);
+                        lines.push(`  _Use \`roadmap_next\` for the top priority item · \`roadmap_list\` for full view_`);
+                        lines.push('');
+                    }
+                }
+            }
+            catch { /* non-critical */ }
             return lines.join('\n');
         }
         // ── session_end ───────────────────────────────────────────────────────────
@@ -4538,6 +4713,161 @@ async function handleBulkLockStream(name, args) {
             return (`✅ **cache_stream_get** – ${len} chunk(s) retrieved for \`${key}\`.\n\n` +
                 `**Preview** (first 500 chars):\n\`\`\`\n${preview}${preview.length < chunks.join('').length ? '…' : ''}\n\`\`\``);
         }
+        // ── Roadmap ──────────────────────────────────────────────────────────────
+        case 'roadmap_add': {
+            const { instance_id: rid, title, description: desc = '', priority = 'medium', tags: rtags = [], milestone = '', } = args;
+            const redis = await getConnection(rid);
+            const id = `rm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+            const item = {
+                id, title, description: desc, priority, tags: rtags, milestone,
+                status: 'planned',
+                created: new Date().toISOString(),
+                updated: new Date().toISOString(),
+                notes: '',
+            };
+            await redis.hset(`cachly:roadmap:${rid}`, id, JSON.stringify(item));
+            const PRIORITY_ICON = { critical: '🔴', high: '🟠', medium: '🟡', low: '🔵' };
+            return [
+                `📋 **Roadmap item added**`,
+                ``,
+                `  ID:       \`${id}\``,
+                `  Title:    ${title}`,
+                `  Priority: ${PRIORITY_ICON[priority] ?? '⚪'} ${priority}`,
+                `  Status:   planned`,
+                milestone ? `  Milestone: ${milestone}` : '',
+                rtags.length ? `  Tags:     ${rtags.join(', ')}` : '',
+                ``,
+                `💡 Use \`roadmap_update(id: "${id}", status: "in-progress")\` when you start working on it.`,
+            ].filter(Boolean).join('\n');
+        }
+        case 'roadmap_update': {
+            const { instance_id: rid, id: itemId, status: newStatus, priority: newPriority, notes: newNotes, title: newTitle, description: newDesc, } = args;
+            const redis = await getConnection(rid);
+            const raw = await redis.hget(`cachly:roadmap:${rid}`, itemId);
+            if (!raw)
+                return `⚠️ **roadmap_update** – Item \`${itemId}\` not found. Use \`roadmap_list\` to see all items.`;
+            const item = JSON.parse(raw);
+            const oldStatus = item.status;
+            if (newStatus)
+                item.status = newStatus;
+            if (newPriority)
+                item.priority = newPriority;
+            if (newTitle)
+                item.title = newTitle;
+            if (newDesc)
+                item.description = newDesc;
+            if (newNotes)
+                item.notes = item.notes ? `${item.notes}\n[${new Date().toISOString().slice(0, 10)}] ${newNotes}` : `[${new Date().toISOString().slice(0, 10)}] ${newNotes}`;
+            item.updated = new Date().toISOString();
+            await redis.hset(`cachly:roadmap:${rid}`, itemId, JSON.stringify(item));
+            const statusEmoji = { planned: '📋', 'in-progress': '⚡', done: '✅', blocked: '🚫', cancelled: '🗑️' };
+            return [
+                `${statusEmoji[newStatus ?? oldStatus] ?? '📋'} **Roadmap updated** \`${itemId}\``,
+                ``,
+                `  Title:  ${item.title}`,
+                oldStatus !== newStatus ? `  Status: ${oldStatus} → ${newStatus}` : `  Status: ${item.status}`,
+                newNotes ? `  Notes:  ${newNotes}` : '',
+            ].filter(Boolean).join('\n');
+        }
+        case 'roadmap_list': {
+            const { instance_id: rid, status: filterStatus = 'open', tag: filterTag, milestone: filterMilestone, priority: filterPriority, } = args;
+            const redis = await getConnection(rid);
+            const all = await redis.hgetall(`cachly:roadmap:${rid}`);
+            if (!all || Object.keys(all).length === 0) {
+                return '📋 **Roadmap is empty.**\n\nUse `roadmap_add` to create your first item.';
+            }
+            const PRIORITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
+            const PRIORITY_ICON = { critical: '🔴', high: '🟠', medium: '🟡', low: '🔵' };
+            const STATUS_ICON = { planned: '📋', 'in-progress': '⚡', done: '✅', blocked: '🚫', cancelled: '🗑️' };
+            const openStatuses = new Set(['planned', 'in-progress', 'blocked']);
+            let items = Object.values(all).map(v => JSON.parse(v));
+            // Filter
+            if (filterStatus === 'open')
+                items = items.filter(i => openStatuses.has(i.status));
+            else if (filterStatus)
+                items = items.filter(i => i.status === filterStatus);
+            if (filterTag)
+                items = items.filter(i => i.tags.includes(filterTag));
+            if (filterMilestone)
+                items = items.filter(i => i.milestone === filterMilestone);
+            if (filterPriority)
+                items = items.filter(i => (PRIORITY_ORDER[i.priority] ?? 99) <= (PRIORITY_ORDER[filterPriority] ?? 99));
+            // Sort: priority asc, then created asc
+            items.sort((a, b) => {
+                const pa = PRIORITY_ORDER[a.priority] ?? 99;
+                const pb = PRIORITY_ORDER[b.priority] ?? 99;
+                return pa !== pb ? pa - pb : a.created.localeCompare(b.created);
+            });
+            if (items.length === 0)
+                return `📋 **No roadmap items** match the current filter (status: ${filterStatus}).`;
+            const grouped = {};
+            for (const it of items) {
+                const st = it.status;
+                if (!grouped[st])
+                    grouped[st] = [];
+                grouped[st].push(it);
+            }
+            const lines = [`📋 **Roadmap** (${items.length} item${items.length !== 1 ? 's' : ''})`, ''];
+            for (const [st, grp] of Object.entries(grouped)) {
+                lines.push(`**${STATUS_ICON[st] ?? '•'} ${st.toUpperCase()}** (${grp.length})`);
+                for (const it of grp) {
+                    const tags = it.tags.length ? ` [${it.tags.join(', ')}]` : '';
+                    const milestone = it.milestone ? ` · ${it.milestone}` : '';
+                    lines.push(`  ${PRIORITY_ICON[it.priority] ?? '⚪'} \`${it.id}\` **${it.title}**${tags}${milestone}`);
+                    if (it.description)
+                        lines.push(`      ${it.description.slice(0, 120)}`);
+                    if (it.notes)
+                        lines.push(`      📝 ${it.notes.split('\n').pop()?.slice(0, 100)}`);
+                }
+                lines.push('');
+            }
+            lines.push(`💡 \`roadmap_update(id, status: "in-progress")\` to start · \`roadmap_next\` for top priority item`);
+            return lines.join('\n');
+        }
+        case 'roadmap_next': {
+            const { instance_id: rid, tag: filterTag } = args;
+            const redis = await getConnection(rid);
+            const all = await redis.hgetall(`cachly:roadmap:${rid}`);
+            if (!all || Object.keys(all).length === 0) {
+                return '📋 **Roadmap is empty.** Use `roadmap_add` to plan your first task.';
+            }
+            const PRIORITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
+            const PRIORITY_ICON = { critical: '🔴', high: '🟠', medium: '🟡', low: '🔵' };
+            let items = Object.values(all)
+                .map(v => JSON.parse(v))
+                .filter(i => i.status === 'in-progress' || i.status === 'planned')
+                .filter(i => !filterTag || i.tags.includes(filterTag));
+            if (items.length === 0)
+                return '🎉 **No open roadmap items!** All tasks are done (or use `roadmap_list` to check).';
+            // in-progress first, then by priority
+            items.sort((a, b) => {
+                if (a.status === 'in-progress' && b.status !== 'in-progress')
+                    return -1;
+                if (b.status === 'in-progress' && a.status !== 'in-progress')
+                    return 1;
+                return (PRIORITY_ORDER[a.priority] ?? 99) - (PRIORITY_ORDER[b.priority] ?? 99);
+            });
+            const next = items[0];
+            const remaining = items.length - 1;
+            const tags = next.tags.length ? `\nTags:      ${next.tags.join(', ')}` : '';
+            const milestone = next.milestone ? `\nMilestone: ${next.milestone}` : '';
+            const notes = next.notes ? `\nNotes:     ${next.notes.split('\n').pop()?.slice(0, 120)}` : '';
+            return [
+                `${next.status === 'in-progress' ? '⚡' : '📋'} **Next up: ${next.title}**`,
+                ``,
+                `ID:        \`${next.id}\``,
+                `Priority:  ${PRIORITY_ICON[next.priority] ?? '⚪'} ${next.priority}`,
+                `Status:    ${next.status}`,
+                next.description ? `\nWhat to do:\n${next.description}` : '',
+                tags, milestone, notes,
+                ``,
+                remaining > 0 ? `(+${remaining} more open item${remaining !== 1 ? 's' : ''} in roadmap)` : '(last open item)',
+                ``,
+                next.status === 'planned'
+                    ? `💡 Start with: \`roadmap_update(id: "${next.id}", status: "in-progress")\``
+                    : `💡 Finish with: \`roadmap_update(id: "${next.id}", status: "done", notes: "...")\``,
+            ].filter(s => s !== undefined).join('\n');
+        }
         default:
             return null;
     }
@@ -4650,6 +4980,8 @@ const EDITOR_FILES = {
     windsurf: '.windsurf/mcp.json',
     copilot: '.vscode/mcp.json',
     continue: '.continue/config.json',
+    cline: '.vscode/mcp.json', // Cline respects VS Code project MCP config
+    zed: '.zed/settings.json', // Zed project-level context_servers
 };
 const CLAUDE_MD_MARKER_START = '<!-- cachly-brain-start -->';
 const CLAUDE_MD_MARKER_END = '<!-- cachly-brain-end -->';
@@ -4664,6 +4996,20 @@ function buildMcpConfig(apiKey, instanceId, editor) {
             },
         }, null, 2);
     }
+    if (editor === 'zed') {
+        return JSON.stringify({
+            context_servers: {
+                cachly: {
+                    command: {
+                        path: 'npx',
+                        args: ['-y', '@cachly-dev/mcp-server@latest'],
+                        env: { CACHLY_API_URL: 'https://api.cachly.dev', CACHLY_JWT: apiKey, CACHLY_BRAIN_INSTANCE_ID: instanceId },
+                    },
+                    settings: {},
+                },
+            },
+        }, null, 2);
+    }
     return JSON.stringify({
         mcpServers: {
             cachly: {
@@ -4992,6 +5338,8 @@ if (process.argv[2] === 'setup') {
     // ── Step 3: Detect editors ────────────────────────────────────────────────
     const cwd = process.cwd();
     const detected = [];
+    const { homedir } = await import('node:os');
+    const home = homedir();
     // Claude Code: always include (CLAUDE.md is universal)
     detected.push('claude');
     if (existsSync(resolve(cwd, '.cursor')))
@@ -5002,7 +5350,21 @@ if (process.argv[2] === 'setup') {
         detected.push('copilot');
     if (existsSync(resolve(cwd, '.continue')))
         detected.push('continue');
-    const editorLabel = (e) => ({ claude: 'Claude Code', cursor: 'Cursor', windsurf: 'Windsurf', copilot: 'GitHub Copilot', continue: 'Continue.dev' })[e] ?? e;
+    // Cline: VS Code extension — detect via globalStorage on the machine
+    const clineGlobalDir = process.platform === 'darwin'
+        ? resolve(home, 'Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev')
+        : resolve(home, '.vscode/extensions');
+    if (existsSync(clineGlobalDir) && !detected.includes('copilot'))
+        detected.push('cline');
+    else if (existsSync(clineGlobalDir))
+        detected.push('cline'); // both copilot + cline share .vscode/mcp.json — fine
+    // Zed editor — detect via app data dir
+    const zedDir = process.platform === 'darwin'
+        ? resolve(home, 'Library/Application Support/Zed')
+        : resolve(home, '.config/zed');
+    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'
@@ -5043,6 +5405,86 @@ if (process.argv[2] === 'setup') {
     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) ────────────────
+    // 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 {
+        const brainRes = await fetch(`${API_URL}/api/v1/instances/${instance.id}/brain/stats`, {
+            headers: { Authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(6000),
+        });
+        if (brainRes.ok) {
+            const brainData = await brainRes.json();
+            const lessons = brainData.lesson_count ?? 0;
+            const contexts = brainData.context_count ?? 0;
+            const score = brainData.quality_score ?? 0;
+            const level = lessons === 0 ? 'Intern 🌱' :
+                lessons < 10 ? 'Junior Dev 🔧' :
+                    lessons < 30 ? 'Mid Dev ⚡' :
+                        lessons < 60 ? 'Senior Dev 🧠' :
+                            lessons < 100 ? 'Staff Eng 🚀' : 'Principal Eng 🏆';
+            console.log(' ✓\n');
+            console.log('┌──────────────────────────────────────────────────────┐');
+            console.log(`│  🧠  Brain Health Report                            │`);
+            console.log('├──────────────────────────────────────────────────────┤');
+            console.log(`│  Lessons stored    : ${String(lessons).padEnd(6)} │  Level: ${level.padEnd(20)}│`);
+            console.log(`│  Context entries   : ${String(contexts).padEnd(6)} │  Quality score: ${String(Math.round(score * 100)).padEnd(3)}%       │`);
+            if (lessons === 0) {
+                console.log('├──────────────────────────────────────────────────────┤');
+                console.log('│  Your Brain is empty and ready to learn.            │');
+                console.log('│  After your first coding session it will contain:   │');
+                console.log('│    • Lessons from every bug you fixed               │');
+                console.log('│    • Your project\'s indexed files                   │');
+                console.log('│    • A session summary for next time                │');
+            }
+            console.log('└──────────────────────────────────────────────────────┘');
+        }
+        else {
+            console.log(' (skipped)');
+        }
+    }
+    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`);
+    process.exit(0);
+}
+// ── CLI: cachly index <dir> ───────────────────────────────────────────────────
+// Usage: npx @cachly-dev/mcp-server@latest index [./path/to/project]
+// Indexes the project directory into the Brain — perfect for CI/CD cron jobs.
+if (process.argv[2] === 'index') {
+    const { resolve } = await import('node:path');
+    const argv = process.argv.slice(3);
+    const flag = (name) => { const i = argv.indexOf(`--${name}`); return i !== -1 ? argv[i + 1] : undefined; };
+    const dir = resolve(flag('dir') ?? argv.find(a => !a.startsWith('--')) ?? '.');
+    const instanceId = flag('instance-id') ?? process.env.CACHLY_BRAIN_INSTANCE_ID;
+    const maxFiles = parseInt(flag('max-files') ?? '500', 10);
+    const namespace = flag('namespace') ?? 'cachly:sem:code';
+    if (!instanceId || !JWT) {
+        console.error('\n❌  CACHLY_BRAIN_INSTANCE_ID and CACHLY_JWT must be set\n');
+        console.error('   export CACHLY_BRAIN_INSTANCE_ID=<uuid>');
+        console.error('   export CACHLY_JWT=<cky_live_...>');
+        console.error('   npx @cachly-dev/mcp-server@latest index ./my-project\n');
+        process.exit(1);
+    }
+    console.log(`\n📂  Indexing: ${dir}`);
+    console.log(`    Instance: ${instanceId.slice(0, 8)}…  Max files: ${maxFiles}\n`);
+    try {
+        const result = await handleTool('index_project', {
+            instance_id: instanceId,
+            dir,
+            max_files: maxFiles,
+            ttl: 86400 * 7,
+            namespace,
+        });
+        console.log(result);
+        console.log('\n✅  Indexing complete.\n');
+    }
+    catch (err) {
+        console.error(`\n❌  Indexing failed: ${err.message}\n`);
+        process.exit(1);
+    }
     process.exit(0);
 }
 // ── Start ─────────────────────────────────────────────────────────────────────