token-pilot 0.14.2 → 0.16.0

package/dist/ast-index/regex-parser-python.js

@@ -0,0 +1,132 @@
+/**
+ * Regex-based fallback parser for Python.
+ * Used when the ast-index binary is unavailable.
+ * Extracts top-level symbols (classes, functions, variables) and class methods.
+ */
+const PY_RESERVED = new Set([
+    'if', 'else', 'elif', 'for', 'while', 'try', 'except', 'finally',
+    'with', 'return', 'yield', 'raise', 'pass', 'break', 'continue',
+    'import', 'from', 'as', 'del', 'assert', 'lambda', 'not', 'and', 'or',
+]);
+// Top-level patterns (indent 0)
+const PY_CLASS_RE = /^class\s+(\w+)\s*[\(:]/;
+const PY_FUNC_RE = /^(?:async\s+)?def\s+(\w+)\s*\(/;
+const PY_ASSIGN_RE = /^([A-Z][A-Z_0-9]+)\s*[=:]/; // MODULE_CONSTANT = ...
+// Method patterns inside class body (indented 4+ spaces or 1+ tab)
+const PY_METHOD_RE = /^(\s{4,}|\t+)(?:async\s+)?def\s+(\w+)\s*\(/;
+// Decorator
+const PY_DECORATOR_RE = /^@(\w[\w.]*)/;
+export function parsePythonRegex(content) {
+    const lines = content.split('\n');
+    const entries = [];
+    let currentClass = null;
+    let pendingDecorators = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const indent = line.match(/^(\s*)/)?.[0].length ?? 0;
+        // Collect decorators
+        const decMatch = trimmed.match(PY_DECORATOR_RE);
+        if (decMatch) {
+            pendingDecorators.push(`@${decMatch[1]}`);
+            continue;
+        }
+        // Close current class when we hit a non-empty line at indent 0
+        // that is a new definition (not a continuation)
+        if (currentClass && indent === 0 && (PY_CLASS_RE.test(trimmed) || PY_FUNC_RE.test(trimmed) || PY_ASSIGN_RE.test(trimmed))) {
+            currentClass.end_line = lineNum - 1;
+            currentClass = null;
+        }
+        // Top-level class
+        if (indent === 0) {
+            const classMatch = trimmed.match(PY_CLASS_RE);
+            if (classMatch && !PY_RESERVED.has(classMatch[1])) {
+                const entry = {
+                    name: classMatch[1],
+                    kind: 'class',
+                    start_line: pendingDecorators.length > 0 ? lineNum - pendingDecorators.length : lineNum,
+                    end_line: 0,
+                    signature: trimmed.slice(0, 120),
+                    decorators: pendingDecorators.length > 0 ? [...pendingDecorators] : undefined,
+                    children: [],
+                };
+                entries.push(entry);
+                currentClass = entry;
+                pendingDecorators = [];
+                continue;
+            }
+            // Top-level function
+            const funcMatch = trimmed.match(PY_FUNC_RE);
+            if (funcMatch && !PY_RESERVED.has(funcMatch[1])) {
+                entries.push({
+                    name: funcMatch[1],
+                    kind: 'function',
+                    start_line: pendingDecorators.length > 0 ? lineNum - pendingDecorators.length : lineNum,
+                    end_line: 0,
+                    signature: trimmed.slice(0, 120),
+                    is_async: trimmed.startsWith('async '),
+                    decorators: pendingDecorators.length > 0 ? [...pendingDecorators] : undefined,
+                });
+                pendingDecorators = [];
+                continue;
+            }
+            // Module-level constant
+            const assignMatch = trimmed.match(PY_ASSIGN_RE);
+            if (assignMatch) {
+                entries.push({
+                    name: assignMatch[1],
+                    kind: 'variable',
+                    start_line: lineNum,
+                    end_line: lineNum,
+                    signature: trimmed.slice(0, 120),
+                });
+                pendingDecorators = [];
+                continue;
+            }
+        }
+        // Methods inside class body
+        if (currentClass && indent >= 4) {
+            const methodMatch = line.match(PY_METHOD_RE);
+            if (methodMatch) {
+                const name = methodMatch[2];
+                if (name && !PY_RESERVED.has(name)) {
+                    const decoratorStart = pendingDecorators.length > 0 ? lineNum - pendingDecorators.length : lineNum;
+                    currentClass.children.push({
+                        name,
+                        kind: 'method',
+                        start_line: decoratorStart,
+                        end_line: lineNum + 5,
+                        signature: trimmed.slice(0, 120),
+                        is_async: trimmed.includes('async '),
+                        visibility: name.startsWith('__') && name.endsWith('__') ? 'public'
+                            : name.startsWith('_') ? 'private' : 'public',
+                        decorators: pendingDecorators.length > 0 ? [...pendingDecorators] : undefined,
+                    });
+                    pendingDecorators = [];
+                }
+                continue;
+            }
+        }
+        // Non-matching line resets decorators
+        if (!decMatch) {
+            pendingDecorators = [];
+        }
+    }
+    // Close last class
+    if (currentClass) {
+        currentClass.end_line = lines.length;
+    }
+    // Fill in end_line for entries
+    for (let i = 0; i < entries.length; i++) {
+        if (entries[i].end_line === 0) {
+            entries[i].end_line = i < entries.length - 1
+                ? entries[i + 1].start_line - 1
+                : lines.length;
+        }
+    }
+    return entries;
+}
+//# sourceMappingURL=regex-parser-python.js.map

package/dist/ast-index/regex-parser.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Regex-based fallback parser for TypeScript/JavaScript.
+ * Used when the ast-index binary is unavailable.
+ * Extracts top-level symbols and class/interface members.
+ */
+import type { AstIndexOutlineEntry } from './types.js';
+export declare function parseTypeScriptRegex(content: string): AstIndexOutlineEntry[];
+//# sourceMappingURL=regex-parser.d.ts.map

package/dist/ast-index/regex-parser.js

@@ -0,0 +1,118 @@
+/**
+ * Regex-based fallback parser for TypeScript/JavaScript.
+ * Used when the ast-index binary is unavailable.
+ * Extracts top-level symbols and class/interface members.
+ */
+const RESERVED = new Set([
+    'if', 'else', 'for', 'while', 'do', 'switch', 'return', 'throw', 'try', 'catch',
+    'const', 'let', 'var', 'import', 'export', 'default', 'new', 'typeof', 'instanceof',
+    'await', 'yield', 'delete', 'void', 'in', 'of', 'case', 'break', 'continue',
+]);
+// Top-level declaration patterns (matched against trimmed line at indent 0)
+const TOP_LEVEL = [
+    { re: /^(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)/, kind: 'class' },
+    { re: /^(?:export\s+)?interface\s+(\w+)/, kind: 'interface' },
+    { re: /^(?:export\s+)?(?:declare\s+)?(?:const\s+)?enum\s+(\w+)/, kind: 'enum' },
+    { re: /^(?:export\s+)?type\s+(\w+)\s*[=<]/, kind: 'type' },
+    { re: /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s*(\w+)/, kind: 'function' },
+    // const/let arrow or function expression: export const foo = (async)? (fn | arrow)
+    { re: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*(?::[^=\n]+)?\s*=\s*(?:async\s+)?(?:function|\([^)]*\)\s*=>|\w+\s*=>|<)/, kind: 'function' },
+];
+// Method pattern inside class/interface body (indented 2+ spaces)
+const METHOD_RE = /^(\s{2,})(?:(?:public|private|protected|static|abstract|override|readonly|async)\s+)*(?:get\s+|set\s+)?(\w+)\s*(?:<[^(]*>)?\s*\(/;
+export function parseTypeScriptRegex(content) {
+    const lines = content.split('\n');
+    const entries = [];
+    // Track which class/interface we're currently inside using brace depth
+    let braceDepth = 0;
+    let currentClass = null;
+    let classOpenDepth = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Count brace changes on this line (skip strings/comments roughly)
+        for (let j = 0; j < line.length; j++) {
+            const ch = line[j];
+            if (ch === '/' && line[j + 1] === '/')
+                break; // line comment
+            if (ch === '{')
+                braceDepth++;
+            else if (ch === '}')
+                braceDepth--;
+        }
+        // Close current class when we return to its opening depth
+        if (currentClass && braceDepth <= classOpenDepth) {
+            currentClass.end_line = lineNum;
+            currentClass = null;
+            classOpenDepth = -1;
+        }
+        if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*'))
+            continue;
+        const indent = line.match(/^(\s*)/)?.[1].length ?? 0;
+        // Top-level declarations (indent 0 only)
+        if (indent === 0) {
+            let hit = false;
+            for (const p of TOP_LEVEL) {
+                const m = trimmed.match(p.re);
+                if (!m)
+                    continue;
+                const name = m[1];
+                if (!name || RESERVED.has(name))
+                    continue;
+                const entry = {
+                    name,
+                    kind: p.kind,
+                    start_line: lineNum,
+                    end_line: 0,
+                    signature: trimmed.slice(0, 120),
+                    children: p.kind === 'class' || p.kind === 'interface' || p.kind === 'enum' ? [] : undefined,
+                };
+                entries.push(entry);
+                if (entry.children !== undefined) {
+                    currentClass = entry;
+                    // Class opens on this line — brace depth after counting this line
+                    classOpenDepth = braceDepth - 1;
+                }
+                hit = true;
+                break;
+            }
+            if (hit)
+                continue;
+        }
+        // Method declarations inside class/interface body
+        if (currentClass && indent >= 2) {
+            const m = line.match(METHOD_RE);
+            if (m) {
+                const name = m[2];
+                if (name && !RESERVED.has(name)) {
+                    // Exclude arrow assignments (those have = before the ()
+                    // and plain function calls like this.foo() or obj.method()
+                    const beforeParen = line.indexOf('(');
+                    const segment = line.slice(0, beforeParen);
+                    if (!segment.includes('.') && !segment.includes('=')) {
+                        currentClass.children.push({
+                            name,
+                            kind: 'method',
+                            start_line: lineNum,
+                            end_line: lineNum + 5,
+                            signature: trimmed.slice(0, 120),
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Fill in end_line for top-level entries that didn't close via brace tracking
+    for (let i = 0; i < entries.length; i++) {
+        if (entries[i].end_line === 0) {
+            entries[i].end_line = i < entries.length - 1
+                ? entries[i + 1].start_line - 1
+                : lines.length;
+        }
+    }
+    return entries;
+}
+//# sourceMappingURL=regex-parser.js.map

package/dist/config/defaults.js

@@ -21,6 +21,7 @@ export const DEFAULT_CONFIG = {
         enabled: true,
         interceptRead: true,
         autoInstall: true,
+        denyThreshold: 300,
     },
     context: {
         estimateTokens: true,

package/dist/core/session-analytics.d.ts

@@ -26,9 +26,9 @@ export declare class SessionAnalytics {
     setContextModeStatus(status: ContextModeStatus): void;
     record(call: ToolCall): void;
     /**
-     * Generate a session report.
+     * Generate session report. Compact by default (~5 lines), verbose=true for full breakdown.
      */
-    report(): string;
+    report(verbose?: boolean): string;
     reset(): void;
 }
 //# sourceMappingURL=session-analytics.d.ts.map

package/dist/core/session-analytics.js

@@ -15,76 +15,102 @@ export class SessionAnalytics {
         this.calls.push(call);
     }
     /**
-     * Generate a session report.
+     * Generate session report. Compact by default (~5 lines), verbose=true for full breakdown.
      */
-    report() {
+    report(verbose = false) {
         const duration = formatDuration(Date.now() - this.sessionStart);
         const totalReturned = this.calls.reduce((s, c) => s + c.tokensReturned, 0);
         const totalWouldBe = this.calls.reduce((s, c) => s + c.tokensWouldBe, 0);
         const saved = totalWouldBe > 0 ? Math.round((1 - totalReturned / totalWouldBe) * 100) : 0;
-        // Group by tool
+        // --- Shared data ---
         const byTool = new Map();
         for (const c of this.calls) {
-            const existing = byTool.get(c.tool) ?? { count: 0, tokens: 0, saved: 0, wouldBe: 0 };
-            existing.count++;
-            existing.tokens += c.tokensReturned;
-            existing.saved += Math.max(0, c.tokensWouldBe - c.tokensReturned);
-            existing.wouldBe += c.tokensWouldBe;
-            byTool.set(c.tool, existing);
+            const e = byTool.get(c.tool) ?? { count: 0, tokens: 0, saved: 0, wouldBe: 0 };
+            e.count++;
+            e.tokens += c.tokensReturned;
+            e.saved += Math.max(0, c.tokensWouldBe - c.tokensReturned);
+            e.wouldBe += c.tokensWouldBe;
+            byTool.set(c.tool, e);
         }
-        const lines = [
-            `SESSION ANALYTICS (${duration})`,
-            '',
-            `Total tool calls: ${this.calls.length}`,
-            `Tokens returned: ~${totalReturned}`,
-            `Tokens saved: ~${totalWouldBe - totalReturned} (${saved}% reduction)`,
-            '',
-            'By tool:',
-        ];
         const sortedTools = Array.from(byTool.entries()).sort((a, b) => b[1].saved - a[1].saved);
-        for (const [tool, stats] of sortedTools) {
-            const reduction = stats.wouldBe > 0
-                ? Math.round((1 - stats.tokens / stats.wouldBe) * 100)
-                : 0;
-            lines.push(`  ${tool}: ${stats.count} calls, ~${stats.tokens} tokens returned, ~${stats.saved} saved (${reduction}% reduction)`);
-        }
-        // Top files by savings
         const byFile = new Map();
         for (const c of this.calls) {
             if (c.path) {
-                const current = byFile.get(c.path) ?? 0;
-                byFile.set(c.path, current + Math.max(0, c.tokensWouldBe - c.tokensReturned));
+                byFile.set(c.path, (byFile.get(c.path) ?? 0) + Math.max(0, c.tokensWouldBe - c.tokensReturned));
             }
         }
-        const topFiles = Array.from(byFile.entries())
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 5);
+        const cacheHits = this.calls.filter(c => c.sessionCacheHit);
+        // --- Compact report ---
+        const tokensSaved = totalWouldBe - totalReturned;
+        const lines = [
+            `SESSION ANALYTICS (${duration})`,
+            `Calls: ${this.calls.length}  ·  Tokens returned: ~${totalReturned}  ·  Saved: ~${tokensSaved} (${saved}%)`,
+        ];
+        if (this.calls.length > 0) {
+            const toolParts = sortedTools.slice(0, 5).map(([tool, s]) => {
+                const pct = s.wouldBe > 0 ? Math.round((1 - s.tokens / s.wouldBe) * 100) : 0;
+                return `${tool} ${s.count}× (${pct}%)`;
+            });
+            lines.push(`Tools: ${toolParts.join('  ·  ')}`);
+        }
+        const topFiles = Array.from(byFile.entries()).sort((a, b) => b[1] - a[1]).slice(0, 3);
         if (topFiles.length > 0) {
+            const fileParts = topFiles.map(([f, s]) => `${f} ~${s}`);
+            lines.push(`Top files: ${fileParts.join('  ·  ')}`);
+        }
+        const extras = [];
+        if (cacheHits.length > 0) {
+            const hitRate = Math.round(cacheHits.length / this.calls.length * 100);
+            extras.push(`Cache: ${cacheHits.length}/${this.calls.length} hits (${hitRate}%)`);
+        }
+        if (this.contextModeStatus.detected) {
+            extras.push(`context-mode: active (${this.contextModeStatus.source})`);
+        }
+        if (extras.length > 0) {
+            lines.push(extras.join('  ·  '));
+        }
+        if (!verbose)
+            return lines.join('\n');
+        // --- Verbose additions ---
+        lines.push('');
+        lines.push('--- DETAILED BREAKDOWN ---');
+        // Full per-tool table
+        if (sortedTools.length > 0) {
+            lines.push('');
+            lines.push('By tool:');
+            for (const [tool, stats] of sortedTools) {
+                const reduction = stats.wouldBe > 0 ? Math.round((1 - stats.tokens / stats.wouldBe) * 100) : 0;
+                lines.push(`  ${tool}: ${stats.count} calls, ~${stats.tokens} tokens returned, ~${stats.saved} saved (${reduction}%)`);
+            }
+        }
+        // Top 5 files
+        const allTopFiles = Array.from(byFile.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5);
+        if (allTopFiles.length > 0) {
             lines.push('');
             lines.push('Top files by savings:');
-            for (const [file, saved] of topFiles) {
-                lines.push(`  ${file}: ~${saved} tokens saved`);
+            for (const [file, fileSaved] of allTopFiles) {
+                lines.push(`  ${file}: ~${fileSaved} tokens saved`);
             }
         }
-        const lowValueTools = sortedTools
+        // Low-value tools
+        const lowValue = sortedTools
             .map(([tool, stats]) => ({
             tool,
             reduction: stats.wouldBe > 0 ? Math.round((1 - stats.tokens / stats.wouldBe) * 100) : 0,
             count: stats.count,
         }))
-            .filter((tool) => tool.reduction < 20);
-        if (lowValueTools.length > 0) {
+            .filter(t => t.reduction < 20);
+        if (lowValue.length > 0) {
             lines.push('');
             lines.push('Needs improvement:');
-            for (const tool of lowValueTools.slice(0, 5)) {
-                lines.push(`  ${tool.tool}: only ${tool.reduction}% reduction across ${tool.count} call${tool.count === 1 ? '' : 's'}`);
+            for (const t of lowValue.slice(0, 5)) {
+                lines.push(`  ${t.tool}: only ${t.reduction}% reduction across ${t.count} call${t.count === 1 ? '' : 's'}`);
             }
         }
-        // Savings breakdown by category
+        // Savings by category
         const byCategory = { compression: 0, cache: 0, dedup: 0, none: 0 };
         for (const c of this.calls) {
-            const cat = c.savingsCategory ?? 'none';
-            byCategory[cat] += Math.max(0, c.tokensWouldBe - c.tokensReturned);
+            byCategory[c.savingsCategory ?? 'none'] += Math.max(0, c.tokensWouldBe - c.tokensReturned);
         }
         if (totalWouldBe > totalReturned) {
             lines.push('');
@@ -96,35 +122,27 @@ export class SessionAnalytics {
             if (byCategory.dedup > 0)
                 lines.push(`  Dedup (already in context): ~${byCategory.dedup} tokens`);
         }
-        // Session cache hits
-        const cacheHits = this.calls.filter(c => c.sessionCacheHit);
+        // Session cache detail
         if (cacheHits.length > 0) {
             const cacheTokensSaved = cacheHits.reduce((s, c) => s + Math.max(0, c.tokensWouldBe - c.tokensReturned), 0);
             lines.push('');
             lines.push(`Session cache: ${cacheHits.length} hits / ${this.calls.length} calls (${Math.round(cacheHits.length / this.calls.length * 100)}% hit rate, ~${cacheTokensSaved} tokens saved)`);
         }
-        // Dedup reminders served
-        const dedupCalls = this.calls.filter(c => c.savingsCategory === 'dedup');
-        if (dedupCalls.length > 0) {
-            lines.push('');
-            lines.push(`Compact reminders/dedup: ${dedupCalls.length} calls (avoided full re-reads)`);
-        }
-        // Delegation stats
+        // Delegation
         const delegated = this.calls.filter(c => c.delegatedToContextMode);
         if (delegated.length > 0) {
-            lines.push('');
             lines.push(`Delegated to context-mode: ${delegated.length} calls`);
         }
-        // Per-intent breakdown (Track 2)
+        // Per-intent breakdown
         const callsWithIntent = this.calls.filter(c => c.intent);
         if (callsWithIntent.length > 0) {
             const byIntent = new Map();
             for (const c of callsWithIntent) {
                 const intent = c.intent;
-                const existing = byIntent.get(intent) ?? { count: 0, saved: 0 };
-                existing.count++;
-                existing.saved += Math.max(0, c.tokensWouldBe - c.tokensReturned);
-                byIntent.set(intent, existing);
+                const e = byIntent.get(intent) ?? { count: 0, saved: 0 };
+                e.count++;
+                e.saved += Math.max(0, c.tokensWouldBe - c.tokensReturned);
+                byIntent.set(intent, e);
             }
             lines.push('');
             lines.push('Per-intent breakdown:');
@@ -135,30 +153,29 @@ export class SessionAnalytics {
                 }
             }
         }
-        // Decision insights (Track 0)
+        // Decision insights
         const tracedCalls = this.calls.filter(c => c.decisionTrace);
         if (tracedCalls.length > 0) {
-            const alreadyInContextCount = tracedCalls.filter(c => c.decisionTrace.alreadyInContext).length;
+            const alreadyInContext = tracedCalls.filter(c => c.decisionTrace.alreadyInContext).length;
             const totalEstimated = tracedCalls.reduce((s, c) => s + c.decisionTrace.estimatedCost, 0);
             const totalActual = tracedCalls.reduce((s, c) => s + c.decisionTrace.actualCost, 0);
             const avgReduction = totalEstimated > 0 ? Math.round((1 - totalActual / totalEstimated) * 100) : 0;
             const missedSavings = tracedCalls.filter(c => c.decisionTrace.cheaperAlternative).length;
             lines.push('');
             lines.push('Decision insights:');
-            lines.push(`  Files already in context: ${alreadyInContextCount} of ${tracedCalls.length} calls (${Math.round(alreadyInContextCount / tracedCalls.length * 100)}%)`);
+            lines.push(`  Files already in context: ${alreadyInContext} of ${tracedCalls.length} calls (${Math.round(alreadyInContext / tracedCalls.length * 100)}%)`);
             lines.push(`  Avg cost reduction: ${avgReduction}% (estimated → actual)`);
             if (missedSavings > 0) {
-                lines.push(`  Missed savings opportunities: ${missedSavings} call${missedSavings === 1 ? '' : 's'} could have used cheaper tools`);
+                lines.push(`  Missed savings: ${missedSavings} call${missedSavings === 1 ? '' : 's'} could have used cheaper tools`);
             }
         }
-        // Context-mode companion status
+        // Context-mode
         if (this.contextModeStatus.detected) {
             lines.push('');
             lines.push('--- Combined Architecture ---');
             lines.push(`context-mode: active (detected via ${this.contextModeStatus.source})`);
             lines.push('Token Pilot handles: code files (AST-level structural reading)');
             lines.push('context-mode handles: shell output, logs, large data files (BM25-indexed)');
-            lines.push('TIP: Use /context-mode:stats for context-mode savings breakdown.');
         }
         return lines.join('\n');
     }

package/dist/core/symbol-resolver.d.ts

@@ -15,7 +15,6 @@ export declare class SymbolResolver {
         contextBefore?: number;
         contextAfter?: number;
     }): string;
-    private mapKind;
     /**
      * Hierarchical search: AuthService → children → login
      */

package/dist/core/symbol-resolver.js

@@ -1,3 +1,4 @@
+import { mapKind } from '../ast-index/parser.js';
 export class SymbolResolver {
     astIndex;
     constructor(astIndex) {
@@ -63,7 +64,7 @@ export class SymbolResolver {
                 symbol: {
                     name: detail.name,
                     qualifiedName: qualifiedName,
-                    kind: this.mapKind(detail.kind),
+                    kind: mapKind(detail.kind),
                     signature: detail.signature ?? detail.name,
                     location: {
                         startLine: detail.start_line,
@@ -96,7 +97,7 @@ export class SymbolResolver {
                     symbol: {
                         name: leafDetail.name,
                         qualifiedName: qualifiedName,
-                        kind: this.mapKind(leafDetail.kind),
+                        kind: mapKind(leafDetail.kind),
                         signature: leafDetail.signature ?? leafDetail.name,
                         location: {
                             startLine: leafDetail.start_line,
@@ -133,16 +134,6 @@ export class SymbolResolver {
         }
         return output.join('\n');
     }
-    mapKind(kind) {
-        const map = {
-            function: 'function', class: 'class', method: 'method',
-            property: 'property', variable: 'variable', type: 'type',
-            interface: 'interface', enum: 'enum', constant: 'constant',
-            namespace: 'namespace', struct: 'class', trait: 'interface',
-            impl: 'class', module: 'namespace',
-        };
-        return map[kind.toLowerCase()] ?? 'function';
-    }
     /**
      * Hierarchical search: AuthService → children → login
      */

package/dist/core/validation.d.ts

@@ -23,6 +23,16 @@ export declare function validateReadSymbolArgs(args: unknown): {
     context_after?: number;
     show?: 'full' | 'head' | 'tail' | 'outline';
 };
+/**
+ * Validate read_symbols arguments (batch multi-symbol read).
+ */
+export declare function validateReadSymbolsArgs(args: unknown): {
+    path: string;
+    symbols: string[];
+    context_before?: number;
+    context_after?: number;
+    show?: 'full' | 'head' | 'tail' | 'outline';
+};
 /**
  * Validate read_range arguments.
  */
@@ -48,6 +58,7 @@ export interface FindUsagesArgs {
     kind?: 'definitions' | 'imports' | 'usages' | 'all';
     limit?: number;
     lang?: string;
+    context_lines?: number;
 }
 export declare function validateFindUsagesArgs(args: unknown): FindUsagesArgs;
 /**
@@ -62,6 +73,7 @@ export declare function validateSmartReadManyArgs(args: unknown): {
 export declare function validateReadForEditArgs(args: unknown): {
     path: string;
     symbol?: string;
+    symbols?: string[];
     line?: number;
     context?: number;
     include_callers?: boolean;