@thegitai/cli 1.0.0-beta.1

package/dist/src/edit-journal.js

@@ -0,0 +1,133 @@
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, lstatSync, readFileSync } from 'node:fs';
+import { resolveProjectPath } from './patcher.js';
+export const MAX_EDIT_JOURNAL_RECORDS = 50;
+const MAX_STORED_CONTENT_CHARS = 1_000_000;
+export function hashContent(content) {
+    return `sha256:${createHash('sha256').update(content).digest('hex')}`;
+}
+export function readFileEditSnapshot(rootDir, filePath) {
+    try {
+        const absPath = resolveProjectPath(rootDir, filePath);
+        if (!existsSync(absPath)) {
+            return { exists: false, content: null, hash: null };
+        }
+        if (lstatSync(absPath).isSymbolicLink()) {
+            return {
+                exists: true,
+                content: null,
+                hash: null,
+                error: `Refusing to snapshot symbolic link: ${filePath}`,
+            };
+        }
+        const content = readFileSync(absPath, 'utf-8');
+        return { exists: true, content, hash: hashContent(content) };
+    }
+    catch (err) {
+        return {
+            exists: false,
+            content: null,
+            hash: null,
+            error: err?.message ? String(err.message) : String(err),
+        };
+    }
+}
+export function isGitWorkTree(rootDir) {
+    try {
+        const output = execFileSync('git', ['-C', rootDir, 'rev-parse', '--is-inside-work-tree'], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        return output.trim() === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+export function isEditToolName(toolName) {
+    return (toolName === 'write_file' ||
+        toolName === 'patch_file' ||
+        toolName === 'str_replace' ||
+        toolName === 'delete_file');
+}
+export function operationFromSnapshots(before, after) {
+    if (before.hash === after.hash)
+        return null;
+    if (!before.exists && after.exists)
+        return 'create';
+    if (before.exists && !after.exists)
+        return 'delete';
+    if (before.exists && after.exists)
+        return 'update';
+    return null;
+}
+export function canStoreEditSnapshot(snapshot) {
+    return (snapshot.error === undefined &&
+        (snapshot.content === null ||
+            snapshot.content.length <= MAX_STORED_CONTENT_CHARS));
+}
+export function normalizeAssistantEditJournal(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((raw) => {
+        if (!raw || typeof raw !== 'object')
+            return null;
+        const entry = raw;
+        const toolName = String(entry.toolName ?? '');
+        const operation = String(entry.operation ?? '');
+        if (!isEditToolName(toolName))
+            return null;
+        if (operation !== 'create' &&
+            operation !== 'update' &&
+            operation !== 'delete') {
+            return null;
+        }
+        const id = String(entry.id ?? '').trim();
+        const filePath = String(entry.filePath ?? '').trim();
+        const toolCallId = String(entry.toolCallId ?? '').trim();
+        if (!id || !filePath || !toolCallId)
+            return null;
+        return {
+            id,
+            turnId: typeof entry.turnId === 'string' && entry.turnId.trim()
+                ? entry.turnId.trim()
+                : null,
+            toolCallId,
+            toolName,
+            filePath,
+            operation,
+            beforeHash: typeof entry.beforeHash === 'string' && entry.beforeHash
+                ? entry.beforeHash
+                : null,
+            afterHash: typeof entry.afterHash === 'string' && entry.afterHash
+                ? entry.afterHash
+                : null,
+            beforeContent: typeof entry.beforeContent === 'string' ? entry.beforeContent : null,
+            createdAt: typeof entry.createdAt === 'string' && entry.createdAt
+                ? entry.createdAt
+                : new Date().toISOString(),
+            revertedAt: typeof entry.revertedAt === 'string' && entry.revertedAt
+                ? entry.revertedAt
+                : null,
+            revertedByToolCallId: typeof entry.revertedByToolCallId === 'string' &&
+                entry.revertedByToolCallId
+                ? entry.revertedByToolCallId
+                : null,
+            gitWorkTree: entry.gitWorkTree === true,
+        };
+    })
+        .filter(Boolean)
+        .slice(-MAX_EDIT_JOURNAL_RECORDS);
+}
+export function formatRecentAssistantEdits(records, maxItems = 8) {
+    const active = records.filter((record) => !record.revertedAt);
+    if (!active.length)
+        return '';
+    return active
+        .slice(-maxItems)
+        .reverse()
+        .map((record) => {
+        const turn = record.turnId ? `, ${record.turnId}` : '';
+        return `- ${record.id}: ${record.operation} ${record.filePath} via ${record.toolName}${turn}`;
+    })
+        .join('\n');
+}