wyrm-mcp 7.3.2 → 7.3.3

package/dist/summarizer.js

@@ -1,13 +1,139 @@
-function p(e){const s=[];if(s.push(`[${e.date}]`),e.objectives){const t=e.objectives.split(`
-`)[0].trim();t&&s.push(`Goal: ${t}`)}if(e.completed){const t=g(e.completed);t.length>0&&s.push(`Done: ${t.slice(0,3).join(", ")}`)}if(e.issues){const t=d(e.issues);t.length>0&&s.push(`Fixed: ${t.slice(0,2).join("; ")}`)}if(e.commits){const t=e.commits.match(/[a-f0-9]{7,}/gi);t&&t.length>0&&s.push(`Commits: ${t.slice(0,3).join(", ")}`)}if(e.files_changed){const t=e.files_changed.split(`
-`).filter(c=>c.trim());t.length>0&&s.push(`Files: ${t.length} changed`)}const i=s.join(" | "),n=Math.ceil(i.length/4);return{summary:i,tokenEstimate:n}}function $(e){const i=e.map(n=>p(n).summary).join(`
-`);return{summary:i,tokenEstimate:Math.ceil(i.length/4)}}function g(e){const s=e.split(`
-`),i=[];for(const n of s){const t=n.match(/^[\s]*[-*•\d.]+[\s]+(.+)/);t&&i.push(t[1].trim().slice(0,50))}return i}function d(e){const s=[],i=e.match(/(?:problem|issue|bug|fix(?:ed)?)[:\s]+([^.\n]+)/gi);if(i)for(const n of i.slice(0,3)){const t=n.replace(/^(?:problem|issue|bug|fix(?:ed)?)[:\s]+/i,"").trim();t.length>5&&s.push(t.slice(0,40))}return s}function r(e){return Math.ceil(e.length/4)}function b(e,s,i,n,t=4e3){const c=[];let o=0;const a=`# ${e.name}
-Stack: ${e.stack||"Unknown"}`;c.push(a),o+=r(a);const m=s.architecture;m&&o+r(m)<t*.4&&(c.push(`
-## Architecture
-${m}`),o+=r(m));const h=s.credentials;if(h&&o+r(h)<t*.5&&(c.push(`
-## Credentials
-${h}`),o+=r(h)),i.length>0){c.push(`
-## Recent Sessions`);for(const l of i){const u=l.summary||p(l).summary,f=r(u);if(o+f<t*.8)c.push(u),o+=f;else break}}if(n.length>0&&o<t*.9){c.push(`
-## Pending Tasks`);for(const l of n.slice(0,10)){const u=`- [${l.priority}] ${l.title}`;o+r(u)<t&&(c.push(u),o+=r(u))}}return c.join(`
-`)}export{b as createContextBundle,r as estimateTokens,$ as summarizeMultipleSessions,p as summarizeSession};
+/**
+ * Wyrm Summarizer - Compresses old sessions to save tokens
+ *
+ * Uses a simple extractive summarization:
+ * - Keeps key information (commits, files, major issues)
+ * - Drops verbose descriptions
+ * - Creates a condensed summary for archived sessions
+ */
+export function summarizeSession(session) {
+    const parts = [];
+    // Date
+    parts.push(`[${session.date}]`);
+    // Objectives - just first line
+    if (session.objectives) {
+        const firstLine = session.objectives.split('\n')[0].trim();
+        if (firstLine)
+            parts.push(`Goal: ${firstLine}`);
+    }
+    // Completed - extract bullet points
+    if (session.completed) {
+        const items = extractBulletPoints(session.completed);
+        if (items.length > 0) {
+            parts.push(`Done: ${items.slice(0, 3).join(', ')}`);
+        }
+    }
+    // Issues - keep key problems
+    if (session.issues) {
+        const issues = extractKeyIssues(session.issues);
+        if (issues.length > 0) {
+            parts.push(`Fixed: ${issues.slice(0, 2).join('; ')}`);
+        }
+    }
+    // Commits - always keep
+    if (session.commits) {
+        const commits = session.commits.match(/[a-f0-9]{7,}/gi);
+        if (commits && commits.length > 0) {
+            parts.push(`Commits: ${commits.slice(0, 3).join(', ')}`);
+        }
+    }
+    // Files - just count
+    if (session.files_changed) {
+        const files = session.files_changed.split('\n').filter(f => f.trim());
+        if (files.length > 0) {
+            parts.push(`Files: ${files.length} changed`);
+        }
+    }
+    const summary = parts.join(' | ');
+    const tokenEstimate = Math.ceil(summary.length / 4);
+    return { summary, tokenEstimate };
+}
+export function summarizeMultipleSessions(sessions) {
+    const summaries = sessions.map(s => summarizeSession(s).summary);
+    const combined = summaries.join('\n');
+    return {
+        summary: combined,
+        tokenEstimate: Math.ceil(combined.length / 4)
+    };
+}
+function extractBulletPoints(text) {
+    const lines = text.split('\n');
+    const bullets = [];
+    for (const line of lines) {
+        const match = line.match(/^[\s]*[-*•\d.]+[\s]+(.+)/);
+        if (match) {
+            bullets.push(match[1].trim().slice(0, 50));
+        }
+    }
+    return bullets;
+}
+function extractKeyIssues(text) {
+    const issues = [];
+    // Look for "Problem:" or "Issue:" patterns
+    const problemMatch = text.match(/(?:problem|issue|bug|fix(?:ed)?)[:\s]+([^.\n]+)/gi);
+    if (problemMatch) {
+        for (const match of problemMatch.slice(0, 3)) {
+            const clean = match.replace(/^(?:problem|issue|bug|fix(?:ed)?)[:\s]+/i, '').trim();
+            if (clean.length > 5)
+                issues.push(clean.slice(0, 40));
+        }
+    }
+    return issues;
+}
+/**
+ * Estimate tokens in a string (rough approximation)
+ */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Create a compressed context bundle under a token limit
+ */
+export function createContextBundle(project, currentContext, recentSessions, pendingQuests, maxTokens = 4000) {
+    const parts = [];
+    let currentTokens = 0;
+    // Project header (always include)
+    const header = `# ${project.name}\nStack: ${project.stack || 'Unknown'}`;
+    parts.push(header);
+    currentTokens += estimateTokens(header);
+    // Architecture/key info from context
+    const arch = currentContext['architecture'];
+    if (arch && currentTokens + estimateTokens(arch) < maxTokens * 0.4) {
+        parts.push(`\n## Architecture\n${arch}`);
+        currentTokens += estimateTokens(arch);
+    }
+    // Credentials (if any)
+    const creds = currentContext['credentials'];
+    if (creds && currentTokens + estimateTokens(creds) < maxTokens * 0.5) {
+        parts.push(`\n## Credentials\n${creds}`);
+        currentTokens += estimateTokens(creds);
+    }
+    // Recent sessions (summarized if needed)
+    if (recentSessions.length > 0) {
+        parts.push('\n## Recent Sessions');
+        for (const session of recentSessions) {
+            const sessionText = session.summary || summarizeSession(session).summary;
+            const tokens = estimateTokens(sessionText);
+            if (currentTokens + tokens < maxTokens * 0.8) {
+                parts.push(sessionText);
+                currentTokens += tokens;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    // Pending quests
+    if (pendingQuests.length > 0 && currentTokens < maxTokens * 0.9) {
+        parts.push('\n## Pending Tasks');
+        for (const quest of pendingQuests.slice(0, 10)) {
+            const questText = `- [${quest.priority}] ${quest.title}`;
+            if (currentTokens + estimateTokens(questText) < maxTokens) {
+                parts.push(questText);
+                currentTokens += estimateTokens(questText);
+            }
+        }
+    }
+    return parts.join('\n');
+}
+//# sourceMappingURL=summarizer.js.map

package/dist/symbols.js

@@ -1,15 +1,291 @@
-import{readdirSync as T,readFileSync as S,statSync as j}from"fs";import{join as v,extname as E,relative as C,basename as F}from"path";const M=[{language:"ts",extensions:[".ts",".mts",".cts"],patterns:[{kind:"function",re:/^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/},{kind:"function",re:/^\s*(?:export\s+)?const\s+(\w+)\s*[:=][^=]*=>/},{kind:"class",re:/^\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/},{kind:"interface",re:/^\s*(?:export\s+)?interface\s+(\w+)/},{kind:"type",re:/^\s*(?:export\s+)?type\s+(\w+)/},{kind:"const",re:/^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[:=]/}]},{language:"tsx",extensions:[".tsx"],patterns:[{kind:"function",re:/^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/},{kind:"function",re:/^\s*(?:export\s+)?const\s+(\w+)\s*[:=][^=]*=>/},{kind:"class",re:/^\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/},{kind:"interface",re:/^\s*(?:export\s+)?interface\s+(\w+)/},{kind:"type",re:/^\s*(?:export\s+)?type\s+(\w+)/}]},{language:"js",extensions:[".js",".mjs",".cjs"],patterns:[{kind:"function",re:/^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/},{kind:"function",re:/^\s*(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/},{kind:"class",re:/^\s*(?:export\s+)?class\s+(\w+)/},{kind:"const",re:/^\s*(?:export\s+)?const\s+(\w+)\s*=/}]},{language:"jsx",extensions:[".jsx"],patterns:[{kind:"function",re:/^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/},{kind:"function",re:/^\s*(?:export\s+)?const\s+(\w+)\s*=\s*\(/},{kind:"class",re:/^\s*(?:export\s+)?class\s+(\w+)/}]},{language:"py",extensions:[".py"],patterns:[{kind:"function",re:/^\s*(?:async\s+)?def\s+(\w+)/},{kind:"class",re:/^\s*class\s+(\w+)/}]},{language:"rs",extensions:[".rs"],patterns:[{kind:"function",re:/^\s*(?:pub(?:\([^)]+\))?\s+)?(?:async\s+|unsafe\s+|const\s+)*fn\s+(\w+)/},{kind:"class",re:/^\s*(?:pub(?:\([^)]+\))?\s+)?struct\s+(\w+)/},{kind:"interface",re:/^\s*(?:pub(?:\([^)]+\))?\s+)?trait\s+(\w+)/},{kind:"type",re:/^\s*(?:pub(?:\([^)]+\))?\s+)?(?:type|enum)\s+(\w+)/}]},{language:"go",extensions:[".go"],patterns:[{kind:"function",re:/^func\s+(?:\([^)]+\)\s+)?(\w+)/},{kind:"type",re:/^type\s+(\w+)\s+(?:struct|interface|=)/}]},{language:"php",extensions:[".php"],patterns:[{kind:"function",re:/^\s*(?:public\s+|private\s+|protected\s+|static\s+)*function\s+(\w+)/},{kind:"class",re:/^\s*(?:abstract\s+|final\s+)*class\s+(\w+)/},{kind:"interface",re:/^\s*interface\s+(\w+)/}]},{language:"rb",extensions:[".rb"],patterns:[{kind:"function",re:/^\s*def\s+(?:self\.)?(\w+)/},{kind:"class",re:/^\s*class\s+(\w+)/}]}],b=new Map;for(const a of M)for(const s of a.extensions)b.set(s,a);const m=new Set(["node_modules",".git","dist","build","target","__pycache__",".next",".nuxt","venv",".venv","env",".env","vendor","coverage",".cache",".parcel-cache",".svelte-kit","out"]),I=256*1024;class U{db;constructor(s){this.db=s}indexProject(s,n){let e=0,t=0;const o=this.db.prepare(`
+/**
+ * Cross-repo symbol graph.
+ *
+ * Light-weight regex-based symbol index across all enrolled projects.
+ * Not a real LSP — no scope analysis, no type resolution. Just "where is
+ * `validateEmail` defined and which files mention it?" workspace-wide.
+ *
+ * Cursor's workspace-symbols stops at the repo boundary. Wyrm doesn't.
+ *
+ * Supported languages (regex-based heuristics):
+ *  - TypeScript / JavaScript (.ts, .tsx, .js, .jsx, .mjs, .cjs)
+ *  - Python (.py)
+ *  - Rust (.rs)
+ *  - Go (.go)
+ *  - PHP (.php)
+ *  - Ruby (.rb)
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { readdirSync, readFileSync, statSync } from 'fs';
+import { join, extname, relative, basename } from 'path';
+const EXTRACTORS = [
+    {
+        language: 'ts',
+        extensions: ['.ts', '.mts', '.cts'],
+        patterns: [
+            { kind: 'function', re: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/ },
+            { kind: 'function', re: /^\s*(?:export\s+)?const\s+(\w+)\s*[:=][^=]*=>/ },
+            { kind: 'class', re: /^\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/ },
+            { kind: 'interface', re: /^\s*(?:export\s+)?interface\s+(\w+)/ },
+            { kind: 'type', re: /^\s*(?:export\s+)?type\s+(\w+)/ },
+            { kind: 'const', re: /^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[:=]/ },
+        ],
+    },
+    {
+        language: 'tsx',
+        extensions: ['.tsx'],
+        patterns: [
+            { kind: 'function', re: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/ },
+            { kind: 'function', re: /^\s*(?:export\s+)?const\s+(\w+)\s*[:=][^=]*=>/ },
+            { kind: 'class', re: /^\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/ },
+            { kind: 'interface', re: /^\s*(?:export\s+)?interface\s+(\w+)/ },
+            { kind: 'type', re: /^\s*(?:export\s+)?type\s+(\w+)/ },
+        ],
+    },
+    {
+        language: 'js',
+        extensions: ['.js', '.mjs', '.cjs'],
+        patterns: [
+            { kind: 'function', re: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/ },
+            { kind: 'function', re: /^\s*(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/ },
+            { kind: 'class', re: /^\s*(?:export\s+)?class\s+(\w+)/ },
+            { kind: 'const', re: /^\s*(?:export\s+)?const\s+(\w+)\s*=/ },
+        ],
+    },
+    {
+        language: 'jsx',
+        extensions: ['.jsx'],
+        patterns: [
+            { kind: 'function', re: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/ },
+            { kind: 'function', re: /^\s*(?:export\s+)?const\s+(\w+)\s*=\s*\(/ },
+            { kind: 'class', re: /^\s*(?:export\s+)?class\s+(\w+)/ },
+        ],
+    },
+    {
+        language: 'py',
+        extensions: ['.py'],
+        patterns: [
+            { kind: 'function', re: /^\s*(?:async\s+)?def\s+(\w+)/ },
+            { kind: 'class', re: /^\s*class\s+(\w+)/ },
+        ],
+    },
+    {
+        language: 'rs',
+        extensions: ['.rs'],
+        patterns: [
+            { kind: 'function', re: /^\s*(?:pub(?:\([^)]+\))?\s+)?(?:async\s+|unsafe\s+|const\s+)*fn\s+(\w+)/ },
+            { kind: 'class', re: /^\s*(?:pub(?:\([^)]+\))?\s+)?struct\s+(\w+)/ },
+            { kind: 'interface', re: /^\s*(?:pub(?:\([^)]+\))?\s+)?trait\s+(\w+)/ },
+            { kind: 'type', re: /^\s*(?:pub(?:\([^)]+\))?\s+)?(?:type|enum)\s+(\w+)/ },
+        ],
+    },
+    {
+        language: 'go',
+        extensions: ['.go'],
+        patterns: [
+            { kind: 'function', re: /^func\s+(?:\([^)]+\)\s+)?(\w+)/ },
+            { kind: 'type', re: /^type\s+(\w+)\s+(?:struct|interface|=)/ },
+        ],
+    },
+    {
+        language: 'php',
+        extensions: ['.php'],
+        patterns: [
+            { kind: 'function', re: /^\s*(?:public\s+|private\s+|protected\s+|static\s+)*function\s+(\w+)/ },
+            { kind: 'class', re: /^\s*(?:abstract\s+|final\s+)*class\s+(\w+)/ },
+            { kind: 'interface', re: /^\s*interface\s+(\w+)/ },
+        ],
+    },
+    {
+        language: 'rb',
+        extensions: ['.rb'],
+        patterns: [
+            { kind: 'function', re: /^\s*def\s+(?:self\.)?(\w+)/ },
+            { kind: 'class', re: /^\s*class\s+(\w+)/ },
+        ],
+    },
+];
+const EXT_LOOKUP = new Map();
+for (const e of EXTRACTORS) {
+    for (const ext of e.extensions)
+        EXT_LOOKUP.set(ext, e);
+}
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', 'target', '__pycache__',
+    '.next', '.nuxt', 'venv', '.venv', 'env', '.env', 'vendor',
+    'coverage', '.cache', '.parcel-cache', '.svelte-kit', 'out',
+]);
+const MAX_FILE_SIZE = 256 * 1024; // 256 KB - skip generated/minified files
+export class SymbolGraph {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Walk a project directory, extract symbols, store in DB. Returns counts. */
+    indexProject(projectId, rootPath) {
+        let fileCount = 0;
+        let symbolCount = 0;
+        const insert = this.db.prepare(`
       INSERT OR IGNORE INTO symbol_index
         (project_id, file_path, symbol, kind, language, line, signature)
       VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);this.db.prepare("DELETE FROM symbol_index WHERE project_id = ?").run(s);const u=this.db.transaction(p=>{for(const i of p)o.run(s,i.file,i.symbol,i.kind,i.lang,i.line,i.signature),t++}),r=p=>{let i;try{i=T(p)}catch{return}for(const c of i){if(c.startsWith(".")&&m.has(c)||m.has(c))continue;const d=v(p,c);let f;try{f=j(d)}catch{continue}if(f.isDirectory()){r(d);continue}if(!f.isFile()||f.size>I)continue;const _=E(c).toLowerCase(),x=b.get(_);if(!x)continue;let l;try{l=S(d,"utf-8")}catch{continue}if(l.length>0&&l.length/(l.split(`
-`).length||1)>500)continue;e++;const R=C(n,d),h=[],w=l.split(`
-`);for(let g=0;g<w.length;g++){const y=w[g];if(!(y.length>500))for(const{kind:O,re:L}of x.patterns){const k=L.exec(y);if(k&&k[1]){h.push({file:R,symbol:k[1],kind:O,lang:x.language,line:g+1,signature:y.trim().slice(0,300)});break}}}h.length>0&&u(h)}};return r(n),{files:e,symbols:t}}search(s,n){const e=[],t=[];return n?.exact?(e.push("symbol = ?"),t.push(s)):(e.push("symbol LIKE ?"),t.push(`%${s}%`)),n?.projectId!=null&&(e.push("project_id = ?"),t.push(n.projectId)),n?.kind&&(e.push("kind = ?"),t.push(n.kind)),n?.language&&(e.push("language = ?"),t.push(n.language)),t.push(n?.limit??50),this.db.prepare(`
+    `);
+        // Clear stale rows for this project before re-indexing.
+        this.db.prepare('DELETE FROM symbol_index WHERE project_id = ?').run(projectId);
+        const insertMany = this.db.transaction((rows) => {
+            for (const r of rows) {
+                insert.run(projectId, r.file, r.symbol, r.kind, r.lang, r.line, r.signature);
+                symbolCount++;
+            }
+        });
+        const walk = (dir) => {
+            let entries;
+            try {
+                entries = readdirSync(dir);
+            }
+            catch {
+                return;
+            }
+            for (const name of entries) {
+                if (name.startsWith('.') && SKIP_DIRS.has(name))
+                    continue;
+                if (SKIP_DIRS.has(name))
+                    continue;
+                const full = join(dir, name);
+                let stat;
+                try {
+                    stat = statSync(full);
+                }
+                catch {
+                    continue;
+                }
+                if (stat.isDirectory()) {
+                    walk(full);
+                    continue;
+                }
+                if (!stat.isFile())
+                    continue;
+                if (stat.size > MAX_FILE_SIZE)
+                    continue;
+                const ext = extname(name).toLowerCase();
+                const extractor = EXT_LOOKUP.get(ext);
+                if (!extractor)
+                    continue;
+                let content;
+                try {
+                    content = readFileSync(full, 'utf-8');
+                }
+                catch {
+                    continue;
+                }
+                // Skip likely-minified / generated files
+                if (content.length > 0 && content.length / (content.split('\n').length || 1) > 500)
+                    continue;
+                fileCount++;
+                const relativeFile = relative(rootPath, full);
+                const rows = [];
+                const lines = content.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    const line = lines[i];
+                    if (line.length > 500)
+                        continue; // skip overlong lines
+                    for (const { kind, re } of extractor.patterns) {
+                        const m = re.exec(line);
+                        if (m && m[1]) {
+                            rows.push({
+                                file: relativeFile,
+                                symbol: m[1],
+                                kind,
+                                lang: extractor.language,
+                                line: i + 1,
+                                signature: line.trim().slice(0, 300),
+                            });
+                            break; // one symbol per line is enough
+                        }
+                    }
+                }
+                if (rows.length > 0)
+                    insertMany(rows);
+            }
+        };
+        walk(rootPath);
+        return { files: fileCount, symbols: symbolCount };
+    }
+    /** Workspace-wide symbol lookup. Optionally scope to a project, kind, language. */
+    search(symbol, opts) {
+        const clauses = [];
+        const params = [];
+        if (opts?.exact) {
+            clauses.push('symbol = ?');
+            params.push(symbol);
+        }
+        else {
+            clauses.push('symbol LIKE ?');
+            params.push(`%${symbol}%`);
+        }
+        if (opts?.projectId != null) {
+            clauses.push('project_id = ?');
+            params.push(opts.projectId);
+        }
+        if (opts?.kind) {
+            clauses.push('kind = ?');
+            params.push(opts.kind);
+        }
+        if (opts?.language) {
+            clauses.push('language = ?');
+            params.push(opts.language);
+        }
+        params.push(opts?.limit ?? 50);
+        const rows = this.db.prepare(`
       SELECT * FROM symbol_index
-      WHERE ${e.join(" AND ")}
+      WHERE ${clauses.join(' AND ')}
       ORDER BY project_id, file_path, line
       LIMIT ?
-    `).all(...t)}callers(s,n){const e=[`%${s}%`];let t=`
+    `).all(...params);
+        return rows;
+    }
+    /** Best-effort caller graph: which files in the project mention this symbol?
+     * Uses ripgrep-style grep over the symbol_index `signature` field (cheap,
+     * approximate — for a true caller graph use LSP). */
+    callers(symbol, projectId) {
+        const params = [`%${symbol}%`];
+        let sql = `
       SELECT * FROM symbol_index
       WHERE signature LIKE ? AND symbol != ?
-    `;return e.push(s),n!=null&&(t+=" AND project_id = ?",e.push(n)),t+=" ORDER BY project_id, file_path, line LIMIT 200",this.db.prepare(t).all(...e)}stats(s){const n=s!=null?"WHERE project_id = ?":"",e=s!=null?[s]:[],t=this.db.prepare(`SELECT COUNT(*) as c FROM symbol_index ${n}`).get(...e).c,o={};for(const r of this.db.prepare(`SELECT language, COUNT(*) as c FROM symbol_index ${n} GROUP BY language`).all(...e))o[r.language]=r.c;const u={};for(const r of this.db.prepare(`SELECT kind, COUNT(*) as c FROM symbol_index ${n} GROUP BY kind`).all(...e))u[r.kind]=r.c;return{total:t,by_language:o,by_kind:u}}clear(s){return this.db.prepare("DELETE FROM symbol_index WHERE project_id = ?").run(s).changes}}function A(a){const s=E(F(a)).toLowerCase();return b.get(s)?.language??null}export{U as SymbolGraph,A as languageForFile};
+    `;
+        params.push(symbol);
+        if (projectId != null) {
+            sql += ' AND project_id = ?';
+            params.push(projectId);
+        }
+        sql += ' ORDER BY project_id, file_path, line LIMIT 200';
+        return this.db.prepare(sql).all(...params);
+    }
+    /** Total symbol count + per-language breakdown. */
+    stats(projectId) {
+        const where = projectId != null ? 'WHERE project_id = ?' : '';
+        const params = projectId != null ? [projectId] : [];
+        const total = this.db.prepare(`SELECT COUNT(*) as c FROM symbol_index ${where}`).get(...params).c;
+        const byLang = {};
+        for (const r of this.db.prepare(`SELECT language, COUNT(*) as c FROM symbol_index ${where} GROUP BY language`).all(...params)) {
+            byLang[r.language] = r.c;
+        }
+        const byKind = {};
+        for (const r of this.db.prepare(`SELECT kind, COUNT(*) as c FROM symbol_index ${where} GROUP BY kind`).all(...params)) {
+            byKind[r.kind] = r.c;
+        }
+        return { total, by_language: byLang, by_kind: byKind };
+    }
+    /** Wipe all symbols for a project (e.g. before a fresh re-index). */
+    clear(projectId) {
+        return this.db.prepare('DELETE FROM symbol_index WHERE project_id = ?').run(projectId).changes;
+    }
+}
+// Helper exposed for tests / debugging — language detection by extension
+export function languageForFile(file) {
+    const ext = extname(basename(file)).toLowerCase();
+    return EXT_LOOKUP.get(ext)?.language ?? null;
+}
+//# sourceMappingURL=symbols.js.map