token-pilot 0.14.2 → 0.16.0

package/dist/core/validation.js

@@ -60,6 +60,44 @@ export function validateReadSymbolArgs(args) {
         show,
     };
 }
+/**
+ * Validate read_symbols arguments (batch multi-symbol read).
+ */
+export function validateReadSymbolsArgs(args) {
+    if (!args || typeof args !== 'object') {
+        throw new Error('Arguments must be an object.');
+    }
+    const a = args;
+    if (typeof a.path !== 'string' || a.path.length === 0) {
+        throw new Error('Required parameter "path" must be a non-empty string.');
+    }
+    if (!Array.isArray(a.symbols) || a.symbols.length === 0) {
+        throw new Error('Required parameter "symbols" must be a non-empty array of strings.');
+    }
+    if (a.symbols.length > 10) {
+        throw new Error('"symbols" can contain at most 10 symbols.');
+    }
+    for (const s of a.symbols) {
+        if (typeof s !== 'string' || s.length === 0) {
+            throw new Error('Each symbol in "symbols" must be a non-empty string.');
+        }
+    }
+    let show;
+    if (a.show !== undefined && a.show !== null) {
+        const valid = ['full', 'head', 'tail', 'outline'];
+        if (typeof a.show !== 'string' || !valid.includes(a.show)) {
+            throw new Error('"show" must be one of: full, head, tail, outline.');
+        }
+        show = a.show;
+    }
+    return {
+        path: a.path,
+        symbols: a.symbols,
+        context_before: optionalNumber(a.context_before, 'context_before'),
+        context_after: optionalNumber(a.context_after, 'context_after'),
+        show,
+    };
+}
 /**
  * Validate read_range arguments.
  */
@@ -118,12 +156,17 @@ export function validateFindUsagesArgs(args) {
     if (limit !== undefined && (limit < 1 || limit > 500)) {
         throw new Error('"limit" must be between 1 and 500.');
     }
+    const context_lines = optionalNumber(a.context_lines, 'context_lines');
+    if (context_lines !== undefined && (context_lines < 0 || context_lines > 10)) {
+        throw new Error('"context_lines" must be between 0 and 10.');
+    }
     return {
         symbol: a.symbol,
         scope: optionalString(a.scope, 'scope'),
         kind,
         limit,
         lang: optionalString(a.lang, 'lang'),
+        context_lines,
     };
 }
 /**
@@ -176,12 +219,29 @@ export function validateReadForEditArgs(args) {
     if (typeof a.path !== 'string' || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
-    if (!a.symbol && !a.line) {
-        throw new Error('Either "symbol" or "line" must be provided.');
+    if (!a.symbol && !a.line && (!Array.isArray(a.symbols) || a.symbols.length === 0)) {
+        throw new Error('Either "symbol", "symbols", or "line" must be provided.');
+    }
+    // Validate symbols array (batch mode)
+    let symbols;
+    if (a.symbols !== undefined && a.symbols !== null) {
+        if (!Array.isArray(a.symbols)) {
+            throw new Error('"symbols" must be an array of strings.');
+        }
+        if (a.symbols.length > 10) {
+            throw new Error('"symbols" can contain at most 10 symbols.');
+        }
+        for (const s of a.symbols) {
+            if (typeof s !== 'string' || s.length === 0) {
+                throw new Error('Each symbol in "symbols" must be a non-empty string.');
+            }
+        }
+        symbols = a.symbols;
     }
     return {
         path: a.path,
         symbol: optionalString(a.symbol, 'symbol'),
+        symbols,
         line: optionalNumber(a.line, 'line'),
         context: optionalNumber(a.context, 'context'),
         include_callers: optionalBool(a.include_callers, 'include_callers'),

package/dist/handlers/code-audit.js

@@ -87,7 +87,7 @@ async function handleTodo(limit, projectRoot, astIndex) {
         return {
             content: [{
                     type: 'text',
-                    text: 'TODO/FIXME COMMENTS: none found.\n\nHINT: ast-index may not detect all comment formats. Try Grep: grep -rn "TODO\\|FIXME\\|HACK" --include="*.ts"',
+                    text: 'TODO/FIXME COMMENTS: none found.\n\nHINT: ast-index may not detect all comment formats. Try Grep with pattern "TODO|FIXME|HACK".',
                 }],
             meta: { files: [] },
         };
@@ -146,7 +146,7 @@ async function handleAnnotations(name, limit, projectRoot, astIndex) {
         return {
             content: [{
                     type: 'text',
-                    text: `ANNOTATIONS @${name}: none found.\n\nHINT: Try Grep for text-based search: grep -rn "@${name}" --include="*.ts"`,
+                    text: `ANNOTATIONS @${name}: none found.\n\nHINT: Try Grep with pattern "@${name}" for text-based search.`,
                 }],
             meta: { files: [] },
         };

package/dist/handlers/find-unused.js

@@ -18,7 +18,7 @@ export async function handleFindUnused(args, astIndex) {
         return { content: [{ type: 'text', text: 'find_unused is disabled: ' + (astIndex.isDisabled()
                         ? 'project root not detected. Call smart_read() on any project file first — this auto-detects the project root and enables ast-index tools.'
                         : 'ast-index built >50k files (likely includes node_modules). Ensure node_modules is in .gitignore.') +
-                        '\nAlternative: use grep_search to find unused exports manually.' }], meta: { files: [] } };
+                        '\nAlternative: use Grep to find unused exports manually.' }], meta: { files: [] } };
     }
     const requestLimit = (args.limit ?? 30) + 20; // extra to compensate for filtering
     const unused = await astIndex.unusedSymbols({

package/dist/handlers/find-usages.d.ts

@@ -10,7 +10,7 @@ import type { FindUsagesArgs } from '../core/validation.js';
  *
  * v1.1: added scope, kind, limit, lang post-filters.
  */
