token-pilot 0.13.0 → 0.14.1

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

package/dist/index.js

@@ -3,6 +3,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { readFileSync } from 'node:fs';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
 import { createServer } from './server.js';
 import { installHook, uninstallHook } from './hooks/installer.js';
 import { findBinary, installBinary, checkBinaryUpdate, isNewerVersion } from './ast-index/binary-manager.js';
@@ -10,14 +11,14 @@ import { loadConfig } from './config/loader.js';
 import { isDangerousRoot } from './core/validation.js';
 const execFileAsync = promisify(execFile);
 const HOOK_DENY_THRESHOLD = 500;
-const CODE_EXTENSIONS = new Set([
+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',
     'dart', 'lua', 'sh', 'bash', 'sql', 'r', 'vue', 'svelte', 'pl', 'pm',
     'ex', 'exs', 'groovy', 'm', 'proto', 'bsl',
     'lisp', 'lsp', 'cl', 'asd',
 ]);
-function getVersion() {
+export function getVersion() {
     try {
         const pkgPath = new URL('../package.json', import.meta.url).pathname;
         const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
@@ -27,50 +28,48 @@ function getVersion() {
         return '0.0.0';
     }
 }
-const args = process.argv.slice(2);
-switch (args[0]) {
-    case 'hook-read':
-        handleHookRead(args[1]);
-        break;
-    case 'hook-edit':
-        handleHookEdit();
-        break;
-    case 'install-hook':
-        handleInstallHook(args[1] || process.cwd());
-        break;
-    case 'uninstall-hook':
-        handleUninstallHook(args[1] || process.cwd());
-        break;
-    case 'install-ast-index':
-        handleInstallAstIndex();
-        break;
-    case 'doctor':
-        handleDoctor();
-        break;
-    case 'init':
-        handleInit(args[1] || process.cwd());
-        break;
-    case '--version':
-    case '-v':
-        console.log(getVersion());
-        process.exit(0);
-        break;
-    case '--help':
-    case '-h':
-        printHelp();
-        break;
-    default:
-        startServer().catch(err => {
-            console.error(`[token-pilot] Fatal: ${err instanceof Error ? err.message : err}`);
-            process.exit(1);
-        });
-        break;
+export async function main(cliArgs = process.argv.slice(2)) {
+    switch (cliArgs[0]) {
+        case 'hook-read':
+            handleHookRead(cliArgs[1]);
+            return;
+        case 'hook-edit':
+            handleHookEdit();
+            return;
+        case 'install-hook':
+            await handleInstallHook(cliArgs[1] || process.cwd());
+            return;
+        case 'uninstall-hook':
+            await handleUninstallHook(cliArgs[1] || process.cwd());
+            return;
+        case 'install-ast-index':
+            await handleInstallAstIndex();
+            return;
+        case 'doctor':
+            await handleDoctor();
+            return;
+        case 'init':
+            await handleInit(cliArgs[1] || process.cwd());
+            return;
+        case '--version':
+        case '-v':
+            console.log(getVersion());
+            process.exit(0);
+            return;
+        case '--help':
+        case '-h':
+            printHelp();
+            return;
+        default:
+            await startServer(cliArgs);
+            return;
+    }
 }
-async function startServer() {
-    let projectRoot = args[0] || process.cwd();
+export async function startServer(cliArgs = process.argv.slice(2)) {
+    let projectRoot = cliArgs[0] || process.cwd();
     // Detect git root for reliable project root
     // Try multiple sources: args[0] → INIT_CWD (npm/npx invoking dir) → PWD → cwd
-    if (!args[0]) {
+    if (!cliArgs[0]) {
         const candidates = [
             process.env.INIT_CWD, // npm/npx sets this to invoking directory
             process.env.PWD, // shell working directory (may differ from cwd)
@@ -140,7 +139,7 @@ async function startServer() {
         process.exit(0);
     });
 }
-function handleHookRead(filePathArg) {
+export function handleHookRead(filePathArg) {
     // Parse stdin (Claude Code hook format) to get tool_input
     let filePath = filePathArg;
     let hasOffset = false;
@@ -193,7 +192,7 @@ function handleHookRead(filePathArg) {
     process.stdout.write(deny);
     process.exit(0);
 }
-function handleHookEdit() {
+export function handleHookEdit() {
     // Parse stdin for Edit tool_input
     let filePath;
     try {
@@ -223,17 +222,17 @@ function handleHookEdit() {
     process.stdout.write(context);
     process.exit(0);
 }
-async function handleInstallHook(projectRoot) {
+export async function handleInstallHook(projectRoot) {
     const result = await installHook(projectRoot);
     console.log(result.message);
-    process.exit(result.installed ? 0 : 1);
+    process.exit(result.fatal ? 1 : 0);
 }
-async function handleUninstallHook(projectRoot) {
+export async function handleUninstallHook(projectRoot) {
     const result = await uninstallHook(projectRoot);
     console.log(result.message);
-    process.exit(result.removed ? 0 : 1);
+    process.exit(result.fatal ? 1 : 0);
 }
-async function handleInstallAstIndex() {
+export async function handleInstallAstIndex() {
     const status = await findBinary();
     if (status.available) {
         // Check if update is available
@@ -256,7 +255,7 @@ async function handleInstallAstIndex() {
         process.exit(1);
     }
 }
-async function handleDoctor() {
+export async function handleDoctor() {
     const version = getVersion();
     const { existsSync } = await import('node:fs');
     const { join } = await import('node:path');
@@ -324,7 +323,7 @@ async function handleDoctor() {
     console.log('');
     process.exit(0);
 }
-async function handleInit(targetDir) {
+export async function handleInit(targetDir) {
     const { existsSync, readFileSync: readFs, writeFileSync } = await import('node:fs');
     const { join } = await import('node:path');
     const mcpPath = join(targetDir, '.mcp.json');
@@ -379,7 +378,7 @@ async function handleInit(targetDir) {
 // ──────────────────────────────────────────────
 // Update checking
 // ──────────────────────────────────────────────
-async function checkNpmLatest(packageName) {
+export async function checkNpmLatest(packageName) {
     try {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), 3000);
@@ -396,7 +395,7 @@ async function checkNpmLatest(packageName) {
         return null;
     }
 }
-async function checkAllUpdates(config, binaryStatus) {
+export async function checkAllUpdates(config, binaryStatus) {
     if (!config.updates.checkOnStartup)
         return;
     const [tpLatest, astUpdate, cmLatest] = await Promise.allSettled([
@@ -427,7 +426,7 @@ async function checkAllUpdates(config, binaryStatus) {
         // On startup, we only notify if explicitly useful.
     }
 }
-function printHelp() {
+export function printHelp() {
     console.log(`token-pilot v${getVersion()} — MCP server for token-efficient code reading
 
 Usage:
@@ -450,4 +449,11 @@ MCP Tools (18):
 `);
     process.exit(0);
 }
+const isDirectRun = process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1];
+if (isDirectRun) {
+    main().catch(err => {
+        console.error(`[token-pilot] Fatal: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    });
+}
 //# sourceMappingURL=index.js.map