salmon-loop 0.2.3

package/dist/cli/reporters/anthropic-stream.js

@@ -0,0 +1,77 @@
+import { randomUUID } from 'crypto';
+import { StreamAssembler, } from '../../core/facades/cli-reporters.js';
+import { encodeNormalizedToAnthropicStreamLines } from '../headless/anthropic-stream-normalized-encoder.js';
+import { encodeAnthropicEnd, encodeAnthropicError, encodeAnthropicResult, encodeAnthropicStart, } from '../headless/anthropic-stream-protocol.js';
+import { createStdoutWriter } from '../headless/stdout-writer.js';
+export class AnthropicStreamReporter {
+    mode;
+    repoPath;
+    sessionId;
+    writer;
+    lastTextResult;
+    assembler = new StreamAssembler();
+    constructor(options = {}) {
+        this.mode = options.mode ?? 'run';
+        this.repoPath = options.repoPath;
+        this.sessionId = options.sessionId ?? randomUUID();
+        this.writer = options.writer ?? createStdoutWriter();
+    }
+    onStart(instruction) {
+        this.emit(encodeAnthropicStart({
+            sessionId: this.sessionId,
+            mode: this.mode,
+            repoPath: this.repoPath,
+            instruction,
+        }));
+    }
+    onEvent(event) {
+        if (event.type === 'llm.output' &&
+            event.kind === 'assistant_message' &&
+            event.step === 'REPORT') {
+            this.lastTextResult = event.content;
+        }
+        if (event.type === 'tool.call.start' ||
+            event.type === 'tool.call.end' ||
+            event.type === 'llm.responses.event' ||
+            event.type === 'llm.stream.delta' ||
+            event.type === 'llm.stream.end') {
+            const normalized = this.assembler.push(event);
+            for (const normalizedEvent of normalized) {
+                const lines = encodeNormalizedToAnthropicStreamLines({
+                    sessionId: this.sessionId,
+                    event: normalizedEvent,
+                });
+                for (const line of lines)
+                    this.emit(line);
+            }
+            return;
+        }
+    }
+    onFinish(result) {
+        this.emit(encodeAnthropicResult({
+            sessionId: this.sessionId,
+            loopResult: result,
+            resultText: this.lastTextResult,
+        }));
+        this.emit(encodeAnthropicEnd({
+            sessionId: this.sessionId,
+            loopResult: result,
+        }));
+    }
+    onError(error) {
+        this.emit(encodeAnthropicError({
+            sessionId: this.sessionId,
+            message: error.message,
+            name: error.name,
+            stack: error.stack,
+        }));
+        this.emit(encodeAnthropicEnd({
+            sessionId: this.sessionId,
+            loopResult: { success: false, reason: error.message },
+        }));
+    }
+    emit(line) {
+        this.writer.writeJsonLine(line);
+    }
+}
+//# sourceMappingURL=anthropic-stream.js.map

package/dist/cli/reporters/base.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=base.js.map

package/dist/cli/reporters/json.js

