salmon-loop 0.2.3

package/dist/cli/commands/context.js

@@ -0,0 +1,57 @@
+import { createContextCacheStore, createDefaultPermissionGate, ContextService, defaultPathAdapter, getLogger, resolveConfig, setChurnRankingPolicy, } from '../../core/facades/cli-context.js';
+import { text } from '../locales/index.js';
+export async function handleContextCommand(options, command) {
+    const allOptions = command.optsWithGlobals();
+    const repoPath = defaultPathAdapter.resolve(allOptions.repo || process.cwd());
+    if (options.file && options.selection) {
+        getLogger().error(text.cli.fileSelectionConflict, true);
+        process.exit(1);
+    }
+    if (!options.instruction) {
+        getLogger().error(text.cli.instructionRequired, true);
+        process.exit(1);
+    }
+    const rawDiffScope = String(options.diffScope || 'primary');
+    if (rawDiffScope !== 'primary' && rawDiffScope !== 'ast_related') {
+        getLogger().error(text.cli.contextInvalidDiffScope(rawDiffScope), true);
+        process.exit(1);
+    }
+    const diffScope = rawDiffScope === 'ast_related' ? 'ast_related' : 'primary';
+    let budgetChars;
+    if (options.budgetChars !== undefined) {
+        const parsed = Number(options.budgetChars);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            getLogger().error(text.cli.contextInvalidBudgetChars(String(options.budgetChars)), true);
+            process.exit(1);
+        }
+        budgetChars = parsed;
+    }
+    const resolvedConfig = await resolveConfig({ repoRoot: repoPath });
+    setChurnRankingPolicy({
+        primaryBoost: resolvedConfig.raw?.context?.churn?.weight?.primary,
+        rerankWeight: resolvedConfig.raw?.context?.churn?.weight?.rerank,
+        tieBreakWeight: resolvedConfig.raw?.context?.churn?.weight?.tiebreak,
+    });
+    const cacheConfig = await createContextCacheStore(repoPath, resolvedConfig.raw, {
+        permissionGate: createDefaultPermissionGate({
+            allowOutsideCacheRoot: Boolean(allOptions.allowOutsideCacheRoot),
+            repoRoot: repoPath,
+        }),
+    });
+    const service = new ContextService({}, {
+        cacheStore: cacheConfig.store,
+        cacheMaxEntries: cacheConfig.maxEntries,
+        cacheTtlMs: cacheConfig.ttlMs,
+    });
+    const result = await service.build({
+        instruction: options.instruction,
+        repoPath,
+        primaryFile: options.file,
+        selection: options.selection,
+        diffScope,
+        budgetChars,
+    });
+    getLogger().success(text.cli.contextBuilt(result.meta.usedChars, result.meta.truncated));
+    process.stdout.write(result.prompt.trimEnd() + '\n');
+}
+//# sourceMappingURL=context.js.map

package/dist/cli/commands/dispatcher.js

@@ -0,0 +1,53 @@
+import { text } from '../locales/index.js';
+import { findCommand } from './registry.js';
+export class CommandDispatcher {
+    async dispatch(input, context) {
+        if (!input) {
+            return { type: 'continue', trimmedInput: '' };
+        }
+        const trimmed = input.trim();
+        // 1. Try to find and execute a valid command
+        const command = findCommand(trimmed);
+        if (command) {
+            try {
+                await command.execute({
+                    emit: context.emit,
+                    sessionManager: context.sessionManager,
+                    input: trimmed,
+                    dispatch: context.dispatch,
+                    queue: context.queue,
+                    toolAuthorization: context.toolAuthorization,
+                    getLlmOutputPolicy: context.getLlmOutputPolicy,
+                    setLlmOutputPolicy: context.setLlmOutputPolicy,
+                });
+                return { type: 'executed' };
+            }
+            catch (_error) {
+                context.emit({
+                    type: 'log',
+                    level: 'error',
+                    message: String(_error),
+                    timestamp: new Date(),
+                });
+                return { type: 'executed' };
+            }
+        }
+        // 2. Safety Check: Intercept unknown commands
+        // We block anything that starts with '/' to prevent accidental leakage of commands to LLM.
+        // This includes typos like '/hepl' or potentially dangerous paths if misinterpreted.
+        if (trimmed.startsWith('/')) {
+            const firstWord = trimmed.split(/\s+/)[0];
+            const message = text.cli.unknownCommand(firstWord);
+            context.emit({
+                type: 'log',
+                level: 'error',
+                message,
+                timestamp: new Date(),
+            });
+            return { type: 'blocked', reason: message };
+        }
+        // 3. Allow normal text
+        return { type: 'continue', trimmedInput: trimmed };
+    }
+}
+//# sourceMappingURL=dispatcher.js.map

package/dist/cli/commands/exit.js

@@ -0,0 +1,9 @@
+import { text } from '../locales/index.js';
+export const exitCommand = {
+    name: '/exit',
+    aliases: ['/quit'],
+    description: text.cli.commandExit,
+    order: 90,
+    execute: () => process.exit(0),
+};
+//# sourceMappingURL=exit.js.map

package/dist/cli/commands/llm-output.js

