token-pilot 0.13.0 → 0.14.2

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

package/dist/handlers/smart-read-many.js

@@ -1,32 +1,86 @@
 import { handleSmartRead } from './smart-read.js';
-import { estimateTokens } from '../core/token-estimator.js';
+import { estimateTokens, formatSavings } from '../core/token-estimator.js';
+import { readFile } from 'node:fs/promises';
+import { resolveSafePath } from '../core/validation.js';
+const MAX_BATCH_FILES = 20;
+const MAX_BATCH_TOKENS = 1400;
+const MAX_FILE_TOKENS = 220;
+const MAX_FILE_LINES = 24;
+const BATCH_CONCURRENCY = 4;
 export async function handleSmartReadMany(args, projectRoot, astIndex, fileCache, contextRegistry, config) {
     if (!args.paths || args.paths.length === 0) {
         return {
             content: [{ type: 'text', text: 'No paths provided.' }],
         };
     }
-    if (args.paths.length > 20) {
+    if (args.paths.length > MAX_BATCH_FILES) {
         return {
-            content: [{ type: 'text', text: `Too many files (${args.paths.length}). Maximum is 20 per batch.` }],
+            content: [{ type: 'text', text: `Too many files (${args.paths.length}). Maximum is ${MAX_BATCH_FILES} per batch.` }],
         };
     }
-    const results = [];
-    let totalTokens = 0;
-    for (const path of args.paths) {
-        try {
+    const uniquePaths = Array.from(new Set(args.paths));
+    const entries = [];
+    for (let i = 0; i < uniquePaths.length; i += BATCH_CONCURRENCY) {
+        const batch = uniquePaths.slice(i, i + BATCH_CONCURRENCY);
+        const settled = await Promise.allSettled(batch.map(async (path) => {
             const result = await handleSmartRead({ path }, projectRoot, astIndex, fileCache, contextRegistry, config);
             const text = result.content[0]?.text ?? '';
-            results.push(text);
-            totalTokens += estimateTokens(text);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            results.push(`FILE: ${path}\nERROR: ${msg}`);
+            const fullTokens = await estimateFullFileTokens(projectRoot, path);
+            return { path, text, fullTokens };
+        }));
+        for (let index = 0; index < settled.length; index++) {
+            const outcome = settled[index];
+            const path = batch[index];
+            if (outcome.status === 'fulfilled') {
+                entries.push(outcome.value);
+            }
+            else {
+                const msg = outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason);
+                entries.push({ path, text: `FILE: ${path}\nERROR: ${msg}`, fullTokens: 0 });
+            }
         }
     }
-    results.push('');
-    results.push(`BATCH: ${args.paths.length} files loaded (~${totalTokens} tokens total)`);
-    return { content: [{ type: 'text', text: results.join('\n\n---\n\n') }] };
+    let remainingBudget = MAX_BATCH_TOKENS;
+    const renderedEntries = [];
+    for (const entry of entries) {
+        const compacted = compactBatchEntry(entry, remainingBudget);
+        renderedEntries.push(compacted);
+        remainingBudget = Math.max(0, remainingBudget - estimateTokens(compacted));
+    }
+    const body = renderedEntries.join('\n\n---\n\n');
+    const actualTokens = estimateTokens(body);
+    const fullTokens = entries.reduce((sum, entry) => sum + entry.fullTokens, 0);
+    const duplicatesRemoved = args.paths.length - uniquePaths.length;
+    const footer = [''];
+    footer.push(`BATCH: ${uniquePaths.length} unique files loaded${duplicatesRemoved > 0 ? ` (${duplicatesRemoved} duplicates skipped)` : ''}`);
+    footer.push(`OUTPUT: ~${actualTokens} tokens`);
+    if (fullTokens > 0) {
+        footer.push(formatSavings(actualTokens, fullTokens));
+    }
+    footer.push('HINT: Re-run smart_read(path) on any compacted file for full detail.');
+    return { content: [{ type: 'text', text: body + '\n' + footer.join('\n') }] };
+}
+function compactBatchEntry(entry, remainingBudget) {
+    const rawTokens = estimateTokens(entry.text);
+    if (remainingBudget <= 60) {
+        return `FILE: ${entry.path}\n(compacted in batch mode — use smart_read("${entry.path}") for full detail)`;
+    }
+    if (rawTokens <= Math.min(MAX_FILE_TOKENS, remainingBudget)) {
+        return entry.text;
+    }
+    const lines = entry.text.split('\n');
+    const head = lines.slice(0, MAX_FILE_LINES).join('\n');
+    const suffix = `\n\n... compacted for batch mode. Use smart_read("${entry.path}") for full detail.`;
+    return head + suffix;
+}
+async function estimateFullFileTokens(projectRoot, relativePath) {
+    try {
+        const absPath = resolveSafePath(projectRoot, relativePath);
+        const content = await readFile(absPath, 'utf-8');
+        return estimateTokens(content);
+    }
+    catch {
+        return 0;
+    }
 }
 //# sourceMappingURL=smart-read-many.js.map

package/dist/handlers/smart-read.js

@@ -4,6 +4,7 @@ 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 { assessConfidence, formatConfidence } from '../core/confidence.js';
 export async function handleSmartRead(args, projectRoot, astIndex, fileCache, contextRegistry, config) {
     const absPath = resolveSafePath(projectRoot, args.path);
     // 0. Guard: directory passed instead of file
@@ -134,6 +135,14 @@ export async function handleSmartRead(args, projectRoot, astIndex, fileCache, co
         tokens: structureTokens,
     });
     contextRegistry.setContentHash(absPath, cached.hash);
-    return { content: [{ type: 'text', text: output + savings }] };
+    // 9. Confidence metadata
+    const confidenceMeta = assessConfidence({
+        symbolResolved: (cached.structure.symbols?.length ?? 0) > 0,
+        fullFile: false,
+        truncated: false,
+        astAvailable: true,
+        crossFileDeps: cached.structure.imports?.length ?? 0,
+    });
+    return { content: [{ type: 'text', text: output + savings + formatConfidence(confidenceMeta) }] };
 }
 //# sourceMappingURL=smart-read.js.map

package/dist/handlers/test-summary.js

@@ -37,7 +37,16 @@ export async function handleTestSummary(args, projectRoot) {
     const rawTokens = estimateTokens(rawOutput);
     const runner = args.runner ?? detectRunner(command, rawOutput);
     const result = parseTestOutput(rawOutput, runner);
-    const formatted = formatTestSummary(result, command, runner, rawTokens);
+    const commandFailed = exitCode !== 0;
+    if (commandFailed && result.failed === 0) {
+        result.failed = 1;
+        result.total = Math.max(result.total, result.passed + result.failed + result.skipped);
+        result.failures.unshift({
+            name: `Command exited with code ${exitCode}`,
+            error: summarizeCommandError(rawOutput),
+        });
+    }
+    const formatted = formatTestSummary(result, command, runner, rawTokens, exitCode, commandFailed);
     return {
         content: [{ type: 'text', text: formatted }],
         rawTokens,
@@ -277,12 +286,23 @@ function parseGeneric(output) {
         : result.passed + result.failed + result.skipped;
     return result;
 }
+function summarizeCommandError(output) {
+    const lines = output
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line.length > 0)
+        .filter(line => !line.startsWith('at ') && !line.startsWith('>'));
+    if (lines.length === 0) {
+        return 'Command failed without producing output.';
+    }
+    return lines.slice(0, 3).join('\n').substring(0, 300);
+}
 // ──────────────────────────────────────────────
 // Formatter
 // ──────────────────────────────────────────────
-function formatTestSummary(result, command, runner, rawTokens) {
+function formatTestSummary(result, command, runner, rawTokens, exitCode, commandFailed) {
     const lines = [];
-    const status = result.failed > 0 ? '❌ FAIL' : '✅ PASS';
+    const status = result.failed > 0 || commandFailed ? '❌ FAIL' : '✅ PASS';
     lines.push(`TEST RESULT: ${status} (${runner})`);
     lines.push('');
     // Stats line
@@ -298,6 +318,9 @@ function formatTestSummary(result, command, runner, rawTokens) {
     if (result.suites)
         parts.push(`${result.suites} suites`);
     lines.push(parts.join(' | '));
+    if (commandFailed && exitCode != null) {
+        lines.push(`Exit code: ${exitCode}`);
+    }
     // Failed tests detail
     if (result.failures.length > 0) {
         lines.push('');

package/dist/hooks/installer.d.ts

@@ -1,16 +1,20 @@
+export interface HookInstallResult {
+    installed: boolean;
+    fatal: boolean;
+    message: string;
+}
+export interface HookUninstallResult {
+    removed: boolean;
+    fatal: boolean;
+    message: string;
+}
 /**
  * Install Token Pilot hook into Claude Code settings.
  * Creates or updates .claude/settings.json with PreToolUse hook.
  */
-export declare function installHook(projectRoot: string): Promise<{
-    installed: boolean;
-    message: string;
-}>;
+export declare function installHook(projectRoot: string): Promise<HookInstallResult>;
 /**
  * Remove Token Pilot hook from Claude Code settings.
  */
-export declare function uninstallHook(projectRoot: string): Promise<{
-    removed: boolean;
-    message: string;
-}>;
+export declare function uninstallHook(projectRoot: string): Promise<HookUninstallResult>;
 //# sourceMappingURL=installer.d.ts.map

package/dist/hooks/installer.js

@@ -42,12 +42,20 @@ export async function installHook(projectRoot) {
             }
             catch {
                 // File exists but has invalid JSON — don't destroy it
-                return { installed: false, message: `Settings file exists but contains invalid JSON: ${settingsPath}. Fix it manually before installing hooks.` };
+                return {
+                    installed: false,
+                    fatal: true,
+                    message: `Settings file exists but contains invalid JSON: ${settingsPath}. Fix it manually before installing hooks.`,
+                };
             }
         }
         catch (err) {
             if (err?.code !== 'ENOENT') {
-                return { installed: false, message: `Cannot read settings: ${err?.message ?? err}` };
+                return {
+                    installed: false,
+                    fatal: true,
+                    message: `Cannot read settings: ${err?.message ?? err}`,
+                };
             }
             // ENOENT — file doesn't exist, start fresh
         }
@@ -58,7 +66,7 @@ export async function installHook(projectRoot) {
             const hasRead = existingHooks.some((h) => h.matcher === 'Read' && isTokenPilotHook(h));
             const hasEdit = existingHooks.some((h) => h.matcher === 'Edit' && isTokenPilotHook(h));
             if (hasRead && hasEdit) {
-                return { installed: false, message: 'Token Pilot hooks already installed.' };
+                return { installed: false, fatal: false, message: 'Token Pilot hooks already installed.' };
             }
             // Add missing hooks
             for (const hookDef of HOOK_CONFIG.hooks.PreToolUse) {
@@ -77,12 +85,13 @@ export async function installHook(projectRoot) {
         await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n');
         return {
             installed: true,
+            fatal: false,
             message: `Hooks installed at ${settingsPath}. Token Pilot will block unbounded Read on large code files and suggest read_for_edit before Edit.`,
         };
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        return { installed: false, message: `Failed to install hook: ${msg}` };
+        return { installed: false, fatal: true, message: `Failed to install hook: ${msg}` };
     }
 }
 /**
@@ -94,7 +103,7 @@ export async function uninstallHook(projectRoot) {
         const raw = await readFile(settingsPath, 'utf-8');
         const settings = JSON.parse(raw);
         if (!settings.hooks?.PreToolUse) {
-            return { removed: false, message: 'No hooks to remove.' };
+            return { removed: false, fatal: false, message: 'No hooks to remove.' };
         }
         settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter((h) => !h.hooks?.some((hook) => hook.command?.includes('token-pilot')));
         if (settings.hooks.PreToolUse.length === 0) {
@@ -104,13 +113,20 @@ export async function uninstallHook(projectRoot) {
             delete settings.hooks;
         }
         await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n');
-        return { removed: true, message: 'Token Pilot hook removed.' };
+        return { removed: true, fatal: false, message: 'Token Pilot hook removed.' };
     }
     catch (err) {
         if (err?.code === 'ENOENT') {
-            return { removed: false, message: 'Settings file not found.' };
+            return { removed: false, fatal: false, message: 'Settings file not found.' };
         }
-        return { removed: false, message: `Failed to process settings: ${err?.message ?? err}` };
+        if (err instanceof SyntaxError) {
+            return {
+                removed: false,
+                fatal: true,
+                message: `Settings file contains invalid JSON: ${settingsPath}. Fix it manually before uninstalling hooks.`,
+            };
+        }
+        return { removed: false, fatal: true, message: `Failed to process settings: ${err?.message ?? err}` };
     }
 }
 //# sourceMappingURL=installer.js.map

package/dist/index.d.ts

@@ -1,3 +1,18 @@
 #!/usr/bin/env node
-export {};
+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 handleHookEdit(): void;
+export declare function handleInstallHook(projectRoot: string): Promise<void>;
+export declare function handleUninstallHook(projectRoot: string): Promise<void>;
+export declare function handleInstallAstIndex(): Promise<void>;
+export declare function handleDoctor(): Promise<void>;
+export declare function handleInit(targetDir: string): Promise<void>;
+export declare function checkNpmLatest(packageName: string): Promise<string | null>;
+import type { TokenPilotConfig } from './types.js';
+import type { BinaryStatus } from './ast-index/binary-manager.js';
+export declare function checkAllUpdates(config: TokenPilotConfig, binaryStatus: BinaryStatus): Promise<void>;
+export declare function printHelp(): void;
 //# sourceMappingURL=index.d.ts.map