token-pilot 0.13.0 → 0.14.1

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

@@ -1,7 +1,12 @@
-import { readFile, stat } from 'node:fs/promises';
+import { readFile, stat, access } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import { createHash } from 'node:crypto';
+import { relative, join } from 'node:path';
 import { estimateTokens } from '../core/token-estimator.js';
 import { resolveSafePath } from '../core/validation.js';
+import { assessConfidence, formatConfidence } from '../core/confidence.js';
+const execFileAsync = promisify(execFile);
 const DEFAULT_CONTEXT = 5;
 export async function handleReadForEdit(args, projectRoot, symbolResolver, fileCache, contextRegistry, astIndex) {
     const absPath = resolveSafePath(projectRoot, args.path);
@@ -91,7 +96,7 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
     const rangeCount = rangeEnd - rangeStart + 1;
     // Extract RAW code (no line number prefixes — ready for Edit old_string)
     const rawCode = lines.slice(rangeStart - 1, rangeEnd).join('\n');
-    const output = [
+    const outputLines = [
         `--- EDIT CONTEXT ---`,
         `FILE: ${args.path}`,
         `TARGET: ${targetLabel}`,
@@ -103,7 +108,54 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
         '',
         `To edit: use exact text above as old_string in Edit tool.`,
         `For Read requirement: Read("${args.path}", offset=${rangeStart}, limit=${rangeCount})`,
-    ].join('\n');
+    ];
+    // --- Optional enrichment sections ---
+    // include_callers: compact caller list via ast-index refs
+    if (args.include_callers && args.symbol && !astIndex.isDisabled()) {
+        try {
+            const refs = await astIndex.refs(args.symbol, 10);
+            const callers = refs.usages.slice(0, 5);
+            if (callers.length > 0) {
+                outputLines.push('');
+                outputLines.push(`CALLERS (${callers.length}):`);
+                for (const c of callers) {
+                    const relPath = relative(projectRoot, c.path);
+                    const ctx = c.context ? ` — ${c.context.trim().slice(0, 80)}` : '';
+                    outputLines.push(`  ${relPath}:${c.line}${ctx}`);
+                }
+            }
+            else {
+                outputLines.push('');
+                outputLines.push('CALLERS: none found');
+            }
+        }
+        catch {
+            // ast-index unavailable — skip silently
+        }
+    }
+    // include_tests: find related test file and list test names
+    if (args.include_tests) {
+        const testSection = await findTestSection(absPath, args.path, projectRoot, astIndex);
+        outputLines.push('');
+        outputLines.push(...testSection);
+    }
+    // include_changes: git diff filtered to target region
+    if (args.include_changes) {
+        const diffSection = await findChangesSection(absPath, projectRoot, rangeStart, rangeEnd);
+        outputLines.push('');
+        outputLines.push(...diffSection);
+    }
+    // Confidence metadata
+    const confidenceMeta = assessConfidence({
+        symbolResolved: !!args.symbol && startLine > 0,
+        fullFile: false,
+        truncated: false,
+        hasCallers: args.include_callers ?? false,
+        hasTests: args.include_tests ?? false,
+        astAvailable: true,
+    });
+    outputLines.push(formatConfidence(confidenceMeta));
+    const output = outputLines.join('\n');
     const tokens = estimateTokens(output);
     // Track in context
     contextRegistry.trackLoad(absPath, {
@@ -115,4 +167,134 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
     });
     return { content: [{ type: 'text', text: output }] };
 }
