@thegitai/cli 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/src/tools/replace-document-text.js

@@ -0,0 +1,234 @@
+import chalk from '../colors.js';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { isSensitiveProjectPath, normalizeProjectRelativePath, } from '../artifact-policy.js';
+import { readCliAuthConfig } from '../api/auth.js';
+import { resolveProjectPath, writeProjectFileBuffer } from '../patcher.js';
+import { repairFilePath, suggestClosestPath } from './path-suggest.js';
+import { isTuiMode } from '../runtime-mode.js';
+function normalizeReplacements(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        if (!item || typeof item !== 'object')
+            return null;
+        const entry = item;
+        const oldText = String(entry.oldText ?? entry.old_text ?? '');
+        const newText = String(entry.newText ?? entry.new_text ?? '');
+        if (!oldText)
+            return null;
+        return { oldText, newText };
+    })
+        .filter(Boolean);
+}
+function relativeEditablePath(rootDir, rawPath) {
+    const resolvedPath = path.isAbsolute(rawPath)
+        ? rawPath
+        : path.resolve(rootDir, rawPath);
+    const projectPath = normalizeProjectRelativePath(rootDir, resolvedPath);
+    if (!projectPath || isSensitiveProjectPath(projectPath))
+        return null;
+    return projectPath.split(path.sep).join('/');
+}
+function renderPreview(filePath, preview) {
+    if (isTuiMode())
+        return;
+    console.log(chalk.bold(`\n  Document text replacement preview for ${filePath}:`));
+    for (const line of preview.split('\n')) {
+        if (line.startsWith('+')) {
+            console.log(chalk.green(line));
+        }
+        else if (line.startsWith('-')) {
+            console.log(chalk.red(line));
+        }
+        else if (line.startsWith('@@')) {
+            console.log(chalk.cyan(line));
+        }
+        else {
+            console.log(chalk.dim(line));
+        }
+    }
+    console.log();
+}
+async function replaceDocumentTextOnServer(config, fileName, fileData, replacements, replaceAll, validate) {
+    const response = await globalThis.fetch(`${config.serverUrl.replace(/\/+$/, '')}/v1/document/replace-text`, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${config.token}`,
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+            fileName,
+            fileData: fileData.toString('base64'),
+            replacements,
+            replaceAll,
+            validate,
+        }),
+    });
+    const data = await response.json().catch(() => null);
+    if (!response.ok) {
+        return {
+            ok: false,
+            error: `Server document edit failed: ${data?.error?.message ?? response.status}`,
+        };
+    }
+    return data;
+}
+export async function replaceDocumentText(context, args) {
+    const sourceRaw = repairFilePath(context.rootDir, String(args.filePath ?? args.file_path ?? '').trim());
+    if (!sourceRaw) {
+        return { ok: false, error: 'filePath is required' };
+    }
+    const sourcePath = relativeEditablePath(context.rootDir, sourceRaw);
+    if (!sourcePath) {
+        return {
+            ok: false,
+            error: 'replace_document_text can only edit permitted files inside the project root.',
+            failureCategory: 'permission_denied',
+        };
+    }
+    if (path.extname(sourcePath).toLowerCase() !== '.docx') {
+        return {
+            ok: false,
+            error: 'replace_document_text only supports .docx files.',
+            failureCategory: 'invalid_argument',
+        };
+    }
+    const outputRaw = String(args.outputPath ?? args.output_path ?? '').trim();
+    const targetPath = outputRaw
+        ? relativeEditablePath(context.rootDir, outputRaw)
+        : sourcePath;
+    if (!targetPath) {
+        return {
+            ok: false,
+            error: 'outputPath must be inside the project root.',
+            failureCategory: 'permission_denied',
+        };
+    }
+    if (path.extname(targetPath).toLowerCase() !== '.docx') {
+        return {
+            ok: false,
+            error: 'outputPath must end with .docx.',
+            failureCategory: 'invalid_argument',
+        };
+    }
+    const replacements = normalizeReplacements(args.replacements);
+    if (!replacements.length) {
+        return {
+            ok: false,
+            error: 'replacements must include at least one { oldText, newText } item.',
+            failureCategory: 'missing_required_argument',
+        };
+    }
+    const authConfig = readCliAuthConfig(context.env);
+    if (!authConfig) {
+        return {
+            ok: false,
+            error: 'Document editing requires a server connection. Please log in first.',
+        };
+    }
+    const sourceAbsPath = resolveProjectPath(context.rootDir, sourcePath);
+    if (!existsSync(sourceAbsPath)) {
+        const suggestion = suggestClosestPath(context.rootDir, sourceAbsPath);
+        return {
+            ok: false,
+            filePath: sourcePath,
+            error: suggestion
+                ? `File does not exist: ${sourcePath}. Did you mean "${suggestion}"? Note the exact punctuation (e.g. curly apostrophe ’ vs straight ').`
+                : `File does not exist: ${sourcePath}`,
+            failureCategory: 'not_found',
+        };
+    }
+    const validateOnly = args.validate === true || args.dryRun === true;
+    const serverResult = await replaceDocumentTextOnServer(authConfig, path.basename(sourcePath), readFileSync(sourceAbsPath), replacements, args.replaceAll === true || args.replace_all === true, validateOnly);
+    if (!serverResult.ok) {
+        return {
+            ...serverResult,
+            filePath: sourcePath,
+            failureCategory: serverResult.failureCategory ?? 'external_service',
+        };
+    }
+    if (validateOnly) {
+        return {
+            ok: true,
+            validate: true,
+            changed: false,
+            filePath: sourcePath,
+            operation: 'replace_document_text',
+            results: serverResult.results,
+        };
+    }
+    const replacementCount = Number(serverResult.replacementCount ?? 0);
+    if (replacementCount === 0) {
+        const failures = Array.isArray(serverResult.replacements)
+            ? serverResult.replacements
+                .filter((item) => item && item.ok === false)
+                .map((item) => `- ${item.error ?? 'no match'}`)
+            : [];
+        return {
+            ok: false,
+            filePath: sourcePath,
+            operation: 'replace_document_text',
+            failureCategory: 'conflict',
+            error: `0 of ${serverResult.requestedCount ?? replacements.length} replacements applied; file unchanged.` +
+                (failures.length ? `\n${failures.join('\n')}` : ''),
+            replacements: serverResult.replacements,
+        };
+    }
+    const preview = String(serverResult.preview ?? '');
+    renderPreview(targetPath, preview);
+    if (!context.autoYes && context.confirmPatch) {
+        const confirmed = await context.confirmPatch(targetPath, preview);
+        if (!confirmed) {
+            if (!isTuiMode()) {
+                console.log(chalk.dim(`  replace_document_text skipped: ${targetPath}`));
+            }
+            return {
+                ok: false,
+                skipped: true,
+                filePath: targetPath,
+                error: 'User declined replace_document_text',
+            };
+        }
+    }
+    const fileData = String(serverResult.fileData ?? '');
+    const nextData = Buffer.from(fileData, 'base64');
+    const write = writeProjectFileBuffer(context.rootDir, targetPath, nextData);
+    const failedCount = Number(serverResult.failedCount ?? 0);
+    const appliedCount = Number(serverResult.appliedCount ?? replacementCount);
+    const requestedCount = Number(serverResult.requestedCount ?? replacements.length);
+    const partialFailures = Array.isArray(serverResult.replacements)
+        ? serverResult.replacements
+            .filter((item) => item && item.ok === false)
+            .map((item) => `- ${item.error ?? 'no match'}`)
+        : [];
+    return {
+        ok: true,
+        filePath: targetPath,
+        sourceFilePath: sourcePath,
+        changed: write.changed,
+        operation: 'replace_document_text',
+        replacementCount: serverResult.replacementCount,
+        requestedCount: serverResult.requestedCount,
+        appliedCount: serverResult.appliedCount,
+        failedCount: serverResult.failedCount,
+        replacements: serverResult.replacements,
+        bytesWritten: nextData.length,
+        ...(failedCount > 0
+            ? {
+                needsRepair: true,
+                failureCategory: 'conflict',
+                error: `${appliedCount} of ${requestedCount} replacements applied; ` +
+                    `${failedCount} missed and still need to be fixed:\n` +
+                    partialFailures.join('\n'),
+                failureDetails: {
+                    category: 'conflict',
+                    tool: 'replace_document_text',
+                    action: 'Re-issue replace_document_text for the missed entries only, with corrected oldText. ' +
+                        'Copy the exact text from read_document (mind curly vs straight quotes), or pass validate:true to test a match first.',
+                },
+            }
+            : {}),
+    };
+}

