@thegitai/cli 1.0.0-beta.13 → 1.0.0-beta.14

package/dist/src/api/chat.js

@@ -3,6 +3,7 @@ import { applySessionSnapshot, snapshotFromSession, } from '../session-store.js'
 import { executeLocalToolCall } from '../tool-executor.js';
 import { createTraceContext, normalizeServerUrl, readErrorResponse, } from './http.js';
 import { collectClientEnvironment } from '../client-environment.js';
+import { autoAttachImages } from '../core/image-path-extractor.js';
 export class TurnCancelledError extends Error {
     name = 'TurnCancelledError';
     constructor(message = 'Turn cancelled.') {
@@ -63,6 +64,9 @@ function snapshotForServer(session) {
     snapshot.clientState.safety = sanitizeSessionSafetyForServer(snapshot.clientState.safety);
     return snapshot;
 }
+function imageAttachmentsForServer(attachments) {
+    return (attachments ?? []).map(({ filePath: _filePath, ...attachment }) => attachment);
+}
 function userHistoryText(entry) {
     return (entry.parts ?? [])
         .map((part) => (typeof part?.text === 'string' ? part.text : ''))
@@ -285,19 +289,33 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
     return finalResult.current;
 }
 export async function sendServerUserMessage({ config, projectIndex, session, input, imageAttachments = [], fetchImpl = globalThis.fetch, signal, }) {
+    const autoAttach = autoAttachImages(input, session.rootDir, imageAttachments);
+    const requestImageAttachments = autoAttach.attachments.length > 0
+        ? [...imageAttachments, ...autoAttach.attachments]
+        : imageAttachments;
+    // requestInput is the server-bound, path-sanitized text ([Image #N] markers in
+    // place of local image paths). Every history-preservation path below (abort,
+    // cancel, failure, mid-stream tool cancel) must persist THIS, never the raw
+    // input — otherwise a cancelled or failed image turn leaks the local
+    // filesystem path into session history and the next snapshot ships it to the
+    // server, defeating the point of sanitizing before the request crosses over.
+    const requestInput = autoAttach.attachments.length > 0 ? autoAttach.sanitizedInput : input;
+    for (const err of autoAttach.errors) {
+        session.onStatus(`Image: ${err}`);
+    }
     const request = {
         modelId: session.modelId,
         session: snapshotForServer(session),
-        input,
+        input: requestInput,
         clientEnvironment: collectClientEnvironment({ env: session.env }),
-        imageAttachments,
+        imageAttachments: imageAttachmentsForServer(requestImageAttachments),
         maxToolSteps: session.maxToolSteps,
         autoYes: session.autoYes,
         agentMode: session.agentMode,
     };
     const trace = createTraceContext();
     const preTurnHistoryLength = session.history.length;
-    const preserveOnAbort = () => preserveCancelledTurnInput(session, input);
+    const preserveOnAbort = () => preserveCancelledTurnInput(session, requestInput);
     if (signal?.aborted) {
         preserveOnAbort();
     }
@@ -324,7 +342,7 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
             config,
             projectIndex,
             session,
-            input,
+            input: requestInput,
             fetchImpl,
             signal,
             traceId: trace.traceId,
@@ -339,7 +357,7 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
     }
     catch (error) {
         if (isTurnCancelledError(error)) {
-            preserveCancelledTurnInput(session, input);
+            preserveCancelledTurnInput(session, requestInput);
             throw error instanceof TurnCancelledError
                 ? error
                 : new TurnCancelledError();
@@ -348,7 +366,7 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
         // speculative cancelled-turn entries in history — otherwise the next
         // request replays a malformed transcript to the server.
         session.history.length = preTurnHistoryLength;
-        preserveFailedTurnInput(session, input, error instanceof ChatTurnFailedError ? error.category : 'unknown_error');
+        preserveFailedTurnInput(session, requestInput, error instanceof ChatTurnFailedError ? error.category : 'unknown_error');
         throw error;
     }
     finally {

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',
@@ -262,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,112 @@
+import { existsSync } 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)';
+// Bare-path characters: exclude whitespace, quotes, prose terminators, ':' (so we
+// don't swallow URL schemes or trailing "see foo.png:" prose) and bracket/brace/paren
+// delimiters on both sides (so markdown "![alt](x.png)" / "(x.png)" don't leak in).
+const BARE_CHAR = "[^\\s\"'<>,:;!?()\\[\\]{}]";
+// A bare token may carry backslash-escaped spaces (terminal drag-and-drop) and an
+// optional Windows drive prefix ("C:\\" or "C:/").
+const BARE_PATH = `(?:[A-Za-z]:[\\\\/])?(?:\\\\ |${BARE_CHAR})+\\.${EXT}`;
+const IMAGE_PATH_PATTERN = new RegExp(`"([^"]*\\.${EXT})"` +
+    `|'([^']*\\.${EXT})'` +
+    `|file://(\\S*\\.${EXT})` +
+    `|(${BARE_PATH})`, 'gi');
+function detectImagePaths(input, cwd) {
+    const regex = new RegExp(IMAGE_PATH_PATTERN.source, IMAGE_PATH_PATTERN.flags);
+    const rawsByPath = new Map();
+    let match;
+    while ((match = regex.exec(input)) !== null) {
+        const raw = match[0];
+        // A bare match containing "://" is a URL scheme remnant (e.g. the "p://" tail
+        // of "http://…" caught by the drive-letter prefix), never a local file path.
+        // Scope this to the bare branch only — a quoted value may legitimately be a
+        // file:// URL, which the quoted branch below decodes.
+        if (match[4] != null && raw.includes('://'))
+            continue;
+        let inner;
+        if (match[1] != null || match[2] != null) {
+            const quoted = (match[1] ?? match[2]);
+            // A quoted value can itself be a file:// URL ("file:///a/b%20c.png"); it
+            // still needs percent-decoding, so route it through the same decoder.
+            if (/^file:\/\//i.test(quoted)) {
+                try {
+                    inner = fileURLToPath(quoted);
+                }
+                catch {
+                    continue;
+                }
+            }
+            else {
+                inner = quoted;
+            }
+        }
+        else if (match[3] != null) {
+            // file:// URL: decode percent-escapes (e.g. "%20") to the real filesystem
+            // path. A malformed URL (bad %-escape) must be skipped, never thrown:
+            // ordinary prose containing a broken file:// URL should not abort the turn.
+            try {
+                inner = fileURLToPath(raw);
+            }
+            catch {
+                try {
+                    inner = decodeURIComponent(match[3]);
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        else {
+            // Bare path: unescape "\\ " sequences produced by terminal drag-and-drop.
+            inner = match[4].replace(/\\ /g, ' ');
+        }
+        const resolvedPath = path.isAbsolute(inner) ? inner : path.resolve(cwd, inner);
+        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 = [];
+    // Seed new markers after the highest existing index, not the existing count.
+    // The TUI can submit a sparse attachment set (e.g. [Image #2] kept after
+    // [Image #1] was deleted from the prompt), so counting would reuse an index
+    // still present in the prompt and make the model inspect the wrong image.
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thegitai/cli",
-  "version": "1.0.0-beta.13",
+  "version": "1.0.0-beta.14",
   "description": "TheGitAI CLI client (source-visible, proprietary)",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://thegit.ai",
@@ -25,10 +25,10 @@
     "@lydell/node-pty-linux-x64": "1.1.0",
     "@lydell/node-pty-win32-arm64": "1.1.0",
     "@lydell/node-pty-win32-x64": "1.1.0",
-    "@thegitai/tui-darwin-arm64": "1.0.0-beta.13",
-    "@thegitai/tui-darwin-x64": "1.0.0-beta.13",
-    "@thegitai/tui-linux-x64": "1.0.0-beta.13",
-    "@thegitai/tui-win32-x64": "1.0.0-beta.13",
+    "@thegitai/tui-darwin-arm64": "1.0.0-beta.14",
+    "@thegitai/tui-darwin-x64": "1.0.0-beta.14",
+    "@thegitai/tui-linux-x64": "1.0.0-beta.14",
+    "@thegitai/tui-win32-x64": "1.0.0-beta.14",
     "@vscode/ripgrep": "1.18.0"
   },
   "publishConfig": {