salmon-loop 0.2.3

package/dist/cli/headless/openai-stream-encoder.js

@@ -0,0 +1,152 @@
+import { randomUUID } from 'crypto';
+import { OpenAiResponsesCanonicalApplier } from './openai-responses-canonical-applier.js';
+import { OpenAiResponsesState, } from './openai-responses-state.js';
+function toEpochSeconds(date) {
+    return Math.floor(date.getTime() / 1000);
+}
+function defaultResponseId() {
+    return `resp_${randomUUID().replace(/-/g, '')}`;
+}
+function defaultItemId() {
+    return `item_${randomUUID().replace(/-/g, '')}`;
+}
+function createResponseObject(params) {
+    const response = {
+        id: params.id,
+        object: 'response',
+        created_at: params.createdAt,
+        output_text: params.outputText,
+        error: params.error,
+        incomplete_details: null,
+        instructions: null,
+        metadata: params.metadata,
+        model: params.model,
+        output: params.output,
+        parallel_tool_calls: true,
+        temperature: null,
+        tool_choice: 'auto',
+        tools: [],
+        top_p: null,
+        status: params.status,
+    };
+    if (typeof params.completedAt === 'number')
+        response.completed_at = params.completedAt;
+    return response;
+}
+function createResponseError(params) {
+    return { code: params.code, message: params.message };
+}
+export class OpenAiStreamEncoder {
+    now;
+    model;
+    responseIdFn;
+    metadata;
+    sequenceNumber = 0;
+    responseId = null;
+    createdAt = null;
+    state;
+    canonicalApplier;
+    constructor(options = {}) {
+        this.now = options.now ?? (() => new Date());
+        this.model = options.model ?? 'unknown';
+        this.responseIdFn = options.responseId ?? defaultResponseId;
+        this.metadata = options.metadata ?? null;
+        this.state = new OpenAiResponsesState(options.itemId ?? defaultItemId);
+        this.canonicalApplier = new OpenAiResponsesCanonicalApplier(this.state);
+    }
+    start() {
+        if (this.responseId)
+            return [];
+        const at = this.now();
+        this.responseId = this.responseIdFn();
+        this.createdAt = toEpochSeconds(at);
+        const response = createResponseObject({
+            id: this.responseId,
+            createdAt: this.createdAt,
+            status: 'in_progress',
+            model: this.model,
+            outputText: '',
+            output: [],
+            error: null,
+            metadata: this.metadata,
+        });
+        return [
+            {
+                type: 'response.created',
+                sequence_number: this.nextSequenceNumber(),
+                response,
+            },
+            {
+                type: 'response.in_progress',
+                sequence_number: this.nextSequenceNumber(),
+                response,
+            },
+        ];
+    }
+    pushResponsesEvent(params) {
+        if (!this.responseId || this.createdAt === null)
+            return [];
+        return this.sequence(this.canonicalApplier.apply(params));
+    }
+    complete(params) {
+        if (!this.responseId || this.createdAt === null)
+            return [];
+        const outputText = this.state.collectOutputText();
+        const completedAt = toEpochSeconds(this.now());
+        const error = params.ok
+            ? null
+            : createResponseError({
+                message: params.message ?? 'Unknown error',
+                code: params.code === 'usage_error' ? 'invalid_prompt' : 'server_error',
+            });
+        const response = createResponseObject({
+            id: this.responseId,
+            createdAt: this.createdAt,
+            status: params.ok ? 'completed' : 'failed',
+            model: this.model,
+            outputText,
+            output: this.state.getOutput(),
+            error,
+            metadata: this.metadata,
+            completedAt: params.ok ? completedAt : undefined,
+        });
+        return this.sequence([
+            { type: params.ok ? 'response.completed' : 'response.failed', response },
+        ]);
+    }
+    crash(error) {
+        const message = error.message || 'Unexpected error';
+        return [
+            ...this.start(),
+            {
+                type: 'error',
+                sequence_number: this.nextSequenceNumber(),
+                code: 'server_error',
+                message,
+                param: null,
+            },
+            ...this.complete({ ok: false, message, code: null }),
+        ];
+    }
+    usageError(params) {
+        const code = params.code ?? 'usage_error';
+        return [
+            ...this.start(),
+            {
+                type: 'error',
+                sequence_number: this.nextSequenceNumber(),
+                code,
+                message: params.message,
+                param: null,
+            },
+            ...this.complete({ ok: false, message: params.message, code }),
+        ];
+    }
+    sequence(events) {
+        return events.map((e) => ({ ...e, sequence_number: this.nextSequenceNumber() }));
+    }
+    nextSequenceNumber() {
+        return this.sequenceNumber++;
+    }
+}
+//# sourceMappingURL=openai-stream-encoder.js.map

package/dist/cli/headless/stdout-writer.js

