@thegitai/cli 1.0.0-preview.4 → 1.0.0-preview.41

package/dist/src/core/session-image-store.js

@@ -0,0 +1,246 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { getClientStateDir } from '../client-state.js';
+import { MAX_IMAGE_SIZE_BYTES, imageExtensionForMime, isSupportedImageMimeType, sniffImageMimeType, } from './image-limits.js';
+const IMAGE_FILE_MODE = 0o600;
+const IMAGE_DIR_MODE = 0o700;
+export const SESSION_IMAGE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+let activeSessionId = null;
+export function setImageStoreSession(sessionId) {
+    activeSessionId = String(sessionId ?? '').trim() || null;
+    contentIndex.clear();
+}
+const contentIndex = new Map();
+function imageContentKey(base64Data) {
+    return createHash('sha256').update(base64Data).digest('hex');
+}
+function rememberStoredImage(base64Data, cachePath) {
+    contentIndex.set(imageContentKey(base64Data), cachePath);
+}
+export function findStoredImageByContent(base64Data) {
+    const cachePath = contentIndex.get(imageContentKey(base64Data));
+    if (!cachePath)
+        return undefined;
+    if (!existsSync(cachePath)) {
+        contentIndex.delete(imageContentKey(base64Data));
+        return undefined;
+    }
+    return cachePath;
+}
+export function getImageStoreSession() {
+    return activeSessionId;
+}
+function safeSessionDirName(sessionId) {
+    const normalized = String(sessionId ?? '').trim();
+    if (!/^[a-zA-Z0-9_-]+$/.test(normalized)) {
+        throw new Error(`Invalid session id "${sessionId}".`);
+    }
+    return normalized;
+}
+export function getSessionImageBaseDir(env = process.env) {
+    return path.join(getClientStateDir(env), 'sessions', 'images');
+}
+export function getSessionImageDir(sessionId, env = process.env) {
+    return path.join(getSessionImageBaseDir(env), safeSessionDirName(sessionId));
+}
+function nextImageNumber(dir) {
+    if (!existsSync(dir))
+        return 1;
+    let highest = 0;
+    for (const name of readdirSync(dir)) {
+        const parsed = Number.parseInt(path.basename(name, path.extname(name)), 10);
+        if (Number.isInteger(parsed) && parsed > highest)
+            highest = parsed;
+    }
+    return highest + 1;
+}
+function ensureSessionImageDir(sessionId, env) {
+    const dir = getSessionImageDir(sessionId, env);
+    mkdirSync(dir, { recursive: true, mode: IMAGE_DIR_MODE });
+    return dir;
+}
+export function storeSessionImageBytes({ sessionId, base64Data, mimeType, env = process.env, }) {
+    const dir = ensureSessionImageDir(sessionId, env);
+    const index = nextImageNumber(dir);
+    const cachePath = path.join(dir, `${index}${imageExtensionForMime(mimeType)}`);
+    writeFileSync(cachePath, Buffer.from(base64Data, 'base64'), {
+        mode: IMAGE_FILE_MODE,
+    });
+    rememberStoredImage(base64Data, cachePath);
+    return { cachePath, mimeType, base64Data, index };
+}
+export function tryCacheAttachmentBytes({ base64Data, mimeType, env = process.env, }) {
+    if (!activeSessionId)
+        return undefined;
+    try {
+        const stored = storeSessionImageBytes({
+            sessionId: activeSessionId,
+            base64Data,
+            mimeType,
+            env,
+        });
+        return { cachePath: stored.cachePath, index: stored.index };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isSessionStorePath(candidate, env = process.env) {
+    if (!activeSessionId)
+        return false;
+    const dir = getSessionImageDir(activeSessionId, env);
+    const resolved = path.resolve(candidate);
+    return (resolved.startsWith(dir + path.sep) && path.dirname(resolved) === dir);
+}
+export function readSessionImageByIndex(index, env = process.env) {
+    if (!activeSessionId || !Number.isInteger(index) || index < 1)
+        return null;
+    const dir = getSessionImageDir(activeSessionId, env);
+    if (!existsSync(dir))
+        return null;
+    try {
+        for (const name of readdirSync(dir)) {
+            if (Number.parseInt(path.basename(name, path.extname(name)), 10) === index) {
+                return readSessionImage(path.join(dir, name));
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export function describeSessionImageStore(env = process.env) {
+    if (!activeSessionId)
+        return null;
+    const dir = getSessionImageDir(activeSessionId, env);
+    if (!existsSync(dir))
+        return null;
+    const indices = [];
+    try {
+        for (const name of readdirSync(dir)) {
+            const parsed = Number.parseInt(path.basename(name, path.extname(name)), 10);
+            if (Number.isInteger(parsed) && parsed >= 1)
+                indices.push(parsed);
+        }
+    }
+    catch {
+        return null;
+    }
+    if (indices.length === 0)
+        return null;
+    return { dir, indices: indices.sort((a, b) => a - b) };
+}
+const MAX_STORE_DIR_CHARS = 512;
+const MAX_STORE_INDICES = 200;
+const STORE_CONTROL_CHARS = /[\u0000-\u001f\u007f]/g;
+export function normalizeSessionImageStore(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const record = value;
+    const dir = String(record.dir ?? '')
+        .replace(STORE_CONTROL_CHARS, ' ')
+        .trim()
+        .slice(0, MAX_STORE_DIR_CHARS);
+    if (!dir)
+        return null;
+    const seen = new Set();
+    for (const raw of Array.isArray(record.indices) ? record.indices : []) {
+        const parsed = Number(raw);
+        if (!Number.isInteger(parsed) || parsed < 1)
+            continue;
+        seen.add(parsed);
+        if (seen.size >= MAX_STORE_INDICES)
+            break;
+    }
+    if (seen.size === 0)
+        return null;
+    return { dir, indices: [...seen].sort((a, b) => a - b) };
+}
+export class SessionImageError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'SessionImageError';
+    }
+}
+export function storeSessionImageFromPath({ sessionId, sourcePath, env = process.env, }) {
+    const resolved = path.resolve(sourcePath);
+    if (!existsSync(resolved) || !statSync(resolved).isFile()) {
+        throw new SessionImageError(`Image file not found: ${resolved}`, 'NOT_FOUND');
+    }
+    const size = statSync(resolved).size;
+    if (size > MAX_IMAGE_SIZE_BYTES) {
+        throw new SessionImageError(`Image file exceeds ${Math.round(MAX_IMAGE_SIZE_BYTES / 1024 / 1024)}MB limit (${(size / 1024 / 1024).toFixed(1)}MB): ${resolved}`, 'TOO_LARGE');
+    }
+    const bytes = readFileSync(resolved);
+    const sniffed = sniffImageMimeType(bytes);
+    if (!sniffed || !isSupportedImageMimeType(sniffed)) {
+        throw new SessionImageError(`Not a supported image file: ${resolved}. Supported: PNG, JPEG, GIF, WebP.`, 'UNSUPPORTED');
+    }
+    const dir = ensureSessionImageDir(sessionId, env);
+    const index = nextImageNumber(dir);
+    const cachePath = path.join(dir, `${index}${imageExtensionForMime(sniffed)}`);
+    writeFileSync(cachePath, bytes, { mode: IMAGE_FILE_MODE });
+    const base64Data = bytes.toString('base64');
+    rememberStoredImage(base64Data, cachePath);
+    return { cachePath, mimeType: sniffed, base64Data, index };
+}
+export function readSessionImage(cachePath) {
+    try {
+        if (!existsSync(cachePath))
+            return null;
+        const bytes = readFileSync(cachePath);
+        const sniffed = sniffImageMimeType(bytes);
+        if (!sniffed)
+            return null;
+        const parsed = Number.parseInt(path.basename(cachePath, path.extname(cachePath)), 10);
+        const base64Data = bytes.toString('base64');
+        rememberStoredImage(base64Data, cachePath);
+        return {
+            cachePath,
+            mimeType: sniffed,
+            base64Data,
+            index: Number.isInteger(parsed) ? parsed : 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function pruneSessionImages(sessionId, env = process.env) {
+    try {
+        rmSync(getSessionImageDir(sessionId, env), { recursive: true, force: true });
+    }
+    catch {
+    }
+}
+export function sweepOrphanSessionImages({ activeSessionIds, maxAgeMs = SESSION_IMAGE_MAX_AGE_MS, env = process.env, now = Date.now(), }) {
+    const baseDir = getSessionImageBaseDir(env);
+    if (!existsSync(baseDir))
+        return 0;
+    let removed = 0;
+    let entries;
+    try {
+        entries = readdirSync(baseDir);
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        if (activeSessionIds.has(entry))
+            continue;
+        const dir = path.join(baseDir, entry);
+        try {
+            if (now - statSync(dir).mtimeMs < maxAgeMs)
+                continue;
+            rmSync(dir, { recursive: true, force: true });
+            removed += 1;
+        }
+        catch {
+        }
+    }
+    return removed;
+}

package/dist/src/edit-journal.js

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { existsSync, lstatSync, readFileSync } from 'node:fs';
+import { closeSync, existsSync, lstatSync, openSync, readFileSync, readSync, } from 'node:fs';
 import path from 'node:path';
 import { BINARY_ARTIFACT_EXTENSIONS } from './artifact-policy.js';
 import { resolveProjectPath } from './patcher.js';
@@ -30,13 +30,33 @@ function snapshotEncoding(filePath, content) {
         return 'base64';
     return 'utf8';
 }
+const MAX_SNAPSHOT_READ_BYTES = MAX_STORED_CONTENT_CHARS;
+const SNAPSHOT_HASH_CHUNK_BYTES = 1024 * 1024;
+function hashFileInChunks(absPath) {
+    const hash = createHash('sha256');
+    const chunk = Buffer.allocUnsafe(SNAPSHOT_HASH_CHUNK_BYTES);
+    const fd = openSync(absPath, 'r');
+    try {
+        for (;;) {
+            const read = readSync(fd, chunk, 0, chunk.length, null);
+            if (read <= 0)
+                break;
+            hash.update(chunk.subarray(0, read));
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+    return `sha256:${hash.digest('hex')}`;
+}
 export function readFileEditSnapshot(rootDir, filePath) {
     try {
         const absPath = resolveProjectPath(rootDir, filePath);
         if (!existsSync(absPath)) {
             return { exists: false, content: null, contentEncoding: 'utf8', hash: null };
         }
-        if (lstatSync(absPath).isSymbolicLink()) {
+        const stat = lstatSync(absPath);
+        if (stat.isSymbolicLink()) {
             return {
                 exists: true,
                 content: null,
@@ -45,6 +65,17 @@ export function readFileEditSnapshot(rootDir, filePath) {
                 error: `Refusing to snapshot symbolic link: ${filePath}`,
             };
         }
+        if (stat.isFile() && stat.size > MAX_SNAPSHOT_READ_BYTES) {
+            return {
+                exists: true,
+                content: null,
+                contentEncoding: BINARY_ARTIFACT_EXTENSIONS.has(path.extname(filePath).toLowerCase())
+                    ? 'base64'
+                    : 'utf8',
+                hash: hashFileInChunks(absPath),
+                error: `File is too large to snapshot (${stat.size} bytes).`,
+            };
+        }
         const content = readFileSync(absPath);
         const encoding = snapshotEncoding(filePath, content);
         return {

package/dist/src/executor.js

@@ -1,6 +1,6 @@
 import chalk from './colors.js';
 import { execFileSync, spawn } from 'child_process';
-import { existsSync, statSync } from 'fs';
+import { accessSync, constants as fsConstants, existsSync, statSync } from 'fs';
 import { createRequire } from 'node:module';
 import os from 'os';
 import path from 'path';
@@ -596,7 +596,7 @@ export function commandUsesSudo(command) {
 }
 export function sudoPromptFromTail(text) {
     const tail = text.slice(-1000).replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');
-    const match = tail.match(/(?:\[sudo\][^\r\n]*password[^\r\n]*: ?|sudo[^\r\n]*password[^\r\n]*: ?|password[^\r\n]*: ?)$/i);
+    const match = tail.match(/(?:\[sudo\][^\r\n]*password[^\r\n]*: ?|\[?sudo[^\r\n]*password[^\r\n]*: ?|password[^\r\n]*: ?)$/i);
     return match?.[0] ?? null;
 }
 function isSudoPromptLine(text) {
@@ -637,6 +637,28 @@ export function buildCommandEnv(cwd) {
         THEGITAI_SCRATCH_DIR: ensureSessionScratchDir(),
     };
 }
+let cachedCommandShell;
+function findBashPath() {
+    const fromPath = (process.env.PATH ?? '')
+        .split(path.delimiter)
+        .filter(Boolean)
+        .map((dir) => path.join(dir, 'bash'));
+    for (const candidate of [...fromPath, '/bin/bash', '/usr/bin/bash']) {
+        try {
+            accessSync(candidate, fsConstants.X_OK);
+            return candidate;
+        }
+        catch { }
+    }
+    return null;
+}
+export function resolveCommandShell() {
+    if (cachedCommandShell !== undefined)
+        return cachedCommandShell;
+    cachedCommandShell =
+        process.platform === 'win32' ? true : (findBashPath() ?? true);
+    return cachedCommandShell;
+}
 function sanitizePtyOutput(command, output, cwd, secrets) {
     return sanitizeCommandText(command, stripSudoPromptText(redactSecrets(output, secrets)), cwd);
 }
@@ -822,7 +844,7 @@ export async function runCommand(command, cwd, { requestSudoPassword, timeout, }
         let killTimer = null;
         const child = spawn(command, {
             cwd,
-            shell: true,
+            shell: resolveCommandShell(),
             detached: process.platform !== 'win32',
             stdio: ['pipe', 'pipe', 'pipe'],
             env: buildCommandEnv(cwd),

package/dist/src/help-text.js

@@ -14,7 +14,7 @@ const PASTE_SHORTCUT = pasteShortcutForPlatform();
 const HELP_MARKDOWN = [
     '# TheGitAI',
     '',
-    'Interactive terminal coding agent. Local repo indexing, file edits, and',
+    'Interactive terminal coding agent. Local repo search, file edits, and',
     'shell commands run on your machine. Model inference and server-executed',
     'tools run on the server.',
     '',
@@ -26,8 +26,12 @@ const HELP_MARKDOWN = [
     '',
     '## Auth',
     '',
-    '- `ai login` — sign in to TheGitAI (opens your browser to the website)',
-    '- `ai login --no-browser` — print a URL and paste the code (for SSH/headless)',
+    '- `ai` — signs you in if you are not already, then starts a session',
+    '- `ai login` — the same thing; kept for muscle memory',
+    '- Signing in opens your browser. When it cannot open one — over SSH, in a',
+    '  container, or when the browser you want is on another device — the same',
+    '  screen prints a URL you can open anywhere and takes the code that page',
+    '  gives you back. There is no mode to pick and no flag to remember.',
     '- `ai whoami` — show the signed-in account',
     '- `ai --usage` — show account usage percentage and reset times',
     '- `ai logout` — sign out',
@@ -47,7 +51,9 @@ const HELP_MARKDOWN = [
     '',
     '## Modes',
     '',
-    '- Default — asks before shell commands and file edits.',
+    '- Default — asks before creating, editing or deleting files and before',
+    '  running commands. Each answer can be remembered for the rest of the',
+    '  session; see Safety & approvals.',
     '- Auto-Accept — approves shell commands and file edits for the session.',
     '- Plan — read-only; the agent can inspect, ask typed questions, and plan,',
     '  with file-reading shell commands only. It will not edit files or run tests,',
@@ -57,7 +63,15 @@ const HELP_MARKDOWN = [
     '## Keys & clipboard',
     '',
     '- **Enter** sends • **Shift+Tab** cycles modes • **Esc** cancels the turn •',
-    '  **Ctrl+C** quits. These are the same on macOS, Linux, and Windows.',
+    '  **Ctrl+C** clears the composer or the queued message, and quits once there',
+    '  is nothing left to clear. These are the same on macOS, Linux, and Windows.',
+    '- **While the agent is working**, Enter queues your message and locks the',
+    '  composer. Press **Enter** again to send it into the running turn: the agent',
+    '  picks it up at its next step instead of waiting for the turn to finish, and',
+    '  the Your messages panel tracks it from queued to delivered. **↑** brings it',
+    '  back for editing and **Esc**/**Ctrl+C** discards it; both unlock the',
+    '  composer for the next message. **Ctrl+V** pastes a screenshot onto the',
+    '  queued message, and it is delivered into the running turn with the text.',
     `- **Paste** into the composer with your terminal's paste shortcut (\`${PASTE_SHORTCUT}\``,
     '  on this system) or by right-clicking the composer.',
     '- **Copy** from the transcript by dragging to select; double-click copies a',
@@ -70,22 +84,46 @@ const HELP_MARKDOWN = [
     '',
     '- `/help` — show this help',
     '- `/about` — show version and platform info',
+    '- `/report` — file a bug privately through the TheGitAI website in your',
+    '  browser (sign in with your existing account)',
     '- `/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',
+    '- Ctrl+B — open the same jobs picker, and the only way in while the agent',
+    '  is working; press it again or Esc to close without touching the turn',
     '- `/jobs output <id>` — print one job\'s full captured output',
     '- `/jobs kill <id>` — stop one background job',
-    '- `/clear` — clear the current conversation history',
+    '- `/new` — start a new conversation; this session remains saved',
+    '- `/logout` — sign out and quit',
     '- `/exit` — quit the session',
     '',
     '## Safety & approvals',
     '',
-    '- TheGitAI asks before running shell commands or applying file edits.',
-    '- At each prompt: **y** approves once, **a** approves the rest of the',
-    '  session, **n** denies.',
+    '- In Default mode TheGitAI asks before it creates a file, edits an existing',
+    '  file, deletes a file, or runs a command. These are four separate',
+    '  permissions: allowing edits does not allow deletions, and allowing file',
+    '  changes does not allow commands.',
+    '- At each prompt: **↑/↓** moves between choices, **Enter** confirms the',
+    '  highlighted one, and **Esc** denies. Deny is selected by default.',
+    '  Single-letter shortcuts were removed on purpose: a prompt can appear',
+    '  while you are typing, and a stray letter must never approve anything.',
+    '- Every prompt offers Approve once, an "Always allow" for that kind of',
+    '  action, and Deny. A command also offers to remember just its prefix — for',
+    '  example approving `npm test -- --watch=false` can allow `npm test`.',
+    '- A prefix is only offered when the command shows a plain verb, as in',
+    '  `npm test` or `git status`. Commands with no verb (`ls -la`), interpreters',
+    '  and wrappers (`bash -c`, `python -c`, `env`, `timeout`, `make`), and',
+    '  destructive or network binaries (`rm`, `sudo`, `curl`) are never offered',
+    '  one — a bare binary grant would mean "anything this program can do".',
+    '  `npm run` must name its script, so the grant is `npm run build`.',
+    '- A remembered prefix never covers a command that chains, pipes, redirects,',
+    '  or substitutes, so allowing `npm test` can never green-light',
+    '  `npm test && rm -rf build`.',
+    '- Everything you allow lasts for the current session only and is forgotten',
+    '  when it ends. `/new` clears it immediately.',
     '- If an approved `sudo` command needs a password, the TUI shows the exact',
     '  command and keeps the password masked and local.',
     '- `-y` / `--yes` at startup auto-approves every shell command and file',
@@ -94,24 +132,27 @@ const HELP_MARKDOWN = [
     '  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.',
+    '  killed jobs disappear immediately. While a turn is running the indicator',
+    '  points at Ctrl+B instead, which opens the same picker without cancelling',
+    '  or interrupting the turn. 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.',
+    '  excluded from search and listing.',
     '',
     '## Troubleshooting',
     '',
-    '- "Not logged in" → run `ai login`.',
     '- Auth or permission errors → run `ai whoami` to confirm the signed-in',
     '  account.',
     '- Usage or quota errors → run `ai --usage`.',
-    '- Signed in with the wrong credentials → `ai logout`, then `ai login` with',
-    '  the account you intended to use.',
+    '- Signed in with the wrong account → `/logout` (or `ai logout`), then run',
+    '  `ai` and sign in as the account you intended to use.',
+    '- The browser did not open, or opened on the wrong machine → open the URL',
+    '  printed on the sign-in screen anywhere you like, choose "On another',
+    '  computer" on that page, and paste the code back into the terminal.',
     '- A local session was used with a different sign-in → sign in with the',
     '  account you used for that session or start a new session.',
-    '- For anything else, re-run the command and report the printed error',
-    '  message — there is no client-side debug mode by design.',
+    '- For anything else, re-run the command and file the printed error',
+    '  message with `/report` — there is no client-side debug mode by design.',
 ].join('\n');
 export function formatAboutCard() {
     return [

package/dist/src/patcher.js

@@ -1,5 +1,5 @@
 import chalk from './colors.js';
-import { chmodSync, closeSync, constants, existsSync, fchmodSync, fstatSync, ftruncateSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, unlinkSync, writeFileSync, } from 'fs';
+import { chmodSync, closeSync, constants, existsSync, fchmodSync, fstatSync, ftruncateSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, realpathSync, unlinkSync, writeFileSync, } from 'fs';
 import path from 'path';
 import { createInterface } from 'readline';
 import { runCommand } from './executor.js';
@@ -271,22 +271,61 @@ export function writeProjectFileBuffer(rootDir, filePath, content) {
     }
     return { absPath, changed: true };
 }
+const MAX_DELETED_CONTENT_BYTES = 64 * 1024;
+const DELETED_BINARY_SNIFF_BYTES = 4096;
+function headHasNulByte(absPath) {
+    const chunk = Buffer.allocUnsafe(DELETED_BINARY_SNIFF_BYTES);
+    let fd = null;
+    try {
+        fd = openSync(absPath, 'r');
+        const read = readSync(fd, chunk, 0, chunk.length, 0);
+        return read > 0 && chunk.subarray(0, read).includes(0);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (fd !== null)
+            closeSync(fd);
+    }
+}
 export function deleteProjectFile(rootDir, filePath) {
     const absPath = resolveProjectPath(rootDir, filePath);
     if (!existsSync(absPath)) {
         return { deleted: false, absPath };
     }
+    let bytes;
     let content;
+    let contentOmitted;
     try {
-        if (!lstatSync(absPath).isSymbolicLink()) {
-            content = readFileSync(absPath, 'utf-8');
+        const stat = lstatSync(absPath);
+        if (!stat.isSymbolicLink()) {
+            bytes = stat.size;
+            if (stat.size > MAX_DELETED_CONTENT_BYTES) {
+                contentOmitted = headHasNulByte(absPath) ? 'binary' : 'too_large';
+            }
+            else {
+                const buffer = readFileSync(absPath);
+                if (buffer.includes(0))
+                    contentOmitted = 'binary';
+                else
+                    content = buffer.toString('utf-8');
+            }
         }
     }
     catch {
+        bytes = undefined;
         content = undefined;
+        contentOmitted = undefined;
     }
     unlinkSync(absPath);
-    return { deleted: true, absPath, content };
+    return {
+        deleted: true,
+        absPath,
+        ...(bytes === undefined ? {} : { bytes }),
+        ...(content === undefined ? {} : { content }),
+        ...(contentOmitted === undefined ? {} : { contentOmitted }),
+    };
 }
 export function readProjectFile(rootDir, filePath) {
     const absPath = resolveProjectPath(rootDir, filePath);