salmon-loop 0.2.3

package/dist/cli/commands/snapshot-interactive.js

@@ -0,0 +1,165 @@
+import { CheckpointManager } from '../../core/facades/cli-command-checkpoint.js';
+import { parseSuggestionContext } from './utils.js';
+const getSnapshotSuggestions = async (sessionManager, currentPrefix) => {
+    const manager = new CheckpointManager();
+    const repoPath = sessionManager.getCurrent().meta.repoPath;
+    const snapshots = await manager.listSnapshots(repoPath);
+    const search = currentPrefix.toLowerCase();
+    return snapshots
+        .filter((s) => s.hash.toLowerCase().startsWith(search))
+        .map((s) => ({
+        name: s.hash.slice(0, 7),
+        description: s.message,
+    }));
+};
+const listCommand = {
+    name: 'list',
+    description: 'List snapshots',
+    usage: '/snapshot list [hash]',
+    getSuggestions: async ({ sessionManager, input }) => {
+        const { currentPrefix } = parseSuggestionContext(input);
+        return getSnapshotSuggestions(sessionManager, currentPrefix);
+    },
+    execute: async ({ emit, sessionManager, input }) => {
+        const args = input.trim().split(/\s+/).slice(1);
+        const hash = args[1]; // /snapshot list <hash>
+        if (!hash) {
+            // List all logic could be added here, currently just asks for selection
+            emit({
+                type: 'log',
+                level: 'info',
+                message: 'Select a snapshot from the suggestions to view its details.',
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const manager = new CheckpointManager();
+        const repoPath = sessionManager.getCurrent().meta.repoPath;
+        const details = await manager.getSnapshotDetails(repoPath, hash);
+        const stagedCount = details.stagedFiles.length;
+        const unstagedCount = details.unstagedFiles.length;
+        emit({
+            type: 'log',
+            level: 'info',
+            message: `Snapshot [${hash.slice(0, 7)}] Details:\n- Staged: ${stagedCount} files\n- Unstaged: ${unstagedCount} files\n\nUse "/snapshot restore ${hash.slice(0, 7)}" to revert your workspace.`,
+            timestamp: new Date(),
+        });
+    },
+};
+const createCommand = {
+    name: 'create',
+    description: 'Create a new snapshot',
+    usage: '/snapshot create [message]',
+    execute: async ({ emit, sessionManager, input }) => {
+        const args = input.trim().split(/\s+/).slice(1);
+        const message = args.slice(1).join(' ') || 'Manual snapshot'; // /snapshot create <msg>
+        const manager = new CheckpointManager();
+        const repoPath = sessionManager.getCurrent().meta.repoPath;
+        const result = await manager.createSafeSnapshot(repoPath, [], message);
+        emit({
+            type: 'log',
+            level: 'info',
+            message: `Snapshot created: ${result.commitHash.slice(0, 7)}`,
+            timestamp: new Date(),
+        });
+    },
+};
+const deleteCommand = {
+    name: 'delete',
+    description: 'Delete a snapshot',
+    usage: '/snapshot delete <hash>',
+    getSuggestions: async ({ sessionManager, input }) => {
+        const { currentPrefix } = parseSuggestionContext(input);
+        return getSnapshotSuggestions(sessionManager, currentPrefix);
+    },
+    execute: async ({ emit, sessionManager, input }) => {
+        const args = input.trim().split(/\s+/).slice(1);
+        const hash = args[1];
+        if (!hash) {
+            emit({
+                type: 'log',
+                level: 'error',
+                message: 'Usage: /snapshot delete <hash>',
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const manager = new CheckpointManager();
+        const repoPath = sessionManager.getCurrent().meta.repoPath;
+        await manager.deleteSnapshot(repoPath, hash);
+        emit({
+            type: 'log',
+            level: 'info',
+            message: `Snapshot ${hash} deleted.`,
+            timestamp: new Date(),
+        });
+    },
+};
+const restoreCommand = {
+    name: 'restore',
+    description: 'Restore workspace to a snapshot',
+    usage: '/snapshot restore <hash>',
+    getSuggestions: async ({ sessionManager, input }) => {
+        const { currentPrefix } = parseSuggestionContext(input);
+        return getSnapshotSuggestions(sessionManager, currentPrefix);
+    },
+    execute: async ({ emit, input }) => {
+        const args = input.trim().split(/\s+/).slice(1);
+        const hash = args[1];
+        if (!hash) {
+            emit({
+                type: 'log',
+                level: 'error',
+                message: 'Usage: /snapshot restore <hash>',
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const message = `Restore will overwrite your current workspace.`;
+        return {
+            action: 'NEED_CONFIRMATION',
+            message,
+            data: {
+                message,
+                command: '/snapshot',
+                args: ['restore', hash],
+                challenge: hash.slice(0, 6),
+            },
+        };
+    },
+};
+export const snapshotInteractiveCommand = {
+    name: '/snapshot',
+    description: 'Manage repository snapshots',
+    order: 40,
+    subcommands: [listCommand, createCommand, deleteCommand, restoreCommand],
+    execute: async (ctx) => {
+        const { emit, input } = ctx;
+        // If this execute is called, it means the user typed "/snapshot" (and potentially args)
+        // but the UI didn't drill down or the user hit enter on the main command.
+        // In a robust implementation, we might delegate to subcommands here manually
+        // if the input matches a subcommand pattern, to support legacy execution style.
+        const args = input.trim().split(/\s+/).slice(1);
+        if (args.length === 0) {
+            emit({
+                type: 'log',
+                level: 'info',
+                message: 'Available subcommands: list, create, delete, restore',
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const subCmdName = args[0].toLowerCase();
+        const subCmd = [listCommand, createCommand, deleteCommand, restoreCommand].find((c) => c.name === subCmdName);
+        if (subCmd) {
+            return subCmd.execute({ ...ctx, input: `/snapshot ${args.join(' ')}` });
+        }
+        emit({
+            type: 'log',
+            level: 'error',
+            message: `Unknown subcommand: ${subCmdName}`,
+            timestamp: new Date(),
+        });
+    },
+};
+//# sourceMappingURL=snapshot-interactive.js.map

package/dist/cli/commands/snapshot.js

@@ -0,0 +1,159 @@
+import { resolve } from 'path';
+import chalk from 'chalk';
+import { CheckpointManager, getLogger } from '../../core/facades/cli-command-checkpoint.js';
+import { text } from '../locales/index.js';
+export async function handleSnapshotList(_options, command) {
+    const allOptions = command.optsWithGlobals();
+    const runPath = resolve(allOptions.repo || process.cwd());
+    const manager = new CheckpointManager();
+    const snapshots = await manager.listSnapshots(runPath);
+    if (snapshots.length === 0) {
+        getLogger().log(text.cli.noSnapshots);
+        return;
+    }
+    getLogger().log(chalk.bold(text.cli.availableSnapshots));
+    getLogger().log(chalk.dim(text.cli.snapshotTableHead));
+    snapshots.forEach((s) => {
+        // Parse the message to extract the description if available.
+        let displayMsg = s.message;
+        try {
+            const meta = JSON.parse(s.message);
+            if (meta.desc) {
+                displayMsg = meta.desc;
+            }
+            else if (meta.staged) {
+                // Fallback for auto-snapshots without explicit description.
+                displayMsg = text.cli.autoSnapshotMsg(meta.staged.substring(0, 7));
+            }
+        }
+        catch {
+            // Keep original message if parsing fails.
+        }
+        getLogger().log(`${chalk.cyan(s.hash)}  ${chalk.gray(s.timestamp)}  ${displayMsg}`);
+    });
+}
+export async function handleSnapshotCreate(options, command) {
+    const allOptions = command.optsWithGlobals();
+    const runPath = resolve(allOptions.repo || process.cwd());
+    const manager = new CheckpointManager();
+    try {
+        const result = await manager.createSafeSnapshot(runPath, options.include || [], options.message);
+        getLogger().success(text.cli.snapshotCreated(result.commitHash));
+        if (options.message) {
+            getLogger().log(text.cli.snapshotMessage(options.message));
+        }
+    }
+    catch (error) {
+        getLogger().error(text.cli.snapshotCreateFailed(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+export async function handleSnapshotShow(hash, options, command) {
+    const allOptions = command.optsWithGlobals();
+    const runPath = resolve(allOptions.repo || process.cwd());
+    const manager = new CheckpointManager();
+    try {
+        const details = await manager.getSnapshotDetails(runPath, hash);
+        getLogger().log(chalk.bold(text.cli.snapshotDetails(hash)));
+        if (details.stagedFiles.length > 0) {
+            getLogger().log(chalk.green('\n' + text.cli.stagedFiles));
+            details.stagedFiles.forEach((f) => getLogger().log(`  ${f}`));
+        }
+        else {
+            getLogger().log(chalk.gray('\n' + text.cli.noStagedFiles));
+        }
+        if (details.unstagedFiles.length > 0) {
+            getLogger().log(chalk.yellow('\n' + text.cli.unstagedChanges));
+            details.unstagedFiles.forEach((f) => getLogger().log(`  ${f}`));
+        }
+        else {
+            getLogger().log(chalk.gray('\n' + text.cli.noUnstagedChanges));
+        }
+        if (options.files) {
+            getLogger().log(chalk.blue('\n' + text.cli.allFilesInSnapshot));
+            const files = await manager.getSnapshotFiles(runPath, hash);
+            files.forEach((f) => getLogger().log(`  ${f}`));
+        }
+    }
+    catch (error) {
+        getLogger().error(text.cli.snapshotShowFailed(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+export async function handleSnapshotDiff(hash, otherHash, options, command) {
+    const allOptions = command.optsWithGlobals();
+    const runPath = resolve(allOptions.repo || process.cwd());
+    const manager = new CheckpointManager();
+    try {
+        const diffOutput = await manager.getSnapshotDiff(runPath, hash, otherHash, options.code);
+        if (!diffOutput.trim()) {
+            getLogger().log(text.cli.noDifferences);
+        }
+        else {
+            process.stdout.write(diffOutput + '\n');
+        }
+    }
+    catch (error) {
+        getLogger().error(text.cli.getDiffFailed(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+export async function handleSnapshotCat(hash, file, _options, command) {
+    const allOptions = command.optsWithGlobals();
+    const runPath = resolve(allOptions.repo || process.cwd());
+    const manager = new CheckpointManager();
+    try {
+        const content = await manager.getSnapshotFileContent(runPath, hash, file);
+        process.stdout.write(content);
+    }
+    catch (error) {
+        getLogger().error(text.cli.readFileFailed(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+export async function handleSnapshotExport(hash, directory, _options, command) {
+    const allOptions = command.optsWithGlobals();
+    const runPath = resolve(allOptions.repo || process.cwd());
+    const targetDir = resolve(directory);
+    const manager = new CheckpointManager();
+    try {
+        getLogger().info(text.cli.exportStarting(hash, targetDir));
+        await manager.exportSnapshot(runPath, hash, targetDir);
+        getLogger().success(text.cli.exportSuccess(hash));
+    }
+    catch (error) {
+        getLogger().error(text.cli.exportFailed(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+export async function handleSnapshotDelete(hash, _options, command) {
+    const allOptions = command.optsWithGlobals();
+    const runPath = resolve(allOptions.repo || process.cwd());
+    const manager = new CheckpointManager();
+    try {
+        await manager.deleteSnapshot(runPath, hash);
+        getLogger().success(text.cli.snapshotDeleted(hash));
+    }
+    catch (error) {
+        getLogger().error(text.cli.snapshotDeleteFailed(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+export async function handleSnapshotClear(options, command) {
+    const allOptions = command.optsWithGlobals();
+    const runPath = resolve(allOptions.repo || process.cwd());
+    const manager = new CheckpointManager();
+    if (!options.force) {
+        getLogger().warn(text.cli.clearForcePrompt);
+        return;
+    }
+    try {
+        await manager.clearSnapshots(runPath);
+        getLogger().success(text.cli.allSnapshotsCleared);
+    }
+    catch (error) {
+        getLogger().error(text.cli.clearSnapshotsFailed(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=snapshot.js.map

package/dist/cli/commands/status.js

@@ -0,0 +1,17 @@
+import { text } from '../locales/index.js';
+export const statusCommand = {
+    name: '/status',
+    description: text.cli.commandStatus,
+    order: 20,
+    execute: ({ emit, sessionManager }) => {
+        const session = sessionManager.getCurrent();
+        const statusMsg = [
+            `Session: ${session.meta.name}`,
+            `ID: ${session.meta.id.slice(0, 8)}`,
+            `Iterations: ${session.meta.totalIterations} (${session.meta.successfulIterations} ok)`,
+            `Messages: ${session.messages.length}`,
+        ].join(' | ');
+        emit({ type: 'log', level: 'info', message: statusMsg, timestamp: new Date() });
+    },
+};
+//# sourceMappingURL=status.js.map

package/dist/cli/commands/subagent.js

@@ -0,0 +1,178 @@
+import { z } from 'zod';
+import { text } from '../locales/index.js';
+const subAgentVerbSchema = z.enum(['list', 'info', 'log', 'stop']);
+const tailParser = (token) => {
+    const [key, value] = token.split('=');
+    if (key !== 'tail')
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.min(50, parsed) : undefined;
+};
+const formatLogLines = (lines) => lines.length === 0 ? ['(no recent log entries)'] : lines;
+const formatAgentRow = (agent) => `${agent.id} | ${agent.status} | ${agent.profile.role} | ${agent.summary ?? 'No summary'}`;
+export const subAgentCommand = {
+    name: '/smallfry',
+    aliases: ['/subagent', '/sub-agent'],
+    order: 70,
+    description: text.cli.commandSubagent,
+    async getSuggestions(context) {
+        const { input } = context;
+        const controller = context.subAgentController;
+        const trimmed = input.trimStart();
+        if (!trimmed.startsWith('/'))
+            return [];
+        const parts = trimmed.split(/\s+/).slice(1);
+        if (parts.length === 0 || !parts[0]) {
+            return subAgentVerbSchema.options.map((verb) => ({
+                name: verb,
+                description: `sub-agent ${verb}`,
+            }));
+        }
+        const verb = parts[0].toLowerCase();
+        if (!subAgentVerbSchema.options.includes(verb)) {
+            const search = verb;
+            return subAgentVerbSchema.options
+                .filter((candidate) => candidate.startsWith(search))
+                .map((candidate) => ({ name: candidate, description: `sub-agent ${candidate}` }));
+        }
+        if (['info', 'log', 'stop'].includes(verb)) {
+            const search = parts[1]?.toLowerCase() ?? '';
+            return (controller?.listAgents() ?? [])
+                .filter((agent) => agent.id.toLowerCase().startsWith(search))
+                .map((agent) => ({
+                name: agent.id,
+                description: `${agent.status} (${agent.profile.role})`,
+            }));
+        }
+        return [];
+    },
+    async execute(context) {
+        const { emit, input } = context;
+        const controller = context.subAgentController;
+        const tokens = input.trim().split(/\s+/).slice(1);
+        const verb = tokens[0]?.toLowerCase();
+        if (!verb) {
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.subagentUsage,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        if (!subAgentVerbSchema.safeParse(verb).success) {
+            emit({
+                type: 'log',
+                level: 'warn',
+                message: text.cli.subagentUnknownVerb(verb),
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const agentIdArg = tokens[1];
+        switch (verb) {
+            case 'list': {
+                const agents = controller?.listAgents() ?? [];
+                const rows = agents.map(formatAgentRow);
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: `${text.cli.subagentListHeader}\n${rows.join('\n')}`,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            case 'info': {
+                if (!agentIdArg) {
+                    emit({
+                        type: 'log',
+                        level: 'warn',
+                        message: text.cli.subagentMissingId('info'),
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                const agent = controller?.getAgent(agentIdArg);
+                if (!agent) {
+                    emit({
+                        type: 'log',
+                        level: 'warn',
+                        message: text.cli.subagentNotFound(agentIdArg),
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: `${text.cli.subagentInfoHeader(agent.id)}\nRole: ${agent.profile.role}\nStatus: ${agent.status}\nSummary: ${agent.summary ?? 'n/a'}\nStop requested: ${agent.stopRequested ? 'yes' : 'no'}`,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            case 'log': {
+                if (!agentIdArg) {
+                    emit({
+                        type: 'log',
+                        level: 'warn',
+                        message: text.cli.subagentMissingId('log'),
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                const agent = controller?.getAgent(agentIdArg);
+                if (!agent) {
+                    emit({
+                        type: 'log',
+                        level: 'warn',
+                        message: text.cli.subagentNotFound(agentIdArg),
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                const tailToken = tokens.find((token) => token.startsWith('tail='));
+                const tail = tailToken ? (tailParser(tailToken) ?? 20) : 20;
+                const lines = formatLogLines(controller?.tailLogs(agentIdArg, tail) ?? []);
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: `${text.cli.subagentLogHeader(agent.id)}\n${lines.join('\n')}`,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            case 'stop': {
+                if (!agentIdArg) {
+                    emit({
+                        type: 'log',
+                        level: 'warn',
+                        message: text.cli.subagentMissingId('stop'),
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                const agent = controller?.getAgent(agentIdArg);
+                if (!agent) {
+                    emit({
+                        type: 'log',
+                        level: 'warn',
+                        message: text.cli.subagentNotFound(agentIdArg),
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                controller?.requestStop(agentIdArg);
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.subagentStopRequested(agentIdArg),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            default:
+                return;
+        }
+    },
+};
+//# sourceMappingURL=subagent.js.map

package/dist/cli/commands/subcommand-suggestions.js

@@ -0,0 +1,63 @@
+import { parseSuggestionContext } from './utils.js';
+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);
+    });
+}
+/**
+ * Default subcommand suggestions for commands that expose `subcommands` but do not define a
+ * top-level `getSuggestions`. This keeps completion behavior consistent across the slash runtime.
+ */
+export async function suggestSubcommands(root, context) {
+    const subcommands = root.subcommands ?? [];
+    if (subcommands.length === 0)
+        return [];
+    const { argIndex, currentPrefix } = parseSuggestionContext(context.input);
+    // Suggest subcommand names at the first argument slot:
+    // "/config " -> ["log", ...]
+    // "/config l" -> ["log", ...]
+    if (argIndex === 1) {
+        const search = currentPrefix.toLowerCase();
+        const seen = new Set();
+        const out = [];
+        for (const cmd of subcommands) {
+            const nameLower = cmd.name.toLowerCase();
+            if (nameLower.startsWith(search)) {
+                if (!seen.has(cmd.name)) {
+                    out.push({ name: cmd.name, description: cmd.description, command: cmd });
+                    seen.add(cmd.name);
+                }
+            }
+            // Avoid noisy alias suggestions when there's no active search.
+            if (!search)
+                continue;
+            for (const alias of cmd.aliases ?? []) {
+                const aliasLower = alias.toLowerCase();
+                if (!aliasLower.startsWith(search))
+                    continue;
+                if (seen.has(alias))
+                    continue;
+                out.push({ name: alias, description: `${cmd.description} (alias)`, command: cmd });
+                seen.add(alias);
+            }
+        }
+        return out;
+    }
+    // Delegate to the subcommand for deeper suggestions:
+    // "/config log " -> delegate to "log" subcommand (argIndex >= 2)
+    if (argIndex > 1) {
+        const tokens = context.input.trim().split(/\s+/);
+        const subName = tokens[1] || '';
+        const sub = findSubcommand(root, subName);
+        if (!sub?.getSuggestions)
+            return [];
+        return await sub.getSuggestions(context);
+    }
+    return [];
+}
+//# sourceMappingURL=subcommand-suggestions.js.map