salmon-loop 0.2.3

package/dist/cli/commands/run/execute.js

@@ -0,0 +1,73 @@
+import { emitLlmOutput, runSalmonLoop, } from '../../../core/facades/cli-run-execute.js';
+import { createCliTaskRunner } from '../../../interfaces/cli/task-runner.js';
+import { createUiAuthorizationProvider } from '../../authorization/provider.js';
+export async function executeRunLoop(params) {
+    const build = params.buildAssistantMessage;
+    if (params.useGui) {
+        const { startGUI } = await import('../../ui/index.js');
+        const result = (await startGUI('run', undefined, async (emit, _input, guiOptions) => {
+            const authorizationProvider = createUiAuthorizationProvider({
+                emit: (event) => emit({ ...event, timestamp: new Date() }),
+                config: params.toolAuthorizationConfig,
+                permissionMode: params.permissionMode,
+            });
+            const runResult = await runSalmonLoop({
+                ...params.loopParams,
+                applyBackOnDirty: params.applyBackOnDirty,
+                signal: guiOptions?.signal,
+                authorizationProvider,
+                authorizationMode: 'deferred',
+                onEvent: (event) => {
+                    emit(event);
+                },
+            });
+            if (runResult.reason !== 'Operation cancelled by user') {
+                emitLlmOutput({
+                    emit,
+                    policy: params.llmOutput,
+                    kind: 'assistant_message',
+                    step: 'REPORT',
+                    content: build(runResult),
+                });
+            }
+            return runResult;
+        }, params.guiConfig));
+        return result;
+    }
+    const abortController = new AbortController();
+    const onInterrupt = () => abortController.abort();
+    process.once('SIGINT', onInterrupt);
+    process.once('SIGTERM', onInterrupt);
+    const runner = createCliTaskRunner({
+        facade: {
+            createTask: async ({ capability, request }) => runSalmonLoop({
+                ...params.loopParams,
+                mode: capability,
+                instruction: request.instruction,
+                applyBackOnDirty: params.applyBackOnDirty,
+                signal: abortController.signal,
+                onEvent: (event) => params.reporter.onEvent(event),
+            }),
+        },
+    });
+    let result;
+    try {
+        result = (await runner.run({
+            capability: String(params.loopParams.mode ?? 'patch'),
+            instruction: String(params.loopParams.instruction ?? ''),
+        }));
+    }
+    finally {
+        process.off('SIGINT', onInterrupt);
+        process.off('SIGTERM', onInterrupt);
+    }
+    emitLlmOutput({
+        emit: (event) => params.reporter.onEvent(event),
+        policy: params.llmOutput,
+        kind: 'assistant_message',
+        step: 'REPORT',
+        content: build(result),
+    });
+    return result;
+}
+//# sourceMappingURL=execute.js.map

package/dist/cli/commands/run/extensions-resolution.js

