@lotagate/cli 0.1.22 → 0.1.24

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

@@ -1,160 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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;
-}