token-pilot 0.15.0 → 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/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.
@@ -51,6 +53,52 @@ function renderSection(title, items) {
     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.
  *
@@ -61,7 +109,7 @@ function renderSection(title, items) {
  *
  * 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: [{
@@ -183,9 +231,21 @@ export async function handleFindUsages(args, astIndex) {
         `REFS: "${args.symbol}" (${totalCount} total: ${definitions.length} def · ${allImports.length} imports · ${allUsages.length} usages)${filterStr}`,
         '',
     ];
-    lines.push(...renderSection('DEFINITIONS', definitions));
-    lines.push(...renderSection('IMPORTS', allImports));
-    lines.push(...renderSection('USAGES', allUsages));
+    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);
+    }
+    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
     const confidenceMeta = assessConfidence({

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)`);