package/dist/src/tools/restore-checkpoint.js

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import chalk from '../colors.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { createPromptCheckpoint, restoreCheckpointFiles, } from '../session-safety.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';

package/dist/src/tools/run-command.js

@@ -1,4 +1,5 @@
-import chalk from 'chalk';
+import chalk from '../colors.js';
+import { startBackgroundJob } from '../background-jobs.js';
 import { getBlockedCommandReason, runCommand, } from '../executor.js';
 import { syncIndexFromDisk } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';
@@ -12,9 +13,10 @@ export async function runShellCommand(context, args) {
     if (!command) {
         return { ok: false, error: 'command is required' };
     }
+    const runInBackground = args.background === true;
     const hasTimeout = typeof args.timeout_ms === 'number' && args.timeout_ms > 0;
     const repoHint = buildNestedGitHint(rootDir, command);
-    const blockedReason = getBlockedCommandReason(command, hasTimeout, rootDir);
+    const blockedReason = getBlockedCommandReason(command, hasTimeout || runInBackground, rootDir);
     if (blockedReason) {
         const error = blockedReason;
         if (!isTuiMode())
@@ -37,7 +39,9 @@ export async function runShellCommand(context, args) {
                 error: 'confirmCommand is required when autoYes is false',
             };
         }
-        const approved = await confirmCommand(command);
+        const approved = await confirmCommand(runInBackground
+            ? `${command}\n\nRuns as a managed background job until it exits or is killed.`
+            : command);
         if (!approved) {
             if (!isTuiMode())
                 console.log(chalk.dim(`  ⏭  Skipped: ${command}`));
@@ -45,10 +49,13 @@ export async function runShellCommand(context, args) {
                 ok: false,
                 skipped: true,
                 command,
-                error: 'User declined command execution',
+                error: 'User declined command execution. Do not rerun this command or try a broader variant of it; either continue without it or ask the user one specific question about how to proceed.',
             };
         }
     }
