salmon-loop 0.2.3

package/dist/cli/ui/index.js

@@ -0,0 +1,136 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { getLogger, LoopEventReporter } from '../../core/facades/cli-ui.js';
+import { text } from '../locales/index.js';
+import { App } from './App.js';
+const TECHNICAL_CONSOLE_PATTERN = /(AI_RetryError|APICallError|RetryError|Last error:|requestBodyValues|responseBody|statusCode:\s*\d+)/i;
+function shouldSuppressConsole(args) {
+    for (const arg of args) {
+        if (arg instanceof Error)
+            return true;
+        if (typeof arg === 'object' && arg !== null)
+            return true;
+        if (typeof arg === 'string' && TECHNICAL_CONSOLE_PATTERN.test(arg))
+            return true;
+    }
+    return false;
+}
+function sanitizeConsoleArgs(args) {
+    return args.map((arg) => {
+        if (typeof arg === 'string') {
+            const looksLikeDump = arg.length > 200 &&
+                /(APICallError|RetryError|\[Symbol\(vercel\.ai\.error|requestBodyValues|responseBody)\b/i.test(arg);
+            return looksLikeDump ? text.errors.technicalDetailsHidden : arg;
+        }
+        if (typeof arg === 'object' && arg !== null) {
+            const code = arg.code || arg.llmCode || arg.name || 'Object';
+            const msg = arg.message || '';
+            return msg ? `[${code}] ${msg}` : `[${code}]`;
+        }
+        return arg;
+    });
+}
+export async function startGUI(mode, sessionManager, runFn, uiConfig) {
+    // Silence global logger to prevent output from interfering with Ink
+    const preReporter = getLogger().getReporter();
+    const preSilent = getLogger().getSilent();
+    getLogger().setSilent(true);
+    const preConsole = {
+        error: console.error,
+        log: console.log,
+        warn: console.warn,
+    };
+    let resolveExit;
+    const exitPromise = new Promise((resolve) => {
+        resolveExit = resolve;
+    });
+    const { waitUntilExit, unmount } = render(_jsx(App, { mode: mode, sessionManager: sessionManager, markdownTheme: uiConfig?.markdownTheme, markdownRenderMode: uiConfig?.markdownRenderMode, logView: uiConfig?.logView, logMode: uiConfig?.logMode, getSuggestions: uiConfig?.getSuggestions, findCommand: uiConfig?.findCommand, onInit: (emit, options, dispatch) => {
+            if (mode !== 'chat')
+                return;
+            runFn(emit, undefined, options, dispatch).catch((err) => {
+                emit({
+                    type: 'log',
+                    message: `Chat Init Error: ${err.message}`,
+                    level: 'error',
+                    source: 'ui.startGUI',
+                    timestamp: new Date(),
+                });
+            });
+        }, onStart: (emit, options) => {
+            if (mode === 'run') {
+                // Route core logs through structured LoopEvents (GUI-safe; no stdout/stderr writes).
+                getLogger().setReporter(new LoopEventReporter(emit, { source: 'core.logger' }));
+                getLogger().setSilent(false);
+                runFn(emit, undefined, options)
+                    .then((result) => {
+                    setTimeout(() => {
+                        unmount();
+                        resolveExit(result);
+                    }, 1500);
+                })
+                    .catch((err) => {
+                    emit({
+                        type: 'log',
+                        message: err.message,
+                        level: 'error',
+                        source: 'ui.startGUI',
+                        timestamp: new Date(),
+                    });
+                    setTimeout(() => {
+                        unmount();
+                        resolveExit({ success: false, reason: err.message });
+                    }, 1500);
+                });
+            }
+        }, onChatInput: (input, emit, options, dispatch) => {
+            if (mode === 'chat') {
+                // Route core logs through structured LoopEvents (GUI-safe; no stdout/stderr writes).
+                getLogger().setReporter(new LoopEventReporter(emit, { source: 'core.logger' }));
+                getLogger().setSilent(false);
+                runFn(emit, input, options, dispatch).catch((err) => {
+                    emit({
+                        type: 'log',
+                        message: `Chat Error: ${err.message}`,
+                        level: 'error',
+                        source: 'ui.startGUI',
+                        timestamp: new Date(),
+                    });
+                });
+            }
+        } }), {
+        exitOnCtrlC: false,
+        patchConsole: true,
+    });
+    // Ink's patchConsole replaces console methods; re-wrap them to prevent object dumps from leaking
+    // into the UI render stream.
+    const inkConsoleError = console.error.bind(console);
+    const inkConsoleLog = console.log.bind(console);
+    const inkConsoleWarn = console.warn.bind(console);
+    console.error = (...args) => {
+        if (shouldSuppressConsole(args))
+            return;
+        inkConsoleError(...sanitizeConsoleArgs(args));
+    };
+    console.log = (...args) => {
+        if (shouldSuppressConsole(args))
+            return;
+        inkConsoleLog(...sanitizeConsoleArgs(args));
+    };
+    console.warn = (...args) => {
+        if (shouldSuppressConsole(args))
+            return;
+        inkConsoleWarn(...sanitizeConsoleArgs(args));
+    };
+    try {
+        const result = await Promise.race([waitUntilExit(), exitPromise]);
+        return result;
+    }
+    finally {
+        getLogger().setReporter(preReporter);
+        getLogger().setSilent(preSilent);
+        console.error = preConsole.error;
+        console.log = preConsole.log;
+        console.warn = preConsole.warn;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/ui/selection/bus.js

@@ -0,0 +1,35 @@
+let dispatchRef = null;
+let pendingRef = null;
+let resolverRef = null;
+export function bindSelectionDispatch(dispatch) {
+    dispatchRef = dispatch;
+}
+export function requestSelection(prompt) {
+    if (!dispatchRef)
+        return Promise.resolve(null);
+    if (resolverRef)
+        return Promise.resolve(null);
+    pendingRef = prompt;
+    dispatchRef({ type: 'SET_SELECTION', payload: prompt });
+    return new Promise((resolve) => {
+        resolverRef = resolve;
+    });
+}
+export function resolveSelection(id, itemIds) {
+    if (!pendingRef || pendingRef.id !== id || !resolverRef)
+        return;
+    const resolve = resolverRef;
+    resolverRef = null;
+    pendingRef = null;
+    dispatchRef?.({ type: 'CLEAR_SELECTION' });
+    resolve(itemIds);
+}
+export function rejectSelection() {
+    if (!pendingRef || !resolverRef)
+        return;
+    resolveSelection(pendingRef.id, null);
+}
+export function getPendingSelection() {
+    return pendingRef;
+}
+//# sourceMappingURL=bus.js.map

package/dist/cli/ui/status/formatStatusBanner.js

@@ -0,0 +1,8 @@
+export function formatStatusBanner(banner) {
+    const face = banner.face.trim();
+    const label = (banner.label ?? '').trim();
+    if (!label)
+        return face;
+    return `${face} ${label}`;
+}
+//# sourceMappingURL=formatStatusBanner.js.map

package/dist/cli/ui/store/context.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useContext, useReducer } from 'react';
+import { uiReducer, initialState } from './reducer.js';
+const UIStoreContext = createContext(undefined);
+export const UIStoreProvider = ({ children }) => {
+    const [state, dispatch] = useReducer(uiReducer, initialState);
+    const store = React.useMemo(() => ({ state, dispatch }), [state, dispatch]);
+    return _jsx(UIStoreContext.Provider, { value: store, children: children });
+};
+export const useUIStore = () => {
+    const context = useContext(UIStoreContext);
+    if (!context) {
+        throw new Error('useUIStore must be used within a UIStoreProvider');
+    }
+    return context;
+};
+//# sourceMappingURL=context.js.map

package/dist/cli/ui/store/reducer.js

@@ -0,0 +1,264 @@
+export const initialState = {
+    contextStack: ['base'],
+    // Static component optimization: completedMessages rendered via <Static>
+    completedMessages: [
+        {
+            id: 'welcome',
+            type: 'system',
+            content: 'WELCOME_LOGO',
+            timestamp: new Date(),
+        },
+    ],
+    activeStreamingMessage: null,
+    queueMessages: [],
+    logView: 'standard',
+    logMode: 'normal',
+    inputContent: '',
+    isSidebarVisible: process.stdout.columns >= 120,
+    terminalWidth: process.stdout.columns || 100,
+    terminalHeight: process.stdout.rows || 30,
+    missionTasks: [],
+    currentPhase: 'idle',
+    isThinking: false,
+    statusBanner: undefined,
+    interruptPending: undefined,
+    changedFiles: [],
+    inputHistory: [],
+};
+export function uiReducer(state, action) {
+    switch (action.type) {
+        case 'SET_INPUT':
+            return { ...state, inputContent: action.payload };
+        case 'SET_LOG_VIEW':
+            return { ...state, logView: action.payload };
+        case 'SET_LOG_MODE':
+            return { ...state, logMode: action.payload };
+        case 'ADD_MESSAGE':
+            return {
+                ...state,
+                completedMessages: [...state.completedMessages, action.payload],
+            };
+        case 'HYDRATE_TRANSCRIPT': {
+            const welcomeMessage = {
+                id: 'welcome',
+                type: 'system',
+                content: 'WELCOME_LOGO',
+                timestamp: new Date(),
+            };
+            return {
+                ...state,
+                completedMessages: [welcomeMessage, ...action.payload],
+                activeStreamingMessage: null,
+                queueMessages: [],
+                pendingAuthorization: undefined,
+                pendingSelection: undefined,
+            };
+        }
+        case 'APPEND_LLM_STREAM': {
+            const { id, delta, timestamp } = action.payload;
+            if (!delta)
+                return state;
+            // If active streaming message exists, accumulate delta
+            if (state.activeStreamingMessage?.id === id) {
+                const updatedActive = {
+                    ...state.activeStreamingMessage,
+                    content: state.activeStreamingMessage.content + delta,
+                };
+                return {
+                    ...state,
+                    activeStreamingMessage: updatedActive,
+                };
+            }
+            // Avoid creating an empty streaming message from whitespace-only prelude chunks.
+            // Once a stream exists, we preserve all deltas (including newlines) for correct formatting.
+            if (delta.trim().length === 0)
+                return state;
+            // Create new active streaming message
+            const newMessage = {
+                id,
+                type: 'assistant',
+                content: delta,
+                timestamp,
+                streamState: 'streaming',
+            };
+            return {
+                ...state,
+                activeStreamingMessage: newMessage,
+            };
+        }
+        case 'ADD_QUEUE_MESSAGE':
+            return { ...state, queueMessages: [...state.queueMessages, action.payload] };
+        case 'SHIFT_QUEUE_MESSAGE':
+            return { ...state, queueMessages: state.queueMessages.slice(1) };
+        case 'REMOVE_QUEUE_MESSAGE':
+            return {
+                ...state,
+                queueMessages: state.queueMessages.filter((msg) => msg.id !== action.payload.id),
+            };
+        case 'CLEAR_QUEUE_MESSAGES':
+            return { ...state, queueMessages: [] };
+        case 'PUSH_CONTEXT':
+            return { ...state, contextStack: [...state.contextStack, action.payload] };
+        case 'POP_CONTEXT': {
+            if (state.contextStack.length <= 1)
+                return state;
+            const newStack = [...state.contextStack];
+            newStack.pop();
+            return { ...state, contextStack: newStack };
+        }
+        case 'TOGGLE_SIDEBAR':
+            return { ...state, isSidebarVisible: !state.isSidebarVisible };
+        case 'UPDATE_DIMENSIONS':
+            return {
+                ...state,
+                terminalWidth: action.payload.width,
+                terminalHeight: action.payload.height,
+                // Auto-hide sidebar if width is too small
+                isSidebarVisible: action.payload.width >= 120 ? state.isSidebarVisible : true,
+            };
+        case 'SET_THINKING':
+            return { ...state, isThinking: action.payload };
+        case 'SET_STATUS_BANNER':
+            return { ...state, statusBanner: action.payload ?? undefined };
+        case 'CLEAR_STATUS_BANNER':
+            if (action.payload?.source && state.statusBanner?.source !== action.payload.source) {
+                return state;
+            }
+            return { ...state, statusBanner: undefined };
+        case 'FINALIZE_INTERRUPT': {
+            if (!state.interruptPending)
+                return state;
+            const interruptMessage = {
+                id: `interrupt-${Date.now()}`,
+                type: 'interrupt',
+                content: state.interruptPending.content ?? '',
+                timestamp: action.payload?.timestamp ?? state.interruptPending.timestamp,
+            };
+            return {
+                ...state,
+                completedMessages: [...state.completedMessages, interruptMessage],
+                interruptPending: undefined,
+            };
+        }
+        case 'UPDATE_PHASE':
+            return {
+                ...state,
+                currentPhase: action.payload,
+                isThinking: action.status === 'running',
+            };
+        case 'UPDATE_WORKSPACE':
+            return {
+                ...state,
+                missionTasks: [
+                    ...state.missionTasks,
+                    {
+                        id: `ws-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+                        content: `Workspace initialized at ${action.payload.path}`,
+                        status: 'completed',
+                    },
+                ],
+            };
+        case 'SET_CHANGED_FILES':
+            return { ...state, changedFiles: action.payload };
+        case 'SET_INPUT_HISTORY':
+            return { ...state, inputHistory: action.payload };
+        case 'APPEND_INPUT': {
+            const trimmed = action.payload.trim();
+            if (!trimmed || trimmed.startsWith('/'))
+                return state;
+            // Deduplication logic
+            if (state.inputHistory.length > 0 &&
+                state.inputHistory[state.inputHistory.length - 1] === trimmed) {
+                return state;
+            }
+            return {
+                ...state,
+                inputHistory: [...state.inputHistory, trimmed].slice(-500),
+            };
+        }
+        case 'COMPLETE_STREAM': {
+            if (!state.activeStreamingMessage)
+                return state;
+            if (action.payload?.id &&
+                action.payload.id !== 'flush-all' &&
+                state.activeStreamingMessage.id !== action.payload.id) {
+                return state;
+            }
+            const completed = {
+                ...state.activeStreamingMessage,
+                streamState: 'completed',
+            };
+            return {
+                ...state,
+                completedMessages: [...state.completedMessages, completed],
+                activeStreamingMessage: null,
+            };
+        }
+        case 'SET_CONFIRMATION':
+            return { ...state, pendingConfirmation: action.payload };
+        case 'CLEAR_CONFIRMATION':
+            return { ...state, pendingConfirmation: undefined };
+        case 'SET_AUTHORIZATION':
+            return { ...state, pendingAuthorization: action.payload };
+        case 'CLEAR_AUTHORIZATION':
+            return { ...state, pendingAuthorization: undefined };
+        case 'SET_SELECTION':
+            return { ...state, pendingSelection: action.payload };
+        case 'CLEAR_SELECTION':
+            return { ...state, pendingSelection: undefined };
+        case 'RESET_MESSAGES': {
+            const welcomeMessage = {
+                id: 'welcome',
+                type: 'system',
+                content: 'WELCOME_LOGO',
+                timestamp: new Date(),
+            };
+            return {
+                ...state,
+                completedMessages: [welcomeMessage],
+                activeStreamingMessage: null,
+                queueMessages: [],
+                pendingAuthorization: undefined,
+                pendingSelection: undefined,
+            };
+        }
+        case 'INTERRUPT_STREAM': {
+            if (state.interruptPending) {
+                return {
+                    ...state,
+                    isThinking: false,
+                    currentPhase: 'idle',
+                };
+            }
+            const pending = {
+                content: action.payload?.content,
+                timestamp: action.payload?.timestamp ?? new Date(),
+            };
+            if (!state.activeStreamingMessage) {
+                return {
+                    ...state,
+                    interruptPending: pending,
+                    isThinking: false,
+                    currentPhase: 'idle',
+                };
+            }
+            const interrupted = {
+                ...state.activeStreamingMessage,
+                streamState: 'paused',
+            };
+            return {
+                ...state,
+                interruptPending: pending,
+                completedMessages: [...state.completedMessages, interrupted],
+                activeStreamingMessage: null,
+                isThinking: false,
+                currentPhase: 'idle',
+            };
+        }
+        case 'UPDATE_PROGRESS':
+            return { ...state, terminalHeight: action.payload };
+        default:
+            return state;
+    }
+}
+//# sourceMappingURL=reducer.js.map

package/dist/cli/ui/store/types.js

@@ -0,0 +1,81 @@
+/**
+ * Get display level for a message type
+ */
+export function getMessageLevel(type) {
+    switch (type) {
+        case 'assistant':
+        case 'assistant_stream':
+        case 'error':
+        case 'warning':
+        case 'todo_card':
+            return 'emphasis';
+        case 'user':
+        case 'tool_result':
+        case 'checkpoint':
+        case 'interrupt':
+        case 'thinking':
+        case 'explore_step':
+        case 'plan_step':
+        case 'patch_step':
+        case 'apply_step':
+        case 'validate_step':
+        case 'verify_step':
+        case 'preflight_step':
+        case 'context_step':
+        case 'ast_validate_step':
+        case 'rollback_step':
+        case 'shrink_step':
+        case 'review_step':
+        case 'report_step':
+        case 'analyze_issues_step':
+            return 'standard';
+        case 'system':
+        case 'queue':
+        case 'tool_call':
+        case 'welcome':
+        default:
+            return 'lightweight';
+    }
+}
+/**
+ * Convert legacy message type to new type
+ */
+export function normalizeLegacyType(type) {
+    if (type === 'ai')
+        return 'assistant';
+    const validTypes = [
+        'user',
+        'assistant',
+        'assistant_stream',
+        'system',
+        'tool_call',
+        'tool_result',
+        'explore_step',
+        'plan_step',
+        'patch_step',
+        'apply_step',
+        'validate_step',
+        'verify_step',
+        'preflight_step',
+        'context_step',
+        'ast_validate_step',
+        'rollback_step',
+        'shrink_step',
+        'review_step',
+        'report_step',
+        'analyze_issues_step',
+        'thinking',
+        'checkpoint',
+        'error',
+        'warning',
+        'queue',
+        'interrupt',
+        'todo_card',
+        'welcome',
+    ];
+    if (validTypes.includes(type)) {
+        return type;
+    }
+    return 'system';
+}
+//# sourceMappingURL=types.js.map