@@ -0,0 +1,69 @@
+import { randomUUID } from 'crypto';
+import { encodeJsonCrash, encodeJsonResult } from '../headless/json-protocol.js';
+import { createStdoutWriter } from '../headless/stdout-writer.js';
+export class JsonReporter {
+    mode;
+    repoPath;
+    sessionId;
+    getStructuredOutput;
+    getPayloadOverrides;
+    now;
+    writer;
+    startedAt = null;
+    instruction;
+    lastTextResult;
+    constructor(options = {}) {
+        this.mode = options.mode ?? 'run';
+        this.repoPath = options.repoPath;
+        this.sessionId = options.sessionId ?? randomUUID();
+        this.getStructuredOutput = options.getStructuredOutput;
+        this.getPayloadOverrides = options.getPayloadOverrides;
+        this.now = options.now ?? (() => new Date());
+        this.writer = options.writer ?? createStdoutWriter();
+    }
+    onStart(instruction) {
+        this.startedAt = this.now();
+        this.instruction = instruction;
+    }
+    onEvent(event) {
+        if (event.type === 'llm.output' &&
+            event.kind === 'assistant_message' &&
+            event.step === 'REPORT') {
+            this.lastTextResult = event.content;
+        }
+    }
+    onFinish(result) {
+        const endedAt = this.now();
+        const startedAt = this.startedAt ?? endedAt;
+        const overrides = this.getPayloadOverrides?.();
+        const structuredOutput = this.getStructuredOutput?.() ?? null;
+        const payload = encodeJsonResult({
+            mode: this.mode,
+            repoPath: this.repoPath,
+            sessionId: this.sessionId,
+            instruction: this.instruction,
+            startedAt,
+            endedAt,
+            resultText: this.lastTextResult ?? '',
+            structuredOutput,
+            loopResult: result,
+            overrides,
+        });
+        this.writer.writeJsonLine(payload);
+    }
+    onError(error) {
+        const endedAt = this.now();
+        const startedAt = this.startedAt ?? endedAt;
+        const payload = encodeJsonCrash({
+            mode: this.mode,
+            repoPath: this.repoPath,
+            sessionId: this.sessionId,
+            instruction: this.instruction,
+            startedAt,
+            endedAt,
+            error,
+        });
+        this.writer.writeJsonLine(payload);
+    }
+}
+//# sourceMappingURL=json.js.map

package/dist/cli/reporters/openai-stream.js

@@ -0,0 +1,72 @@
+import { OpenAiStreamEncoder, } from '../headless/openai-stream-encoder.js';
+import { createStdoutWriter } from '../headless/stdout-writer.js';
+export class OpenAiStreamReporter {
+    writer;
+    encoder;
+    sawOutputTextDelta = false;
+    reportText = null;
+    constructor(options = {}) {
+        this.writer = options.writer ?? createStdoutWriter();
+        this.encoder = new OpenAiStreamEncoder(options);
+    }
+    onStart(_instruction) {
+        for (const line of this.encoder.start())
+            this.emit(line);
+    }
+    onEvent(event) {
+        if (event.type === 'llm.output' &&
+            event.kind === 'assistant_message' &&
+            event.step === 'REPORT') {
+            this.reportText = { text: event.content, timestamp: event.timestamp };
+            return;
+        }
+        if (event.type === 'llm.responses.event') {
+            if (event.event.type === 'response.output_text.delta')
+                this.sawOutputTextDelta = true;
+            const lines = this.encoder.pushResponsesEvent({
+                streamId: event.streamId,
+                event: event.event,
+            });
+            for (const line of lines)
+                this.emit(line);
+            return;
+        }
+    }
+    onFinish(result) {
+        const ok = Boolean(result.success);
+        const message = result.reason || (ok ? undefined : 'Unknown error');
+        const code = result.errorCode ?? null;
+        if (!this.sawOutputTextDelta && this.reportText) {
+            const events = createReportOnlyCanonicalEvents(this.reportText.text);
+            for (const event of events) {
+                const lines = this.encoder.pushResponsesEvent({ streamId: 'report', event });
+                for (const line of lines)
+                    this.emit(line);
+            }
+        }
+        for (const line of this.encoder.complete({ ok, message, code }))
+            this.emit(line);
+    }
+    onError(error) {
+        for (const line of this.encoder.crash(error))
+            this.emit(line);
+    }
+    emit(value) {
+        this.writer.writeJsonLine(value);
+    }
+}
+function createReportOnlyCanonicalEvents(text) {
+    return [
+        { type: 'response.output_text.delta', delta: text },
+        { type: 'response.output_text.done', text },
+        {
+            type: 'response.content_part.done',
+            part: { type: 'output_text', text, annotations: [] },
+        },
+        {
+            type: 'response.output_item.done',
+            item: { type: 'message', role: 'assistant', content: [] },
+        },
+    ];
+}
+//# sourceMappingURL=openai-stream.js.map

package/dist/cli/reporters/standard.js

