salmon-loop 0.2.3

package/dist/cli/chat.js

@@ -0,0 +1,492 @@
+import { buildSessionConversationContext, ChatSessionManager, DEFAULT_LLM_OUTPUT_POLICY, emitLlmOutput, getDefaultSessionContextBudgetTokens, InputHistoryManager, logIgnoredError, getLogger, refreshSessionSummary, routeChatIntent, runSalmonLoop, TokenTracker, } from '../core/facades/cli-chat.js';
+import { createSubAgentController } from '../core/facades/cli-subagent.js';
+import { createUiAuthorizationProvider } from './authorization/provider.js';
+import { commands } from './commands/registry.js';
+import { CHAT_QUEUE_CONFIG } from './config.js';
+import { text } from './locales/index.js';
+import { createCliSlashRuntime } from './slash/runtime.js';
+import { requestSelection } from './ui/selection/bus.js';
+import { buildTranscriptMessages } from './ui/utils/transcript.js';
+import { createAsyncQueue } from './utils/asyncQueue.js';
+/**
+ * Start interactive chat mode
+ */
+export async function startChatMode(options) {
+    const sessionManager = new ChatSessionManager(options.repoPath);
+    await sessionManager.init();
+    const historyManager = new InputHistoryManager(options.repoPath);
+    await historyManager.init();
+    const subAgentController = createSubAgentController();
+    // Load or create session
+    let session = null;
+    let sessionMode = 'new';
+    if (options.resumeSessionId) {
+        session = await sessionManager.load(options.resumeSessionId);
+        if (!session) {
+            throw new Error(text.cli.resumeNotFound(options.resumeSessionId));
+        }
+        sessionMode = 'resume';
+    }
+    else if (options.continue) {
+        session = await sessionManager.loadLast();
+        if (session) {
+            sessionMode = 'continue';
+        }
+    }
+    if (!session) {
+        session = await sessionManager.create();
+        sessionMode = 'new';
+    }
+    // Load input history for this session
+    const inputHistory = await historyManager.load(session.meta.id);
+    // Dynamically import GUI to avoid top-level await issues with yoga-layout
+    const { startGUI } = await import('./ui/index.js');
+    let latestDispatch;
+    let latestEmit;
+    let latestGuiOptions;
+    let thinkingTimer = null;
+    let thinkingVisibleAt = null;
+    let hideTimer = null;
+    let currentInstruction = null;
+    let lastInterruptedInput = null;
+    let currentLlmOutputPolicy = options.llmOutput ?? DEFAULT_LLM_OUTPUT_POLICY;
+    const authorizationProvider = createUiAuthorizationProvider({
+        emit: (event) => {
+            latestEmit?.({ ...event, timestamp: new Date() });
+        },
+        config: options.toolAuthorization,
+        permissionMode: options.permissionMode,
+    });
+    const userInputProvider = {
+        askUser: async (input, requestOptions) => {
+            const answers = {};
+            for (const question of input.questions) {
+                if (requestOptions?.signal?.aborted) {
+                    const err = new Error(text.cli.askUserCancelled);
+                    err.code = 'ASK_USER_CANCELLED';
+                    throw err;
+                }
+                const items = question.options.map((opt) => ({
+                    id: opt.label,
+                    label: opt.label,
+                    description: opt.description,
+                }));
+                const title = question.header?.trim() || question.question;
+                const promptId = `ask-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                const selected = await requestSelection({
+                    id: promptId,
+                    title,
+                    items,
+                    multiSelect: question.multiSelect,
+                });
+                if (!selected || selected.length === 0) {
+                    const err = new Error(text.cli.askUserCancelled);
+                    err.code = 'ASK_USER_CANCELLED';
+                    throw err;
+                }
+                const answer = question.multiSelect ? selected.join(', ') : (selected[0] ?? '');
+                answers[question.question] = answer;
+            }
+            return { questions: input.questions, answers };
+        },
+    };
+    const slashRuntime = await createCliSlashRuntime({
+        repoRoot: options.repoPath,
+        baseCommands: commands,
+        emit: (event) => {
+            latestEmit?.({ ...event, timestamp: new Date() });
+        },
+        authorizationProvider,
+        skillDiscovery: options.extensions?.skillDiscovery,
+    });
+    const setThinking = (value) => {
+        if (!latestDispatch)
+            return;
+        latestDispatch({ type: 'SET_THINKING', payload: value });
+    };
+    const handleThinkingState = (desired) => {
+        if (desired) {
+            if (thinkingVisibleAt !== null)
+                return;
+            if (thinkingTimer)
+                clearTimeout(thinkingTimer);
+            thinkingTimer = setTimeout(() => {
+                thinkingVisibleAt = Date.now();
+                setThinking(true);
+                thinkingTimer = null;
+            }, CHAT_QUEUE_CONFIG.THINKING_SHOW_DELAY_MS);
+            return;
+        }
+        if (thinkingTimer) {
+            clearTimeout(thinkingTimer);
+            thinkingTimer = null;
+        }
+        if (thinkingVisibleAt === null)
+            return;
+        const elapsed = Date.now() - thinkingVisibleAt;
+        const remaining = CHAT_QUEUE_CONFIG.THINKING_MIN_VISIBLE_MS - elapsed;
+        if (hideTimer)
+            clearTimeout(hideTimer);
+        if (remaining > 0) {
+            hideTimer = setTimeout(() => {
+                thinkingVisibleAt = null;
+                setThinking(false);
+                hideTimer = null;
+            }, remaining);
+            return;
+        }
+        thinkingVisibleAt = null;
+        setThinking(false);
+    };
+    const queue = createAsyncQueue((state) => {
+        if (!latestDispatch)
+            return;
+        handleThinkingState(state.isProcessing || state.pendingCount > 0);
+    }, {
+        maxSize: CHAT_QUEUE_CONFIG.MAX_SIZE,
+        overflowStrategy: CHAT_QUEUE_CONFIG.OVERFLOW_STRATEGY,
+    });
+    const isInterruptError = (error) => {
+        if (!(error instanceof Error))
+            return false;
+        return /aborted|cancelled|canceled|interrupted|timed out|timeout/i.test(error.message);
+    };
+    const isInterruptResult = (reason) => {
+        if (!reason)
+            return false;
+        return /cancelled by user/i.test(reason);
+    };
+    const markInterrupted = (input) => {
+        lastInterruptedInput = input;
+        queue.pause();
+        latestEmit?.({
+            type: 'log',
+            level: 'info',
+            message: text.cli.queuePausedAfterInterrupt,
+            timestamp: new Date(),
+        });
+    };
+    const enqueueInput = (input, queueOptions) => {
+        const trimmed = input.trim();
+        if (!trimmed)
+            return;
+        if (!latestDispatch)
+            return;
+        try {
+            const currentSessionId = sessionManager.getCurrent().meta.id;
+            historyManager
+                .append(currentSessionId, trimmed)
+                .catch((error) => logIgnoredError('[History] append failed', error));
+        }
+        catch {
+            // Best-effort: persistence should never block interactive input.
+        }
+        const queueMessageId = `queue-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const queueState = queue.getState();
+        if (typeof CHAT_QUEUE_CONFIG.MAX_SIZE === 'number' &&
+            CHAT_QUEUE_CONFIG.MAX_SIZE >= 0 &&
+            queueState.pendingCount >= CHAT_QUEUE_CONFIG.MAX_SIZE &&
+            CHAT_QUEUE_CONFIG.OVERFLOW_STRATEGY === 'drop_oldest') {
+            latestDispatch({ type: 'SHIFT_QUEUE_MESSAGE' });
+        }
+        latestDispatch({
+            type: 'ADD_QUEUE_MESSAGE',
+            payload: {
+                id: queueMessageId,
+                content: trimmed,
+                timestamp: new Date(),
+            },
+        });
+        const enqueueFn = queueOptions?.front ? queue.enqueueFront : queue.enqueue;
+        let started = false;
+        return enqueueFn(async () => {
+            started = true;
+            latestDispatch?.({ type: 'SHIFT_QUEUE_MESSAGE' });
+            currentInstruction = trimmed;
+            const timeoutAbort = new AbortController();
+            const mergedSignal = mergeAbortSignals([latestGuiOptions?.signal, timeoutAbort.signal]);
+            const modelIdForBudget = options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL;
+            const conversationContext = buildSessionConversationContext(sessionManager.getMessages(), {
+                budgetTokens: getDefaultSessionContextBudgetTokens({ modelId: modelIdForBudget }),
+                summaryState: sessionManager.getSummaryState(),
+            });
+            // Single source of truth: chat runtime owns when a user message is appended to the UI list.
+            // The UI layer must not also append user messages (to avoid duplicates).
+            latestDispatch?.({
+                type: 'ADD_MESSAGE',
+                payload: {
+                    id: `user-${Date.now()}`,
+                    type: 'user',
+                    content: trimmed,
+                    timestamp: new Date(),
+                },
+            });
+            // Add user message
+            sessionManager.addMessage({
+                role: 'user',
+                content: trimmed,
+                timestamp: Date.now(),
+            });
+            const execution = await withTimeout((async () => {
+                const intentDecision = await routeChatIntent(trimmed, {
+                    llm: options.llm,
+                    signal: mergedSignal.signal,
+                });
+                latestEmit?.({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.chatIntentRouted(intentDecision.intent, intentDecision.confidence, intentDecision.reason),
+                    timestamp: new Date(),
+                });
+                const nonMutating = intentDecision.intent === 'review' ||
+                    intentDecision.intent === 'research' ||
+                    intentDecision.intent === 'answer';
+                const strategy = nonMutating ? 'direct' : options.checkpointStrategy || 'worktree';
+                const verboseLevel = options.verbose === true ? 'basic' : options.verbose;
+                const result = await runSalmonLoop({
+                    instruction: trimmed,
+                    verify: options.verifyCommand,
+                    repoPath: options.repoPath,
+                    llm: options.llm,
+                    mode: intentDecision.intent,
+                    strategy,
+                    verbose: verboseLevel,
+                    onEvent: latestEmit,
+                    signal: mergedSignal.signal,
+                    llmOutput: currentLlmOutputPolicy,
+                    outcomeReporter: options.outcomeReporter,
+                    auditScope: options.auditScope,
+                    conversationContext: conversationContext.length > 0 ? conversationContext : undefined,
+                    astValidation: options.astValidation,
+                    languagePlugins: options.languagePlugins,
+                    // Resolve sessionId at call time to support `/session` switching.
+                    langfuseSessionId: options.langfuseSessionId || sessionManager.getCurrent().meta.id,
+                    langfuseUserId: options.langfuseUserId,
+                    authorizationProvider,
+                    authorizationMode: 'deferred',
+                    userInputProvider,
+                    subAgentController,
+                });
+                return { kind: 'flow', mode: intentDecision.intent, result };
+            })(), CHAT_QUEUE_CONFIG.TASK_TIMEOUT_MS, () => timeoutAbort.abort()).finally(() => {
+                mergedSignal.cleanup();
+            });
+            const result = execution.result;
+            const mode = execution.mode;
+            if (!result.success && isInterruptResult(result.reason)) {
+                markInterrupted(trimmed);
+            }
+            // Add assistant message & iteration info
+            const changedFiles = result.changedFiles ?? [];
+            const responseText = (() => {
+                if (!result.success)
+                    return text.cli.chatFailed(result.reason);
+                if (mode === 'answer') {
+                    const content = String(result.assistantMessage ?? '').trim();
+                    return content || text.cli.chatAnswerEmpty;
+                }
+                if (mode === 'review')
+                    return text.cli.chatReviewCompleted;
+                return changedFiles.length === 0
+                    ? text.cli.chatNoChanges
+                    : text.cli.chatSuccess(changedFiles.join(', '));
+            })();
+            if (mode !== 'answer') {
+                emitLlmOutput({
+                    emit: latestEmit,
+                    policy: currentLlmOutputPolicy,
+                    kind: 'assistant_message',
+                    step: 'REPORT',
+                    content: responseText,
+                });
+            }
+            sessionManager.addMessage({
+                role: 'assistant',
+                content: responseText,
+                timestamp: Date.now(),
+            });
+            if (result.history && result.history.length > 0) {
+                sessionManager.addIteration(result.history[result.history.length - 1]);
+            }
+            const usage = await TokenTracker.extractFromResult(result);
+            if (usage) {
+                TokenTracker.accumulate(sessionManager.getCurrent(), usage);
+            }
+            await refreshSessionSummary({
+                sessionManager,
+                llm: options.llm,
+                contextHash: result.contextHash,
+                strategy: 'auto',
+            });
+            await sessionManager.save();
+            currentInstruction = null;
+            return result;
+        }).catch((error) => {
+            if (!started) {
+                latestDispatch?.({ type: 'REMOVE_QUEUE_MESSAGE', payload: { id: queueMessageId } });
+            }
+            if (isInterruptError(error) && currentInstruction) {
+                markInterrupted(currentInstruction);
+            }
+            currentInstruction = null;
+            throw error;
+        });
+    };
+    const queueController = {
+        pause: () => {
+            queue.pause();
+            getLogger().audit('QUEUE_PAUSE', { status: 'paused' }, { source: 'chat', severity: 'low', scope: 'session' });
+        },
+        resume: () => {
+            queue.resume();
+            lastInterruptedInput = null;
+            getLogger().audit('QUEUE_RESUME', { status: 'resumed' }, { source: 'chat', severity: 'low', scope: 'session' });
+        },
+        clear: () => {
+            const cleared = queue.clear();
+            lastInterruptedInput = null;
+            latestDispatch?.({ type: 'CLEAR_QUEUE_MESSAGES' });
+            getLogger().audit('QUEUE_CLEAR', { cleared }, { source: 'chat', severity: 'low', scope: 'session' });
+            return cleared;
+        },
+        retry: () => {
+            if (!lastInterruptedInput)
+                return false;
+            const retryInput = lastInterruptedInput;
+            lastInterruptedInput = null;
+            queue.resume();
+            enqueueInput(retryInput, { front: true });
+            return true;
+        },
+        status: () => {
+            const state = queue.getState();
+            return {
+                pendingCount: state.pendingCount,
+                isProcessing: state.isProcessing,
+                isPaused: state.isPaused,
+                hasInterrupted: Boolean(lastInterruptedInput),
+                interruptedInput: lastInterruptedInput || undefined,
+            };
+        },
+    };
+    const mergeAbortSignals = (signals) => {
+        const controller = new AbortController();
+        const listeners = [];
+        const abort = () => {
+            if (!controller.signal.aborted) {
+                controller.abort();
+            }
+        };
+        for (const signal of signals) {
+            if (!signal)
+                continue;
+            if (signal.aborted) {
+                abort();
+                break;
+            }
+            const handler = () => abort();
+            signal.addEventListener('abort', handler, { once: true });
+            listeners.push({ signal, handler });
+        }
+        const cleanup = () => {
+            for (const { signal, handler } of listeners) {
+                signal.removeEventListener('abort', handler);
+            }
+        };
+        return { signal: controller.signal, cleanup };
+    };
+    const withTimeout = async (promise, timeoutMs, onTimeout) => {
+        if (!timeoutMs)
+            return promise;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                onTimeout?.();
+                reject(new Error('Chat task timed out'));
+            }, timeoutMs);
+            promise
+                .then((result) => {
+                clearTimeout(timer);
+                resolve(result);
+            })
+                .catch((error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    };
+    await startGUI('chat', sessionManager, async (emit, input, guiOptions, dispatch) => {
+        if (input === undefined) {
+            latestDispatch = dispatch || (() => { });
+            latestEmit = emit;
+            latestGuiOptions = guiOptions;
+            // First run: load history into store
+            if (dispatch && session) {
+                dispatch({ type: 'SET_INPUT_HISTORY', payload: inputHistory });
+                dispatch({
+                    type: 'HYDRATE_TRANSCRIPT',
+                    payload: buildTranscriptMessages(sessionManager.getMessages(), { limit: 200 }),
+                });
+            }
+            const idShort = session.meta.id.slice(0, 8);
+            latestEmit?.({
+                type: 'log',
+                level: 'info',
+                message: sessionMode === 'new'
+                    ? text.cli.chatNewSession(idShort)
+                    : text.cli.chatResumed(idShort),
+                timestamp: new Date(),
+            });
+            return;
+        }
+        latestDispatch = dispatch || (() => { });
+        latestEmit = emit;
+        latestGuiOptions = guiOptions;
+        const dispatchResult = await slashRuntime.dispatch(input, {
+            emit,
+            sessionManager,
+            input,
+            dispatch: latestDispatch || (() => { }),
+            subAgentController,
+            queue: queueController,
+            toolAuthorization: options.toolAuthorization,
+            getLlmOutputPolicy: () => currentLlmOutputPolicy,
+            setLlmOutputPolicy: (policy) => {
+                currentLlmOutputPolicy = policy;
+            },
+            // Expose UI abort signal to slash handlers (e.g. tool authorization waits).
+            signal: latestGuiOptions?.signal,
+        });
+        if (dispatchResult.type === 'executed' || dispatchResult.type === 'blocked') {
+            return;
+        }
+        const trimmed = dispatchResult.trimmedInput;
+        if (!trimmed)
+            return;
+        return enqueueInput(trimmed);
+    }, {
+        markdownTheme: options.markdownTheme,
+        markdownRenderMode: options.markdownRenderMode,
+        logView: options.uiLogView,
+        logMode: options.uiLogMode,
+        findCommand: (name) => slashRuntime.findCommand(name),
+        getSuggestions: async (input) => {
+            if (!latestEmit || !latestDispatch)
+                return [];
+            return slashRuntime.getSuggestions(input, {
+                emit: latestEmit,
+                sessionManager,
+                input,
+                dispatch: latestDispatch,
+                subAgentController,
+                queue: queueController,
+                toolAuthorization: options.toolAuthorization,
+                getLlmOutputPolicy: () => currentLlmOutputPolicy,
+                setLlmOutputPolicy: (policy) => {
+                    currentLlmOutputPolicy = policy;
+                },
+                signal: latestGuiOptions?.signal,
+            });
+        },
+    });
+}
+//# sourceMappingURL=chat.js.map

package/dist/cli/cli-runtime-context.js

@@ -0,0 +1,12 @@
+import { detectHeadlessOutputFromArgv, } from './argv/headless-detection.js';
+import { rewriteArgvForPrintMode } from './argv/print-mode.js';
+export function createCliRuntimeContext(program, rawArgv) {
+    const rewrittenArgv = rewriteArgvForPrintMode(rawArgv);
+    const headlessDetection = detectHeadlessOutputFromArgv(rewrittenArgv);
+    return {
+        program,
+        rewrittenArgv,
+        headlessDetection,
+    };
+}
+//# sourceMappingURL=cli-runtime-context.js.map

package/dist/cli/commander-error-adapter.js

@@ -0,0 +1,35 @@
+import { getCommanderCode, getCommanderExitCode } from './commander-error-meta.js';
+import { createHeadlessErrorWriter } from './commands/run/headless-error-writer.js';
+import { createStdoutWriter } from './headless/stdout-writer.js';
+function isCommanderHelpLike(code) {
+    return code === 'commander.helpDisplayed' || code === 'commander.version';
+}
+export function isCommanderError(err) {
+    return (err instanceof Error ? err.name : undefined) === 'CommanderError';
+}
+export function shouldExitCommanderError(err) {
+    return !isCommanderHelpLike(getCommanderCode(err));
+}
+export function getCommanderErrorExitCode(err) {
+    return getCommanderExitCode(err) || 1;
+}
+export function emitHeadlessCommanderUsageError(params) {
+    if (!params.headlessDetection.outputFormat)
+        return;
+    if (isCommanderHelpLike(getCommanderCode(params.err)))
+        return;
+    const writer = createStdoutWriter();
+    const headlessErrorWriter = createHeadlessErrorWriter({
+        repoPath: params.headlessDetection.repoPath ?? process.cwd(),
+        outputFormat: params.headlessDetection.outputFormat,
+        outputProfileForStreamJson: params.headlessDetection.outputProfile ?? 'native',
+        writer,
+        getSessionId: () => undefined,
+        getResumeSessionId: () => params.headlessDetection.resumeSessionId,
+    });
+    headlessErrorWriter.writeUsageError({
+        message: params.err instanceof Error ? params.err.message : String(params.err),
+        instruction: params.headlessDetection.instruction,
+    });
+}
+//# sourceMappingURL=commander-error-adapter.js.map

package/dist/cli/commander-error-meta.js

@@ -0,0 +1,13 @@
+export function getCommanderCode(err) {
+    if (err && typeof err === 'object' && 'code' in err) {
+        return err.code;
+    }
+    return undefined;
+}
+export function getCommanderExitCode(err) {
+    if (err && typeof err === 'object' && 'exitCode' in err) {
+        return err.exitCode;
+    }
+    return undefined;
+}
+//# sourceMappingURL=commander-error-meta.js.map