-export declare function handleFindUsages(args: FindUsagesArgs, astIndex: AstIndexClient): Promise<{
+export declare function handleFindUsages(args: FindUsagesArgs, astIndex: AstIndexClient, projectRoot?: string): Promise<{
     content: Array<{
         type: 'text';
         text: string;

package/dist/handlers/find-usages.js

@@ -1,3 +1,5 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
 import { assessConfidence, formatConfidence } from '../core/confidence.js';
 /**
  * Escape special regex characters in a string.
@@ -22,6 +24,81 @@ const LANG_EXT_MAP = {
     vue: ['.vue'],
     svelte: ['.svelte'],
 };
+/**
+ * Render a section (DEFINITIONS/IMPORTS/USAGES) grouped by file.
+ * Single match per file → one line. Multiple → file header + indented lines.
+ */
+function renderSection(title, items) {
+    if (items.length === 0)
+        return [];
+    const lines = [`${title}:`];
+    const byFile = new Map();
+    for (const item of items) {
+        const arr = byFile.get(item.file) ?? [];
+        arr.push({ line: item.line, text: item.text });
+        byFile.set(item.file, arr);
+    }
+    for (const [file, matches] of byFile) {
+        matches.sort((a, b) => a.line - b.line);
+        if (matches.length === 1) {
+            lines.push(`  ${file}:${matches[0].line}  ${matches[0].text}`);
+        }
+        else {
+            lines.push(`  ${file}:`);
+            for (const m of matches) {
+                lines.push(`    :${m.line}  ${m.text}`);
+            }
+        }
+    }
+    lines.push('');
+    return lines;
+}
+/**
+ * Render a section with surrounding source context lines.
+ */
+async function renderSectionWithContext(title, items, contextLines, projectRoot) {
+    if (items.length === 0)
+        return [];
+    const lines = [`${title}:`];
+    const byFile = new Map();
+    for (const item of items) {
+        const arr = byFile.get(item.file) ?? [];
+        arr.push({ line: item.line, text: item.text });
+        byFile.set(item.file, arr);
+    }
+    for (const [file, matches] of byFile) {
+        matches.sort((a, b) => a.line - b.line);
+        lines.push(`  ${file}:`);
+        // Read file for context
+        let fileLines = null;
+        try {
+            const content = await readFile(resolve(projectRoot, file), 'utf-8');
+            fileLines = content.split('\n');
+        }
+        catch {
+            // File unreadable — fall back to text-only
+            for (const m of matches) {
+                lines.push(`    :${m.line}  ${m.text}`);
+            }
+            continue;
+        }
+        for (let mi = 0; mi < matches.length; mi++) {
+            const m = matches[mi];
+            const start = Math.max(0, m.line - 1 - contextLines);
+            const end = Math.min(fileLines.length, m.line + contextLines);
+            for (let i = start; i < end; i++) {
+                const lineNum = i + 1;
+                const marker = lineNum === m.line ? '>' : ' ';
+                lines.push(`    ${marker} ${lineNum} | ${fileLines[i]}`);
+            }
+            if (mi < matches.length - 1) {
+                lines.push('');
+            }
+        }
+    }
+    lines.push('');
+    return lines;
+}
 /**
  * Find all usages of a symbol across the project.
  *
@@ -32,7 +109,7 @@ const LANG_EXT_MAP = {
  *
  * v1.1: added scope, kind, limit, lang post-filters.
  */
-export async function handleFindUsages(args, astIndex) {
+export async function handleFindUsages(args, astIndex, projectRoot) {
     if (astIndex.isDisabled() || astIndex.isOversized()) {
         return {
             content: [{
@@ -40,7 +117,7 @@ export async function handleFindUsages(args, astIndex) {
                     text: 'find_usages is disabled: ' + (astIndex.isDisabled()
                         ? 'project root not detected. Call smart_read() on any project file first — this auto-detects the project root and enables ast-index tools.'
                         : 'ast-index built >50k files (likely includes node_modules). Ensure node_modules is in .gitignore.')
-                        + '\nAlternative: use grep_search to find symbol references.',
+                        + '\nAlternative: use Grep to find symbol references.',
                 }],
             meta: { files: [], definitions: 0, imports: 0, usages: 0, total: 0 },
         };
@@ -151,32 +228,23 @@ export async function handleFindUsages(args, astIndex) {
         filterHints.push(`kind=${args.kind}`);
     const filterStr = filterHints.length > 0 ? ` [${filterHints.join(', ')}]` : '';
     const lines = [
-        `REFS: "${args.symbol}" (${totalCount} total: ${definitions.length} definitions, ${allImports.length} imports, ${allUsages.length} usages)${filterStr}`,
+        `REFS: "${args.symbol}" (${totalCount} total: ${definitions.length} def · ${allImports.length} imports · ${allUsages.length} usages)${filterStr}`,
         '',
     ];
-    if (definitions.length > 0) {
-        lines.push('DEFINITIONS:');
-        for (const d of definitions) {
-            lines.push(`  ${d.file}:${d.line}`);
-            lines.push(`    ${d.text}`);
-        }
-        lines.push('');
+    if (args.context_lines !== undefined && args.context_lines > 0 && projectRoot) {
+        const [defSection, impSection, useSection] = await Promise.all([
+            renderSectionWithContext('DEFINITIONS', definitions, args.context_lines, projectRoot),
+            renderSectionWithContext('IMPORTS', allImports, args.context_lines, projectRoot),
+            renderSectionWithContext('USAGES', allUsages, args.context_lines, projectRoot),
+        ]);
+        lines.push(...defSection);
+        lines.push(...impSection);
+        lines.push(...useSection);
     }
-    if (allImports.length > 0) {
-        lines.push('IMPORTS:');
-        for (const i of allImports) {
-            lines.push(`  ${i.file}:${i.line}`);
-            lines.push(`    ${i.text}`);
-        }
-        lines.push('');
-    }
-    if (allUsages.length > 0) {
-        lines.push('USAGES:');
-        for (const u of allUsages) {
-            lines.push(`  ${u.file}:${u.line}`);
-            lines.push(`    ${u.text}`);
-        }
-        lines.push('');
+    else {
+        lines.push(...renderSection('DEFINITIONS', definitions));
+        lines.push(...renderSection('IMPORTS', allImports));
+        lines.push(...renderSection('USAGES', allUsages));
     }
     lines.push('HINT: Use read_symbol() or read_range() to load specific results.');
     // Confidence metadata

package/dist/handlers/read-for-edit.d.ts

@@ -5,6 +5,7 @@ import type { ContextRegistry } from '../core/context-registry.js';
 export interface ReadForEditArgs {
     path: string;
     symbol?: string;
+    symbols?: string[];
     line?: number;
     context?: number;
     include_callers?: boolean;

package/dist/handlers/read-for-edit.js

@@ -39,6 +39,71 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
             lastAccess: Date.now(),
         });
     }
+    // --- Batch mode: multiple symbols ---
+    if (args.symbols && args.symbols.length > 0) {
+        let structure = cached?.structure;
+        if (!structure) {
+            structure = await astIndex.outline(absPath) ?? undefined;
+        }
+        const sections = [];
+        sections.push(`--- EDIT CONTEXT (BATCH: ${args.symbols.length} symbols) ---`);
+        sections.push(`FILE: ${args.path}`);
+        sections.push('');
+        let resolved_count = 0;
+        for (let i = 0; i < args.symbols.length; i++) {
+            const symName = args.symbols[i];
+            const resolved = await symbolResolver.resolve(symName, structure);
+            if (!resolved) {
+                sections.push(`=== SYMBOL ${i + 1}/${args.symbols.length}: ${symName} — NOT FOUND ===`);
+                sections.push('');
+                continue;
+            }
+            resolved_count++;
+            const symbolLines = resolved.endLine - resolved.startLine + 1;
+            const MAX_EDIT_LINES = 60;
+            let effStart = resolved.startLine;
+            let effEnd;
+            let label;
+            if (symbolLines <= MAX_EDIT_LINES) {
+                effEnd = resolved.endLine;
+                label = `${symName} [L${effStart}-${effEnd}] (${symbolLines} lines, full)`;
+            }
+            else {
+                effEnd = effStart + MAX_EDIT_LINES - 1;
+                label = `${symName} [L${effStart}-${resolved.endLine}] (showing first ${MAX_EDIT_LINES} of ${symbolLines} lines)`;
+            }
+            const rangeStart = Math.max(1, effStart - ctx);
+            const rangeEnd = Math.min(lines.length, effEnd + ctx);
+            const rawCode = lines.slice(rangeStart - 1, rangeEnd).join('\n');
+            sections.push(`=== SYMBOL ${i + 1}/${args.symbols.length}: ${label} ===`);
+            sections.push('');
+            sections.push(rawCode);
+            sections.push('');
+            // Track each symbol
+            contextRegistry.trackLoad(absPath, {
+                type: 'symbol',
+                symbolName: symName,
+                startLine: rangeStart,
+                endLine: rangeEnd,
+                tokens: estimateTokens(rawCode),
+            });
+        }
+        sections.push('--- END EDIT CONTEXT ---');
+        sections.push('');
+        sections.push(`To edit: use exact text from each section as old_string in Edit tool.`);
+        if (resolved_count < args.symbols.length) {
+            sections.push(`WARNING: ${args.symbols.length - resolved_count} symbol(s) not found. Use smart_read to see available symbols.`);
+        }
+        const confidenceMeta = assessConfidence({
+            symbolResolved: resolved_count > 0,
+            fullFile: false,
+            truncated: false,
+            astAvailable: true,
+        });
+        sections.push(formatConfidence(confidenceMeta));
+        const output = sections.join('\n');
+        return { content: [{ type: 'text', text: output }] };
+    }
     let startLine;
     let endLine;
     let targetLabel;

package/dist/handlers/read-symbols.d.ts

@@ -0,0 +1,18 @@
+import type { AstIndexClient } from '../ast-index/client.js';
+import type { SymbolResolver } from '../core/symbol-resolver.js';
+import type { FileCache } from '../core/file-cache.js';
+import type { ContextRegistry } from '../core/context-registry.js';
+export interface ReadSymbolsArgs {
+    path: string;
+    symbols: string[];
+    context_before?: number;
+    context_after?: number;
+    show?: 'full' | 'head' | 'tail' | 'outline';
+}
+export declare function handleReadSymbols(args: ReadSymbolsArgs, projectRoot: string, symbolResolver: SymbolResolver, fileCache: FileCache, contextRegistry: ContextRegistry, astIndex?: AstIndexClient, advisoryReminders?: boolean): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+//# sourceMappingURL=read-symbols.d.ts.map

package/dist/handlers/read-symbols.js

@@ -0,0 +1,142 @@
+import { readFile } from 'node:fs/promises';
+import { estimateTokens } from '../core/token-estimator.js';
+import { resolveSafePath } from '../core/validation.js';
+import { assessConfidence, formatConfidence } from '../core/confidence.js';
+export async function handleReadSymbols(args, projectRoot, symbolResolver, fileCache, contextRegistry, astIndex, advisoryReminders = true) {
+    const absPath = resolveSafePath(projectRoot, args.path);
+    // Get file content ONCE
+    const cached = fileCache.get(absPath);
+    let lines;
+    if (cached) {
+        lines = cached.lines;
+    }
+    else {
+        const content = await readFile(absPath, 'utf-8');
+        lines = content.split('\n');
+    }
+    // Get AST structure ONCE
+    let structure = cached?.structure;
+    if (!structure && astIndex) {
+        structure = await astIndex.outline(absPath) ?? undefined;
+    }
+    const N = args.symbols.length;
+    const sections = [];
+    // Show mode constants (same as read_symbol.ts)
+    const MAX_SYMBOL_LINES = 300;
+    const MAX_FULL_LINES = 500;
+    const HEAD = 50;
+    const TAIL = 30;
+    let anyTruncated = false;
+    let anyResolved = false;
+    let totalTokens = 0;
+    for (let i = 0; i < N; i++) {
+        const symbolName = args.symbols[i];
+        const idx = i + 1;
+        const resolved = await symbolResolver.resolve(symbolName, structure);
+        if (!resolved) {
+            sections.push(`SYMBOL ${idx}/${N}: ${symbolName}\n` +
+                `ERROR: Symbol "${symbolName}" not found in ${args.path}.\n` +
+                `HINT: Use smart_read("${args.path}") to see available symbols.`);
+            continue;
+        }
+        anyResolved = true;
+        const source = symbolResolver.extractSource(resolved, lines, {
+            contextBefore: args.context_before ?? 2,
+            contextAfter: args.context_after ?? 0,
+        });
+        const loc = `[L${resolved.startLine}-${resolved.endLine}]`;
+        const lineCount = resolved.endLine - resolved.startLine + 1;
+        // Determine effective show mode
+        const showMode = args.show ?? (lineCount > MAX_SYMBOL_LINES ? 'outline' : 'full');
+        let displaySource = source;
+        let truncated = false;
+        if (showMode === 'full') {
+            if (lineCount > MAX_FULL_LINES) {
+                const sourceLines = source.split('\n');
+                displaySource = sourceLines.slice(0, MAX_FULL_LINES).join('\n');
+                displaySource += `\n\n    ... truncated at ${MAX_FULL_LINES} lines (${lineCount - MAX_FULL_LINES} more). Use show="head"/"tail" for targeted view.`;
+                truncated = true;
+            }
+        }
+        else if (showMode === 'head') {
+            const sourceLines = source.split('\n');
+            displaySource = sourceLines.slice(0, HEAD).join('\n');
+            if (lineCount > HEAD) {
+                displaySource += `\n\n    ... ${lineCount - HEAD} more lines. Use show="tail" or read_symbol("${args.path}", "MethodName") for specific parts.`;
+                truncated = true;
+            }
+        }
+        else if (showMode === 'tail') {
+            const sourceLines = source.split('\n');
+            displaySource = sourceLines.slice(-TAIL).join('\n');
+            if (lineCount > TAIL) {
+                displaySource = `    ... ${lineCount - TAIL} lines above ...\n\n` + displaySource;
+                truncated = true;
+            }
+        }
+        else {
+            // 'outline' mode: head + method list + tail
+            if (lineCount > HEAD + TAIL) {
+                const sourceLines = source.split('\n');
+                const head = sourceLines.slice(0, HEAD).join('\n');
+                const tail = sourceLines.slice(-TAIL).join('\n');
+                const omitted = sourceLines.length - HEAD - TAIL;
+                let methodOutline = '';
+                if (resolved.symbol.children && resolved.symbol.children.length > 0) {
+                    const methodLines = resolved.symbol.children.map(c => {
+                        const mLoc = `[L${c.location.startLine}-${c.location.endLine}]`;
+                        return `  ${c.visibility === 'private' ? '🔒 ' : ''}${c.name}${c.kind === 'method' || c.kind === 'function' ? '()' : ''} ${mLoc} (${c.location.lineCount} lines)`;
+                    });
+                    methodOutline = `\nMETHODS (${resolved.symbol.children.length}):\n${methodLines.join('\n')}\n`;
+                }
+                displaySource = [
+                    head,
+                    '',
+                    `    ... ${omitted} lines omitted — use read_symbol("${args.path}", "MethodName") to read specific methods ...`,
+                    methodOutline,
+                    tail,
+                ].join('\n');
+                truncated = true;
+            }
+        }
+        if (truncated)
+            anyTruncated = true;
+        const symbolLines = [
+            `SYMBOL ${idx}/${N}: ${symbolName} (${resolved.symbol.kind}) ${loc} (${lineCount} lines${truncated ? `, show=${showMode}` : ''})`,
+            '',
+            displaySource,
+        ];
+        if (resolved.symbol.references.length > 0) {
+            symbolLines.push('');
+            symbolLines.push(`REFERENCES: ${resolved.symbol.references.join(', ')}`);
+        }
+        sections.push(symbolLines.join('\n'));
+        // Track each symbol
+        const sectionTokens = estimateTokens(symbolLines.join('\n'));
+        totalTokens += sectionTokens;
+        contextRegistry.trackLoad(absPath, {
+            type: 'symbol',
+            symbolName,
+            startLine: resolved.startLine,
+            endLine: resolved.endLine,
+            tokens: sectionTokens,
+        });
+    }
+    if (cached?.hash) {
+        contextRegistry.setContentHash(absPath, cached.hash);
+    }
+    const header = `FILE: ${args.path} | SYMBOLS: ${N} requested`;
+    const body = sections.join('\n\n---\n\n');
+    const footer = 'CONTEXT TRACKED: These symbols are now in your context.';
+    const output = [header, '', body, '', footer].join('\n');
+    // Confidence metadata (aggregate)
+    const confidenceMeta = assessConfidence({
+        symbolResolved: anyResolved,
+        truncated: anyTruncated,
+        fullFile: false,
+        hasCallers: false,
+        astAvailable: !!structure,
+    });
+    return { content: [{ type: 'text', text: output + formatConfidence(confidenceMeta) }] };
+}
+//# sourceMappingURL=read-symbols.js.map

package/dist/handlers/smart-diff.js

@@ -221,6 +221,29 @@ function formatSmartDiff(allFiles, processedFiles, symbolChanges, args, rawToken
     const lines = [];
     lines.push(`CHANGES: ${allFiles.length} file${allFiles.length !== 1 ? 's' : ''}, +${totalAdded} -${totalRemoved} (${scopeLabel})`);
     lines.push('');
+    // Affected symbols summary
+    const allSymbolChanges = [];
+    for (const [file, changes] of symbolChanges) {
+        for (const sc of changes) {
+            allSymbolChanges.push({ file, symbol: sc });
+        }
+    }
+    if (allSymbolChanges.length > 0) {
+        lines.push('AFFECTED SYMBOLS:');
+        // Group by changeType
+        const modified = allSymbolChanges.filter(s => s.symbol.changeType === 'MODIFIED');
+        const added = allSymbolChanges.filter(s => s.symbol.changeType === 'ADDED');
+        const removed = allSymbolChanges.filter(s => s.symbol.changeType === 'REMOVED');
+        for (const [label, group] of [['MODIFIED', modified], ['ADDED', added], ['REMOVED', removed]]) {
+            if (group.length === 0)
+                continue;
+            for (const item of group) {
+                const parens = ['function', 'method'].includes(item.symbol.kind) ? '()' : '';
+                lines.push(`  ${label}: ${item.file}::${item.symbol.name}${parens}`);
+            }
+        }
+        lines.push('');
+    }
     for (const fd of processedFiles) {
         if (lines.length >= MAX_OUTPUT_LINES) {
             lines.push(`... truncated (${allFiles.length - processedFiles.indexOf(fd)} more files)`);

package/dist/handlers/smart-read.js

@@ -4,6 +4,9 @@ import { formatOutline } from '../formatters/structure.js';
 import { estimateTokens, formatSavings } from '../core/token-estimator.js';
 import { resolveSafePath } from '../core/validation.js';
 import { isNonCodeStructured, handleNonCodeRead } from './non-code.js';
+import { parseTypeScriptRegex } from '../ast-index/regex-parser.js';
+import { buildFileStructure } from '../ast-index/enricher.js';
+const TS_JS_EXTENSIONS = new Set(['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs']);
 import { assessConfidence, formatConfidence } from '../core/confidence.js';
 export async function handleSmartRead(args, projectRoot, astIndex, fileCache, contextRegistry, config) {
     const absPath = resolveSafePath(projectRoot, args.path);
@@ -55,7 +58,7 @@ export async function handleSmartRead(args, projectRoot, astIndex, fileCache, co
     const isStale = cached ? await fileCache.isStale(absPath) : true;
     if (!cached || isStale) {
         // 4. Get structure from ast-index
-        const structure = await astIndex.outline(absPath);
+        let structure = await astIndex.outline(absPath);
         if (!structure) {
             // ast-index doesn't support this file type
             // Try non-code structural summary (JSON, YAML, Markdown, TOML)
@@ -64,6 +67,16 @@ export async function handleSmartRead(args, projectRoot, astIndex, fileCache, co
                 if (nonCodeResult)
                     return nonCodeResult;
             }
+            // Regex fallback for TS/JS when binary is unavailable
+            const ext = absPath.split('.').pop()?.toLowerCase() ?? '';
+            if (TS_JS_EXTENSIONS.has(ext)) {
+                const regexEntries = parseTypeScriptRegex(content);
+                if (regexEntries.length > 0) {
+                    structure = await buildFileStructure(absPath, regexEntries);
+                }
+            }
+        }
+        if (!structure) {
             // Fallback: return truncated preview instead of full raw content
             const previewLines = 60;
             const truncated = lines.length > previewLines;

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export declare const CODE_EXTENSIONS: Set<string>;
 export declare function getVersion(): string;
 export declare function main(cliArgs?: string[]): Promise<void>;
 export declare function startServer(cliArgs?: string[]): Promise<void>;
-export declare function handleHookRead(filePathArg?: string): void;
+export declare function handleHookRead(filePathArg?: string, denyThreshold?: number): void;
 export declare function handleHookEdit(): void;
 export declare function handleInstallHook(projectRoot: string): Promise<void>;
 export declare function handleUninstallHook(projectRoot: string): Promise<void>;

package/dist/index.js

@@ -10,7 +10,6 @@ import { findBinary, installBinary, checkBinaryUpdate, isNewerVersion } from './
 import { loadConfig } from './config/loader.js';
 import { isDangerousRoot } from './core/validation.js';
 const execFileAsync = promisify(execFile);
-const HOOK_DENY_THRESHOLD = 500;
 export const CODE_EXTENSIONS = new Set([
     'ts', 'tsx', 'js', 'jsx', 'mjs', 'py', 'go', 'rs', 'java', 'kt', 'kts',
     'swift', 'cs', 'cpp', 'cc', 'cxx', 'hpp', 'c', 'h', 'php', 'rb', 'scala',
@@ -30,9 +29,11 @@ export function getVersion() {
 }
 export async function main(cliArgs = process.argv.slice(2)) {
     switch (cliArgs[0]) {
-        case 'hook-read':
-            handleHookRead(cliArgs[1]);
+        case 'hook-read': {
+            const cfg = await loadConfig(process.cwd());
+            handleHookRead(cliArgs[1], cfg.hooks.denyThreshold);
             return;
+        }
         case 'hook-edit':
             handleHookEdit();
             return;
@@ -139,7 +140,7 @@ export async function startServer(cliArgs = process.argv.slice(2)) {
         process.exit(0);
     });
 }
-export function handleHookRead(filePathArg) {
+export function handleHookRead(filePathArg, denyThreshold = 300) {
     // Parse stdin (Claude Code hook format) to get tool_input
     let filePath = filePathArg;
     let hasOffset = false;
@@ -173,7 +174,7 @@ export function handleHookRead(filePathArg) {
     try {
         const content = readFileSync(filePath, 'utf-8');
         lineCount = content.split('\n').length;
-        if (lineCount <= HOOK_DENY_THRESHOLD) {
+        if (lineCount <= denyThreshold) {
             process.exit(0);
         }
     }