@@ -0,0 +1,226 @@
+import chalk from 'chalk';
+import ProgressBar from 'progress';
+import { ALL_VISIBLE_STEPS, ErrorType, getLogger, mapErrorForDisplay, Phase, } from '../../core/facades/cli-reporters.js';
+import { text } from '../locales/index.js';
+export class StandardReporter {
+    verbose;
+    bar = null;
+    lastAuthorizationSummary;
+    lastStreamId;
+    constructor(verbose = false) {
+        this.verbose = verbose;
+    }
+    onStart(_instruction) {
+        this.initProgressBar();
+    }
+    onEvent(event) {
+        if (!this.bar)
+            this.initProgressBar();
+        switch (event.type) {
+            case 'phase.start': {
+                const phaseKey = event.phase.toLowerCase();
+                const phaseName = text.progress[phaseKey] || event.phase;
+                this.bar?.render({ phase: phaseName });
+                getLogger().step(event.phase, phaseName);
+                break;
+            }
+            case 'phase.end': {
+                const phaseKey = event.phase.toLowerCase();
+                const phaseName = text.progress[phaseKey] || event.phase;
+                this.bar?.tick(1, { phase: phaseName });
+                break;
+            }
+            case 'log':
+                this.handleLogEvent(event);
+                break;
+            case 'authorization.summary': {
+                const summary = this.formatAuthorizationSummary(event.summary);
+                if (summary !== this.lastAuthorizationSummary) {
+                    getLogger().info(text.cli.authorizationSummaryRealtime(summary));
+                    this.lastAuthorizationSummary = summary;
+                }
+                break;
+            }
+            case 'verify.result':
+                if (!event.ok) {
+                    getLogger().error('\n' + text.cli.operationFailed);
+                    getLogger().debug(event.output);
+                }
+                break;
+            case 'diff.meta':
+                getLogger().success(text.cli.diffMeta(event.fileCount, event.lineCount));
+                break;
+            case 'retry':
+                getLogger().warn(text.cli.retry(event.fromAttempt, event.toAttempt, event.reason.substring(0, 100) + '...'));
+                this.bar?.terminate();
+                this.initProgressBar();
+                break;
+            case 'llm.stream.delta': {
+                const delta = event.content;
+                const shouldPrint = delta.length > 0 && (delta.trim().length > 0 || delta.includes('\n'));
+                if (shouldPrint) {
+                    if (event.streamId !== this.lastStreamId) {
+                        this.lastStreamId = event.streamId;
+                        const header = this.renderPhaseLabel(event.step);
+                        if (this.bar) {
+                            this.bar.interrupt(header);
+                        }
+                        else {
+                            getLogger().log(header);
+                        }
+                    }
+                    if (this.bar) {
+                        this.bar.interrupt(delta);
+                    }
+                    else {
+                        process.stdout.write(delta);
+                    }
+                }
+                break;
+            }
+            case 'llm.output': {
+                const header = this.renderPhaseLabel(event.step);
+                if (this.bar) {
+                    this.bar.interrupt(header);
+                    this.bar.interrupt(event.content);
+                }
+                else {
+                    getLogger().log(header);
+                    getLogger().log(event.content);
+                }
+                break;
+            }
+        }
+    }
+    onFinish(result) {
+        this.bar?.terminate();
+        if (result.success) {
+            getLogger().success(text.cli.operationSuccess);
+            getLogger().log(text.cli.attempts(result.attempts));
+        }
+        else {
+            this.handleFailure(result);
+        }
+        if (result.authorizationSummary) {
+            const summary = this.formatAuthorizationSummary(result.authorizationSummary);
+            getLogger().info(text.cli.authorizationSummary(summary));
+        }
+        if (result.budgetSummary) {
+            const s = result.budgetSummary;
+            getLogger().info(text.cli.budgetSummaryTitle);
+            getLogger().info(text.cli.budgetSummaryLine(s.attemptCount, s.adjustmentCount, s.alertCount, s.criticalDropCount, Math.round(s.avgUtilization * 100), Math.round(s.truncationRate * 100), Math.round(s.successRate * 100)));
+        }
+        if (this.verbose && result.logs) {
+            getLogger().log('\n' + chalk.bold(text.cli.stepLogs));
+            result.logs.forEach((log) => {
+                const symbol = log.success
+                    ? chalk.green(text.symbols.success)
+                    : chalk.red(text.symbols.error);
+                getLogger().log(`${symbol} [${chalk.blue(log.step.toUpperCase())}] ${log.output}`);
+            });
+        }
+    }
+    onError(error) {
+        getLogger().error(text.cli.unexpectedError(error.message), true);
+    }
+    initProgressBar() {
+        // 🛡️ DCAP Defense: Check if stderr supports TTY operations to prevent clearLine crashes and unexpected termination
+        const stream = process.stderr;
+        if (typeof stream.clearLine !== 'function' || typeof stream.cursorTo !== 'function') {
+            this.bar = {
+                render: () => { },
+                tick: () => { },
+                terminate: () => { },
+                interrupt: (msg) => getLogger().info(msg),
+            };
+            return;
+        }
+        this.bar = new ProgressBar(`${chalk.blue('[:bar]')} :phase :percent :elapseds`, {
+            total: ALL_VISIBLE_STEPS.length,
+            width: 20,
+            complete: '=',
+            incomplete: ' ',
+        });
+    }
+    renderPhaseLabel(step) {
+        const phaseKey = step.toLowerCase();
+        const phaseName = text.progress[phaseKey] || step;
+        return chalk.blue(`\n[${step.toUpperCase()}] `) + phaseName;
+    }
+    handleLogEvent(event) {
+        const displayMessage = mapErrorForDisplay({
+            message: event.message,
+            code: event.code,
+        }).message;
+        if (event.level === 'error') {
+            getLogger().error(displayMessage);
+        }
+        else if (event.level === 'warn') {
+            getLogger().warn(displayMessage);
+        }
+        else if (event.level === 'trace') {
+            getLogger().trace(displayMessage);
+        }
+        else if (event.level === 'info') {
+            getLogger().info(displayMessage);
+        }
+        else {
+            getLogger().debug(displayMessage);
+        }
+    }
+    formatAuthorizationSummary(summary) {
+        const { auto, allowlist, user, cache, cli, hook } = summary;
+        return `auto=${auto} allowlist=${allowlist} user=${user} cache=${cache} cli=${cli} hook=${hook}`;
+    }
+    handleFailure(result) {
+        const envelope = result.errorEnvelope;
+        const failureReason = envelope?.safeHint || result.safeHint || result.reason;
+        const remediationSteps = envelope?.remediationSteps && envelope.remediationSteps.length > 0
+            ? envelope.remediationSteps
+            : result.remediationSteps;
+        getLogger().error(text.cli.operationFailed);
+        getLogger().bold(text.cli.reason(failureReason));
+        if (result.diagnosticCode) {
+            getLogger().error(`  Diagnostic code: ${result.diagnosticCode}`);
+        }
+        const errorCode = envelope?.code || result.errorCode;
+        if (errorCode) {
+            getLogger().error(text.cli.errorCode(errorCode));
+        }
+        if (result.auditPath) {
+            getLogger().log(text.cli.auditPath(result.auditPath));
+        }
+        if (result.verifyArtifact?.handle) {
+            getLogger().log(text.cli.verifyOutputArtifact(result.verifyArtifact.handle));
+        }
+        if (Array.isArray(remediationSteps) && remediationSteps.length > 0) {
+            for (const step of remediationSteps) {
+                getLogger().cyan(`${text.symbols.suggestion} ${step}`);
+            }
+        }
+        if (result.failurePhase === Phase.PREFLIGHT) {
+            if (result.reasonCode === 'PREFLIGHT_DIRTY') {
+                getLogger().cyan(`${text.symbols.suggestion} Suggestion: ${text.suggestions.dirty}`);
+            }
+            else if (result.reasonCode === 'PREFLIGHT_NOT_GIT') {
+                getLogger().cyan(`${text.symbols.suggestion} Suggestion: ${text.suggestions.notGit}`);
+            }
+        }
+        else if (result.failurePhase === Phase.VERIFY) {
+            if (result.errorType === ErrorType.COMPILATION) {
+                getLogger().cyan(`${text.symbols.suggestion} Suggestion: ${text.suggestions.compilation}`);
+            }
+            else if (result.errorType === ErrorType.LINT) {
+                getLogger().cyan(`${text.symbols.suggestion} Suggestion: ${text.suggestions.lint}`);
+            }
+            else {
+                getLogger().cyan(`${text.symbols.suggestion} Suggestion: ${text.suggestions.test}`);
+            }
+        }
+        else if (result.failurePhase === Phase.ROLLBACK) {
+            getLogger().cyan(`${text.symbols.suggestion} Suggestion: ${text.suggestions.rollbackFailed}`);
+        }
+        getLogger().log(text.cli.attempts(result.attempts));
+    }
+}
+//# sourceMappingURL=standard.js.map

