salmon-loop 0.2.3

package/dist/cli/slash/runtime.js

@@ -0,0 +1,240 @@
+import { createSlashRegistry, createStandardToolstack, executeSkill, logIgnoredError, getLogger, RuntimeEnvironment, SkillLoader, SlashRouter, } from '../../core/facades/cli-slash-runtime.js';
+import { suggestSubcommands } from '../commands/subcommand-suggestions.js';
+import { text } from '../locales/index.js';
+function isSafeSkillId(id) {
+    return /^[a-z0-9][a-z0-9-_]*$/i.test(id);
+}
+function skillToSlashSpec(skill) {
+    const id = String(skill.id || '').trim();
+    if (!id || !isSafeSkillId(id))
+        return null;
+    return {
+        name: `/${id}`,
+        description: skill.metadata?.description || `Skill: ${id}`,
+        hidden: skill.metadata?.userInvocable === false,
+        order: 220,
+    };
+}
+function commandToSlashSpec(cmd) {
+    return {
+        name: cmd.name,
+        description: cmd.description,
+        aliases: cmd.aliases,
+        hidden: cmd.hidden,
+        order: cmd.order,
+    };
+}
+export async function createCliSlashRuntime(options) {
+    const skillLoader = new SkillLoader({
+        repoRoot: options.repoRoot,
+        useDefaults: options.skillDiscovery?.useDefaults,
+        extraPaths: options.skillDiscovery?.paths,
+    });
+    const skills = await skillLoader.initialize();
+    const skillSpecs = skills.map(skillToSlashSpec).filter((s) => Boolean(s));
+    const commandSpecs = options.baseCommands.map(commandToSlashSpec);
+    // /help is best-effort and must reflect the effective registry (including skills).
+    const helpSpec = {
+        name: '/help',
+        description: 'Show available commands',
+        order: 80,
+    };
+    const registry = createSlashRegistry({
+        commands: [helpSpec, ...commandSpecs, ...skillSpecs],
+    });
+    const commandTokenIndex = new Map();
+    for (const cmd of options.baseCommands) {
+        commandTokenIndex.set(cmd.name.toLowerCase(), cmd);
+        for (const alias of cmd.aliases ?? []) {
+            commandTokenIndex.set(alias.toLowerCase(), cmd);
+        }
+    }
+    const skillBySlash = new Map();
+    for (const skill of skills) {
+        const spec = skillToSlashSpec(skill);
+        if (!spec)
+            continue;
+        skillBySlash.set(spec.name.toLowerCase(), skill);
+    }
+    const handlers = {
+        getHandler(commandName) {
+            const normalized = commandName.toLowerCase();
+            if (normalized === '/help') {
+                const handler = {
+                    execute: async (_req) => {
+                        const visible = registry.list().filter((c) => !c.hidden);
+                        const maxName = Math.max(...visible.map((c) => c.name.length), 0);
+                        const rows = visible.map((c) => `${c.name}`.padEnd(maxName + 2) + c.description);
+                        options.emit({
+                            type: 'log',
+                            level: 'info',
+                            message: text.cli.helpAvailableCommands(rows.join('\n')),
+                            timestamp: new Date(),
+                        });
+                        return { kind: 'consumed' };
+                    },
+                };
+                return handler;
+            }
+            const base = commandTokenIndex.get(normalized);
+            if (base) {
+                const baseGetSuggestions = base.getSuggestions ??
+                    (base.subcommands && base.subcommands.length > 0
+                        ? async (ctx) => suggestSubcommands(base, ctx)
+                        : undefined);
+                return {
+                    execute: async (req) => {
+                        const meta = (req.meta ?? {});
+                        await base.execute({
+                            emit: meta.emit,
+                            sessionManager: meta.sessionManager,
+                            input: req.rawInput,
+                            dispatch: meta.dispatch,
+                            queue: meta.queue,
+                            toolAuthorization: meta.toolAuthorization,
+                            getLlmOutputPolicy: meta.getLlmOutputPolicy,
+                            setLlmOutputPolicy: meta.setLlmOutputPolicy,
+                        });
+                        return { kind: 'consumed' };
+                    },
+                    getSuggestions: baseGetSuggestions
+                        ? async (_slashReq) => {
+                            const meta = (_slashReq.meta ?? {});
+                            const suggestions = await baseGetSuggestions({
+                                emit: meta.emit,
+                                sessionManager: meta.sessionManager,
+                                input: _slashReq.rawInput,
+                                dispatch: meta.dispatch,
+                                queue: meta.queue,
+                                toolAuthorization: meta.toolAuthorization,
+                                getLlmOutputPolicy: meta.getLlmOutputPolicy,
+                                setLlmOutputPolicy: meta.setLlmOutputPolicy,
+                            });
+                            return suggestions.map((s) => ({ name: s.name, description: s.description }));
+                        }
+                        : undefined,
+                };
+            }
+            const skill = skillBySlash.get(normalized);
+            if (skill) {
+                return {
+                    execute: async (req) => {
+                        const meta = (req.meta ?? {});
+                        const signal = meta?.signal;
+                        // Prepare an isolated worktree environment for governed shell execution.
+                        const silentEmit = (event) => {
+                            if (event?.type === 'log' && event?.level === 'error') {
+                                options.emit(event);
+                                return;
+                            }
+                            getLogger().debug(`[slash.skill] ${JSON.stringify(event)}`);
+                        };
+                        const env = new RuntimeEnvironment({
+                            instruction: `slash:${skill.id}`,
+                            repoPath: options.repoRoot,
+                            strategy: 'worktree',
+                            dryRun: false,
+                            verbose: undefined,
+                        }, silentEmit);
+                        try {
+                            await env.setup();
+                            const toolstack = await createStandardToolstack({
+                                repoRoot: env.activeRepoPath,
+                                persistenceRoot: options.repoRoot,
+                                worktreeRoot: env.activeRepoPath,
+                                attemptId: 0,
+                                dryRun: false,
+                                allowedToolNames: ['shell.exec'],
+                                authorizationProvider: options.authorizationProvider,
+                                authorizationMode: 'deferred',
+                            });
+                            const res = await executeSkill({
+                                skill,
+                                argsText: req.argsText,
+                                toolRouter: toolstack.router,
+                                toolCtx: {
+                                    repoRoot: env.activeRepoPath,
+                                    worktreeRoot: env.activeRepoPath,
+                                    persistenceRoot: options.repoRoot,
+                                    attemptId: 0,
+                                    dryRun: false,
+                                },
+                                signal,
+                            });
+                            if (res.status !== 'SUCCESS' || !res.injectedPrompt.trim()) {
+                                options.emit({
+                                    type: 'log',
+                                    level: 'error',
+                                    message: text.cli.skillNoPrompt(skill.id),
+                                    timestamp: new Date(),
+                                });
+                                return { kind: 'consumed' };
+                            }
+                            return { kind: 'rewrite', input: res.injectedPrompt };
+                        }
+                        finally {
+                            await env
+                                .teardown()
+                                .catch((error) => logIgnoredError('[SlashRuntime] env teardown failed', error));
+                        }
+                    },
+                };
+            }
+            return undefined;
+        },
+    };
+    const router = new SlashRouter({
+        registry,
+        handlers,
+        unknownSlashPolicy: 'block',
+    });
+    const mapDecisionToDispatch = (decision) => {
+        if (decision.kind === 'consumed')
+            return { type: 'executed' };
+        if (decision.kind === 'rewrite') {
+            return { type: 'continue', trimmedInput: decision.input };
+        }
+        if (decision.kind === 'forward') {
+            return { type: 'continue', trimmedInput: decision.input };
+        }
+        if (decision.kind === 'block') {
+            if (decision.code === 'UNKNOWN_SLASH') {
+                const cmd = String(decision.details?.commandName ?? '');
+                const firstWord = cmd.split(/\s+/)[0] || cmd;
+                const message = text.cli.unknownCommand(firstWord);
+                return { type: 'blocked', reason: message };
+            }
+            const message = decision.code === 'NO_HANDLER'
+                ? text.cli.slashHandlerUnavailable
+                : text.cli.slashInternalError;
+            return { type: 'blocked', reason: message };
+        }
+        return { type: 'executed' };
+    };
+    const findCommand = (name) => commandTokenIndex.get(name.trim().toLowerCase());
+    return {
+        router,
+        findCommand,
+        async getSuggestions(input, context) {
+            const items = await router.suggest(input, context);
+            return items.map((i) => {
+                const cmd = findCommand(i.commandName || i.name.trim());
+                return { name: i.name, description: i.description, command: cmd };
+            });
+        },
+        async dispatch(input, context) {
+            const decision = await router.dispatch(input, context);
+            const mapped = mapDecisionToDispatch(decision);
+            if (mapped.type === 'blocked') {
+                options.emit({
+                    type: 'log',
+                    level: 'error',
+                    message: mapped.reason,
+                    timestamp: new Date(),
+                });
+            }
+            return mapped;
+        },
+    };
+}
+//# sourceMappingURL=runtime.js.map

