salmon-loop 0.2.3

package/dist/cli/commands/allowlist.js

@@ -0,0 +1,270 @@
+import { EXECUTION_PHASES, getLogger } from '../../core/facades/cli-command-allowlist.js';
+import { clearAllowlist, clearAllowlistCache, listAllowlist, persistAllowlistDecision, removeAllowlistRule, } from '../authorization/allowlist.js';
+import { text } from '../locales/index.js';
+import { clearKnownToolNames, getKnownToolNames, getKnownToolNamesSync, validateSideEffects, } from './tool-names.js';
+import { hashArgsInput, parseSuggestionContext, parseToken, parseTokenList } from './utils.js';
+export const allowlistCommand = {
+    name: '/allowlist',
+    description: text.cli.commandAuth,
+    order: 70,
+    hidden: true,
+    getSuggestions: ({ input }) => {
+        const { argIndex, currentPrefix } = parseSuggestionContext(input);
+        const parts = input.trimStart().split(/\s+/);
+        const sub = parts[1]?.toLowerCase();
+        if (argIndex === 1) {
+            const subCommands = ['list', 'add', 'remove', 'clear', 'hash', 'reload'];
+            const search = currentPrefix.toLowerCase();
+            return subCommands
+                .filter((s) => s.startsWith(search))
+                .map((s) => ({ name: s, description: text.cli.authSubcommandHint(s) }));
+        }
+        if (argIndex === 2 && ['list', 'add', 'remove', 'clear'].includes(sub)) {
+            const scopes = ['repo', 'user'];
+            const search = currentPrefix.toLowerCase();
+            return scopes
+                .filter((s) => s.startsWith(search))
+                .map((s) => ({ name: s, description: text.cli.authScopeHint(s) }));
+        }
+        if (argIndex === 3 && ['add', 'remove'].includes(sub)) {
+            const repoRoot = process.cwd();
+            const search = currentPrefix.toLowerCase();
+            const tools = Array.from(getKnownToolNamesSync(repoRoot)).filter((name) => name.toLowerCase().startsWith(search));
+            return tools.map((tool) => ({
+                name: tool,
+                description: text.cli.authToolNameHint,
+            }));
+        }
+        if (argIndex === 4 && ['add', 'remove'].includes(sub)) {
+            const phases = EXECUTION_PHASES.map((p) => p.toLowerCase());
+            const search = currentPrefix.toLowerCase();
+            return phases
+                .filter((p) => p.startsWith(search))
+                .map((p) => ({ name: p, description: text.cli.authPhaseHint(p) }));
+        }
+        return [];
+    },
+    execute: async ({ emit, input, sessionManager, toolAuthorization }) => {
+        const repoRoot = sessionManager.getCurrent().meta.repoPath;
+        const config = toolAuthorization;
+        if (!config) {
+            emit({
+                type: 'log',
+                level: 'error',
+                message: text.cli.authConfigMissing,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const args = input.trim().split(/\s+/).slice(1);
+        const subCommand = (args[0] || 'list').toLowerCase();
+        const scopeArg = args[1]?.toLowerCase();
+        const scope = scopeArg === 'user' ? 'user' : 'repo';
+        if (subCommand === 'reload') {
+            await clearAllowlistCache({ config, repoRoot });
+            clearKnownToolNames(repoRoot);
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.authCacheCleared,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        if (subCommand === 'hash') {
+            const raw = args.slice(1).join(' ').trim();
+            if (!raw) {
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.authHashUsage,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const hash = hashArgsInput(raw);
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.authHashResult(hash),
+                timestamp: new Date(),
+            });
+            return;
+        }
+        if (subCommand === 'list') {
+            const allowlist = await listAllowlist({ config, repoRoot, scope });
+            const entries = Object.entries(allowlist.tools);
+            if (entries.length === 0) {
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.authListEmpty(scope),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const lines = entries.flatMap(([tool, entry]) => {
+                const rules = entry.rules || [];
+                if (rules.length === 0) {
+                    return [text.cli.authListEntry(tool, entry.mode || 'allow', undefined, undefined)];
+                }
+                return rules.map((rule) => text.cli.authListEntry(tool, rule.mode, rule.phase?.toLowerCase(), rule.argsHash, rule.sideEffects));
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: lines.join('\n'),
+                timestamp: new Date(),
+            });
+            return;
+        }
+        if (subCommand === 'clear') {
+            await clearAllowlist({ config, repoRoot, scope });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.authCleared(scope),
+                timestamp: new Date(),
+            });
+            return;
+        }
+        if (subCommand === 'add') {
+            const toolName = args[2];
+            if (!toolName) {
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.authAddUsage,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            let knownTools;
+            try {
+                knownTools = await getKnownToolNames(repoRoot);
+            }
+            catch (error) {
+                getLogger().warn(`Failed to load tool registry for validation: ${error instanceof Error ? error.message : String(error)}`);
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.authToolRegistryUnavailable,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            if (!knownTools.has(toolName)) {
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.authInvalidToolName(toolName),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const phase = args[3]?.toUpperCase();
+            if (phase && !EXECUTION_PHASES.includes(phase)) {
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.authInvalidPhase(phase),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const tokens = args.slice(4);
+            const sideEffectsRaw = parseTokenList(tokens, 'effects');
+            const sideEffectsValidation = validateSideEffects(sideEffectsRaw);
+            if (sideEffectsValidation.invalid && sideEffectsValidation.invalid.length > 0) {
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.authInvalidSideEffects(sideEffectsValidation.invalid.join(', ')),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const sideEffects = sideEffectsValidation.valid;
+            const argsHash = parseToken(tokens, 'args');
+            const mode = tokens.includes('deny') ? 'deny' : 'allow';
+            await persistAllowlistDecision({
+                config,
+                repoRoot,
+                toolName,
+                phase: (phase || 'CONTEXT'),
+                scope,
+                mode,
+                sideEffects,
+                argsHash,
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.authAdded(toolName, scope, mode),
+                timestamp: new Date(),
+            });
+            return;
+        }
+        if (subCommand === 'remove') {
+            const toolName = args[2];
+            if (!toolName) {
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.authRemoveUsage,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const phase = args[3]?.toUpperCase();
+            if (phase && !EXECUTION_PHASES.includes(phase)) {
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.authInvalidPhase(phase),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const tokens = args.slice(4);
+            const sideEffectsRaw = parseTokenList(tokens, 'effects');
+            const sideEffectsValidation = validateSideEffects(sideEffectsRaw);
+            if (sideEffectsValidation.invalid && sideEffectsValidation.invalid.length > 0) {
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.authInvalidSideEffects(sideEffectsValidation.invalid.join(', ')),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const sideEffects = sideEffectsValidation.valid;
+            const argsHash = parseToken(tokens, 'args');
+            const removed = await removeAllowlistRule({
+                config,
+                repoRoot,
+                scope,
+                toolName,
+                phase: phase,
+                sideEffects,
+                argsHash,
+            });
+            emit({
+                type: 'log',
+                level: removed ? 'info' : 'warn',
+                message: removed
+                    ? text.cli.authRemoved(toolName, scope)
+                    : text.cli.authRemoveMissing(toolName, scope),
+                timestamp: new Date(),
+            });
+            return;
+        }
+        emit({
+            type: 'log',
+            level: 'error',
+            message: text.cli.authUsage,
+            timestamp: new Date(),
+        });
+    },
+};
+//# sourceMappingURL=allowlist.js.map

package/dist/cli/commands/chat.js

@@ -0,0 +1,120 @@
+import { resolve } from 'path';
+import { createPluginRegistry, createPromptRegistry, createRuntimeLlm, setPluginRegistry, setPromptRegistry, ExtensionConfigError, getLogger, normalizePermissionMode, PluginLoader, resolveConfig, resolveExtensions, } from '../../core/facades/cli-command-chat.js';
+import { text } from '../locales/index.js';
+import { resolveAuditScope } from '../utils/audit-scope.js';
+import { resolveLlmOutputPolicyFromCli } from '../utils/llm-output.js';
+import { createOutcomeReporter } from '../utils/outcome-reporter.js';
+import { resolveVerifyOption } from '../utils/verify-resolver.js';
+export async function handleChatCommand(options, command) {
+    const allOptions = command.optsWithGlobals();
+    const runPath = resolve(allOptions.repo || process.cwd());
+    const printInstruction = typeof allOptions.print === 'string'
+        ? allOptions.print
+        : undefined;
+    const continueSession = Boolean(allOptions.continue);
+    const resumeSessionId = typeof allOptions.resume === 'string'
+        ? allOptions.resume
+        : undefined;
+    if (printInstruction) {
+        getLogger().error(text.cli.printCommandConflict('chat'), true);
+        process.exit(1);
+    }
+    if (continueSession && resumeSessionId) {
+        getLogger().error(text.cli.continueResumeConflict, true);
+        process.exit(1);
+    }
+    // Initialize plugins (including user plugins from .salmonloop/languages)
+    const languagePlugins = createPluginRegistry();
+    setPluginRegistry(languagePlugins);
+    setPromptRegistry(createPromptRegistry());
+    await PluginLoader.loadPlugins(languagePlugins, runPath);
+    const resolvedConfig = await resolveConfig({
+        repoRoot: runPath,
+        enableConfigFile: true,
+    });
+    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 rawPermissionMode = allOptions.mode ?? resolvedConfig.permissionMode ?? 'interactive';
+    const permissionMode = normalizePermissionMode(rawPermissionMode);
+    if (!permissionMode) {
+        getLogger().error(`Invalid --mode "${String(rawPermissionMode)}". Expected "interactive" or "yolo".`);
+        process.exit(1);
+    }
+    const llmOutputResolution = resolveLlmOutputPolicyFromCli(resolvedConfig.llmOutput, allOptions.llmOutput);
+    if (!llmOutputResolution.ok) {
+        getLogger().error(text.cli.invalidLlmOutputKind(llmOutputResolution.invalid), true);
+        process.exitCode = 1;
+        return;
+    }
+    const llmOutput = llmOutputResolution.policy;
+    const { llm } = createRuntimeLlm(resolvedConfig.llm, {
+        langfuseEnabled: resolvedConfig.observability.langfuse.enabled,
+    });
+    const outcomeReporter = createOutcomeReporter({
+        enabled: resolvedConfig.observability.langfuse.outcome,
+        endpoint: resolvedConfig.observability.langfuse.endpoint,
+        llmBaseUrl: resolvedConfig.llm.api.baseUrl,
+        langfuseApiKey: resolvedConfig.observability.langfuse.apiKey,
+    });
+    // Smart verification resolution with auto-detection
+    const verifyCommand = await resolveVerifyOption(runPath, allOptions.verify, resolvedConfig.verify.command);
+    // Verification is now optional - the loop will skip if undefined
+    if (!verifyCommand) {
+        getLogger().warn(text.verify.noCommandFound);
+    }
+    // Dynamic import to avoid circular dependencies if any, and keep startup fast
+    const { startChatMode } = await import('../chat.js');
+    let extensionResolution;
+    try {
+        extensionResolution = await resolveExtensions({ repoRoot: runPath });
+    }
+    catch (err) {
+        if (err instanceof ExtensionConfigError) {
+            getLogger().error(`Extension configuration invalid: ${err.message}`);
+            process.exit(1);
+        }
+        throw err;
+    }
+    try {
+        await startChatMode({
+            repoPath: runPath,
+            llm,
+            verifyCommand,
+            checkpointStrategy: permissionMode === 'yolo' &&
+                typeof command.getOptionValueSource === 'function' &&
+                command.getOptionValueSource('checkpointStrategy') !== 'cli'
+                ? 'direct'
+                : allOptions.checkpointStrategy || 'worktree',
+            continue: continueSession,
+            resumeSessionId,
+            verbose: allOptions.verbose,
+            llmOutput,
+            markdownTheme: resolvedConfig.markdownTheme,
+            markdownRenderMode: resolvedConfig.markdownRenderMode,
+            uiLogView: resolvedConfig.ui.logView,
+            uiLogMode: resolvedConfig.ui.logMode,
+            astValidation: resolvedConfig.astValidation,
+            toolAuthorization: resolvedConfig.toolAuthorization,
+            permissionMode,
+            extensions: extensionResolution.resolved,
+            outcomeReporter,
+            auditScope,
+            langfuseSessionId: resolvedConfig.observability.langfuse.sessionId,
+            langfuseUserId: resolvedConfig.observability.langfuse.userId,
+            languagePlugins,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        getLogger().error(msg, true);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=chat.js.map

package/dist/cli/commands/config.js

@@ -0,0 +1,250 @@
+import { ConfigError, detectConfigFileFormat, FileAdapter, getDefaultRepoConfigPaths, normalizeUiLogView, parseConfigText, sanitizeError, stringifyConfigText, validateConfigFileV1, } from '../../core/facades/cli-command-config.js';
+import { text } from '../locales/index.js';
+import { allowlistCommand } from './allowlist.js';
+import { llmOutputCommand } from './llm-output.js';
+import { logModeCommand } from './log-mode.js';
+import { modeCommand } from './mode.js';
+import { parseSuggestionContext } from './utils.js';
+const LOG_VIEW_SUGGESTIONS = ['full', 'standard', 'compact'];
+async function resolveConfigPathForReadWrite(fileAdapter, repoRoot) {
+    const candidates = getDefaultRepoConfigPaths(repoRoot);
+    for (const p of candidates) {
+        if (await fileAdapter.exists(p))
+            return p;
+    }
+    return candidates[0];
+}
+function delegateInputToCommand(originalInput, targetCommand) {
+    const trimmed = originalInput.trimStart();
+    const tokens = trimmed.split(/\s+/);
+    const rest = tokens.slice(2).join(' ');
+    const isSpaceTrailing = originalInput.endsWith(' ');
+    const base = rest ? `${targetCommand} ${rest}` : targetCommand;
+    return isSpaceTrailing ? `${base} ` : base;
+}
+async function readUiLogViewFromConfig(repoRoot) {
+    const fileAdapter = new FileAdapter();
+    const configPath = await resolveConfigPathForReadWrite(fileAdapter, repoRoot);
+    const exists = await fileAdapter.exists(configPath);
+    if (!exists)
+        return undefined;
+    const raw = await fileAdapter.readFile(configPath);
+    const parsed = parseConfigText(raw, configPath);
+    const validated = validateConfigFileV1(parsed);
+    return validated.ui?.log?.view;
+}
+async function persistUiLogView(repoRoot, view) {
+    const fileAdapter = new FileAdapter();
+    const configPath = await resolveConfigPathForReadWrite(fileAdapter, repoRoot);
+    const exists = await fileAdapter.exists(configPath);
+    let baseConfig = { version: 1 };
+    if (exists) {
+        const raw = await fileAdapter.readFile(configPath);
+        const parsed = parseConfigText(raw, configPath);
+        validateConfigFileV1(parsed);
+        baseConfig = parsed;
+    }
+    if (!baseConfig.version) {
+        baseConfig.version = 1;
+    }
+    baseConfig.ui = {
+        ...(baseConfig.ui ?? {}),
+        log: {
+            ...(baseConfig.ui?.log ?? {}),
+            view,
+        },
+    };
+    const format = detectConfigFileFormat(configPath);
+    await fileAdapter.writeFile(configPath, stringifyConfigText(baseConfig, format));
+    return configPath;
+}
+const viewSubcommand = {
+    name: 'view',
+    description: text.cli.configViewDescription,
+    usage: text.cli.configViewUsage,
+    getSuggestions: ({ input }) => {
+        const { argIndex, currentPrefix } = parseSuggestionContext(input);
+        if (argIndex !== 2)
+            return [];
+        const search = currentPrefix.toLowerCase();
+        return LOG_VIEW_SUGGESTIONS.filter((v) => v.startsWith(search)).map((v) => ({
+            name: v,
+            description: text.cli.configViewSuggestion(v),
+        }));
+    },
+    execute: async ({ emit, input, sessionManager, dispatch }) => {
+        const args = input.trim().split(/\s+/).slice(1);
+        const rawValue = args[1];
+        const repoRoot = sessionManager.getCurrent().meta.repoPath;
+        if (!rawValue) {
+            try {
+                const current = (await readUiLogViewFromConfig(repoRoot)) ?? 'standard';
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.configViewCurrent(current),
+                    timestamp: new Date(),
+                });
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.configViewUsage,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            catch (error) {
+                const message = error instanceof ConfigError
+                    ? text.config.error(error.code ?? 'CONFIG_INVALID_ROOT', error.details)
+                    : sanitizeError(error);
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.configViewPersistFailed(message),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+        }
+        const normalized = normalizeUiLogView(rawValue);
+        if (!normalized) {
+            emit({
+                type: 'log',
+                level: 'error',
+                message: text.cli.configViewInvalid(rawValue),
+                timestamp: new Date(),
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.configViewUsage,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        try {
+            const configPath = await persistUiLogView(repoRoot, normalized);
+            dispatch?.({ type: 'SET_LOG_VIEW', payload: normalized });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.configViewUpdated(normalized),
+                timestamp: new Date(),
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.configViewPersisted(configPath),
+                timestamp: new Date(),
+            });
+        }
+        catch (error) {
+            const message = error instanceof ConfigError
+                ? text.config.error(error.code ?? 'CONFIG_INVALID_ROOT', error.details)
+                : sanitizeError(error);
+            emit({
+                type: 'log',
+                level: 'error',
+                message: text.cli.configViewPersistFailed(message),
+                timestamp: new Date(),
+            });
+        }
+    },
+};
+const logModeSubcommand = {
+    name: 'log-mode',
+    aliases: ['log', 'mode'],
+    description: text.cli.configLogModeDescription,
+    usage: text.cli.configLogModeUsage,
+    getSuggestions: (ctx) => logModeCommand.getSuggestions?.({
+        ...ctx,
+        input: delegateInputToCommand(ctx.input, '/log-mode'),
+    }) ?? [],
+    execute: async (ctx) => logModeCommand.execute({ ...ctx, input: delegateInputToCommand(ctx.input, '/log-mode') }),
+};
+const permissionModeSubcommand = {
+    name: 'permission-mode',
+    aliases: ['perm-mode', 'perm', 'permission'],
+    description: text.cli.configPermissionModeDescription,
+    usage: text.cli.configPermissionModeUsage,
+    getSuggestions: (ctx) => modeCommand.getSuggestions?.({
+        ...ctx,
+        input: delegateInputToCommand(ctx.input, '/mode'),
+    }) ?? [],
+    execute: async (ctx) => modeCommand.execute({ ...ctx, input: delegateInputToCommand(ctx.input, '/mode') }),
+};
+const outputSubcommand = {
+    name: 'output',
+    description: text.cli.configOutputDescription,
+    usage: text.cli.configOutputUsage,
+    getSuggestions: (ctx) => llmOutputCommand.getSuggestions?.({
+        ...ctx,
+        input: delegateInputToCommand(ctx.input, '/output'),
+    }) ?? [],
+    execute: async (ctx) => llmOutputCommand.execute({ ...ctx, input: delegateInputToCommand(ctx.input, '/output') }),
+};
+const allowlistSubcommand = {
+    name: 'allowlist',
+    aliases: ['auth'],
+    description: text.cli.configAllowlistDescription,
+    usage: text.cli.configAllowlistUsage,
+    getSuggestions: (ctx) => allowlistCommand.getSuggestions?.({
+        ...ctx,
+        input: delegateInputToCommand(ctx.input, '/allowlist'),
+    }) ?? [],
+    execute: async (ctx) => allowlistCommand.execute({ ...ctx, input: delegateInputToCommand(ctx.input, '/allowlist') }),
+};
+function findSubcommand(root, name) {
+    const needle = name.trim().toLowerCase();
+    if (!needle)
+        return undefined;
+    return (root.subcommands ?? []).find((c) => {
+        if (c.name.toLowerCase() === needle)
+            return true;
+        return (c.aliases ?? []).some((a) => a.toLowerCase() === needle);
+    });
+}
+const configSubcommands = [
+    logModeSubcommand,
+    viewSubcommand,
+    outputSubcommand,
+    allowlistSubcommand,
+    permissionModeSubcommand,
+];
+export const configCommand = {
+    name: '/config',
+    description: text.cli.commandConfig,
+    order: 55,
+    subcommands: configSubcommands,
+    execute: async (ctx) => {
+        const { emit, input } = ctx;
+        const args = input.trim().split(/\s+/).slice(1);
+        if (args.length === 0) {
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.configUsage,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const subCmdName = args[0].toLowerCase();
+        const subCmd = findSubcommand(configCommand, subCmdName);
+        if (subCmd) {
+            return subCmd.execute({ ...ctx, input: `/config ${args.join(' ')}` });
+        }
+        emit({
+            type: 'log',
+            level: 'error',
+            message: text.cli.configUnknownSubcommand(subCmdName),
+            timestamp: new Date(),
+        });
+        emit({
+            type: 'log',
+            level: 'info',
+            message: text.cli.configUsage,
+            timestamp: new Date(),
+        });
+    },
+};
+//# sourceMappingURL=config.js.map