@@ -0,0 +1,135 @@
+import { ConfigError, DEFAULT_LLM_OUTPUT_POLICY, detectConfigFileFormat, FileAdapter, getDefaultRepoConfigPaths, LLM_OUTPUT_KINDS, parseConfigText, resolveLlmOutputPolicy, sanitizeError, stringifyConfigText, validateConfigFileV1, } from '../../core/facades/cli-command-config.js';
+import { text } from '../locales/index.js';
+import { parseLlmOutputKinds } from '../utils/llm-output.js';
+import { parseSuggestionContext } from './utils.js';
+const OUTPUT_SUGGESTIONS = ['none', 'all', ...LLM_OUTPUT_KINDS];
+function formatKinds(kinds) {
+    if (kinds.length === 0)
+        return 'none';
+    return kinds.join(', ');
+}
+async function resolveConfigPathForReadWrite(fileAdapter, repoRoot) {
+    const candidates = getDefaultRepoConfigPaths(repoRoot);
+    for (const p of candidates) {
+        if (await fileAdapter.exists(p))
+            return p;
+    }
+    return candidates[0];
+}
+async function persistLlmOutputKinds(repoRoot, kinds) {
+    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.output = {
+        ...(baseConfig.output ?? {}),
+        llm: {
+            ...(baseConfig.output?.llm ?? {}),
+            kinds,
+        },
+    };
+    const format = detectConfigFileFormat(configPath);
+    await fileAdapter.writeFile(configPath, stringifyConfigText(baseConfig, format));
+    return configPath;
+}
+export const llmOutputCommand = {
+    name: '/output',
+    description: text.cli.commandLlmOutput,
+    aliases: ['/llm-output'],
+    order: 60,
+    hidden: true,
+    getSuggestions: ({ input }) => {
+        const { argIndex, currentPrefix } = parseSuggestionContext(input);
+        if (argIndex !== 1)
+            return [];
+        const search = currentPrefix.toLowerCase();
+        return OUTPUT_SUGGESTIONS.filter((kind) => kind.startsWith(search)).map((kind) => ({
+            name: kind,
+            description: text.cli.llmOutputSuggestion(kind),
+        }));
+    },
+    execute: async ({ emit, input, getLlmOutputPolicy, setLlmOutputPolicy, sessionManager }) => {
+        if (!setLlmOutputPolicy) {
+            emit({
+                type: 'log',
+                level: 'error',
+                message: text.cli.llmOutputUnavailable,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const args = input.trim().split(/\s+/).slice(1);
+        const raw = args.join(' ').trim();
+        const current = getLlmOutputPolicy?.() ?? DEFAULT_LLM_OUTPUT_POLICY;
+        if (!raw) {
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.llmOutputCurrent(formatKinds(current.kinds)),
+                timestamp: new Date(),
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.llmOutputUsage,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const parsed = parseLlmOutputKinds(raw);
+        if (!parsed.ok) {
+            emit({
+                type: 'log',
+                level: 'error',
+                message: text.cli.invalidLlmOutputKind(parsed.invalid),
+                timestamp: new Date(),
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.llmOutputUsage,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const policy = resolveLlmOutputPolicy({ kinds: parsed.kinds });
+        try {
+            const repoRoot = sessionManager.getCurrent().meta.repoPath;
+            const configPath = await persistLlmOutputKinds(repoRoot, policy.kinds);
+            setLlmOutputPolicy(policy);
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.llmOutputUpdated(formatKinds(policy.kinds)),
+                timestamp: new Date(),
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.llmOutputPersisted(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.llmOutputPersistFailed(message),
+                timestamp: new Date(),
+            });
+        }
+    },
+};
+//# sourceMappingURL=llm-output.js.map

package/dist/cli/commands/log-mode.js

@@ -0,0 +1,143 @@
+import { ConfigError, detectConfigFileFormat, FileAdapter, getDefaultRepoConfigPaths, normalizeUiLogMode, parseConfigText, sanitizeError, stringifyConfigText, validateConfigFileV1, } from '../../core/facades/cli-command-config.js';
+import { text } from '../locales/index.js';
+import { parseSuggestionContext } from './utils.js';
+const LOG_MODE_SUGGESTIONS = ['quiet', 'normal', 'debug'];
+async function resolveConfigPathForReadWrite(fileAdapter, repoRoot) {
+    const candidates = getDefaultRepoConfigPaths(repoRoot);
+    for (const p of candidates) {
+        if (await fileAdapter.exists(p))
+            return p;
+    }
+    return candidates[0];
+}
+async function readUiLogModeFromConfig(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?.mode;
+}
+async function persistUiLogMode(repoRoot, mode) {
+    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 ?? {}),
+            mode,
+        },
+    };
+    const format = detectConfigFileFormat(configPath);
+    await fileAdapter.writeFile(configPath, stringifyConfigText(baseConfig, format));
+    return configPath;
+}
+export const logModeCommand = {
+    name: '/log-mode',
+    description: text.cli.commandLogMode,
+    order: 54,
+    hidden: true,
+    getSuggestions: ({ input }) => {
+        const { argIndex, currentPrefix } = parseSuggestionContext(input);
+        if (argIndex !== 1)
+            return [];
+        const search = currentPrefix.toLowerCase();
+        return LOG_MODE_SUGGESTIONS.filter((m) => m.startsWith(search)).map((m) => ({
+            name: m,
+            description: text.cli.logModeSuggestion(m),
+        }));
+    },
+    execute: async ({ emit, input, sessionManager, dispatch }) => {
+        const args = input.trim().split(/\s+/).slice(1);
+        const rawValue = args[0];
+        const repoRoot = sessionManager.getCurrent().meta.repoPath;
+        if (!rawValue) {
+            try {
+                const current = (await readUiLogModeFromConfig(repoRoot)) ?? 'normal';
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.logModeCurrent(current),
+                    timestamp: new Date(),
+                });
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.logModeUsage,
+                    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.logModePersistFailed(message),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+        }
+        const normalized = normalizeUiLogMode(rawValue);
+        if (!normalized) {
+            emit({
+                type: 'log',
+                level: 'error',
+                message: text.cli.logModeInvalid(rawValue),
+                timestamp: new Date(),
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.logModeUsage,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        try {
+            const configPath = await persistUiLogMode(repoRoot, normalized);
+            dispatch?.({ type: 'SET_LOG_MODE', payload: normalized });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.logModeUpdated(normalized),
+                timestamp: new Date(),
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.logModePersisted(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.logModePersistFailed(message),
+                timestamp: new Date(),
+            });
+        }
+    },
+};
+//# sourceMappingURL=log-mode.js.map

package/dist/cli/commands/mode.js

@@ -0,0 +1,136 @@
+import { ConfigError, detectConfigFileFormat, FileAdapter, getDefaultRepoConfigPaths, normalizePermissionMode, parseConfigText, sanitizeError, stringifyConfigText, validateConfigFileV1, } from '../../core/facades/cli-command-config.js';
+import { text } from '../locales/index.js';
+import { parseSuggestionContext } from './utils.js';
+const MODE_SUGGESTIONS = ['interactive', 'yolo'];
+async function resolveConfigPathForReadWrite(fileAdapter, repoRoot) {
+    const candidates = getDefaultRepoConfigPaths(repoRoot);
+    for (const p of candidates) {
+        if (await fileAdapter.exists(p))
+            return p;
+    }
+    return candidates[0];
+}
+async function readPermissionModeFromConfig(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 normalizePermissionMode(validated.mode);
+}
+async function persistPermissionMode(repoRoot, mode) {
+    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.mode = mode;
+    const format = detectConfigFileFormat(configPath);
+    await fileAdapter.writeFile(configPath, stringifyConfigText(baseConfig, format));
+    return configPath;
+}
+export const modeCommand = {
+    name: '/mode',
+    aliases: ['/permission-mode', '/perm-mode'],
+    description: text.cli.commandMode,
+    order: 53,
+    getSuggestions: ({ input }) => {
+        const { argIndex, currentPrefix } = parseSuggestionContext(input);
+        if (argIndex !== 1)
+            return [];
+        const search = currentPrefix.toLowerCase();
+        return MODE_SUGGESTIONS.filter((m) => m.startsWith(search)).map((m) => ({
+            name: m,
+            description: text.cli.modeSuggestion(m),
+        }));
+    },
+    execute: async ({ emit, input, sessionManager }) => {
+        const args = input.trim().split(/\s+/).slice(1);
+        const rawValue = args[0];
+        const repoRoot = sessionManager.getCurrent().meta.repoPath;
+        if (!rawValue) {
+            try {
+                const current = (await readPermissionModeFromConfig(repoRoot)) ?? 'interactive';
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.modeCurrent(current),
+                    timestamp: new Date(),
+                });
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.modeUsage,
+                    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.modePersistFailed(message),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+        }
+        const normalized = normalizePermissionMode(rawValue);
+        if (!normalized) {
+            emit({
+                type: 'log',
+                level: 'error',
+                message: text.cli.modeInvalid(rawValue),
+                timestamp: new Date(),
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.modeUsage,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        try {
+            const configPath = await persistPermissionMode(repoRoot, normalized);
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.modeUpdated(normalized),
+                timestamp: new Date(),
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.modePersisted(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.modePersistFailed(message),
+                timestamp: new Date(),
+            });
+        }
+    },
+};
+//# sourceMappingURL=mode.js.map

package/dist/cli/commands/new.js

@@ -0,0 +1,18 @@
+import { text } from '../locales/index.js';
+export const newCommand = {
+    name: '/new',
+    description: text.cli.commandClear,
+    order: 10,
+    execute: async ({ emit, sessionManager, dispatch }) => {
+        const session = await sessionManager.create();
+        dispatch({ type: 'RESET_MESSAGES' });
+        emit({ type: 'checkpoint.created', worktreePath: '', baseRef: '', timestamp: new Date() });
+        emit({
+            type: 'log',
+            level: 'info',
+            message: text.cli.chatNewSession(session.meta.id.slice(0, 8)),
+            timestamp: new Date(),
+        });
+    },
+};
+//# sourceMappingURL=new.js.map