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

package/dist/src/core/clipboard.js

@@ -1,4 +1,6 @@
 import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
 const MAX_IMAGE_SIZE_BYTES = 10 * 1024 * 1024;
 const MIME_BY_EXT = {
     '.png': 'image/png',
@@ -21,6 +23,14 @@ export function isSupportedImageMimeType(mime) {
 }
 function whichSync(cmd) {
     try {
+        if (process.platform === 'win32') {
+            execFileSync('where.exe', [cmd], {
+                stdio: 'ignore',
+                timeout: 2000,
+                windowsHide: true,
+            });
+            return true;
+        }
         execFileSync('which', [cmd], { stdio: 'ignore', timeout: 2000 });
         return true;
     }
@@ -93,6 +103,52 @@ function readClipboardLinux() {
     }
     throw new ClipboardError('Clipboard contains no image data.', 'NO_IMAGE');
 }
+const WINDOWS_CLIPBOARD_IMAGE_PS = [
+    '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8;',
+    '$ErrorActionPreference = "Stop";',
+    'Add-Type -AssemblyName System.Drawing;',
+    '$img = Get-Clipboard -Format Image;',
+    'if ($null -eq $img) { exit 2 }',
+    '$ms = New-Object System.IO.MemoryStream;',
+    '$img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png);',
+    '[Convert]::ToBase64String($ms.ToArray())',
+].join(' ');
+function readClipboardWindows() {
+    try {
+        const b64 = execFileSync('powershell.exe', ['-NoProfile', '-Command', WINDOWS_CLIPBOARD_IMAGE_PS], {
+            encoding: 'utf-8',
+            timeout: 5000,
+            maxBuffer: MAX_IMAGE_SIZE_BYTES * 2,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        }).trim();
+        if (!b64) {
+            throw new ClipboardError('Clipboard contains no image data.', 'NO_IMAGE');
+        }
+        const buf = Buffer.from(b64, 'base64');
+        if (!buf.length) {
+            throw new ClipboardError('Clipboard contains no image data.', 'NO_IMAGE');
+        }
+        if (buf.length > MAX_IMAGE_SIZE_BYTES) {
+            throw new ClipboardError('Clipboard image exceeds 10MB size limit.', 'READ_FAILED');
+        }
+        return { base64Data: b64, mimeType: 'image/png' };
+    }
+    catch (err) {
+        if (err instanceof ClipboardError)
+            throw err;
+        if (err?.status === 2) {
+            throw new ClipboardError('Clipboard contains no image data. Copy an image first (Win+Shift+S), then press Alt+V.', 'NO_IMAGE');
+        }
+        if (isMaxBufferError(err)) {
+            throw new ClipboardError('Clipboard image exceeds 10MB size limit.', 'READ_FAILED');
+        }
+        const detail = [err?.message, err?.stderr?.toString?.()?.trim()]
+            .filter(Boolean)
+            .join(' — ');
+        throw new ClipboardError(`Failed to read clipboard image on Windows: ${detail || 'unknown error'}`, 'READ_FAILED');
+    }
+}
 function readClipboardDarwin() {
     if (whichSync('pngpaste')) {
         try {
@@ -123,6 +179,8 @@ export function readClipboardImage(platform = process.platform) {
             return readClipboardLinux();
         case 'darwin':
             return readClipboardDarwin();
+        case 'win32':
+            return readClipboardWindows();
         default:
             throw new ClipboardError(`Clipboard image paste is not supported on ${platform}.`, 'NO_TOOL');
     }
@@ -206,3 +264,20 @@ export function writeClipboardText(text, platform = process.platform) {
     }
     throw new ClipboardError(`Clipboard text copy is not supported on ${platform}.`, 'NO_TOOL');
 }
+export function loadImageFromFile(filePath) {
+    const resolved = path.resolve(filePath);
+    if (!existsSync(resolved)) {
+        throw new ClipboardError(`Image file not found: ${resolved}`, 'READ_FAILED');
+    }
+    const stat = statSync(resolved);
+    if (stat.size > MAX_IMAGE_SIZE_BYTES) {
+        throw new ClipboardError(`Image file exceeds 10MB limit (${(stat.size / 1024 / 1024).toFixed(1)}MB): ${resolved}`, 'READ_FAILED');
+    }
+    const ext = path.extname(resolved).toLowerCase();
+    const mimeType = MIME_BY_EXT[ext];
+    if (!mimeType) {
+        throw new ClipboardError(`Unsupported image format "${ext}". Supported: PNG, JPEG, GIF, WebP.`, 'READ_FAILED');
+    }
+    const buf = readFileSync(resolved);
+    return { base64Data: buf.toString('base64'), mimeType };
+}

package/dist/src/core/image-path-extractor.js

@@ -0,0 +1,144 @@
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadImageFromFile } from './clipboard.js';
+const EXT = '(?:png|jpe?g|gif|webp)';
+const BARE_CHAR = "[^\\s\"'<>,:;!?()\\[\\]{}]";
+const BARE_PATH = `(?:[A-Za-z]:[\\\\/])?(?:\\\\ |${BARE_CHAR})+\\.${EXT}`;
+const IMAGE_PATH_PATTERN = new RegExp(`"([^"]*\\.${EXT})"` +
+    `|'([^']*\\.${EXT})'` +
+    `|file://(\\S*\\.${EXT})` +
+    `|(${BARE_PATH})`, 'gi');
+const EXTENSION_TOKEN = new RegExp(`^(?:[A-Za-z]:[\\\\/])?(?:\\\\ |${BARE_CHAR})+$`);
+const MAX_EXTENSION_TOKENS = 8;
+function isFile(p) {
+    try {
+        return statSync(p, { throwIfNoEntry: false })?.isFile() ?? false;
+    }
+    catch {
+        return false;
+    }
+}
+function extendBareMatchAcrossSpaces(input, matchStart, raw, cwd) {
+    const baseInner = raw.replace(/\\ /g, ' ');
+    const baseExists = isFile(path.isAbsolute(baseInner) ? baseInner : path.resolve(cwd, baseInner));
+    let best = null;
+    let candidate = raw;
+    let start = matchStart;
+    let addedSeparator = false;
+    for (let hops = 0; hops < MAX_EXTENSION_TOKENS; hops++) {
+        if (start < 2 || input[start - 1] !== ' ' || /\s/.test(input[start - 2]))
+            break;
+        let i = start - 2;
+        while (i >= 0 && !/\s/.test(input[i]))
+            i--;
+        const tokenStart = i + 1;
+        const token = input.slice(tokenStart, start - 1);
+        if (!EXTENSION_TOKEN.test(token))
+            break;
+        candidate = `${token} ${candidate}`;
+        start = tokenStart;
+        addedSeparator = addedSeparator || /[\\/]/.test(token);
+        if (baseExists && !addedSeparator)
+            continue;
+        const inner = candidate.replace(/\\ /g, ' ');
+        const resolved = path.isAbsolute(inner) ? inner : path.resolve(cwd, inner);
+        if (isFile(resolved))
+            best = candidate;
+    }
+    return best ?? raw;
+}
+function detectImagePaths(input, cwd) {
+    const regex = new RegExp(IMAGE_PATH_PATTERN.source, IMAGE_PATH_PATTERN.flags);
+    const detected = [];
+    let match;
+    while ((match = regex.exec(input)) !== null) {
+        let raw = match[0];
+        if (match[4] != null && raw.includes('://'))
+            continue;
+        let inner;
+        if (match[1] != null || match[2] != null) {
+            const quoted = (match[1] ?? match[2]);
+            if (/^file:\/\//i.test(quoted)) {
+                try {
+                    inner = fileURLToPath(quoted);
+                }
+                catch {
+                    continue;
+                }
+            }
+            else {
+                inner = quoted;
+            }
+        }
+        else if (match[3] != null) {
+            try {
+                inner = fileURLToPath(raw);
+            }
+            catch {
+                try {
+                    inner = decodeURIComponent(match[3]);
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        else {
+            raw = extendBareMatchAcrossSpaces(input, match.index, raw, cwd);
+            inner = raw.replace(/\\ /g, ' ');
+        }
+        const resolvedPath = path.isAbsolute(inner) ? inner : path.resolve(cwd, inner);
+        const start = match.index - (raw.length - match[0].length);
+        while (detected.length > 0) {
+            const prev = detected[detected.length - 1];
+            if (prev.start + prev.raw.length <= start)
+                break;
+            detected.pop();
+        }
+        detected.push({ resolvedPath, raw, start });
+    }
+    const rawsByPath = new Map();
+    for (const { resolvedPath, raw } of detected) {
+        const existing = rawsByPath.get(resolvedPath);
+        if (existing) {
+            existing.push(raw);
+        }
+        else {
+            rawsByPath.set(resolvedPath, [raw]);
+        }
+    }
+    return rawsByPath;
+}
+export function autoAttachImages(input, cwd, existing = []) {
+    const max = 2;
+    const rawsByPath = detectImagePaths(input, cwd);
+    let sanitizedInput = input;
+    const attachments = [];
+    const errors = [];
+    const maxExistingIndex = existing.reduce((highest, a) => Math.max(highest, a.index ?? 0), 0);
+    for (const [resolvedPath, rawForms] of rawsByPath) {
+        if (existing.length + attachments.length >= max)
+            break;
+        if (!existsSync(resolvedPath))
+            continue;
+        try {
+            const loaded = loadImageFromFile(resolvedPath);
+            const idx = maxExistingIndex + attachments.length + 1;
+            attachments.push({
+                index: idx,
+                mimeType: loaded.mimeType,
+                base64Data: loaded.base64Data,
+                source: 'file',
+                filePath: resolvedPath,
+            });
+            for (const raw of rawForms) {
+                sanitizedInput = sanitizedInput.replace(raw, `[Image #${idx}]`);
+            }
+        }
+        catch (err) {
+            errors.push(err.message);
+        }
+    }
+    return { sanitizedInput, attachments, errors };
+}

package/dist/src/edit-journal.js

@@ -1,33 +1,64 @@
 import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { existsSync, lstatSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { BINARY_ARTIFACT_EXTENSIONS } from './artifact-policy.js';
 import { resolveProjectPath } from './patcher.js';
 export const MAX_EDIT_JOURNAL_RECORDS = 50;
-const MAX_STORED_CONTENT_CHARS = 1_000_000;
-export function hashContent(content) {
+const MAX_STORED_CONTENT_CHARS = 8_000_000;
+export function hashBytes(content) {
     return `sha256:${createHash('sha256').update(content).digest('hex')}`;
 }
+export function hashContent(content) {
+    return hashBytes(Buffer.from(content, 'utf8'));
+}
+export function hashStoredContent(content, encoding = 'utf8') {
+    return encoding === 'base64'
+        ? hashBytes(Buffer.from(content, 'base64'))
+        : hashContent(content);
+}
+export function storedContentBuffer(content, encoding = 'utf8') {
+    return encoding === 'base64'
+        ? Buffer.from(content, 'base64')
+        : Buffer.from(content, 'utf8');
+}
+function snapshotEncoding(filePath, content) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (BINARY_ARTIFACT_EXTENSIONS.has(ext))
+        return 'base64';
+    if (content.includes(0))
+        return 'base64';
+    return 'utf8';
+}
 export function readFileEditSnapshot(rootDir, filePath) {
     try {
         const absPath = resolveProjectPath(rootDir, filePath);
         if (!existsSync(absPath)) {
-            return { exists: false, content: null, hash: null };
+            return { exists: false, content: null, contentEncoding: 'utf8', hash: null };
         }
         if (lstatSync(absPath).isSymbolicLink()) {
             return {
                 exists: true,
                 content: null,
+                contentEncoding: 'utf8',
                 hash: null,
                 error: `Refusing to snapshot symbolic link: ${filePath}`,
             };
         }
-        const content = readFileSync(absPath, 'utf-8');
-        return { exists: true, content, hash: hashContent(content) };
+        const content = readFileSync(absPath);
+        const encoding = snapshotEncoding(filePath, content);
+        return {
+            exists: true,
+            content: encoding === 'base64' ? content.toString('base64') : content.toString('utf8'),
+            contentEncoding: encoding,
+            hash: hashBytes(content),
+        };
     }
     catch (err) {
         return {
             exists: false,
             content: null,
+            contentEncoding: 'utf8',
             hash: null,
             error: err?.message ? String(err.message) : String(err),
         };
@@ -46,7 +77,8 @@ export function isEditToolName(toolName) {
     return (toolName === 'write_file' ||
         toolName === 'patch_file' ||
         toolName === 'str_replace' ||
-        toolName === 'delete_file');
+        toolName === 'delete_file' ||
+        toolName === 'replace_document_text');
 }
 export function operationFromSnapshots(before, after) {
     if (before.hash === after.hash)
@@ -102,6 +134,7 @@ export function normalizeAssistantEditJournal(value) {
                 ? entry.afterHash
                 : null,
             beforeContent: typeof entry.beforeContent === 'string' ? entry.beforeContent : null,
+            beforeContentEncoding: entry.beforeContentEncoding === 'base64' ? 'base64' : 'utf8',
             createdAt: typeof entry.createdAt === 'string' && entry.createdAt
                 ? entry.createdAt
                 : new Date().toISOString(),

package/dist/src/executor.js

@@ -1,11 +1,25 @@
-import chalk from 'chalk';
-import * as pty from '@homebridge/node-pty-prebuilt-multiarch';
+import chalk from './colors.js';
 import { execFileSync, spawn } from 'child_process';
 import { existsSync, statSync } from 'fs';
+import { createRequire } from 'node:module';
 import os from 'os';
 import path from 'path';
 import { ARTIFACT_INSPECT_BLOCK_DIRS, getBlockedArtifactInspectDir, relativeProjectPath, } from './artifact-policy.js';
 import { emitCommandOutput, isTuiMode } from './runtime-mode.js';
+import { ensureSessionScratchDir, isInsideTheGitAiScratch, sessionScratchDir, } from './scratch-dir.js';
+const requireFromHere = createRequire(import.meta.url);
+let nodePtyCache;
+function loadNodePty() {
+    if (nodePtyCache !== undefined)
+        return nodePtyCache;
+    try {
+        nodePtyCache = requireFromHere('@lydell/node-pty');
+    }
+    catch {
+        nodePtyCache = null;
+    }
+    return nodePtyCache;
+}
 const COMMON_TOOLCHAIN_BIN_DIRS = ['/usr/local/go/bin'];
 function detectVenvBin(dir) {
     for (const name of ['.venv', 'venv', 'env']) {
@@ -204,6 +218,7 @@ function isExistingDirectory(absPath) {
         return false;
     }
 }
+const OS_TEMP_BLOCK_MARKER = 'os-temp:';
 function getBlockedOsTempInspection(rawToken, rootDir) {
     const token = normalizeToken(rawToken);
     if (!token || !path.isAbsolute(token))
@@ -211,6 +226,8 @@ function getBlockedOsTempInspection(rawToken, rootDir) {
     const resolved = path.resolve(token);
     if (!isInsideOsTemp(resolved))
         return null;
+    if (isInsideTheGitAiScratch(resolved))
+        return null;
     if (rootDir) {
         const resolvedRoot = path.resolve(rootDir);
         if (resolved === resolvedRoot ||
@@ -221,7 +238,7 @@ function getBlockedOsTempInspection(rawToken, rootDir) {
     if (resolved === path.resolve(os.tmpdir()) ||
         hasPathGlob(token) ||
         isExistingDirectory(resolved)) {
-        return path.basename(os.tmpdir()) || os.tmpdir();
+        return `${OS_TEMP_BLOCK_MARKER}${path.basename(os.tmpdir()) || os.tmpdir()}`;
     }
     return null;
 }
@@ -237,6 +254,9 @@ function findBlockedDirForToken(rawToken, rootDir, baseDir, allowBareDirMatch =
         const resolved = path.isAbsolute(token)
             ? path.resolve(token)
             : path.resolve(baseDir ?? rootDir, token);
+        const osTempResolved = getBlockedOsTempInspection(resolved, rootDir);
+        if (osTempResolved)
+            return osTempResolved;
         return getBlockedProjectPathDir(resolved, rootDir);
     }
     if (!allowBareDirMatch || !BLOCKED_PATH_INSPECT_DIRS.has(token)) {
@@ -373,11 +393,16 @@ function findBlockedDirInCommandTokens(command, rootDir, baseDir) {
     }
     return null;
 }
+function expandTempEnvRefs(command) {
+    return command
+        .replace(/\$\{THEGITAI_SCRATCH_DIR[^}]*\}|\$THEGITAI_SCRATCH_DIR\b/g, sessionScratchDir())
+        .replace(/\$\{TMPDIR[^}]*\}|\$TMPDIR\b/g, process.env.TMPDIR || os.tmpdir());
+}
 function findIgnoredPathInspection(command, rootDir) {
     if (!FILE_INSPECTION_COMMAND_PATTERN.test(command)) {
         return null;
     }
-    const haystack = maskNonPathIgnoreDirTokens(maskHereDocumentBodies(command));
+    const haystack = maskNonPathIgnoreDirTokens(maskHereDocumentBodies(expandTempEnvRefs(command)));
     const baseDir = getCommandBaseDir(haystack, rootDir);
     const blockedDir = findBlockedDirInCommandTokens(haystack, rootDir, baseDir);
     if (blockedDir) {
@@ -434,7 +459,7 @@ function shouldDropOutputLine(line, rootDir, baseDir) {
 function isLsDirectoryHeader(line) {
     return /^\.?\/?.+:$/.test(line) && !line.includes(' ');
 }
-function sanitizeCommandText(command, text, rootDir) {
+export function sanitizeCommandText(command, text, rootDir) {
     if (!text)
         return '';
     const lines = text.split('\n');
@@ -509,7 +534,7 @@ export function cancelActiveCommand() {
         cancelled: true,
     });
 }
-function terminateChild(child, signal) {
+export function terminateChild(child, signal) {
     if (!child?.pid)
         return;
     if (process.platform === 'win32') {
@@ -537,10 +562,17 @@ function terminateChild(child, signal) {
     }
 }
 export function getBlockedPathInspectDir(command, rootDir) {
-    return findIgnoredPathInspection(command, rootDir);
+    const blocked = findIgnoredPathInspection(command, rootDir);
+    return blocked?.startsWith(OS_TEMP_BLOCK_MARKER)
+        ? blocked.slice(OS_TEMP_BLOCK_MARKER.length)
+        : blocked;
 }
 export function getBlockedCommandReason(command, hasTimeout, rootDir) {
     const ignoredDir = findIgnoredPathInspection(command, rootDir);
+    if (ignoredDir?.startsWith(OS_TEMP_BLOCK_MARKER)) {
+        const tempName = ignoredDir.slice(OS_TEMP_BLOCK_MARKER.length);
+        return `Listing or scanning the shared OS temp directory (${tempName}) is blocked because it can contain other users' and processes' files. Use the session scratch directory ${ensureSessionScratchDir()} for temporary scripts and files — creating, running, and listing are all allowed there — or reference an exact file path.`;
+    }
     if (ignoredDir) {
         return `Command inspects an off-limits generated or dependency directory (${ignoredDir}). Avoid that path.`;
     }
@@ -559,7 +591,7 @@ export function getBlockedCommandReason(command, hasTimeout, rootDir) {
     }
     return null;
 }
-function commandUsesSudo(command) {
+export function commandUsesSudo(command) {
     return /\bsudo\b/.test(getUnquotedShellText(command));
 }
 export function sudoPromptFromTail(text) {
@@ -587,7 +619,7 @@ function redactSecrets(text, secrets) {
     }
     return redacted;
 }
-function buildCommandEnv(cwd) {
+export function buildCommandEnv(cwd) {
     const venvBin = detectVenvBin(cwd);
     const envPath = buildCommandPath(process.env.PATH, venvBin ? [venvBin] : []);
     return {
@@ -602,12 +634,13 @@ function buildCommandEnv(cwd) {
         npm_config_fund: 'false',
         npm_config_audit: 'false',
         NUXI_INIT_SKIP_PROMPT: 'true',
+        THEGITAI_SCRATCH_DIR: ensureSessionScratchDir(),
     };
 }
 function sanitizePtyOutput(command, output, cwd, secrets) {
     return sanitizeCommandText(command, stripSudoPromptText(redactSecrets(output, secrets)), cwd);
 }
-async function runPtyCommand(command, cwd, effectiveTimeout, exploratory, requestSudoPassword) {
+async function runPtyCommand(command, cwd, effectiveTimeout, exploratory, requestSudoPassword, nodePty) {
     return new Promise((resolve) => {
         let output = '';
         let timedOut = false;
@@ -623,7 +656,7 @@ async function runPtyCommand(command, cwd, effectiveTimeout, exploratory, reques
         const args = process.platform === 'win32'
             ? ['/d', '/s', '/c', command]
             : ['-lc', command];
-        const child = pty.spawn(shell, args, {
+        const child = nodePty.spawn(shell, args, {
             cols: 120,
             rows: 30,
             cwd,
@@ -776,7 +809,10 @@ export async function runCommand(command, cwd, { requestSudoPassword, timeout, }
     }
     const exploratory = isExploratoryCommand(command);
     if (requestSudoPassword && commandUsesSudo(command)) {
-        return runPtyCommand(command, cwd, effectiveTimeout, exploratory, requestSudoPassword);
+        const nodePty = loadNodePty();
+        if (nodePty) {
+            return runPtyCommand(command, cwd, effectiveTimeout, exploratory, requestSudoPassword, nodePty);
+        }
     }
     return new Promise((resolve) => {
         let stdout = '';

package/dist/src/help-text.js

@@ -1,8 +1,5 @@
-import chalk from 'chalk';
-// The bound keys (Enter/Esc/Ctrl+C/Tab/arrows) are identical across platforms in
-// a terminal. The one thing that genuinely differs is the terminal's paste
-// shortcut, so surface the one for the host OS (right-click paste works
-// everywhere regardless).
+import chalk from './colors.js';
+import { getCliVersion, getPlatformTag } from './version.js';
 function pasteShortcutForPlatform() {
     switch (process.platform) {
         case 'darwin':
@@ -45,6 +42,7 @@ const HELP_MARKDOWN = [
     '',
     '- `-y, --yes` — start in Auto-Accept mode',
     '- `-h, --help` — show this help',
+    '- `-v, --version` — print the version and exit',
     '',
     '## Modes',
     '',
@@ -70,10 +68,15 @@ const HELP_MARKDOWN = [
     '## Chat commands',
     '',
     '- `/help` — show this help',
+    '- `/about` — show version and platform info',
     '- `/usage` — show account usage percentage and reset times',
     '- `/model` — list supported models and pick one',
     '- `/model <id>` — switch the active model without clearing history',
     '- `/resume` — resume a saved session for this repo',
+    '- `/jobs` — manage long-running commands like dev servers and watchers:',
+    '  browse them, press Enter to expand one and read its output, k to stop it',
+    '- `/jobs output <id>` — print one job\'s full captured output',
+    '- `/jobs kill <id>` — stop one background job',
     '- `/clear` — clear the current conversation history',
     '- `/exit` — quit the session',
     '',
@@ -86,6 +89,12 @@ const HELP_MARKDOWN = [
     '  command and keeps the password masked and local.',
     '- `-y` / `--yes` at startup auto-approves every shell command and file',
     '  edit for the whole session — use with care.',
+    '- Long-running commands (e.g. dev servers) can run as managed background',
+    '  jobs after the same approval as any other command. Background output',
+    '  stays quiet once the model has responded; the footer shows only a compact',
+    '  shell-running indicator, `/jobs` lists, inspects, and kills jobs, and',
+    '  killed jobs disappear immediately. Every job is killed when the session',
+    '  ends.',
     '- File and shell operations are confined to the target repo root.',
     '- Sensitive directories (`.git`, `node_modules`, build output) are',
     '  never indexed.',
@@ -100,6 +109,16 @@ const HELP_MARKDOWN = [
     '- For anything else, re-run the command and report the printed error',
     '  message — there is no client-side debug mode by design.',
 ].join('\n');
+export function formatAboutCard() {
+    return [
+        '```',
+        'TheGitAI',
+        `  Version   ${getCliVersion()}`,
+        `  Platform  ${getPlatformTag()}`,
+        `  Node      ${process.version}`,
+        '```',
+    ].join('\n');
+}
 export function formatHelpMarkdown() {
     return HELP_MARKDOWN;
 }

package/dist/src/markdown-renderer.js

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import chalk from './colors.js';
 function renderInline(text) {
     const parts = String(text ?? '').split(/(`[^`]+`)/g);
     return parts

package/dist/src/patcher.js

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import chalk from './colors.js';
 import { existsSync, lstatSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
 import path from 'path';
 import { createInterface } from 'readline';
@@ -162,13 +162,28 @@ export function writeProjectFile(rootDir, filePath, content) {
             }
         }
         catch {
-            // If we can't read it for some reason, proceed with write
         }
     }
     mkdirSync(path.dirname(absPath), { recursive: true });
     writeFileSync(absPath, content, 'utf-8');
     return { absPath, changed: true };
 }
+export function writeProjectFileBuffer(rootDir, filePath, content) {
+    const absPath = resolveProjectPath(rootDir, filePath);
+    if (existsSync(absPath)) {
+        try {
+            const existingContent = readFileSync(absPath);
+            if (existingContent.equals(content)) {
+                return { absPath, changed: false };
+            }
+        }
+        catch {
+        }
+    }
+    mkdirSync(path.dirname(absPath), { recursive: true });
+    writeFileSync(absPath, content);
+    return { absPath, changed: true };
+}
 export function deleteProjectFile(rootDir, filePath) {
     const absPath = resolveProjectPath(rootDir, filePath);
     if (!existsSync(absPath)) {