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

package/dist/src/scanner.js

@@ -1,14 +1,12 @@
 import { execSync } from 'child_process';
-import { readFileSync, statSync } from 'fs';
-import { glob } from 'glob';
+import { readdirSync, readFileSync, statSync } from 'fs';
 import path from 'path';
 import { getNodePrimarySignature, getStructuralChildren, parseRepoSource, } from './tree-sitter-runtime.js';
-import { ARTIFACT_FALLBACK_IGNORE_GLOBS, ARTIFACT_IGNORE_DIRS, ARTIFACT_IGNORE_FILES, ARTIFACT_INSPECT_BLOCK_DIRS, BINARY_ARTIFACT_EXTENSIONS, isSensitiveProjectPath, shouldIgnoreArtifactPath, } from './artifact-policy.js';
+import { ARTIFACT_IGNORE_DIRS, ARTIFACT_IGNORE_FILES, ARTIFACT_INSPECT_BLOCK_DIRS, BINARY_ARTIFACT_EXTENSIONS, isSensitiveProjectPath, shouldIgnoreArtifactPath, } from './artifact-policy.js';
 const BINARY_EXTENSIONS = BINARY_ARTIFACT_EXTENSIONS;
 const ALWAYS_IGNORE_FILES = ARTIFACT_IGNORE_FILES;
 export const ALWAYS_IGNORE_DIRS = ARTIFACT_IGNORE_DIRS;
 export const BLOCKED_PATH_INSPECT_DIRS = ARTIFACT_INSPECT_BLOCK_DIRS;
-const FALLBACK_IGNORE = ARTIFACT_FALLBACK_IGNORE_GLOBS;
 export const SCANNER_MAX_SOURCE_FILE_BYTES = 100 * 1024;
 const MAX_FILE_SIZE = SCANNER_MAX_SOURCE_FILE_BYTES;
 const MAX_CHUNKS = 2000;
@@ -16,26 +14,69 @@ const TARGET_CHUNK_CHARS = 1800;
 const MAX_CHUNK_CHARS = 2800;
 const FALLBACK_OVERLAP_LINES = 10;
 const MAX_STRUCTURE_DEPTH = 2;