@@ -0,0 +1,22 @@
+import { resolveExtensions, ExtensionConfigError } from '../../../core/extensions/index.js';
+import { getLogger } from '../../../core/facades/cli-observability.js';
+export async function resolveRunExtensions(params) {
+    try {
+        const extensionResolution = await resolveExtensions({ repoRoot: params.repoPath });
+        return { ok: true, extensionResolution };
+    }
+    catch (err) {
+        if (err instanceof ExtensionConfigError) {
+            getLogger().error(`Extension configuration invalid: ${err.message}`);
+            if (params.outputFormat === 'json') {
+                params.writeJsonFailure({
+                    message: `Extension configuration invalid: ${err.message}`,
+                    repoPath: params.repoPath,
+                });
+            }
+            return { ok: false, exitCode: 1 };
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=extensions-resolution.js.map

package/dist/cli/commands/run/handler.js

@@ -0,0 +1,434 @@
+import { randomUUID } from 'crypto';
+import { buildSessionConversationContext, createPluginRegistry, createPromptRegistry, getExitCode, getDefaultSessionContextBudgetTokens, getLogger, normalizePermissionMode, setPluginRegistry, setPromptRegistry, } from '../../../core/facades/cli-run-handler.js';
+import { createStdoutWriter } from '../../headless/stdout-writer.js';
+import { text } from '../../locales/index.js';
+import { StderrLogReporter } from '../../reporters/stderr-log-reporter.js';
+import { resolveAuditScope } from '../../utils/audit-scope.js';
+import { createOutcomeReporter } from '../../utils/outcome-reporter.js';
+import { buildRunAssistantMessage } from './assistant-message.js';
+import { resolveRunConfig } from './config-resolution.js';
+import { handleEarlyRunCommandErrors } from './early-errors.js';
+import { executeRunLoop } from './execute.js';
+import { resolveRunExtensions } from './extensions-resolution.js';
+import { createHeadlessErrorWriter } from './headless-error-writer.js';
+import { ensureInstructionOrExit } from './instruction-guard.js';
+import { buildRunLoopParams } from './loop-params.js';
+import { resolveRunMode } from './mode.js';
+import { parseRunCommandOptions } from './parse-options.js';
+import { persistRunSession } from './persist-session.js';
+import { runPreflight } from './preflight.js';
+import { createRunReporter } from './reporter-factory.js';
+import { createRuntimeLlmAndWarn } from './runtime-llm.js';
+import { resolveRunRuntimeOptions } from './runtime-options.js';
+import { initializeSession } from './session.js';
+import { buildStructuredOutputState } from './structured-output.js';
+import { logRunVerboseSummary, resolveVerboseLevel } from './verbose.js';
+export async function handleRunCommand(options, command) {
+    const parsed = parseRunCommandOptions(command);
+    const allOptions = parsed.allOptions;
+    const runPath = parsed.repoPath;
+    const languagePlugins = createPluginRegistry();
+    setPluginRegistry(languagePlugins);
+    setPromptRegistry(createPromptRegistry());
+    const continueSession = parsed.continueSession;
+    const resumeSessionId = parsed.resumeSessionId;
+    const printInstruction = parsed.printInstruction;
+    const explicitInstruction = parsed.explicitInstruction;
+    const jsonSchemaSpec = parsed.jsonSchemaSpec;
+    const rawOutputFormat = parsed.rawOutputFormat;
+    if (rawOutputFormat !== 'text' &&
+        rawOutputFormat !== 'stream-json' &&
+        rawOutputFormat !== 'json') {
+        getLogger().error(text.cli.invalidOutputFormat(rawOutputFormat), true);
+        process.exit(1);
+    }
+    const outputFormat = rawOutputFormat;
+    const headlessOutput = outputFormat !== 'text';
+    const rawOutputProfile = parsed.rawOutputProfile;
+    const outputProfileForStreamJson = parsed.outputProfileForStreamJson;
+    const headlessIncludeToolInput = parsed.headlessIncludeToolInput;
+    const headlessIncludeToolOutput = parsed.headlessIncludeToolOutput;
+    const headlessIncludeAuthorizationDecisions = parsed.headlessIncludeAuthorizationDecisions;
+    const allowOutsideCacheRoot = parsed.allowOutsideCacheRoot;
+    const stdoutWriter = createStdoutWriter();
+    const instruction = parsed.instruction;
+    const printMode = Boolean(printInstruction);
+    const useGui = !headlessOutput && !printMode && allOptions.gui !== false && process.stdout.isTTY;
+    if (headlessOutput) {
+        getLogger().setReporter(new StderrLogReporter());
+    }
+    const wantSessionPersistence = !allOptions.printConfig &&
+        (headlessOutput ||
+            continueSession ||
+            Boolean(resumeSessionId) ||
+            typeof instruction === 'string');
+    let sessionManager;
+    let sessionIdForOutput;
+    const headlessErrorWriter = createHeadlessErrorWriter({
+        repoPath: runPath,
+        outputFormat,
+        outputProfileForStreamJson,
+        writer: stdoutWriter,
+        getSessionId: () => sessionIdForOutput,
+        getResumeSessionId: () => resumeSessionId,
+    });
+    const earlyError = handleEarlyRunCommandErrors({
+        headlessOutput,
+        outputFormat,
+        rawOutputProfile,
+        outputProfileForStreamJson,
+        headlessIncludeToolInput,
+        headlessIncludeToolOutput,
+        headlessIncludeAuthorizationDecisions,
+        instruction,
+        printInstruction,
+        explicitInstruction,
+        continueSession,
+        resumeSessionId,
+        jsonSchemaSpec,
+        sessionIdForOutput,
+        headlessErrorWriter,
+    });
+    if (!earlyError.ok) {
+        process.exitCode = earlyError.exitCode;
+        return;
+    }
+    if (wantSessionPersistence) {
+        try {
+            const initialized = await initializeSession({
+                repoPath: runPath,
+                continueSession,
+                resumeSessionId,
+            });
+            sessionManager = initialized.sessionManager;
+            sessionIdForOutput = initialized.sessionId;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (outputFormat !== 'text') {
+                if (resumeSessionId) {
+                    headlessErrorWriter.writeUsageError({
+                        sessionId: resumeSessionId,
+                        instruction,
+                        message: msg,
+                    });
+                }
+                else {
+                    headlessErrorWriter.writeUnexpectedError({
+                        sessionId: sessionIdForOutput,
+                        instruction,
+                        message: msg,
+                    });
+                }
+            }
+            else {
+                getLogger().error(msg);
+            }
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const allowedToolRules = parsed.allowedToolRules;
+    const disallowedToolRules = parsed.disallowedToolRules;
+    const rawPreflightPolicy = String(allOptions.preflightPolicy || 'lenient');
+    if (rawPreflightPolicy !== 'lenient' && rawPreflightPolicy !== 'strict') {
+        getLogger().error(text.cli.invalidPreflightPolicy(rawPreflightPolicy), true);
+        return;
+    }
+    const preflightPolicy = rawPreflightPolicy;
+    await runPreflight({
+        languagePlugins,
+        repoPath: runPath,
+        validate: Boolean(allOptions.validate),
+        useGui,
+        preflightPolicy,
+    });
+    if (allOptions.validate && !instruction)
+        return;
+    const writeJsonFailure = (params) => {
+        headlessErrorWriter.writeJsonFailure({
+            exitCode: params.exitCode,
+            message: params.message,
+            errorCode: params.errorCode,
+            repoPath: params.repoPath,
+            instruction: params.instruction,
+            sessionId: sessionIdForOutput ?? randomUUID(),
+        });
+    };
+    const configResult = await resolveRunConfig({
+        repoPath: runPath,
+        cliOptions: allOptions,
+        outputFormat,
+        writeJsonFailure: ({ message, errorCode, repoPath }) => writeJsonFailure({ message, errorCode, repoPath }),
+    });
+    if (!configResult.ok) {
+        process.exitCode = 1;
+        return;
+    }
+    if ('printedConfig' in configResult)
+        return;
+    const resolvedConfig = configResult.resolvedConfig;
+    const runtimeOptions = await resolveRunRuntimeOptions({
+        repoPath: runPath,
+        resolvedConfig,
+        cliOptions: allOptions,
+        outputFormat,
+        writeJsonFailure: ({ message, repoPath }) => writeJsonFailure({ message, repoPath }),
+    });
+    if (!runtimeOptions.ok) {
+        process.exitCode = runtimeOptions.exitCode;
+        return;
+    }
+    const llmOutput = runtimeOptions.llmOutput;
+    const effectiveVerify = runtimeOptions.effectiveVerify;
+    const effectiveWorktreePrepare = runtimeOptions.effectiveWorktreePrepare;
+    const instructionGuard = ensureInstructionOrExit({
+        command,
+        instruction,
+        validate: Boolean(allOptions.validate),
+        outputFormat,
+        sessionIdForOutput,
+        writeJsonFailure: ({ message, repoPath }) => writeJsonFailure({ message, repoPath }),
+        repoPath: runPath,
+        headlessErrorWriter,
+    });
+    if (!instructionGuard.ok) {
+        process.exitCode = instructionGuard.exitCode;
+        return;
+    }
+    const instructionText = instruction;
+    const rawPermissionMode = allOptions.mode ?? resolvedConfig.permissionMode ?? 'interactive';
+    const permissionMode = normalizePermissionMode(rawPermissionMode);
+    if (!permissionMode) {
+        getLogger().error(`Invalid --mode "${String(rawPermissionMode)}". Expected "interactive" or "yolo".`);
+        process.exitCode = 1;
+        return;
+    }
+    const rawMode = String(allOptions.actMode || 'patch');
+    const mode = resolveRunMode(rawMode);
+    if (!mode) {
+        getLogger().error(text.cli.invalidActMode(rawMode));
+        if (outputFormat === 'json') {
+            writeJsonFailure({ message: text.cli.invalidActMode(rawMode), repoPath: runPath });
+        }
+        else if (outputFormat === 'stream-json') {
+            headlessErrorWriter.writeUsageError({
+                sessionId: sessionIdForOutput ?? randomUUID(),
+                message: text.cli.invalidActMode(rawMode),
+                instruction,
+            });
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const rawEnvironmentMode = String(allOptions.environmentMode || 'strict');
+    if (rawEnvironmentMode !== 'strict' && rawEnvironmentMode !== 'parity') {
+        getLogger().error(text.cli.invalidEnvironmentMode(rawEnvironmentMode));
+        if (outputFormat === 'json') {
+            writeJsonFailure({
+                message: text.cli.invalidEnvironmentMode(rawEnvironmentMode),
+                repoPath: runPath,
+            });
+        }
+        else if (outputFormat === 'stream-json') {
+            headlessErrorWriter.writeUsageError({
+                sessionId: sessionIdForOutput ?? randomUUID(),
+                message: text.cli.invalidEnvironmentMode(rawEnvironmentMode),
+                instruction,
+            });
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const extensionsResult = await resolveRunExtensions({
+        repoPath: runPath,
+        outputFormat,
+        writeJsonFailure: ({ message, repoPath }) => writeJsonFailure({ message, repoPath }),
+    });
+    if (!extensionsResult.ok) {
+        process.exitCode = 1;
+        return;
+    }
+    const extensionResolution = extensionsResult.extensionResolution;
+    if (!effectiveVerify) {
+        getLogger().warn(text.verify.noCommandFound);
+    }
+    const verboseLevel = resolveVerboseLevel(allOptions.verbose);
+    logRunVerboseSummary({
+        verboseLevel,
+        instruction: instructionText,
+        verify: effectiveVerify,
+        repoPath: runPath,
+        file: allOptions.file,
+        selection: allOptions.selection,
+        allowedToolRules,
+        disallowedToolRules,
+        dryRun: allOptions.dryRun,
+        configPath: resolvedConfig.source.used ? resolvedConfig.source.path || '' : undefined,
+    });
+    try {
+        const auditScopeResolution = resolveAuditScope({
+            cliValue: allOptions.auditScope,
+            configValue: resolvedConfig.observability.audit.scope,
+        });
+        if (!auditScopeResolution.ok) {
+            getLogger().error(text.cli.invalidAuditScope(auditScopeResolution.invalid), true);
+            process.exit(1);
+        }
+        const auditScope = auditScopeResolution.value;
+        const { llm } = createRuntimeLlmAndWarn({
+            llmConfig: resolvedConfig.llm,
+            langfuseEnabled: resolvedConfig.observability.langfuse.enabled,
+        });
+        let structuredOutputState = { ok: true, candidate: null };
+        const reporter = createRunReporter({
+            useGui,
+            outputFormat,
+            rawOutputProfile,
+            repoPath: runPath,
+            sessionIdForOutput,
+            writer: stdoutWriter,
+            verbose: Boolean(allOptions.verbose),
+            model: resolvedConfig.llm.models?.selectedModelId,
+            getStructuredOutput: () => structuredOutputState.ok ? structuredOutputState.candidate : null,
+            getPayloadOverrides: () => {
+                if (structuredOutputState.ok)
+                    return undefined;
+                const reason = structuredOutputState.errorCode === 'SCHEMA_INVALID'
+                    ? (structuredOutputState.errorReason ?? text.cli.structuredOutputSchemaFailed)
+                    : text.cli.structuredOutputSchemaFailed;
+                return {
+                    success: false,
+                    exitCode: 1,
+                    reason,
+                    reasonCode: 'SCHEMA_VALIDATION_FAILED',
+                    errorCode: structuredOutputState.errorCode ?? 'SCHEMA_VALIDATION_FAILED',
+                    structuredOutputError: structuredOutputState.errorReason,
+                };
+            },
+        });
+        reporter.onStart(instructionText);
+        const applyBackOnDirty = allOptions.applyBackOnDirty === 'abort' ? 'abort' : '3way';
+        const outcomeReporter = createOutcomeReporter({
+            enabled: resolvedConfig.observability.langfuse.outcome,
+            endpoint: resolvedConfig.observability.langfuse.endpoint,
+            llmBaseUrl: resolvedConfig.llm.api.baseUrl,
+            langfuseApiKey: resolvedConfig.observability.langfuse.apiKey,
+        });
+        const modelIdForBudget = llm.getModelId?.() ||
+            resolvedConfig.llm.models?.selectedModelId ||
+            process.env.SALMONLOOP_MODEL ||
+            process.env.S8P_MODEL;
+        const shouldInjectSessionContext = Boolean(continueSession || resumeSessionId);
+        const conversationContext = shouldInjectSessionContext && sessionManager
+            ? buildSessionConversationContext(sessionManager.getMessages(), {
+                budgetTokens: getDefaultSessionContextBudgetTokens({ modelId: modelIdForBudget }),
+                summaryState: sessionManager.getSummaryState(),
+            })
+            : [];
+        const loopParams = buildRunLoopParams({
+            instruction: instructionText,
+            verify: effectiveVerify,
+            repoPath: runPath,
+            llm,
+            languagePlugins,
+            conversationContext: conversationContext.length > 0 ? conversationContext : undefined,
+            mode,
+            dryRun: allOptions.dryRun,
+            forceReset: allOptions.forceReset,
+            file: allOptions.file,
+            selection: allOptions.selection,
+            verbose: verboseLevel,
+            checkpointStrategy: permissionMode === 'yolo' &&
+                typeof command.getOptionValueSource === 'function' &&
+                command.getOptionValueSource('checkpointStrategy') !== 'cli'
+                ? 'direct'
+                : allOptions.checkpointStrategy,
+            environmentMode: rawEnvironmentMode,
+            applyBackOnDirty,
+            worktreePrepare: effectiveWorktreePrepare,
+            llmOutput,
+            outcomeReporter,
+            auditScope,
+            langfuseSessionId: resolvedConfig.observability.langfuse.sessionId || sessionIdForOutput,
+            langfuseUserId: resolvedConfig.observability.langfuse.userId,
+            astValidation: resolvedConfig.astValidation,
+            toolAuthorization: resolvedConfig.toolAuthorization,
+            extensions: extensionResolution?.resolved,
+            headlessOutput,
+            printMode,
+            headlessIncludeToolInput,
+            headlessIncludeToolOutput,
+            headlessIncludeAuthorizationDecisions,
+            allowOutsideCacheRoot,
+            permissionRules: permissionMode === 'yolo'
+                ? undefined
+                : allowedToolRules.length > 0 || disallowedToolRules.length > 0
+                    ? { allow: allowedToolRules, deny: disallowedToolRules }
+                    : undefined,
+            permissionMode,
+        });
+        const buildAssistantMessage = (result) => buildRunAssistantMessage({ mode, result });
+        const result = await executeRunLoop({
+            useGui,
+            loopParams,
+            applyBackOnDirty: loopParams.applyBackOnDirty,
+            reporter,
+            llmOutput,
+            buildAssistantMessage,
+            toolAuthorizationConfig: resolvedConfig.toolAuthorization,
+            permissionMode,
+            guiConfig: {
+                markdownTheme: resolvedConfig.markdownTheme,
+                markdownRenderMode: resolvedConfig.markdownRenderMode,
+                logView: resolvedConfig.ui.logView,
+                logMode: resolvedConfig.ui.logMode,
+            },
+        });
+        structuredOutputState = await buildStructuredOutputState({
+            outputFormat,
+            jsonSchemaSpec,
+            result,
+            repoPath: runPath,
+            instruction: instructionText,
+            sessionIdForOutput,
+            exitCode: getExitCode(result),
+            reasonCode: result.reasonCode,
+        });
+        if (!structuredOutputState.ok &&
+            structuredOutputState.errorKind === 'schema_invalid' &&
+            structuredOutputState.errorReason) {
+            structuredOutputState.errorReason = text.cli.jsonSchemaLoadFailed(structuredOutputState.errorReason);
+        }
+        reporter.onFinish(result);
+        await persistRunSession({
+            sessionManager,
+            llm,
+            instruction: instructionText,
+            result,
+            buildAssistantMessage,
+        });
+        process.exitCode = headlessErrorWriter.writeResultExitCode(result, structuredOutputState.ok);
+        return;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        getLogger().error(text.cli.unexpectedError(msg), false);
+        if (outputFormat === 'json') {
+            writeJsonFailure({
+                message: text.cli.unexpectedError(msg),
+                repoPath: runPath,
+                instruction,
+            });
+        }
+        else if (outputFormat === 'stream-json') {
+            headlessErrorWriter.writeUnexpectedError({
+                sessionId: sessionIdForOutput ?? resumeSessionId ?? randomUUID(),
+                message: text.cli.unexpectedError(msg),
+            });
+        }
+        process.exitCode = 1;
+        return;
+    }
+}
+//# sourceMappingURL=handler.js.map