package/dist/cli/reporters/stderr-log-reporter.js

@@ -0,0 +1,71 @@
+import chalk from 'chalk';
+import { mapErrorForDisplay, } from '../../core/facades/cli-reporters.js';
+export class StderrLogReporter {
+    verboseLevel;
+    constructor(verboseLevel = 'none') {
+        this.verboseLevel = verboseLevel;
+    }
+    setVerbose(level) {
+        this.verboseLevel = level;
+    }
+    get isBasic() {
+        return this.verboseLevel === 'basic' || this.verboseLevel === 'extended';
+    }
+    get isExtended() {
+        return this.verboseLevel === 'extended';
+    }
+    log(level, message, metadata) {
+        const safeMessage = mapErrorForDisplay({
+            message,
+            code: metadata?.code,
+        }).message;
+        const writeLine = (line) => {
+            process.stderr.write(line + '\n');
+        };
+        switch (level) {
+            case 'info':
+            case 'log':
+            case 'bold':
+                writeLine(level === 'bold' ? chalk.bold(safeMessage) : safeMessage);
+                break;
+            case 'success':
+                writeLine(chalk.green(safeMessage));
+                break;
+            case 'warn':
+            case 'degraded':
+                writeLine(level === 'degraded'
+                    ? chalk.magenta(`[DEGRADED] ${safeMessage}`)
+                    : chalk.yellow(safeMessage));
+                break;
+            case 'error':
+                writeLine(chalk.red(safeMessage));
+                break;
+            case 'debug':
+                if (this.isBasic)
+                    writeLine(chalk.gray(safeMessage));
+                break;
+            case 'trace':
+                if (this.isExtended)
+                    writeLine(chalk.gray(safeMessage));
+                break;
+            case 'cyan':
+                writeLine(chalk.cyan(safeMessage));
+                break;
+            case 'dim':
+                writeLine(chalk.dim(safeMessage));
+                break;
+            case 'step':
+                if (this.isBasic) {
+                    const phase = metadata?.phase || 'STEP';
+                    writeLine(chalk.blue(`\n[${phase.toUpperCase()}] `) + safeMessage);
+                }
+                break;
+            case 'audit': {
+                const timestamp = new Date().toISOString();
+                writeLine(chalk.bgBlue.white(`[AUDIT] ${timestamp} - ${safeMessage}`));
+                break;
+            }
+        }
+    }
+}
+//# sourceMappingURL=stderr-log-reporter.js.map

