@lotagate/cli 0.1.21 → 0.1.22

package/dist/infrastructure/sessions/file-goal-store.js

@@ -0,0 +1,160 @@
+import crypto from 'node:crypto';
+import { CliError } from '../../domain/errors/cli-error.js';
+import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
+import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
+import { addGoalUsage, EMPTY_GOAL_USAGE, isGoalEvaluation, isGoalEventType, isGoalState, validateGoalInput, } from '../../domain/orchestration/goal.js';
+export class FileGoalStore {
+    sessions;
+    constructor(sessions) {
+        this.sessions = sessions;
+    }
+    async get(sessionId) {
+        return reconstructGoal(await this.sessions.readEvents(sessionId));
+    }
+    async create(sessionId, input) {
+        return this.sessions.withLock(sessionId, async () => {
+            const validated = validateGoalInput(input);
+            const current = reconstructGoal(await this.sessions.readEvents(sessionId));
+            if (current?.status === 'active' || current?.status === 'paused')
+                return this.appendState(current, validated, 'goal.replaced');
+            return this.appendState(undefined, validated, 'goal.created', sessionId);
+        });
+    }
+    async replace(sessionId, input) {
+        return this.sessions.withLock(sessionId, async () => this.appendState(undefined, validateGoalInput(input), 'goal.replaced', sessionId));
+    }
+    async pause(sessionId, reason = 'Paused by user.') {
+        return this.sessions.withLock(sessionId, async () => {
+            const state = await this.requireActiveUnlocked(sessionId);
+            const updated = { ...state, status: 'paused', updatedAt: now(), lastError: bound(reason, RESOURCE_LIMITS.goalReasonBytes) };
+            await this.append(updated, 'goal.paused', { reason: updated.lastError }, true);
+            return updated;
+        });
+    }
+    async resume(sessionId) {
+        return this.sessions.withLock(sessionId, async () => {
+            const state = await this.getOrThrowUnlocked(sessionId);
+            if (state.status !== 'paused')
+                throw this.invalidState(`Goal cannot be resumed from ${state.status}.`);
+            const resumedAt = now();
+            const updated = clearLastError({ ...state, status: 'active', startedAt: resumedAt, updatedAt: resumedAt });
+            await this.append(updated, 'goal.resumed', {}, true);
+            return updated;
+        });
+    }
+    async recordTurn(sessionId) {
+        return this.sessions.withLock(sessionId, async () => {
+            const state = await this.requireActiveUnlocked(sessionId);
+            const updated = { ...state, turns: state.turns + 1, updatedAt: now() };
+            await this.append(updated, 'goal.turn.started', {}, true);
+            return updated;
+        });
+    }
+    async recordUsage(sessionId, delta) {
+        return this.sessions.withLock(sessionId, async () => {
+            const state = await this.requireActiveUnlocked(sessionId);
+            const updated = { ...state, usage: addGoalUsage(state.usage, delta), updatedAt: now() };
+            await this.append(updated, 'goal.usage_recorded', {}, true);
+            return updated;
+        });
+    }
+    async recordEvaluation(sessionId, evaluation) {
+        return this.sessions.withLock(sessionId, async () => {
+            const state = await this.requireActiveUnlocked(sessionId);
+            if (!isGoalEvaluation(evaluation))
+                throw this.invalidState('Goal evaluation is invalid.');
+            const status = statusForDecision(evaluation.decision);
+            const normalized = normalizeEvaluation(evaluation);
+            const updated = clearLastError({ ...state, status, evaluatorRuns: state.evaluatorRuns + 1, updatedAt: now(), lastEvaluation: normalized });
+            await this.append(updated, status === 'active' ? 'goal.evaluated' : `goal.${status}`, { evaluation: normalized }, true);
+            return updated;
+        });
+    }
+    async clear(sessionId, reason = 'Cleared by user.') {
+        await this.sessions.withLock(sessionId, async () => {
+            const state = reconstructGoal(await this.sessions.readEvents(sessionId));
+            if (state !== undefined)
+                await this.append(state, 'goal.cleared', { reason: bound(reason, RESOURCE_LIMITS.goalReasonBytes) }, true);
+        });
+    }
+    async requireActiveUnlocked(sessionId) {
+        const state = await this.getOrThrowUnlocked(sessionId);
+        if (state.status !== 'active')
+            throw this.invalidState(`Goal is not active: ${state.status}.`);
+        return state;
+    }
+    async getOrThrowUnlocked(sessionId) {
+        const state = reconstructGoal(await this.sessions.readEvents(sessionId));
+        if (state === undefined)
+            throw new CliError(CLI_ERROR_CODES.GOAL_NOT_FOUND, `Goal not found for session: ${sessionId}`, { category: 'goal', userMessage: 'No goal is configured for this session.' });
+        return state;
+    }
+    invalidState(message) {
+        return new CliError(CLI_ERROR_CODES.GOAL_INVALID_STATE, message, { category: 'goal', userMessage: message });
+    }
+    async appendState(current, input, type, sessionId) {
+        const targetSessionId = current?.sessionId ?? sessionId;
+        if (targetSessionId === undefined)
+            throw this.invalidState('A session id is required to create a goal.');
+        const state = createState(targetSessionId, input);
+        await this.append(state, type, {}, true);
+        return state;
+    }
+    async append(state, type, extra, locked) {
+        await this.sessions.appendEvent({ type, timestamp: now(), sessionId: state.sessionId, data: { goal: serializeState(state), ...extra } }, { locked });
+    }
+}
+function createState(sessionId, input) {
+    const timestamp = now();
+    return {
+        id: crypto.randomUUID(), sessionId, objective: input.objective, status: 'active', createdAt: timestamp,
+        updatedAt: timestamp, startedAt: timestamp, turns: 0, evaluatorRuns: 0, usage: { ...EMPTY_GOAL_USAGE },
+        ...(input.tokenBudget === undefined ? {} : { tokenBudget: input.tokenBudget }),
+        ...(input.maxTurns === undefined ? {} : { maxTurns: input.maxTurns }),
+        ...(input.maxDurationMs === undefined ? {} : { maxDurationMs: input.maxDurationMs }),
+    };
+}
+function reconstructGoal(events) {
+    let state;
+    for (const event of events) {
+        if (!isGoalEventType(event.type))
+            continue;
+        if (event.type === 'goal.cleared') {
+            state = undefined;
+            continue;
+        }
+        const candidate = event.data?.['goal'];
+        if (!isGoalState(candidate))
+            continue;
+        state = candidate;
+        if (event.type === 'goal.evaluated' && event.data?.['evaluation'] !== undefined && isGoalEvaluation(event.data['evaluation']))
+            state = { ...state, lastEvaluation: event.data['evaluation'] };
+    }
+    return state;
+}
+function statusForDecision(decision) {
+    if (decision === 'complete')
+        return 'completed';
+    if (decision === 'blocked')
+        return 'blocked';
+    if (decision === 'budget_limited')
+        return 'budget_limited';
+    if (decision === 'usage_limited')
+        return 'usage_limited';
+    return 'active';
+}
+function normalizeEvaluation(value) {
+    return {
+        decision: value.decision, reason: bound(value.reason, RESOURCE_LIMITS.goalReasonBytes),
+        evidence: value.evidence.slice(0, RESOURCE_LIMITS.goalEvidenceItems).map((item) => bound(item, RESOURCE_LIMITS.goalEvidenceBytes)),
+        timestamp: value.timestamp,
+        ...(value.evaluatorModel === undefined ? {} : { evaluatorModel: bound(value.evaluatorModel, 256) }),
+    };
+}
+function serializeState(state) { return { ...state, objective: bound(state.objective, RESOURCE_LIMITS.goalObjectiveBytes) }; }
+function bound(value, maximum) { return value.length <= maximum ? value : `${value.slice(0, maximum - 3)}...`; }
+function now() { return new Date().toISOString(); }
+function clearLastError(state) {
+    delete state.lastError;
+    return state;
+}