package/dist/cli/ui/App.js

@@ -0,0 +1,273 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import React from 'react';
+import { logIgnoredError, readPlan } from '../../core/facades/cli-ui.js';
+import { text } from '../locales/index.js';
+import { bindAuthorizationDispatch, resolveAuthorization } from './authorization/bus.js';
+import { StretchingThinking } from './components/animations/StretchingThinking.js';
+import { CommandInput } from './components/CommandInput.js';
+import { MessageList } from './components/MessageList.js';
+import { StatusBannerLine } from './components/StatusBannerLine.js';
+import { TodoDrawer } from './components/TodoDrawer.js';
+import { UI_CONFIG } from './config.js';
+import { useCommandLifecycle } from './hooks/useCommandLifecycle.js';
+import { useLoopEvents } from './hooks/useLoopEvents.js';
+import { useTerminalDimensions } from './hooks/useTerminalDimensions.js';
+import { bindSelectionDispatch } from './selection/bus.js';
+import { UIStoreProvider, useUIStore } from './store/context.js';
+import { COLORS } from './styles/theme.js';
+const MemoMessageList = React.memo(MessageList);
+function buildTodoSummaryCard(todos) {
+    const maxItems = 12;
+    const preview = todos.slice(0, maxItems);
+    const lines = [];
+    for (const t of preview) {
+        const checked = t.status === 'done';
+        // Keep TODO cards as plain text to avoid markdown list bullets (e.g. "*") injected by terminal renderers.
+        lines.push(`[${checked ? 'x' : ' '}] ${t.text}`);
+    }
+    if (todos.length > preview.length) {
+        lines.push(`… and ${todos.length - preview.length} more`);
+    }
+    return lines.join('\n');
+}
+function parseTodoPriority(text) {
+    const trimmed = text.trimStart();
+    const first = trimmed[0];
+    if (first === '!')
+        return { priority: 'high', text: trimmed.slice(1).trimStart() };
+    if (first === '·')
+        return { priority: 'medium', text: trimmed.slice(1).trimStart() };
+    if (first === '‐')
+        return { priority: 'low', text: trimmed.slice(1).trimStart() };
+    return { priority: undefined, text: text.trim() };
+}
+function toTodoStatus(step) {
+    if (step.checkbox === 'checked' || step.status === 'done')
+        return 'done';
+    if (step.status === 'active' || step.status === 'conflict')
+        return 'in_progress';
+    return 'pending';
+}
+function toTodoItems(read) {
+    const ordered = [...(read.active ?? []), ...(read.pending ?? []), ...(read.recentDone ?? [])];
+    const seen = new Set();
+    const items = [];
+    for (const step of ordered) {
+        if (!step?.stepId || seen.has(step.stepId))
+            continue;
+        seen.add(step.stepId);
+        if (step.stepId === 'work_root')
+            continue;
+        const parsed = parseTodoPriority(step.text);
+        items.push({
+            id: step.stepId,
+            status: toTodoStatus(step),
+            text: parsed.text,
+            priority: parsed.priority,
+        });
+    }
+    return items;
+}
+export const AppCore = ({ mode, onStart, onChatInput, getSuggestions: getSuggestionsProp, findCommand, onInit, sessionManager, markdownTheme, markdownRenderMode, logView, logMode, }) => {
+    const { state, dispatch } = useUIStore();
+    React.useEffect(() => {
+        if (!logView)
+            return;
+        dispatch({ type: 'SET_LOG_VIEW', payload: logView });
+    }, [dispatch, logView]);
+    React.useEffect(() => {
+        if (!logMode)
+            return;
+        dispatch({ type: 'SET_LOG_MODE', payload: logMode });
+    }, [dispatch, logMode]);
+    const lifecycleStatus = state.isThinking ? 'running' : 'idle';
+    const { signal } = useCommandLifecycle(lifecycleStatus, () => process.exit(0));
+    // Use modular hooks for environment and loop events
+    useTerminalDimensions();
+    const [todoExpanded, setTodoExpanded] = React.useState(false);
+    const [todoItems, setTodoItems] = React.useState([]);
+    const [taskRunning, setTaskRunning] = React.useState(false);
+    const repoRootRef = React.useRef(process.cwd());
+    if (repoRootRef.current === process.cwd()) {
+        try {
+            repoRootRef.current = String(sessionManager.getCurrent().meta.repoPath ?? process.cwd());
+        }
+        catch {
+            // ignore
+        }
+    }
+    React.useEffect(() => {
+        try {
+            repoRootRef.current = String(sessionManager.getCurrent().meta.repoPath ?? process.cwd());
+        }
+        catch {
+            repoRootRef.current = process.cwd();
+        }
+    }, [sessionManager]);
+    const todoSessionRef = React.useRef(null);
+    const refreshTimerRef = React.useRef(null);
+    const refreshTodos = React.useCallback(async () => {
+        const runtime = todoSessionRef.current;
+        if (!runtime?.sessionId)
+            return [];
+        try {
+            const res = await readPlan({
+                persistenceRoot: repoRootRef.current,
+                sessionId: runtime.sessionId,
+            });
+            const items = toTodoItems(res);
+            setTodoItems(items);
+            return items;
+        }
+        catch {
+            // Best-effort; UI should never crash due to plan persistence issues.
+            return [];
+        }
+    }, []);
+    const scheduleRefreshTodos = React.useCallback(() => {
+        if (refreshTimerRef.current)
+            clearTimeout(refreshTimerRef.current);
+        refreshTimerRef.current = setTimeout(() => {
+            refreshTodos().catch((error) => logIgnoredError('[UI] refreshTodos failed', error));
+        }, 120);
+    }, [refreshTodos]);
+    React.useEffect(() => {
+        return () => {
+            if (refreshTimerRef.current)
+                clearTimeout(refreshTimerRef.current);
+        };
+    }, []);
+    const interceptEvent = React.useCallback((event) => {
+        if (event.type === 'plan.runtime.ready') {
+            todoSessionRef.current = { sessionId: event.sessionId, planPathHint: event.planPathHint };
+            scheduleRefreshTodos();
+        }
+        else if (event.type === 'plan.runtime.unavailable') {
+            todoSessionRef.current = null;
+            setTodoItems([]);
+        }
+        else if (event.type === 'run.start') {
+            // Prevent stale TODOs from a previous interrupted run from re-hydrating
+            // before the new runtime plan is initialized.
+            todoSessionRef.current = null;
+            setTodoItems([]);
+            setTodoExpanded(true);
+            setTaskRunning(true);
+            scheduleRefreshTodos();
+        }
+        else if (event.type === 'run.end') {
+            void (async () => {
+                const items = await refreshTodos();
+                if (items.length === 0)
+                    return;
+                const normalized = event.success
+                    ? items.map((t) => ({ ...t, status: 'done' }))
+                    : items;
+                const content = buildTodoSummaryCard(normalized);
+                dispatch({
+                    type: 'ADD_MESSAGE',
+                    payload: {
+                        id: `todo-card-${Date.now()}`,
+                        type: 'todo_card',
+                        content,
+                        timestamp: new Date(),
+                    },
+                });
+            })();
+            setTodoExpanded(false);
+            setTaskRunning(false);
+        }
+        else if (event.type === 'phase.end') {
+            if (event.phase === 'PLAN') {
+                scheduleRefreshTodos();
+            }
+        }
+        else if (event.type === 'tool.call.end') {
+            if (typeof event.toolName === 'string' && event.toolName.startsWith('plan.')) {
+                scheduleRefreshTodos();
+            }
+        }
+    }, [dispatch, refreshTodos, scheduleRefreshTodos]);
+    const { sanitizeAndDispatch } = useLoopEvents(mode, onStart, signal, {
+        interceptEvent,
+    });
+    const initCalledRef = React.useRef(false);
+    React.useEffect(() => {
+        if (mode !== 'chat')
+            return;
+        if (!onInit)
+            return;
+        if (initCalledRef.current)
+            return;
+        initCalledRef.current = true;
+        onInit((event) => sanitizeAndDispatch(event), { signal }, dispatch);
+    }, [mode, onInit, signal, dispatch, sanitizeAndDispatch]);
+    const pendingConfirmationRef = React.useRef(state.pendingConfirmation);
+    React.useEffect(() => {
+        pendingConfirmationRef.current = state.pendingConfirmation;
+    }, [state.pendingConfirmation]);
+    React.useEffect(() => {
+        bindAuthorizationDispatch(dispatch);
+    }, [dispatch]);
+    React.useEffect(() => {
+        bindSelectionDispatch(dispatch);
+    }, [dispatch]);
+    const handleChatInput = React.useCallback(async (value) => {
+        if (!onChatInput)
+            return;
+        const result = await onChatInput(value, (ev) => sanitizeAndDispatch(ev), {
+            signal,
+        }, dispatch);
+        if (result?.action === 'NEED_CONFIRMATION') {
+            dispatch({ type: 'SET_CONFIRMATION', payload: result.data });
+        }
+        else {
+            dispatch({ type: 'SET_INPUT', payload: '' });
+            if (pendingConfirmationRef.current) {
+                dispatch({ type: 'CLEAR_CONFIRMATION' });
+            }
+        }
+        return result;
+    }, [dispatch, onChatInput, sanitizeAndDispatch, signal]);
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsx(Box, { flexGrow: 1, flexDirection: "column", paddingX: UI_CONFIG.MESSAGE_AREA_PADDING_X, paddingBottom: UI_CONFIG.MESSAGE_AREA_PADDING_BOTTOM, children: _jsx(MemoMessageList, { markdownTheme: markdownTheme, markdownRenderMode: markdownRenderMode }) }), (state.isThinking || state.statusBanner) && (_jsx(Box, { paddingX: UI_CONFIG.MESSAGE_AREA_PADDING_X, paddingY: 0, flexShrink: 0, children: state.statusBanner ? (_jsx(StatusBannerLine, { face: state.statusBanner.face, label: state.statusBanner.label })) : (_jsx(StretchingThinking, {})) })), taskRunning && todoItems.length > 0 && (_jsx(TodoDrawer, { todos: todoItems, isExpanded: todoExpanded, onToggle: () => setTodoExpanded((v) => !v) })), _jsx(Box, { flexDirection: "column", marginTop: 0, flexShrink: 0, borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, borderColor: COLORS.border.subtle, children: _jsxs(Box, { paddingY: 1, flexDirection: "row", paddingX: UI_CONFIG.INPUT_ROW_PADDING_X, children: [_jsx(Box, { marginRight: 1, children: _jsxs(Text, { color: COLORS.semantic.salmon, bold: true, children: [' ', 's8p>', ' '] }) }), _jsx(CommandInput, { value: state.inputContent, onChange: (val) => dispatch({ type: 'SET_INPUT', payload: val }), getSuggestions: (input) => getSuggestionsProp ? getSuggestionsProp(input) : Promise.resolve([]), findCommand: findCommand, onSubmit: async (val) => {
+                                if (state.pendingAuthorization) {
+                                    const trimmed = val.trim();
+                                    const [challenge, mode] = trimmed.split(/\s+/);
+                                    if (challenge === state.pendingAuthorization.challenge) {
+                                        if (mode === 'save' || mode === 'repo') {
+                                            resolveAuthorization(state.pendingAuthorization.id, {
+                                                outcome: 'allow',
+                                                persist: 'repo',
+                                            });
+                                        }
+                                        else if (mode === 'global' || mode === 'user') {
+                                            resolveAuthorization(state.pendingAuthorization.id, {
+                                                outcome: 'allow',
+                                                persist: 'user',
+                                            });
+                                        }
+                                        else {
+                                            const allowSession = mode === 'all' || mode === 'session';
+                                            resolveAuthorization(state.pendingAuthorization.id, {
+                                                outcome: allowSession ? 'allow_session' : 'allow_once',
+                                            });
+                                        }
+                                    }
+                                    dispatch({ type: 'SET_INPUT', payload: '' });
+                                    return;
+                                }
+                                if (onChatInput && val.trim()) {
+                                    // Chat message ordering is owned by the chat runtime (queue + event pipeline).
+                                    // Avoid duplicating user messages here; `src/cli/chat.ts` is the single source of truth.
+                                    try {
+                                        await handleChatInput(val);
+                                    }
+                                    catch (_error) {
+                                        // Swallow to keep UI responsive.
+                                    }
+                                }
+                            }, placeholder: text.cli.gui.inputPlaceholder })] }) })] }));
+};
+export const App = (props) => (_jsx(UIStoreProvider, { children: _jsx(AppCore, { ...props }) }));
+//# sourceMappingURL=App.js.map

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