package/dist/cli/reporters/stream-json.js

@@ -0,0 +1,111 @@
+import { randomUUID } from 'crypto';
+import { StreamAssembler, } from '../../core/facades/cli-reporters.js';
+import { encodeNormalizedToNativeStreamLines } from '../headless/native-stream-normalized-encoder.js';
+import { createStdoutWriter } from '../headless/stdout-writer.js';
+import { encodeStreamEnd, encodeStreamFailure, encodeStreamLoopEvent, encodeStreamResult, encodeStreamStart, getStreamExitCode, } from '../headless/stream-json-protocol.js';
+export class StreamJsonReporter {
+    mode;
+    repoPath;
+    sessionId;
+    now;
+    uuid;
+    writer;
+    lastTextResult;
+    assembler = new StreamAssembler();
+    constructor(options = {}) {
+        this.mode = options.mode ?? 'run';
+        this.repoPath = options.repoPath;
+        this.sessionId = options.sessionId ?? randomUUID();
+        this.now = options.now ?? (() => new Date());
+        this.uuid = options.uuid ?? randomUUID;
+        this.writer = options.writer ?? createStdoutWriter();
+    }
+    onStart(instruction) {
+        this.emit(encodeStreamStart({
+            uuid: this.uuid(),
+            mode: this.mode,
+            repoPath: this.repoPath,
+            sessionId: this.sessionId,
+            instruction,
+            at: this.now(),
+        }));
+    }
+    onEvent(event) {
+        if (event.type === 'llm.output' &&
+            event.kind === 'assistant_message' &&
+            event.step === 'REPORT') {
+            this.lastTextResult = event.content;
+        }
+        if (event.type === 'tool.call.start' ||
+            event.type === 'tool.call.end' ||
+            event.type === 'llm.responses.event' ||
+            event.type === 'llm.stream.delta' ||
+            event.type === 'llm.stream.end') {
+            const normalized = this.assembler.push(event);
+            for (const normalizedEvent of normalized) {
+                const lines = encodeNormalizedToNativeStreamLines({
+                    sessionId: this.sessionId,
+                    uuid: this.uuid,
+                    event: normalizedEvent,
+                });
+                for (const line of lines)
+                    this.emit(line);
+            }
+            return;
+        }
+        this.emit(encodeStreamLoopEvent({ uuid: this.uuid(), sessionId: this.sessionId, event }));
+    }
+    onFinish(result) {
+        if (result.authorizationSummary) {
+            const at = this.now();
+            this.emit(encodeStreamLoopEvent({
+                uuid: this.uuid(),
+                sessionId: this.sessionId,
+                event: {
+                    type: 'authorization.summary',
+                    stage: 'final',
+                    summary: result.authorizationSummary,
+                    timestamp: at,
+                },
+            }));
+        }
+        const at = this.now();
+        const resultLine = encodeStreamResult({
+            uuid: this.uuid(),
+            sessionId: this.sessionId,
+            loopResult: result,
+            at,
+            resultText: this.lastTextResult,
+        });
+        this.emit(resultLine);
+        const exitCode = getStreamExitCode(result);
+        this.emit(encodeStreamEnd({
+            uuid: this.uuid(),
+            sessionId: this.sessionId,
+            at: this.now(),
+            success: Boolean(result.success),
+            exitCode,
+        }));
+    }
+    onError(error) {
+        this.emit(encodeStreamFailure({
+            uuid: this.uuid(),
+            sessionId: this.sessionId,
+            at: this.now(),
+            message: error.message,
+            name: error.name,
+            stack: error.stack,
+        }));
+        this.emit(encodeStreamEnd({
+            uuid: this.uuid(),
+            sessionId: this.sessionId,
+            at: this.now(),
+            success: false,
+            exitCode: 1,
+        }));
+    }
+    emit(line) {
+        this.writer.writeJsonLine(line);
+    }
+}
+//# sourceMappingURL=stream-json.js.map

package/dist/cli/run-cli.js

@@ -0,0 +1,25 @@
+import { createCliRuntimeContext } from './cli-runtime-context.js';
+import { bootstrapProgram } from './program-bootstrap.js';
+import { registerProgramCommands } from './program-commands.js';
+import { configureGlobalProgramOptions } from './program-options.js';
+import { configureProgramOutputForHeadless } from './program-output-mode.js';
+import { parseProgramOrExit } from './program-parse.js';
+export function buildCliProgram() {
+    const program = bootstrapProgram();
+    configureGlobalProgramOptions(program);
+    registerProgramCommands(program);
+    return program;
+}
+export function createCliContextFromArgv(argv) {
+    const program = buildCliProgram();
+    return createCliRuntimeContext(program, argv);
+}
+export async function executeCliContext(context) {
+    configureProgramOutputForHeadless(context);
+    await parseProgramOrExit(context);
+}
+export async function runCli(argv) {
+    const context = createCliContextFromArgv(argv);
+    await executeCliContext(context);
+}
+//# sourceMappingURL=run-cli.js.map