package/dist/infrastructure/sessions/file-session-store.d.ts

@@ -0,0 +1,48 @@
+import type { SessionEvent, SessionMetadata, TranscriptEntry } from '../../domain/session/session.js';
+import type { Attachment } from '../../domain/session/attachment.js';
+import type { SessionStore, SessionBundle, SessionHistory, SessionJournalAppend, SessionRepairResult } from '../../ports/session-store.js';
+import type { PlatformPaths } from '../platform/platform-paths.js';
+export declare class FileSessionStore implements SessionStore {
+    private readonly paths;
+    constructor(paths: PlatformPaths);
+    create(input: Omit<SessionMetadata, 'id' | 'createdAt' | 'updatedAt'>): Promise<SessionMetadata>;
+    get(sessionId: string): Promise<SessionMetadata | undefined>;
+    list(projectFingerprint?: string): Promise<readonly SessionMetadata[]>;
+    updateStatus(sessionId: string, status: SessionMetadata['status']): Promise<SessionMetadata>;
+    rename(sessionId: string, name: string): Promise<SessionMetadata>;
+    appendEvent(event: SessionEvent, options?: {
+        locked?: boolean;
+    }): Promise<void>;
+    appendTranscript(sessionId: string, entry: TranscriptEntry): Promise<void>;
+    appendJournal(sessionId: string, records: readonly SessionJournalAppend[]): Promise<void>;
+    readEvents(sessionId: string): Promise<readonly SessionEvent[]>;
+    readTranscript(sessionId: string): Promise<readonly TranscriptEntry[]>;
+    readHistory(sessionId: string): Promise<SessionHistory>;
+    delete(sessionId: string): Promise<boolean>;
+    fork(sessionId: string, overrides?: Partial<Pick<SessionMetadata, 'model' | 'profile'>>): Promise<SessionMetadata>;
+    compact(sessionId: string, summary: string, options?: {
+        turnId?: string;
+    }): Promise<void>;
+    export(sessionId: string): Promise<SessionBundle>;
+    import(bundle: SessionBundle, projectFingerprint: string, cwd: string): Promise<SessionMetadata>;
+    saveAttachment(sessionId: string, attachment: Attachment, bytes: Uint8Array): Promise<Attachment>;
+    private persistAttachment;
+    readAttachment(sessionId: string, attachmentId: string): Promise<Uint8Array | undefined>;
+    recoverStaleLock(sessionId: string): Promise<boolean>;
+    repair(sessionId: string): Promise<SessionRepairResult>;
+    withLock<T>(sessionId: string, action: () => Promise<T>): Promise<T>;
+    private require;
+    private requirePaths;
+    private locate;
+    private locateByScan;
+    private projectKeys;
+    private readOrRebuildIndex;
+    private indexMatchesJournals;
+    private projectJournalIds;
+    private projectHasJournals;
+    private rebuildProjectIndex;
+    private readSnapshot;
+    private appendJournalLocked;
+    private readAttachmentMetadata;
+    private corrupt;
+}