@@ -0,0 +1,35 @@
+let dispatchRef = null;
+let pendingRef = null;
+let resolverRef = null;
+export function bindAuthorizationDispatch(dispatch) {
+    dispatchRef = dispatch;
+}
+export function requestAuthorization(prompt) {
+    if (!dispatchRef)
+        return Promise.resolve({ outcome: 'deny', reason: 'UI unavailable' });
+    if (resolverRef)
+        return Promise.resolve({ outcome: 'deny', reason: 'Authorization pending' });
+    pendingRef = prompt;
+    dispatchRef({ type: 'SET_AUTHORIZATION', payload: prompt });
+    return new Promise((resolve) => {
+        resolverRef = resolve;
+    });
+}
+export function resolveAuthorization(id, decision) {
+    if (!pendingRef || pendingRef.id !== id || !resolverRef)
+        return;
+    const resolve = resolverRef;
+    resolverRef = null;
+    pendingRef = null;
+    dispatchRef?.({ type: 'CLEAR_AUTHORIZATION' });
+    resolve(decision);
+}
+export function rejectAuthorization() {
+    if (!pendingRef || !resolverRef)
+        return;
+    resolveAuthorization(pendingRef.id, { outcome: 'deny', reason: 'User cancelled' });
+}
+export function getPendingAuthorization() {
+    return pendingRef;
+}
+//# sourceMappingURL=bus.js.map