@thegitai/cli 1.0.0-beta.1

package/dist/src/session-store.js

@@ -0,0 +1,266 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import { getClientStateDir } from './client-state.js';
+import { normalizeAssistantEditJournal } from './edit-journal.js';
+import { cloneSessionSafetyState, createSessionSafetyState, mergeLocalSessionSafetyState, normalizeSessionSafetyState, } from './session-safety.js';
+import { truncate } from './utils.js';
+const SESSION_STORE_VERSION = 1;
+const MAX_RECENT_SESSIONS = 5;
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value ?? null));
+}
+function normalizeIsoDate(value) {
+    const text = typeof value === 'string' ? value : '';
+    const time = Date.parse(text);
+    return Number.isFinite(time) ? new Date(time).toISOString() : new Date().toISOString();
+}
+function normalizeSessionName(name) {
+    const text = String(name ?? '').trim();
+    if (!text)
+        return null;
+    if (text.length > 120) {
+        throw new Error('Session name must be 120 characters or fewer.');
+    }
+    if (/[\r\n\t]/.test(text)) {
+        throw new Error('Session name cannot contain control whitespace.');
+    }
+    return text;
+}
+function sanitizeOpaqueState(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return cloneJson(value);
+}
+function sanitizeClientState(value) {
+    const raw = value && typeof value === 'object' ? value : {};
+    return {
+        editCounter: Math.max(0, Number.parseInt(String(raw.editCounter ?? 0), 10) || 0),
+        editJournal: normalizeAssistantEditJournal(raw.editJournal),
+        stickyFilePaths: Array.isArray(raw.stickyFilePaths)
+            ? raw.stickyFilePaths.map((item) => String(item ?? '')).filter(Boolean)
+            : [],
+        safety: normalizeSessionSafetyState(raw.safety),
+    };
+}
+function safeSessionFileName(id) {
+    const normalized = String(id ?? '').trim();
+    if (!/^[a-zA-Z0-9_-]+$/.test(normalized)) {
+        throw new Error(`Invalid session id "${id}".`);
+    }
+    return `${normalized}.json`;
+}
+function getSessionBaseDir(env = process.env) {
+    return getClientStateDir(env);
+}
+export function getSessionProjectKey(rootDir) {
+    const resolvedRoot = path.resolve(rootDir);
+    const projectName = path.basename(resolvedRoot).replace(/[^a-zA-Z0-9._-]/g, '_') || 'project';
+    const hash = createHash('sha256')
+        .update(resolvedRoot)
+        .digest('hex')
+        .slice(0, 16);
+    return `${projectName}-${hash}`;
+}
+function getSessionProjectDir(rootDir, env = process.env) {
+    return path.join(getSessionBaseDir(env), 'sessions', 'projects', getSessionProjectKey(rootDir));
+}
+function getSessionPath(rootDir, sessionId, env = process.env) {
+    return path.join(getSessionProjectDir(rootDir, env), safeSessionFileName(sessionId));
+}
+function listSessionFiles(rootDir, env = process.env) {
+    const dir = getSessionProjectDir(rootDir, env);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name.endsWith('.json'))
+        .map((name) => path.join(dir, name));
+}
+function normalizeHistory(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => entry &&
+        typeof entry === 'object' &&
+        typeof entry.role === 'string' &&
+        Array.isArray(entry.parts));
+}
+function normalizeSnapshot(raw, rootDir) {
+    if (!raw || typeof raw !== 'object') {
+        throw new Error('Session file is not valid JSON object data.');
+    }
+    if (raw.version !== SESSION_STORE_VERSION) {
+        throw new Error(`Unsupported session file version "${raw.version}".`);
+    }
+    const id = String(raw.id ?? '').trim();
+    safeSessionFileName(id);
+    const modelId = Number(raw.modelId);
+    if (!Number.isInteger(modelId) || modelId <= 0) {
+        throw new Error(`Session "${id}" is missing modelId.`);
+    }
+    return {
+        version: SESSION_STORE_VERSION,
+        id,
+        name: normalizeSessionName(raw.name ?? null),
+        rootDir: path.resolve(rootDir),
+        projectKey: getSessionProjectKey(rootDir),
+        createdAt: normalizeIsoDate(raw.createdAt),
+        updatedAt: normalizeIsoDate(raw.updatedAt),
+        modelId,
+        history: cloneJson(normalizeHistory(raw.history)),
+        clientState: sanitizeClientState(raw.clientState),
+        serverState: sanitizeOpaqueState(raw.serverState),
+    };
+}
+function loadSnapshotFile(filePath, rootDir) {
+    return normalizeSnapshot(JSON.parse(readFileSync(filePath, 'utf-8')), rootDir);
+}
+function loadAllSnapshots(rootDir, env = process.env) {
+    const snapshots = [];
+    for (const filePath of listSessionFiles(rootDir, env)) {
+        try {
+            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));
+}
+function writeSnapshot(snapshot, env = process.env) {
+    const dir = getSessionProjectDir(snapshot.rootDir, env);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const filePath = getSessionPath(snapshot.rootDir, snapshot.id, env);
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    writeFileSync(tempPath, `${JSON.stringify(snapshot, null, 2)}\n`, {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+    renameSync(tempPath, filePath);
+}
+function assertSessionNameAvailable(rootDir, name, sessionId, env = process.env) {
+    if (!name)
+        return;
+    const duplicate = loadAllSnapshots(rootDir, env).find((snapshot) => snapshot.name === name && snapshot.id !== sessionId);
+    if (duplicate) {
+        throw new Error(`Session name "${name}" is already used by ${duplicate.id}. Use --session "${name}" to resume it or choose a different name.`);
+    }
+}
+export function pruneSavedSessions(rootDir, env = process.env) {
+    const snapshots = loadAllSnapshots(rootDir, env);
+    const keep = new Set(snapshots.slice(0, MAX_RECENT_SESSIONS).map((snapshot) => snapshot.id));
+    for (const snapshot of snapshots.slice(MAX_RECENT_SESSIONS)) {
+        if (!keep.has(snapshot.id)) {
+            rmSync(getSessionPath(rootDir, snapshot.id, env), { force: true });
+        }
+    }
+}
+export function snapshotFromSession(session) {
+    const now = new Date().toISOString();
+    const createdAt = normalizeIsoDate(session.sessionCreatedAt ?? now);
+    session.sessionCreatedAt = createdAt;
+    session.sessionUpdatedAt = now;
+    return {
+        version: SESSION_STORE_VERSION,
+        id: session.sessionId,
+        name: normalizeSessionName(session.sessionName ?? null),
+        rootDir: path.resolve(session.rootDir),
+        projectKey: getSessionProjectKey(session.rootDir),
+        createdAt,
+        updatedAt: now,
+        modelId: session.modelId,
+        history: cloneJson(session.history),
+        clientState: {
+            editCounter: session.clientState.editCounter,
+            editJournal: normalizeAssistantEditJournal(session.clientState.editJournal),
+            stickyFilePaths: Array.from(session.clientState.stickyFilePaths),
+            safety: cloneSessionSafetyState(session.clientState.safety ?? createSessionSafetyState()),
+        },
+        serverState: sanitizeOpaqueState(session.serverState),
+    };
+}
+export function saveSessionState(session, env = process.env) {
+    const snapshot = snapshotFromSession(session);
+    assertSessionNameAvailable(snapshot.rootDir, snapshot.name, snapshot.id, env);
+    writeSnapshot(snapshot, env);
+    pruneSavedSessions(snapshot.rootDir, env);
+    return snapshot;
+}
+export function applySessionSnapshot(session, snapshot, options = {}) {
+    const currentAgentMode = session.agentMode;
+    session.sessionId = snapshot.id;
+    session.sessionName = snapshot.name;
+    session.sessionCreatedAt = snapshot.createdAt;
+    session.sessionUpdatedAt = snapshot.updatedAt;
+    session.modelId = Number(options.modelOverride ?? snapshot.modelId);
+    session.history = cloneJson(snapshot.history);
+    session.serverState = sanitizeOpaqueState(snapshot.serverState);
+    session.agentMode = options.preserveAgentMode ? currentAgentMode : 'default';
+    session.autoYes = session.agentMode === 'auto-accept';
+    session.turnState = {
+        id: null,
+        historyStartIndex: session.history.length,
+        retrievedFilePaths: [],
+        injectedContext: '',
+        userInput: '',
+    };
+    session.clientState = {
+        stickyFilePaths: new Set(snapshot.clientState.stickyFilePaths),
+        editJournal: normalizeAssistantEditJournal(snapshot.clientState.editJournal),
+        editCounter: Math.max(0, snapshot.clientState.editCounter ?? 0),
+        safety: mergeLocalSessionSafetyState(session.clientState.safety, snapshot.clientState.safety),
+    };
+}
+function extractMarkedSection(text, marker) {
+    const index = text.indexOf(marker);
+    if (index === -1)
+        return '';
+    const after = text.slice(index + marker.length).trimStart();
+    const end = after.indexOf('\n\n');
+    return (end === -1 ? after : after.slice(0, end)).trim();
+}
+function extractLastUserMessage(history) {
+    for (let i = history.length - 1; i >= 0; i--) {
+        const entry = history[i];
+        if (!entry || entry.role !== 'user')
+            continue;
+        const text = (entry.parts ?? [])
+            .map((part) => (typeof part?.text === 'string' ? part.text : ''))
+            .filter(Boolean)
+            .join('\n')
+            .trim();
+        if (!text)
+            continue;
+        const request = extractMarkedSection(text, 'Current user request:') ||
+            extractMarkedSection(text, 'User request:');
+        const message = extractMarkedSection(text, 'Current user message:') ||
+            extractMarkedSection(text, 'User message:');
+        return truncate(request || message || text, 120);
+    }
+    return '';
+}
+function metadataFromSnapshot(snapshot) {
+    return {
+        id: snapshot.id,
+        name: snapshot.name,
+        rootDir: snapshot.rootDir,
+        createdAt: snapshot.createdAt,
+        updatedAt: snapshot.updatedAt,
+        modelId: snapshot.modelId,
+        messageCount: snapshot.history.length,
+        lastUserMessage: extractLastUserMessage(snapshot.history),
+        summaryPreview: '',
+    };
+}
+export function listSessionMetadata(rootDir, env = process.env) {
+    return loadAllSnapshots(rootDir, env).map(metadataFromSnapshot);
+}
+export function loadSessionSnapshot(rootDir, identifier, env = process.env) {
+    const target = String(identifier ?? '').trim();
+    if (!target)
+        return null;
+    const snapshots = loadAllSnapshots(rootDir, env);
+    return (snapshots.find((snapshot) => snapshot.id === target) ??
+        snapshots.find((snapshot) => snapshot.name === target) ??
+        null);
+}

package/dist/src/session.js

@@ -0,0 +1,93 @@
+import path from 'node:path';
+import { normalizeAgentMode, } from './agent-mode.js';
+import { createSessionSafetyState, } from './session-safety.js';
+import { clampInteger } from './utils.js';
+const DEFAULT_MAX_TOOL_STEPS = 32;
+function defaultStatus(message) {
+    if (message.trim()) {
+        console.log(message);
+    }
+}
+function defaultContextLog(message) {
+    if (message.trim()) {
+        console.log(message);
+    }
+}
+function createSessionId() {
+    return `session_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+}
+function cloneOpaqueState(value) {
+    if (!value || typeof value !== 'object') {
+        return {};
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+function preserveProviderSelection(serverState) {
+    const clone = cloneOpaqueState(serverState);
+    const providerSelection = clone.providerSelection &&
+        typeof clone.providerSelection === 'object' &&
+        !Array.isArray(clone.providerSelection)
+        ? clone.providerSelection
+        : null;
+    return providerSelection ? { providerSelection } : {};
+}
+export function createSession({ rootDir, autoYes = false, agentMode, modelId, maxToolSteps = DEFAULT_MAX_TOOL_STEPS, confirmCommand = null, confirmPatch = null, requestSudoPassword = null, onStatus = null, onContextLog = null, onToolEvent = null, env = process.env, sessionId = createSessionId(), sessionName = null, history = [], serverState = null, editJournal = [], stickyFilePaths = [], editCounter = 0, safety = createSessionSafetyState(), }) {
+    const createdAt = new Date().toISOString();
+    const initialAgentMode = normalizeAgentMode(agentMode ?? (autoYes ? 'auto-accept' : 'default'));
+    return {
+        rootDir: path.resolve(rootDir),
+        env,
+        autoYes: initialAgentMode === 'auto-accept',
+        agentMode: initialAgentMode,
+        maxToolSteps: clampInteger(maxToolSteps, DEFAULT_MAX_TOOL_STEPS, 128),
+        onStatus: onStatus ?? defaultStatus,
+        onContextLog: onContextLog ?? defaultContextLog,
+        onToolEvent,
+        confirmCommand,
+        confirmPatch,
+        requestSudoPassword,
+        history: JSON.parse(JSON.stringify(history)),
+        initialized: true,
+        sessionId,
+        sessionName,
+        sessionCreatedAt: createdAt,
+        sessionUpdatedAt: createdAt,
+        modelId: Number(modelId),
+        turnState: {
+            id: null,
+            historyStartIndex: history.length,
+            retrievedFilePaths: [],
+            injectedContext: '',
+            userInput: '',
+        },
+        clientState: {
+            stickyFilePaths: new Set(stickyFilePaths),
+            editJournal: [...editJournal],
+            editCounter: Math.max(0, editCounter),
+            safety,
+        },
+        serverState: cloneOpaqueState(serverState),
+    };
+}
+export function clearConversation(session) {
+    session.history = [];
+    session.serverState = preserveProviderSelection(session.serverState);
+    session.turnState = {
+        id: null,
+        historyStartIndex: 0,
+        retrievedFilePaths: [],
+        injectedContext: '',
+        userInput: '',
+    };
+    session.clientState = {
+        stickyFilePaths: new Set(),
+        editJournal: [],
+        editCounter: 0,
+        safety: createSessionSafetyState(),
+    };
+}
+export async function disposeSession(_session) { }
+export function switchModel(session, modelId) {
+    session.modelId = Number(modelId);
+    return { id: session.modelId };
+}

package/dist/src/tool-executor.js

@@ -0,0 +1,188 @@
+import { canStoreEditSnapshot, isEditToolName, isGitWorkTree, MAX_EDIT_JOURNAL_RECORDS, operationFromSnapshots, readFileEditSnapshot, } from './edit-journal.js';
+import { clearEditFailure, collectCommandMutations, captureMutationBaseline, ensureActiveCheckpoint, recordEditFailure, recordSessionEdit, rememberCheckpointFiles, } from './session-safety.js';
+import { buildAgentModeToolBlockedResult, } from './agent-mode.js';
+import { dispatchTool } from './tools/index.js';
+import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './tools/shell-diagnostics.js';
+const EDIT_FILE_PATH_ARG_ALIASES = [
+    'filePath',
+    'file_path',
+    'filepath',
+    'path',
+    'file',
+    'filename',
+];
+function toolCallSummary(call) {
+    const args = call.args && typeof call.args === 'object' ? call.args : {};
+    if (call.name === 'run_command') {
+        return String(args.command ?? args.cmd ?? '').trim();
+    }
+    if (call.name === 'run_node_script') {
+        return String(args.script ?? '').trim().slice(0, 120);
+    }
+    const filePath = getEditToolFilePath(call);
+    if (filePath)
+        return filePath;
+    if (typeof args.query === 'string')
+        return args.query.slice(0, 120);
+    return '';
+}
+export function formatToolCallForStatus(call) {
+    const summary = toolCallSummary(call);
+    return summary ? `Tool: ${call.name} ${summary}` : `Tool: ${call.name}`;
+}
+function getEditToolFilePath(call) {
+    const args = call.args && typeof call.args === 'object' ? call.args : {};
+    for (const key of EDIT_FILE_PATH_ARG_ALIASES) {
+        const value = args[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return '';
+}
+function recordAssistantEdit(session, call, result, before) {
+    if (!before || !isEditToolName(call.name))
+        return;
+    if (!result || typeof result !== 'object' || result.ok !== true) {
+        const filePath = getEditToolFilePath(call);
+        if (filePath && result?.error) {
+            const failure = recordEditFailure(session.clientState.safety, filePath, call.name, String(result.error));
+            if (failure && failure.count >= 2) {
+                result.staleViewEscalation = {
+                    filePath,
+                    failedEditAttempts: failure.count,
+                    action: 'Re-read the full file and inspect diagnostics before retrying this edit.',
+                };
+            }
+        }
+        return;
+    }
+    const filePath = String(result.filePath ?? getEditToolFilePath(call)).trim();
+    if (!filePath)
+        return;
+    const after = readFileEditSnapshot(session.rootDir, filePath);
+    if (before.error || after.error)
+        return;
+    const operation = operationFromSnapshots(before, after);
+    if (!operation || !canStoreEditSnapshot(before))
+        return;
+    if ((operation === 'update' || operation === 'delete') && before.content === null) {
+        return;
+    }
+    const id = `edit_${++session.clientState.editCounter}`;
+    session.clientState.editJournal.push({
+        id,
+        turnId: session.turnState.id,
+        toolCallId: call.id,
+        toolName: call.name,
+        filePath,
+        operation,
+        beforeHash: before.hash,
+        afterHash: after.hash,
+        beforeContent: operation === 'create' ? null : before.content,
+        createdAt: new Date().toISOString(),
+        revertedAt: null,
+        revertedByToolCallId: null,
+        gitWorkTree: isGitWorkTree(session.rootDir),
+    });
+    if (session.clientState.editJournal.length > MAX_EDIT_JOURNAL_RECORDS) {
+        session.clientState.editJournal.splice(0, session.clientState.editJournal.length - MAX_EDIT_JOURNAL_RECORDS);
+    }
+    const checkpoint = ensureActiveCheckpoint(session.clientState.safety, session.turnState.id);
+    recordSessionEdit(session.clientState.safety, {
+        kind: 'tool_edit',
+        turnId: session.turnState.id,
+        toolCallId: call.id,
+        toolName: call.name,
+        filePath,
+        operation,
+        beforeHash: before.hash,
+        afterHash: after.hash,
+        beforeContent: operation === 'create' ? null : before.content,
+        checkpointId: checkpoint.id,
+    });
+    clearEditFailure(session.clientState.safety, filePath);
+}
+export async function executeLocalToolCall(toolContext, session, call) {
+    session.onStatus(formatToolCallForStatus(call));
+    try {
+        const agentModeBlocked = buildAgentModeToolBlockedResult(session.agentMode, call);
+        if (agentModeBlocked) {
+            const result = agentModeBlocked;
+            session.onToolEvent?.({ call, result });
+            return result;
+        }
+        const filePathBeforeEdit = isEditToolName(call.name) ? getEditToolFilePath(call) : '';
+        if (filePathBeforeEdit) {
+            rememberCheckpointFiles(session.clientState.safety, session.rootDir, [filePathBeforeEdit], session.turnState.id);
+        }
+        const beforeEditSnapshot = filePathBeforeEdit
+            ? readFileEditSnapshot(session.rootDir, filePathBeforeEdit)
+            : null;
+        const commandTracker = call.name === 'run_command' || call.name === 'run_node_script'
+            ? captureMutationBaseline(session.rootDir)
+            : null;
+        const context = {
+            rootDir: session.rootDir,
+            projectIndex: toolContext.projectIndex,
+            autoYes: session.autoYes,
+            confirmCommand: session.confirmCommand,
+            confirmPatch: session.confirmPatch,
+            requestSudoPassword: session.requestSudoPassword,
+            onStatus: session.onStatus,
+            editJournal: session.clientState.editJournal,
+            safety: session.clientState.safety,
+            currentTurnId: session.turnState.id,
+            currentToolCallId: call.id,
+            env: session.env,
+            markEditReverted: (editId, toolCallId) => {
+                const record = session.clientState.editJournal.find((entry) => entry.id === editId);
+                if (record) {
+                    record.revertedAt = new Date().toISOString();
+                    record.revertedByToolCallId = toolCallId;
+                }
+            },
+        };
+        const result = await dispatchTool(context, call);
+        recordAssistantEdit(session, call, result, beforeEditSnapshot);
+        if (result && commandTracker && (call.name === 'run_command' || call.name === 'run_node_script')) {
+            const checkpoint = ensureActiveCheckpoint(session.clientState.safety, session.turnState.id);
+            const records = collectCommandMutations({
+                state: session.clientState.safety,
+                rootDir: session.rootDir,
+                tracker: commandTracker,
+                toolName: call.name,
+                toolCallId: call.id,
+                turnId: session.turnState.id,
+                checkpointId: checkpoint.id,
+            });
+            if (records.length) {
+                invalidateShellDiagnosticsCache(session.rootDir);
+                rememberCheckpointFiles(session.clientState.safety, session.rootDir, records.map((record) => record.filePath), session.turnState.id);
+                result.sessionEdits = records.map((record) => ({
+                    id: record.id,
+                    filePath: record.filePath,
+                    operation: record.operation,
+                    beforeHash: record.beforeHash,
+                    afterHash: record.afterHash,
+                }));
+                result.diagnostics = runShellDiagnostics(session.rootDir);
+            }
+        }
+        session.onToolEvent?.({ call, result });
+        return result;
+    }
+    catch (error) {
+        const result = {
+            ok: false,
+            failureCategory: 'tool_exception',
+            failureDetails: {
+                category: 'tool_exception',
+                tool: call.name,
+                action: 'Retry with corrected parameters or report the tool exception if it persists.',
+            },
+            error: error instanceof Error ? error.message : String(error),
+        };
+        session.onToolEvent?.({ call, result });
+        return result;
+    }
+}