+    if (runInBackground) {
+        return runBackgroundCommand(context, command, args.timeout_ms, repoHint);
+    }
     const result = await runCommand(command, rootDir, {
         requestSudoPassword,
         timeout: typeof args.timeout_ms === 'number' && args.timeout_ms > 0 ? args.timeout_ms : undefined,
@@ -67,19 +74,9 @@ export async function runShellCommand(context, args) {
     if (repoSync.added || repoSync.modified || repoSync.removed) {
         onStatus(`Synced repo state after command (${repoSync.added} added, ${repoSync.modified} modified, ${repoSync.removed} removed).`);
     }
-    // Redact connection-string passwords so shell output (e.g. `cat .env`,
-    // `printenv`) cannot leak them into history or telemetry.
-    let output = typeof result.output === 'string'
-        ? redactConnectionStringCredentials(result.output)
+    const output = typeof result.output === 'string'
+        ? boundCommandOutput(redactConnectionStringCredentials(result.output))
         : result.output;
-    if (typeof output === 'string' && output.length > MAX_OUTPUT_CHARS) {
-        const headSize = Math.floor(MAX_OUTPUT_CHARS * 0.2);
-        const tailSize = MAX_OUTPUT_CHARS - headSize;
-        output =
-            output.slice(0, headSize) +
-                `\n\n... (${output.length - headSize - tailSize} chars truncated) ...\n\n` +
-                output.slice(-tailSize);
-    }
     return {
         ok: result.exitCode === 0,
         command,
@@ -92,3 +89,73 @@ export async function runShellCommand(context, args) {
         repoHint,
     };
 }
+export function boundCommandOutput(output) {
+    if (output.length <= MAX_OUTPUT_CHARS)
+        return output;
+    const headSize = Math.floor(MAX_OUTPUT_CHARS * 0.2);
+    const tailSize = MAX_OUTPUT_CHARS - headSize;
+    return (output.slice(0, headSize) +
+        `\n\n... (${output.length - headSize - tailSize} chars truncated) ...\n\n` +
+        output.slice(-tailSize));
+}
+async function runBackgroundCommand(context, command, timeoutMs, repoHint) {
+    const { rootDir, projectIndex, onStatus } = context;
+    const started = await startBackgroundJob(command, rootDir, {
+        startupWaitMs: typeof timeoutMs === 'number' && timeoutMs > 0 ? timeoutMs : undefined,
+        sessionId: context.sessionId,
+    });
+    if (!started.ok || !started.snapshot) {
+        if (!isTuiMode())
+            console.log(chalk.red(`\n  ✖ ${started.error}`));
+        return {
+            ok: false,
+            blocked: true,
+            command,
+            error: started.error ?? 'Background job failed to start.',
+            repoHint,
+        };
+    }
+    const snapshot = started.snapshot;
+    const repoSync = projectIndex.initialized
+        ? await syncIndexFromDisk(projectIndex)
+        : {
+            added: 0,
+            modified: 0,
+            removed: 0,
+            indexedChunks: 0,
+            retrievalTokensUsed: 0,
+        };
+    invalidateShellDiagnosticsCache(rootDir);
+    if (repoSync.added || repoSync.modified || repoSync.removed) {
+        onStatus(`Synced repo state after command (${repoSync.added} added, ${repoSync.modified} modified, ${repoSync.removed} removed).`);
+    }
+    const output = boundCommandOutput(redactConnectionStringCredentials(started.startupOutput ?? '').trim());
+    if (snapshot.status === 'running') {
+        return {
+            ok: true,
+            backgrounded: true,
+            command,
+            jobId: snapshot.id,
+            status: 'running',
+            pid: snapshot.pid,
+            output,
+            note: `Background job ${snapshot.id} is running. Use shell_job_output to poll status and new output, and shell_job_kill to stop it.`,
+            repoSync,
+            retrievalTokensUsed: repoSync.retrievalTokensUsed,
+            repoHint,
+        };
+    }
+    return {
+        ok: snapshot.exitCode === 0,
+        backgrounded: true,
+        command,
+        jobId: snapshot.id,
+        status: snapshot.status,
+        exitCode: snapshot.exitCode,
+        output,
+        note: `Background job ${snapshot.id} finished during the startup window.`,
+        repoSync,
+        retrievalTokensUsed: repoSync.retrievalTokensUsed,
+        repoHint,
+    };
+}

package/dist/src/tools/run-node-script.js

@@ -1,8 +1,9 @@
-import chalk from 'chalk';
+import chalk from '../colors.js';
 import { execFileSync, spawn } from 'node:child_process';
 import { syncIndexFromDisk } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { buildDeferredShellDiagnostics, invalidateShellDiagnosticsCache, } from './shell-diagnostics.js';
+import { ensureSessionScratchDir } from '../scratch-dir.js';
 const DEFAULT_TIMEOUT = 5 * 60 * 1000;
 const MAX_OUTPUT_CHARS = 4000;
 const MAX_CAPTURE_CHARS = 1024 * 1024;
@@ -99,6 +100,7 @@ function executeNodeScript(rootDir, script, timeout) {
                 npm_config_progress: 'false',
                 npm_config_fund: 'false',
                 npm_config_audit: 'false',
+                THEGITAI_SCRATCH_DIR: ensureSessionScratchDir(),
             },
             stdio: ['pipe', 'pipe', 'pipe'],
         });

package/dist/src/tools/shell-job-kill.js

@@ -0,0 +1,48 @@
+import { killBackgroundJob } from '../background-jobs.js';
+import { redactConnectionStringCredentials } from '../secret-preview.js';
+const MAX_JOB_TOOL_OUTPUT_CHARS = 64 * 1024;
+function boundJobToolOutput(output) {
+    if (output.length <= MAX_JOB_TOOL_OUTPUT_CHARS)
+        return output;
+    const headSize = Math.floor(MAX_JOB_TOOL_OUTPUT_CHARS * 0.2);
+    const tailSize = MAX_JOB_TOOL_OUTPUT_CHARS - headSize;
+    return (output.slice(0, headSize) +
+        `\n\n... (${output.length - headSize - tailSize} chars truncated) ...\n\n` +
+        output.slice(-tailSize));
+}
+export async function shellJobKill(context, args) {
+    const jobId = String(args.job_id ?? '').trim();
+    if (!jobId) {
+        return {
+            ok: false,
+            error: 'job_id is required',
+            failureCategory: 'missing_required_argument',
+        };
+    }
+    const result = await killBackgroundJob(jobId, {
+        sessionId: context.sessionId,
+    });
+    if (!result.ok || !result.snapshot) {
+        return {
+            ok: false,
+            error: result.error ?? 'Background job lookup failed.',
+            failureCategory: 'not_found',
+        };
+    }
+    const snapshot = result.snapshot;
+    let finalOutput = redactConnectionStringCredentials(result.finalOutput ?? '');
+    if (result.droppedChars) {
+        finalOutput = `... (${result.droppedChars} chars of older output dropped) ...\n${finalOutput}`;
+    }
+    finalOutput = boundJobToolOutput(finalOutput);
+    return {
+        ok: true,
+        jobId: snapshot.id,
+        command: snapshot.command,
+        status: snapshot.status,
+        exitCode: snapshot.exitCode,
+        alreadyFinished: result.alreadyFinished === true,
+        ranMs: (snapshot.endedAt ?? Date.now()) - snapshot.startedAt,
+        finalOutput,
+    };
+}

package/dist/src/tools/shell-job-output.js

@@ -0,0 +1,51 @@
+import { MAX_JOB_WAIT_MS, readBackgroundJobOutput, } from '../background-jobs.js';
+import { redactConnectionStringCredentials } from '../secret-preview.js';
+const MAX_JOB_TOOL_OUTPUT_CHARS = 64 * 1024;
+function boundJobToolOutput(output) {
+    if (output.length <= MAX_JOB_TOOL_OUTPUT_CHARS)
+        return output;
+    const headSize = Math.floor(MAX_JOB_TOOL_OUTPUT_CHARS * 0.2);
+    const tailSize = MAX_JOB_TOOL_OUTPUT_CHARS - headSize;
+    return (output.slice(0, headSize) +
+        `\n\n... (${output.length - headSize - tailSize} chars truncated) ...\n\n` +
+        output.slice(-tailSize));
+}
+export async function shellJobOutput(context, args) {
+    const jobId = String(args.job_id ?? '').trim();
+    if (!jobId) {
+        return {
+            ok: false,
+            error: 'job_id is required',
+            failureCategory: 'missing_required_argument',
+        };
+    }
+    const waitMs = typeof args.wait_ms === 'number' && args.wait_ms > 0
+        ? Math.min(args.wait_ms, MAX_JOB_WAIT_MS)
+        : 0;
+    const result = await readBackgroundJobOutput(jobId, {
+        waitMs,
+        sessionId: context.sessionId,
+    });
+    if (!result.ok || !result.snapshot) {
+        return {
+            ok: false,
+            error: result.error ?? 'Background job lookup failed.',
+            failureCategory: 'not_found',
+        };
+    }
+    const snapshot = result.snapshot;
+    let newOutput = redactConnectionStringCredentials(result.newOutput ?? '');
+    if (result.droppedChars) {
+        newOutput = `... (${result.droppedChars} chars of older output dropped) ...\n${newOutput}`;
+    }
+    newOutput = boundJobToolOutput(newOutput);
+    return {
+        ok: true,
+        jobId: snapshot.id,
+        command: snapshot.command,
+        status: snapshot.status,
+        exitCode: snapshot.exitCode,
+        elapsedMs: (snapshot.endedAt ?? Date.now()) - snapshot.startedAt,
+        newOutput,
+    };
+}

package/dist/src/tools/str-replace.js

@@ -1,10 +1,13 @@
-import chalk from 'chalk';
+import chalk from '../colors.js';
+import path from 'node:path';
 import { normalizeProjectRelativePath } from '../artifact-policy.js';
 import { readProjectFile, writeProjectFile } from '../patcher.js';
+import { repairFilePath } from './path-suggest.js';
 import { upsertIndexFile } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { getCurrentFileHash, resolveRedactionTokens } from '../session-safety.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+const DOCUMENT_EXTENSIONS = new Set(['.pdf', '.xlsx', '.docx']);
 function countOccurrences(haystack, needle) {
     if (needle.length === 0)
         return 0;
@@ -74,7 +77,7 @@ function buildStrReplacePreview(oldString, newString) {
 }
 export async function strReplace(context, args) {
     const { rootDir, projectIndex, autoYes, confirmPatch } = context;
-    const filePath = String(args.filePath ?? args.file_path ?? '').trim();
+    const filePath = repairFilePath(rootDir, String(args.filePath ?? args.file_path ?? '').trim());
     let oldString = typeof args.old_string === 'string'
         ? args.old_string
         : typeof args.oldString === 'string'
@@ -92,6 +95,17 @@ export async function strReplace(context, args) {
     if (oldString.length === 0) {
         return { ok: false, error: 'old_string is required and must be non-empty' };
     }
+    const ext = path.extname(filePath).toLowerCase();
+    if (DOCUMENT_EXTENSIONS.has(ext)) {
+        return {
+            ok: false,
+            filePath,
+            error: ext === '.docx'
+                ? 'Use replace_document_text for .docx files.'
+                : `Use read_document for ${ext} files; text replacement is not supported.`,
+            failureCategory: 'invalid_argument',
+        };
+    }
     let originalContent;
     try {
         originalContent = readProjectFile(rootDir, filePath);

package/dist/src/tools/undo-edit.js

@@ -1,6 +1,6 @@
-import chalk from 'chalk';
-import { hashContent, readFileEditSnapshot, } from '../edit-journal.js';
-import { deleteProjectFile, writeProjectFile, } from '../patcher.js';
+import chalk from '../colors.js';
+import { hashStoredContent, readFileEditSnapshot, storedContentBuffer, } from '../edit-journal.js';
+import { deleteProjectFile, writeProjectFile, writeProjectFileBuffer, } from '../patcher.js';
 import { removeIndexFile, upsertIndexFile, } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
@@ -84,7 +84,7 @@ function validateUndoPlan(rootDir, records) {
                     currentHash,
                 };
             }
-            const beforeContentHash = hashContent(record.beforeContent);
+            const beforeContentHash = hashStoredContent(record.beforeContent, record.beforeContentEncoding);
             if (beforeContentHash !== record.beforeHash) {
                 return {
                     ok: false,
@@ -110,7 +110,9 @@ async function applyUndo(context, record) {
     if (record.beforeContent === null) {
         throw new Error(`Cannot undo ${record.id}: the stored pre-edit snapshot is incomplete.`);
     }
-    const { changed } = writeProjectFile(rootDir, record.filePath, record.beforeContent);
+    const { changed } = record.beforeContentEncoding === 'base64'
+        ? writeProjectFileBuffer(rootDir, record.filePath, storedContentBuffer(record.beforeContent, record.beforeContentEncoding))
+        : writeProjectFile(rootDir, record.filePath, record.beforeContent);
     if (changed) {
         await upsertIndexFile(projectIndex, record.filePath);
     }

package/dist/src/tools/update-todos.js

@@ -0,0 +1,27 @@
+import { extractTodosArg, replaceTodos } from '../todo-list.js';
+export function updateTodos(_context, args) {
+    const rawTodos = extractTodosArg(args);
+    if (rawTodos === undefined) {
+        return {
+            ok: false,
+            error: 'todos is required (pass [] to clear the list).',
+            failureCategory: 'missing_required_argument',
+        };
+    }
+    const result = replaceTodos(rawTodos);
+    if (!result.ok) {
+        return {
+            ok: false,
+            error: result.error,
+            failureCategory: 'invalid_argument',
+        };
+    }
+    const { snapshot, normalizations } = result;
+    return {
+        ok: true,
+        todos: snapshot.items,
+        completedCount: snapshot.completedCount,
+        totalCount: snapshot.totalCount,
+        ...(normalizations.length ? { normalizations } : {}),
+    };
+}

package/dist/src/tools/write-file.js

@@ -1,10 +1,12 @@
-import chalk from 'chalk';
+import chalk from '../colors.js';
+import path from 'node:path';
 import { normalizeProjectRelativePath } from '../artifact-policy.js';
 import { writeProjectFile } from '../patcher.js';
 import { upsertIndexFile } from '../project-index.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { getCurrentFileHash, hasFreshFullReadCoverage, resolveRedactionTokens, } from '../session-safety.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+const DOCUMENT_EXTENSIONS = new Set(['.pdf', '.xlsx', '.docx']);
 export async function writeFile(context, args) {
     const { rootDir, projectIndex } = context;
     const filePath = String(args.filePath ?? '').trim();
@@ -12,6 +14,17 @@ export async function writeFile(context, args) {
     if (!filePath) {
         return { ok: false, error: 'filePath is required' };
     }
+    const ext = path.extname(filePath).toLowerCase();
+    if (DOCUMENT_EXTENSIONS.has(ext)) {
+        return {
+            ok: false,
+            filePath,
+            error: ext === '.docx'
+                ? 'Use replace_document_text for .docx files.'
+                : `Use read_document for ${ext} files; write_file is not supported.`,
+            failureCategory: 'invalid_argument',
+        };
+    }
     const coveragePath = normalizeProjectRelativePath(rootDir, filePath) ?? filePath;
     const currentHash = getCurrentFileHash(rootDir, filePath);
     if (currentHash !== null &&

package/dist/src/tree-sitter-runtime.js

@@ -5,8 +5,15 @@ import { fileURLToPath } from 'node:url';
 import { addSignatureForNode } from './extractors/index.js';
 import { getRepoMapLanguageForFile, } from './repo-map-languages.js';
 const require = createRequire(import.meta.url);
-const TreeSitter = require('web-tree-sitter');
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function resolveVendoredTreeSitter() {
+    const candidates = [
+        path.resolve(__dirname, '..', 'vendor', 'web-tree-sitter', 'web-tree-sitter.cjs'),
+        path.resolve(__dirname, '..', '..', 'vendor', 'web-tree-sitter', 'web-tree-sitter.cjs'),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+const TreeSitter = require(resolveVendoredTreeSitter());
 let parserInitPromise = null;
 const parserCache = Object.create(null);
 const languageCache = Object.create(null);