+// --- Helper: find related test file and extract test names ---
+async function findTestSection(absPath, relPath, projectRoot, astIndex) {
+    // Derive test file path from source path using common conventions
+    // src/handlers/foo.ts → tests/handlers/foo.test.ts
+    // src/core/bar.ts → tests/core/bar.test.ts
+    const srcPrefix = 'src/';
+    let testRelPath;
+    if (relPath.startsWith(srcPrefix)) {
+        const rest = relPath.slice(srcPrefix.length);
+        const ext = rest.match(/\.[^.]+$/)?.[0] ?? '.ts';
+        const base = rest.replace(/\.[^.]+$/, '');
+        testRelPath = `tests/${base}.test${ext}`;
+    }
+    else {
+        const ext = relPath.match(/\.[^.]+$/)?.[0] ?? '.ts';
+        const base = relPath.replace(/\.[^.]+$/, '');
+        testRelPath = `${base}.test${ext}`;
+    }
+    const testAbsPath = join(projectRoot, testRelPath);
+    try {
+        await access(testAbsPath);
+    }
+    catch {
+        return [`TESTS: none found (expected at ${testRelPath})`];
+    }
+    // Test file exists — try to get outline for test names
+    const lines = [`TESTS: ${testRelPath}`];
+    if (!astIndex.isDisabled()) {
+        try {
+            const outline = await astIndex.outline(testAbsPath);
+            if (outline?.symbols && outline.symbols.length > 0) {
+                for (const sym of outline.symbols) {
+                    lines.push(`  ${sym.kind} ${sym.name}`);
+                    if (sym.children) {
+                        for (const child of sym.children) {
+                            lines.push(`    ${child.kind} ${child.name}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // outline failed — just show file path
+        }
+    }
+    return lines;
+}
+// --- Helper: git diff filtered to target region ---
+async function findChangesSection(absPath, projectRoot, rangeStart, rangeEnd) {
+    const MAX_DIFF_LINES = 30;
+    try {
+        // Try unstaged changes first
+        let diffOutput = '';
+        let diffLabel = 'unstaged';
+        try {
+            const { stdout } = await execFileAsync('git', ['diff', 'HEAD', '--', absPath], {
+                cwd: projectRoot,
+                timeout: 5000,
+            });
+            diffOutput = stdout;
+        }
+        catch {
+            // git not available or not a repo
+            return ['RECENT CHANGES: unavailable (not a git repo)'];
+        }
+        // If no unstaged changes, try last commit
+        if (!diffOutput.trim()) {
+            try {
+                const { stdout } = await execFileAsync('git', ['diff', 'HEAD~1', '--', absPath], {
+                    cwd: projectRoot,
+                    timeout: 5000,
+                });
+                diffOutput = stdout;
+                diffLabel = 'last commit';
+            }
+            catch {
+                // no previous commit
+            }
+        }
+        if (!diffOutput.trim()) {
+            return ['RECENT CHANGES: none (file unchanged)'];
+        }
+        // Filter hunks to those overlapping with target range
+        const relevantLines = filterDiffHunks(diffOutput, rangeStart, rangeEnd);
+        if (relevantLines.length === 0) {
+            return ['RECENT CHANGES: none in target region'];
+        }
+        const lines = [`RECENT CHANGES (${diffLabel}):`];
+        const trimmed = relevantLines.slice(0, MAX_DIFF_LINES);
+        for (const line of trimmed) {
+            lines.push(`  ${line}`);
+        }
+        if (relevantLines.length > MAX_DIFF_LINES) {
+            lines.push(`  ... ${relevantLines.length - MAX_DIFF_LINES} more lines`);
+        }
+        return lines;
+    }
+    catch {
+        return ['RECENT CHANGES: unavailable'];
+    }
+}
+/** Filter diff output to only hunks overlapping [rangeStart, rangeEnd]. */
+function filterDiffHunks(diff, rangeStart, rangeEnd) {
+    const allLines = diff.split('\n');
+    const result = [];
+    let inRelevantHunk = false;
+    for (const line of allLines) {
+        // Hunk header: @@ -a,b +c,d @@
+        const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+        if (hunkMatch) {
+            const hunkStart = parseInt(hunkMatch[1], 10);
+            const hunkLen = parseInt(hunkMatch[2] ?? '1', 10);
+            const hunkEnd = hunkStart + hunkLen - 1;
+            // Check overlap with target range
+            inRelevantHunk = hunkStart <= rangeEnd && hunkEnd >= rangeStart;
+            if (inRelevantHunk) {
+                result.push(line);
+            }
+            continue;
+        }
+        // Skip diff metadata lines (diff --git, index, ---, +++)
+        if (line.startsWith('diff ') || line.startsWith('index ') || line.startsWith('--- ') || line.startsWith('+++ ')) {
+            continue;
+        }
+        if (inRelevantHunk && (line.startsWith('+') || line.startsWith('-') || line.startsWith(' '))) {
+            result.push(line);
+        }
+    }
+    return result;
+}
 //# sourceMappingURL=read-for-edit.js.map

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

@@ -5,7 +5,7 @@ export interface ReadRangeArgs {
     start_line: number;
     end_line: number;
 }
-export declare function handleReadRange(args: ReadRangeArgs, projectRoot: string, fileCache: FileCache, contextRegistry: ContextRegistry): Promise<{
+export declare function handleReadRange(args: ReadRangeArgs, projectRoot: string, fileCache: FileCache, contextRegistry: ContextRegistry, advisoryReminders?: boolean): Promise<{
     content: Array<{
         type: 'text';
         text: string;

package/dist/handlers/read-range.js

@@ -1,7 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { estimateTokens } from '../core/token-estimator.js';
 import { resolveSafePath } from '../core/validation.js';
-export async function handleReadRange(args, projectRoot, fileCache, contextRegistry) {
+export async function handleReadRange(args, projectRoot, fileCache, contextRegistry, advisoryReminders = true) {
     const absPath = resolveSafePath(projectRoot, args.path);
     // Get lines
     const cached = fileCache.get(absPath);
@@ -13,6 +13,18 @@ export async function handleReadRange(args, projectRoot, fileCache, contextRegis
         const content = await readFile(absPath, 'utf-8');
         lines = content.split('\n');
     }
+    // Dedup: check if full file is already in context and unchanged
+    if (advisoryReminders) {
+        const hash = cached?.hash;
+        if (hash && !contextRegistry.isStale(absPath, hash)) {
+            if (contextRegistry.isFullyLoaded(absPath)) {
+                const reminder = contextRegistry.rangeReminder(absPath, args.start_line, args.end_line);
+                if (reminder) {
+                    return { content: [{ type: 'text', text: reminder }] };
+                }
+            }
+        }
+    }
     const start = Math.max(0, args.start_line - 1);
     const end = Math.min(lines.length, args.end_line);
     if (start >= lines.length || start >= end) {
@@ -39,6 +51,9 @@ export async function handleReadRange(args, projectRoot, fileCache, contextRegis
         endLine: args.end_line,
         tokens,
     });
+    if (cached?.hash) {
+        contextRegistry.setContentHash(absPath, cached.hash);
+    }
     return { content: [{ type: 'text', text: output }] };
 }
 //# sourceMappingURL=read-range.js.map

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

@@ -9,7 +9,7 @@ export interface ReadSymbolArgs {
     context_after?: number;
     show?: 'full' | 'head' | 'tail' | 'outline';
 }
-export declare function handleReadSymbol(args: ReadSymbolArgs, projectRoot: string, symbolResolver: SymbolResolver, fileCache: FileCache, contextRegistry: ContextRegistry, astIndex?: AstIndexClient): Promise<{
+export declare function handleReadSymbol(args: ReadSymbolArgs, projectRoot: string, symbolResolver: SymbolResolver, fileCache: FileCache, contextRegistry: ContextRegistry, astIndex?: AstIndexClient, advisoryReminders?: boolean): Promise<{
     content: Array<{
         type: 'text';
         text: string;

package/dist/handlers/read-symbol.js

@@ -1,7 +1,8 @@
 import { readFile } from 'node:fs/promises';
 import { estimateTokens } from '../core/token-estimator.js';
 import { resolveSafePath } from '../core/validation.js';
-export async function handleReadSymbol(args, projectRoot, symbolResolver, fileCache, contextRegistry, astIndex) {
+import { assessConfidence, formatConfidence } from '../core/confidence.js';
+export async function handleReadSymbol(args, projectRoot, symbolResolver, fileCache, contextRegistry, astIndex, advisoryReminders = true) {
     const absPath = resolveSafePath(projectRoot, args.path);
     // Get file content
     const cached = fileCache.get(absPath);
@@ -13,6 +14,18 @@ export async function handleReadSymbol(args, projectRoot, symbolResolver, fileCa
         const content = await readFile(absPath, 'utf-8');
         lines = content.split('\n');
     }
+    // Dedup: check if content already in context and unchanged
+    if (advisoryReminders) {
+        const hash = cached?.hash;
+        if (hash && !contextRegistry.isStale(absPath, hash)) {
+            if (contextRegistry.isFullyLoaded(absPath) || contextRegistry.isSymbolLoaded(absPath, args.symbol)) {
+                const reminder = contextRegistry.symbolReminder(absPath, args.symbol);
+                if (reminder) {
+                    return { content: [{ type: 'text', text: reminder }] };
+                }
+            }
+        }
+    }
     // Resolve symbol — auto-fetch structure if not cached
     let structure = cached?.structure;
     if (!structure && astIndex) {
@@ -116,6 +129,17 @@ export async function handleReadSymbol(args, projectRoot, symbolResolver, fileCa
         endLine: resolved.endLine,
         tokens,
     });
-    return { content: [{ type: 'text', text: output }] };
+    if (cached?.hash) {
+        contextRegistry.setContentHash(absPath, cached.hash);
+    }
+    // Confidence metadata
+    const confidenceMeta = assessConfidence({
+        symbolResolved: true,
+        truncated,
+        fullFile: false,
+        hasCallers: resolved.symbol.references.length > 0,
+        astAvailable: !!structure,
+    });
+    return { content: [{ type: 'text', text: output + formatConfidence(confidenceMeta) }] };
 }
 //# sourceMappingURL=read-symbol.js.map

package/dist/handlers/related-files.d.ts

@@ -2,10 +2,21 @@ import type { AstIndexClient } from '../ast-index/client.js';
 export interface RelatedFilesArgs {
     path: string;
 }
+export interface RelatedFilesMeta {
+    imports: string[];
+    importedBy: string[];
+    tests: string[];
+    ranked: {
+        high: string[];
+        medium: string[];
+        low: string[];
+    };
+}
 export declare function handleRelatedFiles(args: RelatedFilesArgs, projectRoot: string, astIndex: AstIndexClient): Promise<{
     content: Array<{
         type: 'text';
         text: string;
     }>;
+    meta: RelatedFilesMeta;
 }>;
 //# sourceMappingURL=related-files.d.ts.map

package/dist/handlers/related-files.js

@@ -1,5 +1,9 @@
-import { basename, extname } from 'node:path';
+import { existsSync } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { basename, dirname, extname, relative, resolve } from 'node:path';
 import { resolveSafePath } from '../core/validation.js';
+const execFileAsync = promisify(execFile);
 /**
  * Language families — files with extensions in the same family are considered related.
  * This prevents cross-language false positives (e.g. Python files showing as importers of TS).
@@ -32,36 +36,64 @@ const TEST_PATTERNS = [
     /\/tests?\//,
 ];
 export async function handleRelatedFiles(args, projectRoot, astIndex) {
+    const emptyMeta = { imports: [], importedBy: [], tests: [], ranked: { high: [], medium: [], low: [] } };
     if (astIndex.isDisabled() || astIndex.isOversized()) {
-        return { content: [{ type: 'text', text: 'related_files is disabled: ' + (astIndex.isDisabled()
+        return {
+            content: [{
+                    type: 'text',
+                    text: 'related_files 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 smart_read() to see file imports in the outline.' }] };
+                        : 'ast-index built >50k files (likely includes node_modules). Ensure node_modules is in .gitignore.')
+                        + '\nAlternative: use smart_read() to see file imports in the outline.',
+                }],
+            meta: emptyMeta,
+        };
     }
     const absPath = resolveSafePath(projectRoot, args.path);
     const fileName = basename(absPath);
     const fileBase = fileName.replace(/\.\w+$/, '');
-    const sections = [`RELATED FILES: ${args.path}`, ''];
-    // 1. Forward imports (what this file imports)
+    const fileDir = dirname(absPath);
+    // Scoring map: relPath → RankedFile
+    const fileScores = new Map();
+    function addScore(relPath, points, tag) {
+        const existing = fileScores.get(relPath);
+        if (existing) {
+            existing.score += points;
+            if (!existing.tags.includes(tag))
+                existing.tags.push(tag);
+        }
+        else {
+            fileScores.set(relPath, { relPath, score: points, tags: [tag] });
+        }
+    }
+    // Track original categories for backwards-compatible meta
+    const importPaths = new Set();
+    const importedByPaths = [];
+    const testPaths = [];
+    // 1. Forward imports (what this file imports) → +4 per file
     try {
         const imports = await astIndex.fileImports(absPath);
         if (imports && imports.length > 0) {
-            sections.push('IMPORTS (this file uses):');
             for (const imp of imports) {
-                const specStr = imp.specifiers?.length ? imp.specifiers.join(', ') : '*';
-                sections.push(`  → ${imp.source}  (${specStr})`);
+                const resolvedImport = resolveImportPath(absPath, imp.source, projectRoot);
+                if (resolvedImport) {
+                    const relPath = relative(projectRoot, resolvedImport);
+                    importPaths.add(relPath);
+                    addScore(relPath, 4, 'import');
+                    // Same directory bonus
+                    if (dirname(resolvedImport) === fileDir) {
+                        addScore(relPath, 2, 'same-dir');
+                    }
+                }
             }
-            sections.push('');
         }
     }
     catch {
         // fileImports not available — skip silently
     }
-    // 2. Reverse imports (what imports this file)
-    const importedBy = [];
+    // 2. Reverse imports (what imports this file) → +3 per file, +1 per extra ref
     const sourceLang = getLangFamily(absPath);
     try {
-        // Get structure to find exported symbol names
         const structure = await astIndex.outline(absPath);
         const exportNames = [];
         if (structure) {
@@ -71,85 +103,189 @@ export async function handleRelatedFiles(args, projectRoot, astIndex) {
                     break;
             }
         }
-        // Also try the file base name as a symbol
         if (!exportNames.includes(fileBase)) {
             exportNames.push(fileBase);
         }
-        // Search refs for each exported symbol (check imports + usages)
         const seenFiles = new Set();
         seenFiles.add(absPath);
+        // Track ref count per file for multi-ref bonus
+        const refCounts = new Map();
         for (const name of exportNames) {
             try {
                 const refs = await astIndex.refs(name, 30);
-                // Check both imports and usages — imports catch direct `import X from`,
-                // usages catch re-exports, function calls, type references from other files
                 const refEntries = [
                     ...(refs?.imports ?? []),
                     ...(refs?.usages ?? []),
                 ];
                 for (const ref of refEntries) {
                     const refPath = ref.path;
-                    if (!refPath || seenFiles.has(refPath))
+                    if (!refPath || seenFiles.has(refPath)) {
+                        // Still count extra refs for already-seen files
+                        if (refPath && refPath !== absPath) {
+                            const rp = relative(projectRoot, refPath);
+                            refCounts.set(rp, (refCounts.get(rp) ?? 0) + 1);
+                        }
                         continue;
-                    // Filter cross-language false positives:
-                    // only include files from the same language family
+                    }
                     if (sourceLang) {
                         const refLang = getLangFamily(refPath);
                         if (refLang && refLang !== sourceLang)
                             continue;
                     }
                     seenFiles.add(refPath);
-                    importedBy.push(refPath);
+                    const relPath = relative(projectRoot, refPath);
+                    importedByPaths.push(relPath);
+                    refCounts.set(relPath, (refCounts.get(relPath) ?? 0) + 1);
+                    addScore(relPath, 3, 'importer');
+                    // Same directory bonus
+                    if (dirname(refPath) === fileDir) {
+                        addScore(relPath, 2, 'same-dir');
+                    }
                 }
             }
             catch {
                 // skip symbol
             }
         }
-        if (importedBy.length > 0) {
-            sections.push('IMPORTED BY (uses this file):');
-            for (const p of importedBy) {
-                sections.push(`  → ${p}`);
+        // Apply multi-ref bonus: +1 per extra ref beyond the first
+        for (const [relPath, count] of refCounts) {
+            if (count > 1) {
+                addScore(relPath, count - 1, 'multi-ref');
             }
-            sections.push('');
         }
     }
     catch {
         // refs not available — skip silently
     }
-    // 3. Test files
+    // 3. Test files → +5 per file
     try {
         const allFiles = await astIndex.listFiles();
-        const testFiles = [];
         if (allFiles && allFiles.length > 0) {
             for (const f of allFiles) {
-                // Match test files for this module
                 const fBase = basename(f);
                 if (fBase.includes(fileBase) && TEST_PATTERNS.some(p => p.test(f))) {
-                    testFiles.push(f);
+                    const relPath = relative(projectRoot, f);
+                    testPaths.push(relPath);
+                    addScore(relPath, 5, 'test');
                 }
             }
         }
-        if (testFiles.length > 0) {
-            sections.push('TESTS:');
-            for (const t of testFiles) {
-                sections.push(`  → ${t}`);
-            }
-            sections.push('');
-        }
     }
     catch {
         // listFiles not available — skip silently
     }
-    // 4. Check if we found anything useful
-    if (sections.length <= 2) {
+    // 4. Recently changed files → +2 boost
+    const changedFiles = await getRecentlyChangedFiles(projectRoot);
+    for (const [, ranked] of fileScores) {
+        if (changedFiles.has(ranked.relPath)) {
+            addScore(ranked.relPath, 2, 'changed');
+        }
+    }
+    // 5. Sort by score and bucket into high/medium/low
+    const allRanked = Array.from(fileScores.values()).sort((a, b) => b.score - a.score);
+    const high = [];
+    const medium = [];
+    const low = [];
+    for (const r of allRanked) {
+        if (r.score >= 5)
+            high.push(r);
+        else if (r.score >= 3)
+            medium.push(r);
+        else
+            low.push(r);
+    }
+    // 6. Build output
+    const sections = [`RELATED FILES: ${args.path}`, ''];
+    if (high.length > 0) {
+        sections.push(`HIGH VALUE (${high.length} file${high.length > 1 ? 's' : ''} — read these first):`);
+        for (const r of high) {
+            sections.push(`  ★ ${r.relPath}  [${r.tags.join(', ')}]`);
+        }
+        sections.push('');
+    }
+    if (medium.length > 0) {
+        sections.push(`MEDIUM (${medium.length} file${medium.length > 1 ? 's' : ''}):`);
+        for (const r of medium) {
+            sections.push(`  · ${r.relPath}  [${r.tags.join(', ')}]`);
+        }
+        sections.push('');
+    }
+    if (low.length > 0) {
+        sections.push(`LOW (${low.length} file${low.length > 1 ? 's' : ''} — read only if needed):`);
+        for (const r of low) {
+            sections.push(`  · ${r.relPath}  [${r.tags.join(', ')}]`);
+        }
+        sections.push('');
+    }
+    if (allRanked.length === 0) {
         sections.push('No related files found. AST index may not cover this file.');
         sections.push('HINT: Use smart_read() to explore the file structure.');
     }
     else {
-        // Suggested reading order
-        sections.push('HINT: Use smart_read_many(paths=[...]) to read related files at once.');
+        const highPaths = high.map(r => `"${r.relPath}"`).join(', ');
+        if (high.length > 0) {
+            sections.push(`HINT: Use smart_read_many(paths=[${highPaths}]) to read the most relevant files.`);
+        }
+        else {
+            sections.push('HINT: Use smart_read_many(paths=[...]) to read related files at once.');
+        }
+    }
+    return {
+        content: [{ type: 'text', text: sections.join('\n') }],
+        meta: {
+            imports: Array.from(importPaths).sort(),
+            importedBy: Array.from(new Set(importedByPaths)).sort(),
+            tests: Array.from(new Set(testPaths)).sort(),
+            ranked: {
+                high: high.map(r => r.relPath),
+                medium: medium.map(r => r.relPath),
+                low: low.map(r => r.relPath),
+            },
+        },
+    };
+}
+/** Get files changed in the last 5 commits (single git call). */
+async function getRecentlyChangedFiles(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['diff', '--name-only', 'HEAD~5'], {
+            cwd: projectRoot,
+            timeout: 5000,
+        });
+        const files = stdout.trim().split('\n').filter(Boolean);
+        return new Set(files);
+    }
+    catch {
+        // git not available, not a repo, or <5 commits — try smaller range
+        try {
+            const { stdout } = await execFileAsync('git', ['diff', '--name-only', 'HEAD~1'], {
+                cwd: projectRoot,
+                timeout: 5000,
+            });
+            const files = stdout.trim().split('\n').filter(Boolean);
+            return new Set(files);
+        }
+        catch {
+            return new Set();
+        }
+    }
+}
+function resolveImportPath(sourceFile, importSource, projectRoot) {
+    if (!importSource.startsWith('.') && !importSource.startsWith('/')) {
+        return null;
+    }
+    const basePath = importSource.startsWith('/')
+        ? resolve(projectRoot, '.' + importSource)
+        : resolve(dirname(sourceFile), importSource);
+    const candidates = [
+        basePath,
+        ...['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.php', '.go', '.rs', '.java', '.kt', '.swift']
+            .flatMap((ext) => [`${basePath}${ext}`, resolve(basePath, `index${ext}`)]),
+    ];
+    for (const candidate of candidates) {
+        if (candidate.startsWith(projectRoot) && existsSync(candidate)) {
+            return candidate;
+        }
     }
-    return { content: [{ type: 'text', text: sections.join('\n') }] };
+    return null;
 }
 //# sourceMappingURL=related-files.js.map