+function parseGitLsFilesOutput(output) {
+    return String(output)
+        .split('\0')
+        .filter(Boolean)
+        .filter((filePath) => !shouldIgnorePath(filePath));
+}
 function getFiles(rootDir, { limit = Infinity } = {}) {
     try {
-        const output = execSync('git ls-files --cached --others --exclude-standard', { cwd: rootDir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
-        const files = output
-            .split('\n')
-            .filter(Boolean)
-            .filter((filePath) => !shouldIgnorePath(filePath));
+        const output = execSync('git ls-files -z --cached --others --exclude-standard', { cwd: rootDir, stdio: ['pipe', 'pipe', 'pipe'] });
+        const files = parseGitLsFilesOutput(output);
         return Number.isFinite(limit) ? files.slice(0, limit) : files;
     }
     catch {
-        return glob
-            .sync('**/*', {
-            cwd: rootDir,
-            nodir: true,
-            dot: false,
-            ignore: FALLBACK_IGNORE,
-        })
-            .slice(0, Number.isFinite(limit) ? limit : undefined);
+        return walkProjectFilesFallback(rootDir, Number.isFinite(limit) ? limit : Infinity);
     }
 }
+const FALLBACK_LOCKFILES = new Set([
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+]);
+function isFallbackIgnoredFile(relPath, fileName) {
+    if (shouldIgnorePath(relPath))
+        return true;
+    if (fileName.endsWith('.lock'))
+        return true;
+    return FALLBACK_LOCKFILES.has(fileName);
+}
+function walkProjectFilesFallback(rootDir, limit) {
+    const results = [];
+    const visit = (relDir) => {
+        if (results.length >= limit)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(path.join(rootDir, relDir), {
+                withFileTypes: true,
+            });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (results.length >= limit)
+                return;
+            const name = entry.name;
+            if (name.startsWith('.'))
+                continue;
+            const relPath = relDir ? `${relDir}/${name}` : name;
+            if (entry.isDirectory()) {
+                if (ALWAYS_IGNORE_DIRS.has(name) || shouldIgnoreArtifactPath(relPath)) {
+                    continue;
+                }
+                visit(relPath);
+            }
+            else if (entry.isFile() && !isFallbackIgnoredFile(relPath, name)) {
+                results.push(relPath);
+            }
+        }
+    };
+    visit('');
+    return results;
+}
 function shouldSkipFile(relPath, stat) {
     if (shouldIgnorePath(relPath))
         return true;

package/dist/src/scratch-dir.js

@@ -0,0 +1,57 @@
+import { chmodSync, lstatSync, mkdirSync, mkdtempSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+let cachedScratchDir = null;
+export function sessionScratchDir() {
+    if (!cachedScratchDir) {
+        cachedScratchDir = path.join(os.tmpdir(), `thegitai-${process.pid}`);
+    }
+    return cachedScratchDir;
+}
+function isSquattedScratchRoot(dir) {
+    try {
+        const st = lstatSync(dir);
+        if (st.isSymbolicLink() || !st.isDirectory())
+            return true;
+        if (process.platform !== 'win32' &&
+            typeof process.getuid === 'function' &&
+            st.uid !== process.getuid()) {
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+export function ensureSessionScratchDir() {
+    const dir = sessionScratchDir();
+    try {
+        if (isSquattedScratchRoot(dir)) {
+            cachedScratchDir = mkdtempSync(path.join(os.tmpdir(), 'thegitai-'));
+            return cachedScratchDir;
+        }
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        if (process.platform !== 'win32') {
+            chmodSync(dir, 0o700);
+        }
+    }
+    catch {
+    }
+    return sessionScratchDir();
+}
+export function isInsideTheGitAiScratch(absPath) {
+    const tempRoot = path.resolve(os.tmpdir());
+    const relPath = path.relative(tempRoot, path.resolve(absPath));
+    if (!relPath || relPath.startsWith('..') || path.isAbsolute(relPath)) {
+        return false;
+    }
+    const first = relPath.split(/[\\/]/, 1)[0] ?? '';
+    if (!/^thegitai(?:$|[-.])/i.test(first)) {
+        return false;
+    }
+    if (/[*?[\]{}]/.test(first)) {
+        return false;
+    }
+    return !isSquattedScratchRoot(path.join(tempRoot, first));
+}

package/dist/src/secret-preview.js

@@ -6,11 +6,7 @@ const PRIVATE_KEY_REDACTION = '[REDACTED: private key]';
 const SENSITIVE_JSON_KEY_PATTERN = /^(?:private[_-]?key|secret|api[_-]?key|password|client_secret|refresh_token|access_token|id_token|auth_provider_x509_cert_url)$/i;
 const PEM_BLOCK_PATTERN = /-----BEGIN [^-]*(?:PRIVATE KEY|SECRET KEY|OPENSSH PRIVATE KEY)[\s\S]*?-----END [^-]*(?:PRIVATE KEY|SECRET KEY|OPENSSH PRIVATE KEY)-----/gi;
 const PEM_SECRET_PATH_PATTERN = /\.(?:pem|key)$/i;
-// Password embedded in a connection-string URL, e.g.
-// `postgresql://user:PASS@host`. Redacted from shell output so secrets in
-// commands like `cat .env` do not leak into history or telemetry.
 const URL_CREDENTIALS_PATTERN = /\b([a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:)([^\s/@]+)(@)/gi;
-/** Redact only userinfo passwords in connection-string URLs (zero false positives). */
 export function redactConnectionStringCredentials(text) {
     return text.replace(URL_CREDENTIALS_PATTERN, (_match, prefix, _password, at) => `${prefix}${VALUE_REDACTION}${at}`);
 }
@@ -72,12 +68,6 @@ export function isDotenvLikePath(value) {
     const base = path.posix.basename(text.replace(/\\/g, '/'));
     return DOTENV_BASENAME_PATTERN.test(base);
 }
-/**
- * True only for a clean dotenv file we can safely show with keys visible and
- * values tokenized: no PEM block, not JSON, and every non-blank/non-comment line
- * is a `KEY=VALUE` assignment. Anything ambiguous (a stray line that might be a
- * raw secret) returns false so the caller keeps the opaque blackout instead.
- */
 export function looksLikeEditableDotenv(content) {
     PEM_BLOCK_PATTERN.lastIndex = 0;
     if (PEM_BLOCK_PATTERN.test(content))

package/dist/src/session-safety.js

@@ -2,14 +2,14 @@ import { execFileSync } from 'node:child_process';
 import { lstatSync, readdirSync } from 'node:fs';
 import path from 'node:path';
 import { ARTIFACT_IGNORE_DIRS, normalizeProjectRelativePath, shouldIgnoreArtifactPath, } from './artifact-policy.js';
-import { hashContent, readFileEditSnapshot } from './edit-journal.js';
-import { deleteProjectFile, resolveProjectPath, writeProjectFile } from './patcher.js';
+import { hashBytes, readFileEditSnapshot, storedContentBuffer, } from './edit-journal.js';
+import { deleteProjectFile, resolveProjectPath, writeProjectFile, writeProjectFileBuffer, } from './patcher.js';
 import { removeIndexFile, upsertIndexFile } from './project-index.js';
 const MAX_CHECKPOINTS = 20;
 const MAX_SESSION_EDITS = 500;
 const MAX_READ_RECORDS = 200;
 const MAX_REDACTION_TOKENS = 500;
-const MAX_SNAPSHOT_CONTENT_CHARS = 1_000_000;
+const MAX_SNAPSHOT_CONTENT_CHARS = 8_000_000;
 const MAX_MUTATION_SCAN_FILES = 2000;
 const MAX_BASELINE_CONTENT_BYTES = 50 * 1024 * 1024;
 export function createSessionSafetyState() {
@@ -34,6 +34,14 @@ function normalizeEditOperation(value) {
         ? text
         : null;
 }
+function normalizeStoredContentEncoding(value) {
+    return value === 'base64' ? 'base64' : 'utf8';
+}
+function writeStoredProjectFile(rootDir, filePath, content, encoding) {
+    return encoding === 'base64'
+        ? writeProjectFileBuffer(rootDir, filePath, storedContentBuffer(content, encoding))
+        : writeProjectFile(rootDir, filePath, content);
+}
 export function normalizeSessionSafetyState(value) {
     const raw = value && typeof value === 'object' ? value : {};
     const safety = createSessionSafetyState();
@@ -57,6 +65,7 @@ export function normalizeSessionSafetyState(value) {
                         exists: file.exists === true,
                         hash: typeof file.hash === 'string' ? file.hash : null,
                         content: typeof file.content === 'string' ? file.content : null,
+                        contentEncoding: normalizeStoredContentEncoding(file.contentEncoding),
                         skipped: typeof file.skipped === 'string' && file.skipped.trim()
                             ? file.skipped.trim()
                             : undefined,
@@ -143,6 +152,7 @@ export function normalizeSessionSafetyState(value) {
                 beforeHash: typeof item.beforeHash === 'string' ? item.beforeHash : null,
                 afterHash: typeof item.afterHash === 'string' ? item.afterHash : null,
                 beforeContent: typeof item.beforeContent === 'string' ? item.beforeContent : null,
+                beforeContentEncoding: normalizeStoredContentEncoding(item.beforeContentEncoding),
                 createdAt: typeof item.createdAt === 'string' && item.createdAt
                     ? item.createdAt
                     : new Date().toISOString(),
@@ -242,7 +252,10 @@ export function mergeLocalSessionSafetyState(local, incoming) {
         for (const file of checkpoint.files) {
             if (file.content == null)
                 continue;
-            localCheckpointContent.set(`${checkpoint.id}\0${file.filePath}\0${file.hash ?? ''}`, file.content);
+            localCheckpointContent.set(`${checkpoint.id}\0${file.filePath}\0${file.hash ?? ''}`, {
+                content: file.content,
+                contentEncoding: file.contentEncoding,
+            });
         }
     }
     next.checkpoints = next.checkpoints.map((checkpoint) => ({
@@ -251,17 +264,35 @@ export function mergeLocalSessionSafetyState(local, incoming) {
             if (file.content != null)
                 return file;
             const content = localCheckpointContent.get(`${checkpoint.id}\0${file.filePath}\0${file.hash ?? ''}`);
-            return content == null ? file : { ...file, content };
+            return content == null
+                ? file
+                : {
+                    ...file,
+                    content: content.content,
+                    contentEncoding: content.contentEncoding,
+                };
         }),
     }));
     const localBeforeContent = new Map(localState.sessionEdits
         .filter((edit) => edit.beforeContent != null)
-        .map((edit) => [edit.id, edit.beforeContent]));
+        .map((edit) => [
+        edit.id,
+        {
+            beforeContent: edit.beforeContent,
+            beforeContentEncoding: edit.beforeContentEncoding,
+        },
+    ]));
     next.sessionEdits = next.sessionEdits.map((edit) => {
         if (edit.beforeContent != null)
             return edit;
         const beforeContent = localBeforeContent.get(edit.id);
-        return beforeContent == null ? edit : { ...edit, beforeContent };
+        return beforeContent == null
+            ? edit
+            : {
+                ...edit,
+                beforeContent: beforeContent.beforeContent,
+                beforeContentEncoding: beforeContent.beforeContentEncoding,
+            };
     });
     return next;
 }
@@ -279,6 +310,7 @@ function readCheckpointSnapshot(rootDir, filePath) {
             exists: false,
             hash: null,
             content: null,
+            contentEncoding: 'utf8',
             skipped: `Refusing to checkpoint ignored or out-of-project path: ${filePath}`,
         };
     }
@@ -289,6 +321,7 @@ function readCheckpointSnapshot(rootDir, filePath) {
             exists: snapshot.exists,
             hash: snapshot.hash,
             content: null,
+            contentEncoding: snapshot.contentEncoding,
             skipped: snapshot.error,
         };
     }
@@ -298,6 +331,7 @@ function readCheckpointSnapshot(rootDir, filePath) {
             exists: snapshot.exists,
             hash: snapshot.hash,
             content: null,
+            contentEncoding: snapshot.contentEncoding,
             skipped: `File is too large to checkpoint (${snapshot.content.length} chars).`,
         };
     }
@@ -306,6 +340,7 @@ function readCheckpointSnapshot(rootDir, filePath) {
         exists: snapshot.exists,
         hash: snapshot.hash,
         content: snapshot.content,
+        contentEncoding: snapshot.contentEncoding,
     };
 }
 export function createPromptCheckpoint(state, label, turnId) {
@@ -419,17 +454,6 @@ export function resolveRedactionTokens(state, text, filePath, hash) {
 }
 const DOTENV_ASSIGNMENT_PATTERN = /^(\s*(?:export\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=)(.*)$/;
 const DOTENV_COMMENT_PATTERN = /^(\s*#\s*)(\S.*)$/;
-/**
- * Redact a dotenv file's values while leaving keys visible. Every assignment's
- * value is replaced with a stable, reversible token so the agent can see the
- * file's structure and edit it (remove or replace lines) without ever seeing a
- * secret value; `resolveRedactionTokens` swaps the real values back on write.
- * Comment bodies are tokenized too, because developers routinely leave
- * commented-out credentials in dotenv files and those must not leak where the
- * opaque preview would have hidden them. Callers must confirm the content is
- * clean dotenv (`looksLikeEditableDotenv`) first so the only non-assignment
- * lines reaching here are blanks and comments.
- */
 export function redactDotenvWithStableTokens(state, content, filePath, hash) {
     const tokens = [];
     const redactedLines = content.split('\n').map((line) => {
@@ -455,14 +479,6 @@ export function redactDotenvWithStableTokens(state, content, filePath, hash) {
     });
     return { content: redactedLines.join('\n'), tokens };
 }
-/**
- * The redaction-token registry is capped at `MAX_REDACTION_TOKENS`; a read that
- * emits more tokens than that would evict its own oldest tokens, leaving
- * `[REDACTED:n]` markers in the preview that `write_file`/`str_replace` can no
- * longer resolve (silently writing the literal token back). So a dotenv file
- * with more tokenizable lines than the budget must not use the editable preview
- * — the caller falls back to the opaque blackout instead.
- */
 export function dotenvFitsRedactionBudget(content) {
     let count = 0;
     for (const line of content.split('\n')) {
@@ -661,7 +677,7 @@ export async function restoreCheckpointFiles(args) {
         const before = readFileEditSnapshot(args.rootDir, snapshot.filePath);
         try {
             if (snapshot.exists) {
-                const result = writeProjectFile(args.rootDir, snapshot.filePath, snapshot.content ?? '');
+                const result = writeStoredProjectFile(args.rootDir, snapshot.filePath, snapshot.content ?? '', snapshot.contentEncoding);
                 if (result.changed)
                     changed = true;
                 if (syncPolicy)
@@ -693,7 +709,7 @@ export async function restoreCheckpointFiles(args) {
                         if (item.before.content == null) {
                             throw new Error('previous file content is unavailable');
                         }
-                        writeProjectFile(args.rootDir, item.snapshot.filePath, item.before.content);
+                        writeStoredProjectFile(args.rootDir, item.snapshot.filePath, item.before.content, item.before.contentEncoding);
                         if (syncPolicy) {
                             await upsertIndexFile(args.projectIndex, item.snapshot.filePath);
                         }
@@ -749,6 +765,7 @@ export async function restoreCheckpointFiles(args) {
             beforeHash: item.before.hash,
             afterHash: item.after.hash,
             beforeContent: item.before.content,
+            beforeContentEncoding: item.before.contentEncoding,
             checkpointId: checkpoint.id,
         });
         restored.push({
@@ -777,6 +794,18 @@ function git(args, cwd) {
         return null;
     }
 }
+function gitBuffer(args, cwd) {
+    try {
+        return execFileSync('git', args, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 10_000,
+        });
+    }
+    catch {
+        return null;
+    }
+}
 export function findGitRoot(startDir) {
     const root = git(['rev-parse', '--show-toplevel'], startDir);
     return root ? path.resolve(root) : null;
@@ -897,14 +926,15 @@ function readGitHeadSnapshot(rootDir, filePath) {
         return null;
     const abs = resolveProjectPath(rootDir, filePath);
     const relToGit = path.relative(gitRoot, abs).split(path.sep).join('/');
-    const content = git(['show', `HEAD:${relToGit}`], gitRoot);
+    const content = gitBuffer(['show', `HEAD:${relToGit}`], gitRoot);
     if (content == null)
         return null;
     return {
         filePath,
         exists: true,
-        hash: hashContent(content),
-        content,
+        hash: hashBytes(content),
+        content: content.toString('base64'),
+        contentEncoding: 'base64',
     };
 }
 export function captureMutationBaseline(rootDir, options) {
@@ -932,6 +962,7 @@ export function captureMutationBaseline(rootDir, options) {
                 exists: true,
                 hash: null,
                 content: null,
+                contentEncoding: 'utf8',
                 skipped: `Pre-command snapshot skipped: project baseline content budget exceeded (${contentBudget} bytes). Restore for this file is not available.`,
             });
             continue;
@@ -978,6 +1009,7 @@ export function collectCommandMutations(args) {
                 exists: false,
                 hash: null,
                 content: null,
+                contentEncoding: 'utf8',
             };
         if (before.hash === after.hash && !before.skipped)
             continue;
@@ -1000,6 +1032,7 @@ export function collectCommandMutations(args) {
             beforeHash: before.hash,
             afterHash: after.hash,
             beforeContent: before.content,
+            beforeContentEncoding: before.contentEncoding,
             checkpointId: args.checkpointId,
         });
         records.push(record);

package/dist/src/session-store.js

@@ -122,7 +122,6 @@ function loadAllSnapshots(rootDir, env = process.env) {
             snapshots.push(loadSnapshotFile(filePath, rootDir));
         }
         catch {
-            // Skip corrupted snapshots silently — customers have no actionable debug path here.
         }
     }
     return snapshots.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));

package/dist/src/todo-list.js

@@ -0,0 +1,106 @@
+export const MAX_TODO_ITEMS = 20;
+export const MAX_TODO_TEXT_CHARS = 160;
+let items = [];
+let activeSessionId = null;
+const STATUS_ALIASES = {
+    pending: 'pending',
+    todo: 'pending',
+    not_started: 'pending',
+    in_progress: 'in_progress',
+    active: 'in_progress',
+    doing: 'in_progress',
+    completed: 'completed',
+    complete: 'completed',
+    done: 'completed',
+};
+function normalizeStatus(raw) {
+    const key = String(raw ?? '')
+        .trim()
+        .toLowerCase()
+        .replace(/[-\s]+/g, '_');
+    return STATUS_ALIASES[key] ?? null;
+}
+export function isCompletedStatus(raw) {
+    return normalizeStatus(raw) === 'completed';
+}
+const TODOS_ARG_ALIASES = ['items', 'todo_list', 'todoList', 'list', 'tasks'];
+export function extractTodosArg(args) {
+    if (!args || typeof args !== 'object')
+        return undefined;
+    const record = args;
+    if (record.todos !== undefined)
+        return record.todos;
+    for (const key of TODOS_ARG_ALIASES) {
+        if (record[key] !== undefined)
+            return record[key];
+    }
+    return undefined;
+}
+export function setTodoSession(sessionId) {
+    const next = String(sessionId ?? '').trim() || null;
+    if (activeSessionId !== next) {
+        items = [];
+    }
+    activeSessionId = next;
+}
+export function listTodos() {
+    return items.map((item) => ({ ...item }));
+}
+export function getTodoSnapshot() {
+    return {
+        items: listTodos(),
+        completedCount: items.filter((item) => item.status === 'completed').length,
+        totalCount: items.length,
+    };
+}
+export function clearTodos() {
+    items = [];
+}
+export function replaceTodos(raw) {
+    if (!Array.isArray(raw)) {
+        return { ok: false, error: 'todos must be an array of { text, status } items.' };
+    }
+    const normalizations = [];
+    if (raw.length > MAX_TODO_ITEMS) {
+        return {
+            ok: false,
+            error: `todos supports at most ${MAX_TODO_ITEMS} items; got ${raw.length}. Use fewer, broader steps.`,
+        };
+    }
+    const next = [];
+    let sawInProgress = false;
+    for (const [index, entry] of raw.entries()) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            return { ok: false, error: `todos[${index}] must be an object with text and status.` };
+        }
+        const text = String(entry.text ?? '')
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (!text) {
+            return { ok: false, error: `todos[${index}].text must be a non-empty string.` };
+        }
+        const status = normalizeStatus(entry.status);
+        if (!status) {
+            return {
+                ok: false,
+                error: `todos[${index}].status must be one of: pending, in_progress, completed.`,
+            };
+        }
+        let boundedText = text;
+        if (boundedText.length > MAX_TODO_TEXT_CHARS) {
+            boundedText = `${boundedText.slice(0, MAX_TODO_TEXT_CHARS - 1)}…`;
+            normalizations.push(`todos[${index}].text truncated to ${MAX_TODO_TEXT_CHARS} chars`);
+        }
+        let finalStatus = status;
+        if (status === 'in_progress') {
+            if (sawInProgress) {
+                finalStatus = 'pending';
+                normalizations.push(`todos[${index}] demoted to pending: only one item can be in_progress`);
+            }
+            sawInProgress = true;
+        }
+        next.push({ text: boundedText, status: finalStatus });
+    }
+    items = next;
+    return { ok: true, snapshot: getTodoSnapshot(), normalizations };
+}