@roackb2/heddle 1.1.0 → 1.3.0

package/dist/src/server/features/control-plane/services/chat-sessions.js

@@ -1,651 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { createChatSession, readChatSession, readChatSessionCatalog, saveChatSessions } from '../../../../core/chat/engine/sessions/storage.js';
-import { DEFAULT_OPENAI_MODEL } from '../../../../core/config.js';
-import { credentialModeFromSource, resolveCompatibleActiveModel } from '../../../../core/llm/model-policy.js';
-import { inferProviderFromModel } from '../../../../core/llm/providers.js';
-import { parseUnifiedDiffFiles } from '../../../../core/review/diff-domain.js';
-import { hasProviderCredentialForModel, resolveProviderCredentialSourceForModel } from '../../../../core/runtime/api-keys.js';
-import { buildConversationMessages } from '../../../../core/chat/engine/sessions/conversation-lines.js';
-import { runConversationTurn } from '../../../../core/chat/engine/index.js';
-import { requestToolApproval } from '../../../../core/approvals/surface.js';
-import { createControlPlanePendingApprovalView, createControlPlaneSessionEventPublisher, } from './chat-session-events.js';
-export function createControlPlaneChatSession(args) {
-    const existing = readChatSessionViews(args.sessionStoragePath);
-    const nextNumber = existing.length + 1;
-    const model = resolveControlPlaneSessionCreationModel(args);
-    const credentialRuntime = {
-        preferApiKey: args.preferApiKey,
-        credentialStorePath: args.credentialStorePath,
-    };
-    const session = createChatSession({
-        id: `session-${Date.now()}`,
-        name: args.suggestedName?.trim() || `Session ${nextNumber}`,
-        apiKeyPresent: args.apiKeyPresent ?? hasProviderCredentialForModel(model, credentialRuntime),
-        model,
-        workspaceId: args.workspaceId,
-    });
-    const currentSessions = readChatSessionCatalog(args.sessionStoragePath)
-        .map((entry) => readChatSession(args.sessionStoragePath, entry.id, hasProviderCredentialForModel(model, credentialRuntime)))
-        .filter((candidate) => Boolean(candidate));
-    saveChatSessions(args.sessionStoragePath, [session, ...currentSessions]);
-    return projectChatSessionDetail(session)[0];
-}
-function resolveControlPlaneSessionCreationModel(args) {
-    const activeModel = firstNonEmpty(args.model, process.env.OPENAI_MODEL, process.env.ANTHROPIC_MODEL) ?? DEFAULT_OPENAI_MODEL;
-    const provider = inferProviderFromModel(activeModel);
-    const credentialMode = credentialModeFromSource(resolveProviderCredentialSourceForModel(activeModel, {
-        preferApiKey: args.preferApiKey,
-        credentialStorePath: args.credentialStorePath,
-    }));
-    return resolveCompatibleActiveModel({
-        activeModel,
-        provider,
-        credentialMode,
-    }).model;
-}
-function firstNonEmpty(...values) {
-    return values.find((value) => typeof value === 'string' && value.trim().length > 0);
-}
-export function updateControlPlaneChatSessionSettings(args) {
-    const currentSessions = readChatSessionCatalog(args.sessionStoragePath)
-        .map((entry) => readChatSession(args.sessionStoragePath, entry.id, true))
-        .filter((candidate) => Boolean(candidate));
-    const nextSessions = currentSessions.map((session) => (session.id === args.sessionId ?
-        {
-            ...session,
-            model: args.model ?? session.model,
-            reasoningEffort: args.reasoningEffort === null ? undefined : args.reasoningEffort ?? session.reasoningEffort,
-            driftEnabled: args.driftEnabled ?? session.driftEnabled,
-            updatedAt: new Date().toISOString(),
-        }
-        : session));
-    const updated = nextSessions.find((session) => session.id === args.sessionId);
-    if (!updated) {
-        throw new Error(`Chat session not found: ${args.sessionId}`);
-    }
-    saveChatSessions(args.sessionStoragePath, nextSessions);
-    return projectChatSessionDetail(updated)[0];
-}
-const sessionEventBus = new EventEmitter();
-const pendingApprovals = new Map();
-const inFlightRuns = new Map();
-export async function submitChatPrompt(args) {
-    if (inFlightRuns.has(args.sessionId)) {
-        throw new Error('A run is already in progress for this session.');
-    }
-    if (process.env.HEDDLE_E2E_FAKE_AGENT === '1') {
-        return runFakeE2eSessionPrompt(args);
-    }
-    const controller = new AbortController();
-    inFlightRuns.set(args.sessionId, controller);
-    const events = createControlPlaneSessionEventPublisher({
-        eventBus: sessionEventBus,
-        sessionId: args.sessionId,
-    });
-    try {
-        const result = await runConversationTurn({
-            workspaceRoot: args.workspaceRoot,
-            stateRoot: args.stateRoot,
-            sessionStoragePath: args.sessionStoragePath,
-            traceDir: join(args.stateRoot, 'traces'),
-            sessionId: args.sessionId,
-            prompt: args.continuePrompt ?? args.prompt,
-            apiKey: args.apiKey,
-            preferApiKey: args.preferApiKey,
-            systemContext: args.systemContext,
-            memoryMaintenanceMode: args.memoryMaintenanceMode,
-            abortSignal: controller.signal,
-            leaseOwner: args.leaseOwner,
-            host: {
-                events: {
-                    onAgentLoopEvent: events.hostPort.events?.onAgentLoopEvent,
-                },
-                compaction: {
-                    onPreflightCompactionStatus: events.hostPort.compaction?.onPreflightCompactionStatus,
-                    onFinalCompactionStatus: events.hostPort.compaction?.onFinalCompactionStatus,
-                },
-                approvals: {
-                    requestToolApproval: async ({ call, tool }) => {
-                        const decision = await requestToolApproval({
-                            call,
-                            tool,
-                            createView: createControlPlanePendingApprovalView,
-                            storePending: ({ view, resolve }) => {
-                                pendingApprovals.set(args.sessionId, {
-                                    approval: view,
-                                    resolve,
-                                });
-                            },
-                            publish: (_view, callForEvent) => {
-                                events.publishApprovalRequested(callForEvent);
-                            },
-                        });
-                        pendingApprovals.delete(args.sessionId);
-                        return decision;
-                    },
-                },
-            },
-        });
-        return {
-            ...result,
-            session: projectChatSessionDetail(result.session)[0] ?? null,
-        };
-    }
-    finally {
-        pendingApprovals.delete(args.sessionId);
-        inFlightRuns.delete(args.sessionId);
-    }
-}
-export async function continueChatPrompt(args) {
-    const session = readChatSession(args.sessionStoragePath, args.sessionId, true);
-    if (!session) {
-        throw new Error(`Chat session not found: ${args.sessionId}`);
-    }
-    if (!session.history.length || !session.lastContinuePrompt) {
-        throw new Error('There is no interrupted or prior run to continue yet.');
-    }
-    return await submitChatPrompt({
-        ...args,
-        prompt: 'Continue from where you left off.',
-        continuePrompt: session.lastContinuePrompt,
-    });
-}
-async function runFakeE2eSessionPrompt(args) {
-    const session = readChatSession(args.sessionStoragePath, args.sessionId, true);
-    if (!session) {
-        throw new Error(`Chat session not found: ${args.sessionId}`);
-    }
-    const timestamp = new Date().toISOString();
-    const assistantText = `Mocked E2E agent response: ${args.prompt}`;
-    const nextHistory = [
-        ...session.history,
-        { role: 'user', content: args.prompt },
-        { role: 'assistant', content: assistantText },
-    ];
-    const nextTurn = {
-        id: `e2e-turn-${Date.now()}`,
-        prompt: args.prompt,
-        outcome: 'done',
-        summary: assistantText,
-        steps: 1,
-        traceFile: 'e2e-fake-trace.jsonl',
-        events: ['Mocked E2E session run completed.'],
-    };
-    const updatedSession = {
-        ...session,
-        history: nextHistory,
-        messages: buildConversationMessages(nextHistory),
-        turns: [...session.turns, nextTurn].slice(-8),
-        updatedAt: timestamp,
-        lastContinuePrompt: args.prompt,
-        lease: undefined,
-    };
-    saveChatSessions(args.sessionStoragePath, readChatSessionCatalog(args.sessionStoragePath)
-        .map((entry) => readChatSession(args.sessionStoragePath, entry.id, true))
-        .filter((candidate) => Boolean(candidate))
-        .map((candidate) => candidate.id === session.id ? updatedSession : candidate));
-    sessionEventBus.emit(args.sessionId, {
-        sessionId: args.sessionId,
-        timestamp,
-        event: {
-            type: 'trace',
-            runId: `e2e-${args.sessionId}`,
-            timestamp,
-            event: {
-                type: 'run.finished',
-                outcome: 'done',
-                summary: assistantText,
-                step: 1,
-                timestamp,
-            },
-        },
-    });
-    return {
-        outcome: 'done',
-        summary: assistantText,
-        session: projectChatSessionDetail(updatedSession)[0] ?? null,
-    };
-}
-export function subscribeToControlPlaneSessionEvents(sessionId, listener) {
-    sessionEventBus.on(sessionId, listener);
-    return () => {
-        sessionEventBus.off(sessionId, listener);
-    };
-}
-export function getPendingControlPlaneApproval(sessionId) {
-    return pendingApprovals.get(sessionId)?.approval;
-}
-export function isControlPlaneSessionRunning(sessionId) {
-    return inFlightRuns.has(sessionId);
-}
-export function cancelControlPlaneSessionRun(sessionId) {
-    const controller = inFlightRuns.get(sessionId);
-    if (!controller) {
-        return false;
-    }
-    controller.abort();
-    pendingApprovals.delete(sessionId);
-    return true;
-}
-export function resolvePendingControlPlaneApproval(sessionId, decision) {
-    const pending = pendingApprovals.get(sessionId);
-    if (!pending) {
-        return false;
-    }
-    pendingApprovals.delete(sessionId);
-    pending.resolve(decision);
-    return true;
-}
-export function readChatSessionViews(sessionStoragePath) {
-    return readChatSessionCatalog(sessionStoragePath)
-        .flatMap(projectChatSessionView)
-        .sort((left, right) => (right.updatedAt ?? '').localeCompare(left.updatedAt ?? ''));
-}
-export function readChatSessionDetail(sessionStoragePath, id) {
-    const session = readChatSession(sessionStoragePath, id, true);
-    return session ? projectChatSessionDetail(session)[0] : undefined;
-}
-export function readChatTurnReview(sessionStoragePath, sessionId, turnId) {
-    const session = readChatSessionDetail(sessionStoragePath, sessionId);
-    const turn = session?.turns.find((candidate) => candidate.id === turnId);
-    if (!turn) {
-        return undefined;
-    }
-    return loadChatTurnReview(turn.traceFile);
-}
-export function resolveChatSessionFilePath(stateRoot, sessionId) {
-    return join(stateRoot, 'chat-sessions', `${sessionId}.json`);
-}
-export function projectChatSessionView(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return [];
-    }
-    const candidate = raw;
-    const id = typeof candidate.id === 'string' ? candidate.id : undefined;
-    const name = typeof candidate.name === 'string' ? candidate.name : undefined;
-    if (!id || !name) {
-        return [];
-    }
-    const turns = Array.isArray(candidate.turns) ? candidate.turns : [];
-    const messages = Array.isArray(candidate.messages) ? candidate.messages : [];
-    const lastTurn = readObject(turns.at(-1));
-    const context = readObject(candidate.context);
-    const archives = Array.isArray(candidate.archives) ? candidate.archives.map(readObject).filter(Boolean) : [];
-    const rawCompactionStatus = readString(context?.compactionStatus);
-    const compactionStatus = rawCompactionStatus === 'idle' || rawCompactionStatus === 'running' || rawCompactionStatus === 'failed' ?
-        rawCompactionStatus
-        : undefined;
-    const contextView = context ?
-        omitUndefined({
-            estimatedHistoryTokens: readNumber(context.estimatedHistoryTokens),
-            estimatedRequestTokens: readNumber(context.estimatedRequestTokens),
-            lastRunInputTokens: readNumber(context.lastRunInputTokens),
-            lastRunOutputTokens: readNumber(context.lastRunOutputTokens),
-            lastRunTotalTokens: readNumber(context.lastRunTotalTokens),
-            compactedMessages: readNumber(context.compactedMessages),
-            compactedAt: readString(context.compactedAt),
-            compactionStatus,
-            compactionError: readString(context.compactionError),
-            archiveCount: readNumber(context.archiveCount),
-            currentSummaryPath: readString(context.currentSummaryPath),
-            lastArchivePath: readString(context.lastArchivePath),
-        })
-        : undefined;
-    const archiveViews = archives.flatMap((archive) => {
-        const archiveObject = readObject(archive);
-        if (!archiveObject) {
-            return [];
-        }
-        const id = readString(archiveObject.id);
-        const path = readString(archiveObject.path);
-        const summaryPath = readString(archiveObject.summaryPath);
-        const messageCount = readNumber(archiveObject.messageCount);
-        const createdAt = readString(archiveObject.createdAt);
-        if (!id || !path || !summaryPath || messageCount === undefined || !createdAt) {
-            return [];
-        }
-        return [omitUndefined({
-                id,
-                path,
-                summaryPath,
-                shortDescription: readString(archiveObject.shortDescription),
-                messageCount,
-                createdAt,
-                summaryModel: readString(archiveObject.summaryModel),
-            })];
-    });
-    return [omitUndefined({
-            id,
-            name,
-            workspaceId: readString(candidate.workspaceId),
-            createdAt: readString(candidate.createdAt),
-            updatedAt: readString(candidate.updatedAt),
-            model: readString(candidate.model),
-            reasoningEffort: readReasoningEffort(candidate.reasoningEffort),
-            driftEnabled: typeof candidate.driftEnabled === 'boolean' ? candidate.driftEnabled : undefined,
-            driftLevel: readLatestDriftLevel(turns),
-            messageCount: messages.length,
-            turnCount: turns.length,
-            lastPrompt: readString(lastTurn?.prompt),
-            lastOutcome: readString(lastTurn?.outcome),
-            lastSummary: readString(lastTurn?.summary),
-            context: contextView && Object.keys(contextView).length > 0 ? contextView : undefined,
-            archives: archiveViews.length > 0 ? archiveViews : undefined,
-        })];
-}
-function readReasoningEffort(value) {
-    return value === 'low' || value === 'medium' || value === 'high' || value === 'ultrahigh' ? value : undefined;
-}
-function readLatestDriftLevel(turns) {
-    for (let index = turns.length - 1; index >= 0; index--) {
-        const turn = readObject(turns[index]);
-        const traceFile = readString(turn?.traceFile);
-        const driftLevel = traceFile ? readLatestDriftLevelFromTrace(traceFile) : undefined;
-        if (driftLevel) {
-            return driftLevel;
-        }
-    }
-    return undefined;
-}
-function omitUndefined(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
-}
-function readLatestDriftLevelFromTrace(traceFile) {
-    if (!traceFile || !existsSync(traceFile)) {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(readFileSync(traceFile, 'utf8'));
-        if (!Array.isArray(parsed)) {
-            return undefined;
-        }
-        for (let index = parsed.length - 1; index >= 0; index--) {
-            const event = readObject(parsed[index]);
-            if (event?.type !== 'cyberloop.annotation') {
-                continue;
-            }
-            const driftLevel = readString(event.driftLevel);
-            if (driftLevel === 'unknown' || driftLevel === 'low' || driftLevel === 'medium' || driftLevel === 'high') {
-                return driftLevel;
-            }
-        }
-    }
-    catch {
-        return undefined;
-    }
-    return undefined;
-}
-export function projectChatSessionDetail(raw) {
-    const base = projectChatSessionView(raw)[0];
-    if (!base || !raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return [];
-    }
-    const candidate = raw;
-    const messages = Array.isArray(candidate.messages) ? candidate.messages.flatMap(projectChatSessionMessage) : [];
-    const turns = Array.isArray(candidate.turns) ? candidate.turns.flatMap(projectChatTurnView) : [];
-    return [{
-            ...base,
-            messages,
-            turns,
-            lastContinuePrompt: readString(candidate.lastContinuePrompt),
-        }];
-}
-function projectChatSessionMessage(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return [];
-    }
-    const candidate = raw;
-    const id = readString(candidate.id);
-    const role = candidate.role === 'user' || candidate.role === 'assistant' ? candidate.role : undefined;
-    const text = readString(candidate.text);
-    if (!id || !role || !text) {
-        return [];
-    }
-    return [{
-            id,
-            role,
-            text,
-            isStreaming: readBoolean(candidate.isStreaming),
-            isPending: readBoolean(candidate.isPending),
-        }];
-}
-function projectChatTurnView(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return [];
-    }
-    const candidate = raw;
-    const id = readString(candidate.id);
-    const prompt = readString(candidate.prompt);
-    const outcome = readString(candidate.outcome);
-    const summary = readString(candidate.summary);
-    const traceFile = readString(candidate.traceFile);
-    const steps = readNumber(candidate.steps);
-    const events = Array.isArray(candidate.events) ? candidate.events.filter((event) => typeof event === 'string') : [];
-    if (!id || !prompt || !outcome || !summary || !traceFile || steps === undefined) {
-        return [];
-    }
-    return [{
-            id,
-            prompt,
-            outcome,
-            summary,
-            steps,
-            traceFile,
-            events,
-        }];
-}
-function loadChatTurnReview(traceFile) {
-    if (!traceFile || !existsSync(traceFile)) {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(readFileSync(traceFile, 'utf8'));
-        if (!Array.isArray(parsed)) {
-            return undefined;
-        }
-        const reviewCommands = [];
-        const verificationCommands = [];
-        const mutationCommands = [];
-        const approvals = [];
-        const files = new Map();
-        let diffExcerpt;
-        let finalSummary;
-        for (const entry of parsed) {
-            const event = readObject(entry);
-            const type = readString(event?.type);
-            if (!event || !type) {
-                continue;
-            }
-            if (type === 'tool.result') {
-                const tool = readString(event.tool) ?? 'unknown';
-                const result = readObject(event.result);
-                if (tool === 'edit_file' && readBoolean(result?.ok) === true) {
-                    const output = readObject(result?.output);
-                    const file = projectEditFileReview(output);
-                    if (file) {
-                        addChangedFile(files, file);
-                    }
-                }
-                const output = readObject(result?.output);
-                const evidence = output ? projectCommandEvidence(tool, output) : undefined;
-                if (!evidence) {
-                    continue;
-                }
-                if (isReviewCommand(evidence.command)) {
-                    reviewCommands.push(evidence);
-                    if (!diffExcerpt && /^git diff(?:\s|$)/.test(evidence.command) && evidence.stdout) {
-                        diffExcerpt = evidence.stdout;
-                    }
-                    if (/^git diff(?:\s|$)/.test(evidence.command) && evidence.stdout) {
-                        for (const file of parseGitDiffFiles(evidence.stdout)) {
-                            addChangedFile(files, file);
-                        }
-                    }
-                    continue;
-                }
-                if (isVerificationCommand(evidence.command)) {
-                    verificationCommands.push(evidence);
-                    continue;
-                }
-                if (tool === 'run_shell_mutate') {
-                    mutationCommands.push(evidence);
-                }
-                continue;
-            }
-            if (type === 'tool.call') {
-                const call = readObject(event.call);
-                const tool = readString(call?.tool);
-                if (tool !== 'edit_file') {
-                    continue;
-                }
-                const input = readObject(call?.input);
-                const path = readString(input?.path);
-                mutationCommands.push({
-                    tool,
-                    command: path ? `edit_file ${path}` : 'edit_file',
-                });
-                continue;
-            }
-            if (type === 'tool.approval_resolved') {
-                const call = readObject(event.call);
-                const tool = readString(call?.tool);
-                if (!tool) {
-                    continue;
-                }
-                const input = readObject(call?.input);
-                approvals.push({
-                    tool,
-                    command: readString(input?.command) ?? readString(input?.path),
-                    approved: readBoolean(event.approved) ?? false,
-                    reason: readString(event.reason),
-                    timestamp: readString(event.timestamp),
-                });
-                continue;
-            }
-            if (type === 'run.finished') {
-                finalSummary = readString(event.summary) ?? finalSummary;
-            }
-        }
-        return {
-            traceFile,
-            diffExcerpt,
-            finalSummary,
-            files: [...files.values()],
-            reviewCommands: dedupeEvidence(reviewCommands),
-            verificationCommands: dedupeEvidence(verificationCommands),
-            mutationCommands: dedupeEvidence(mutationCommands),
-            approvals,
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-function projectCommandEvidence(tool, output) {
-    const command = readString(output.command);
-    if (!command) {
-        return undefined;
-    }
-    return {
-        tool,
-        command,
-        exitCode: readNumber(output.exitCode),
-        stdout: normalizeCommandText(readString(output.stdout)),
-        stderr: normalizeCommandText(readString(output.stderr)),
-    };
-}
-function dedupeEvidence(evidence) {
-    const seen = new Set();
-    return evidence.filter((entry) => {
-        const key = `${entry.tool}:${entry.command}`;
-        if (seen.has(key)) {
-            return false;
-        }
-        seen.add(key);
-        return true;
-    });
-}
-function isReviewCommand(command) {
-    return /^git (?:status\b|diff\b|show\b|branch\b|remote\b)/.test(command);
-}
-function isVerificationCommand(command) {
-    return /^(?:yarn|npm|pnpm|bun|vitest|jest|tsx|tsc|go test|cargo test|pytest|ruff|eslint)\b/.test(command);
-}
-function projectEditFileReview(output) {
-    if (!output) {
-        return undefined;
-    }
-    const path = readString(output.path);
-    const diff = readObject(output.diff);
-    const patch = normalizeCommandText(readString(diff?.diff));
-    if (!path) {
-        return undefined;
-    }
-    return {
-        path,
-        status: statusFromEditAction(readString(output.action)),
-        source: 'edit_file',
-        patch,
-        diff: patch ? parseUnifiedDiffFiles(patch).find((file) => file.path === path || file.oldPath === path) : undefined,
-        truncated: readBoolean(diff?.truncated),
-    };
-}
-function statusFromEditAction(action) {
-    switch (action) {
-        case 'created':
-            return 'added';
-        case 'overwritten':
-        case 'replaced':
-            return 'modified';
-        default:
-            return 'unknown';
-    }
-}
-function parseGitDiffFiles(diff) {
-    return parseUnifiedDiffFiles(diff).map((file) => ({
-        path: file.path,
-        status: file.status === 'copied' ? 'modified' : file.status,
-        source: 'git_diff',
-        patch: normalizeCommandText(file.patch),
-        diff: file,
-        truncated: file.binary === true,
-    }));
-}
-function addChangedFile(files, file) {
-    const existing = files.get(file.path);
-    if (!existing) {
-        files.set(file.path, file);
-        return;
-    }
-    if (existing.source === 'edit_file') {
-        return;
-    }
-    if (file.source === 'edit_file' || (!existing.patch && file.patch)) {
-        files.set(file.path, file);
-    }
-}
-function normalizeCommandText(value) {
-    if (!value) {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return undefined;
-    }
-    return trimmed.length > 2400 ? `${trimmed.slice(0, 2399)}…` : trimmed;
-}
-function readObject(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
-}
-function readString(value) {
-    return typeof value === 'string' ? value : undefined;
-}
-function readBoolean(value) {
-    return typeof value === 'boolean' ? value : undefined;
-}
-function readNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
-//# sourceMappingURL=chat-sessions.js.map