@@ -0,0 +1,9 @@
+export function createStdoutWriter(options = {}) {
+    const write = options.write ?? ((chunk) => process.stdout.write(chunk));
+    return {
+        write,
+        writeLine: (line) => write(line + '\n'),
+        writeJsonLine: (value) => write(JSON.stringify(value) + '\n'),
+    };
+}
+//# sourceMappingURL=stdout-writer.js.map

package/dist/cli/headless/stream-json-protocol.js

@@ -0,0 +1,136 @@
+import { getExitCode } from '../../core/facades/cli-headless.js';
+function toIso(date) {
+    return date.toISOString();
+}
+function dropUndefined(obj) {
+    const out = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === undefined)
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+function mapLoopEventToJson(event) {
+    const { timestamp: _ts, ...rest } = event;
+    return dropUndefined(rest);
+}
+export function getStreamExitCode(result) {
+    return getExitCode(result);
+}
+function extractParentToolUseId(event) {
+    if (event.type === 'tool.call.start' || event.type === 'tool.call.end')
+        return event.callId;
+    return undefined;
+}
+function encodeEnvelope(params) {
+    return dropUndefined({
+        uuid: params.uuid,
+        session_id: params.sessionId,
+        event: params.event,
+        parent_tool_use_id: params.parentToolUseId,
+    });
+}
+export function encodeStreamStart(params) {
+    return encodeEnvelope({
+        uuid: params.uuid,
+        sessionId: params.sessionId,
+        event: dropUndefined({
+            type: 'start',
+            timestamp: toIso(params.at),
+            command: params.mode,
+            repo_path: params.repoPath,
+            instruction: params.instruction,
+        }),
+    });
+}
+export function encodeStreamEvent(params) {
+    return encodeEnvelope({
+        uuid: params.uuid,
+        sessionId: params.sessionId,
+        parentToolUseId: params.parentToolUseId,
+        event: dropUndefined({
+            ...params.event,
+            timestamp: toIso(params.at),
+        }),
+    });
+}
+export function encodeStreamLoopEvent(params) {
+    const parentToolUseId = extractParentToolUseId(params.event);
+    return encodeEnvelope({
+        uuid: params.uuid,
+        sessionId: params.sessionId,
+        parentToolUseId,
+        event: dropUndefined({
+            ...mapLoopEventToJson(params.event),
+            timestamp: toIso(params.event.timestamp),
+        }),
+    });
+}
+export function encodeStreamResult(params) {
+    const exitCode = getStreamExitCode(params.loopResult);
+    return encodeEnvelope({
+        uuid: params.uuid,
+        sessionId: params.sessionId,
+        event: dropUndefined({
+            type: 'result',
+            timestamp: toIso(params.at),
+            success: Boolean(params.loopResult.success),
+            exit_code: exitCode,
+            reason: params.loopResult.safeHint ?? params.loopResult.reason,
+            reason_code: params.loopResult.reasonCode,
+            diagnostic_code: params.loopResult.diagnosticCode ?? params.loopResult.reasonCode,
+            safe_hint: params.loopResult.safeHint ?? params.loopResult.reason,
+            remediation_steps: params.loopResult.remediationSteps ?? [],
+            attempts: params.loopResult.attempts,
+            changed_files: params.loopResult.changedFiles,
+            audit_path: params.loopResult.auditPath,
+            error_code: params.loopResult.errorCode,
+            authorization_summary: params.loopResult.authorizationSummary,
+            result: params.resultText,
+            run_end: {
+                success: Boolean(params.loopResult.success),
+                exit_code: exitCode,
+                timestamp: toIso(params.at),
+            },
+        }),
+    });
+}
+export function encodeStreamFailure(params) {
+    return encodeEnvelope({
+        uuid: params.uuid,
+        sessionId: params.sessionId,
+        event: {
+            type: 'error',
+            timestamp: toIso(params.at),
+            error: dropUndefined({
+                name: params.name,
+                message: params.message,
+                stack: params.stack,
+            }),
+        },
+    });
+}
+export function encodeStreamCrash(params) {
+    return encodeStreamFailure({
+        uuid: params.uuid,
+        sessionId: params.sessionId,
+        at: params.at,
+        message: params.error.message,
+        name: params.error.name,
+        stack: params.error.stack,
+    });
+}
+export function encodeStreamEnd(params) {
+    return encodeEnvelope({
+        uuid: params.uuid,
+        sessionId: params.sessionId,
+        event: {
+            type: 'end',
+            timestamp: toIso(params.at),
+            success: params.success,
+            exit_code: params.exitCode,
+        },
+    });
+}
+//# sourceMappingURL=stream-json-protocol.js.map

package/dist/cli/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env bun
+// 1. MUST be the very first lines to force all chalk instances (even in node_modules)
+// to use color support before they complete initialization.
+process.env.FORCE_COLOR = '3';
+import 'dotenv/config';
+import { runCli } from './run-cli.js';
+await runCli(process.argv);
+//# sourceMappingURL=index.js.map