@sheepbun/yips 0.1.1

package/dist/agent/commands/command-catalog.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCommandCatalog = loadCommandCatalog;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const GENERIC_DESCRIPTIONS = new Set(["Tool command", "Markdown skill", "Command"]);
+const RESTORED_COMMAND_DEFAULTS = [
+    { name: "backend", description: "Switch AI backends (llamacpp, claude)", kind: "builtin" },
+    { name: "clear", description: "Clear context and start a new session", kind: "builtin" },
+    { name: "dl", description: "Alias for /download", kind: "builtin" },
+    { name: "download", description: "Open the interactive model downloader", kind: "builtin" },
+    { name: "exit", description: "Exit Yips", kind: "builtin" },
+    { name: "fetch", description: "Retrieve and display content from a URL", kind: "tool" },
+    { name: "grab", description: "Read a file's content into context", kind: "tool" },
+    { name: "help", description: "Show available commands and tips", kind: "skill" },
+    { name: "memorize", description: "Save a fact to long-term memory", kind: "tool" },
+    { name: "model", description: "Open the Model Manager or switch to a specific model", kind: "builtin" },
+    { name: "new", description: "Start a new session", kind: "builtin" },
+    { name: "nick", description: "Set a custom nickname for a model", kind: "builtin" },
+    { name: "quit", description: "Exit Yips", kind: "builtin" },
+    { name: "search", description: "Search the web (DuckDuckGo)", kind: "tool" },
+    { name: "sessions", description: "Interactively select and load a session", kind: "builtin" },
+    { name: "stream", description: "Toggle streaming responses", kind: "builtin" },
+    { name: "tokens", description: "Show or set token counter mode and max", kind: "builtin" },
+    { name: "update", description: "Check for newer Yips versions and upgrade guidance", kind: "builtin" },
+    { name: "verbose", description: "Toggle verbose output", kind: "builtin" },
+    { name: "vt", description: "Toggle the Virtual Terminal", kind: "tool" }
+];
+function normalizeCommandName(name) {
+    return name.trim().replace(/^\/+/, "").toLowerCase();
+}
+function isGenericDescription(description) {
+    const trimmed = description.trim();
+    if (trimmed.length === 0) {
+        return true;
+    }
+    return GENERIC_DESCRIPTIONS.has(trimmed);
+}
+function normalizeDescription(description) {
+    const trimmed = description.trim();
+    return trimmed.length > 0 ? trimmed : "Command";
+}
+function sortedDirectoryEntries(path) {
+    return (0, node_fs_1.readdirSync)(path, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+}
+function fileNames(path) {
+    return (0, node_fs_1.readdirSync)(path, { withFileTypes: true })
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+}
+function fileBasename(filename) {
+    const dotIndex = filename.lastIndexOf(".");
+    return dotIndex >= 0 ? filename.slice(0, dotIndex) : filename;
+}
+function pickCommandFile(commandDir, commandDirName, extension) {
+    if (!(0, node_fs_1.existsSync)(commandDir)) {
+        return null;
+    }
+    const names = fileNames(commandDir);
+    const extensionLower = extension.toLowerCase();
+    const targetBase = commandDirName.toLowerCase();
+    const exact = names.find((name) => {
+        if (!name.toLowerCase().endsWith(extensionLower)) {
+            return false;
+        }
+        return fileBasename(name).toLowerCase() === targetBase;
+    });
+    if (exact) {
+        return (0, node_path_1.join)(commandDir, exact);
+    }
+    const fallback = names.find((name) => name.toLowerCase().endsWith(extensionLower));
+    return fallback ? (0, node_path_1.join)(commandDir, fallback) : null;
+}
+function toNonEmptyTrimmedLines(text) {
+    return text
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+function descriptionFromLines(lines) {
+    for (const line of lines) {
+        if (/^description\s*:/iu.test(line)) {
+            const extracted = line.replace(/^description\s*:\s*/iu, "").trim();
+            if (extracted.length > 0) {
+                return extracted;
+            }
+        }
+    }
+    const first = lines[0];
+    if (!first) {
+        return null;
+    }
+    const split = first.split(" - ");
+    if (split.length > 1) {
+        const remainder = split.slice(1).join(" - ").trim();
+        if (remainder.length > 0) {
+            return remainder;
+        }
+    }
+    return first;
+}
+function extractPythonDescription(contents) {
+    const docstringMatch = contents.match(/^\s*(?:#.*\r?\n|\s)*(?:"""([\s\S]*?)"""|'''([\s\S]*?)''')/u);
+    const docstring = docstringMatch?.[1] ?? docstringMatch?.[2];
+    if (!docstring) {
+        return null;
+    }
+    return descriptionFromLines(toNonEmptyTrimmedLines(docstring));
+}
+function extractMarkdownDescription(contents) {
+    const lines = toNonEmptyTrimmedLines(contents);
+    if (lines.length === 0) {
+        return null;
+    }
+    const first = lines[0];
+    if (!first) {
+        return null;
+    }
+    if (!first.startsWith("#")) {
+        return first;
+    }
+    for (const line of lines.slice(1)) {
+        if (line.startsWith("#") || line.startsWith("!") || line.startsWith("```")) {
+            continue;
+        }
+        return line;
+    }
+    const heading = first.replace(/^#+\s*/u, "").trim();
+    return heading.length > 0 ? heading : null;
+}
+function readTextSafely(path) {
+    try {
+        return (0, node_fs_1.readFileSync)(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function discoverCommands(parentDir, parentKind) {
+    if (!(0, node_fs_1.existsSync)(parentDir)) {
+        return [];
+    }
+    const discovered = [];
+    for (const commandDirName of sortedDirectoryEntries(parentDir)) {
+        const commandName = normalizeCommandName(commandDirName);
+        if (commandName.length === 0) {
+            continue;
+        }
+        const commandDir = (0, node_path_1.join)(parentDir, commandDirName);
+        const pythonPath = pickCommandFile(commandDir, commandDirName, ".py");
+        const markdownPath = pickCommandFile(commandDir, commandDirName, ".md");
+        let kind = parentKind;
+        let description = null;
+        let priority = 0;
+        if (pythonPath) {
+            const contents = readTextSafely(pythonPath);
+            if (contents) {
+                description = extractPythonDescription(contents);
+            }
+            kind = "tool";
+            priority = description ? 2 : 0;
+        }
+        else if (markdownPath) {
+            const contents = readTextSafely(markdownPath);
+            if (contents) {
+                description = extractMarkdownDescription(contents);
+            }
+            kind = "skill";
+            priority = description ? 2 : 0;
+        }
+        discovered.push({
+            name: commandName,
+            description: normalizeDescription(description ?? "Command"),
+            kind,
+            implemented: false,
+            priority
+        });
+    }
+    return discovered;
+}
+function upsertCatalogEntry(catalog, candidate) {
+    const normalizedName = normalizeCommandName(candidate.name);
+    if (normalizedName.length === 0) {
+        return;
+    }
+    const normalizedCandidate = {
+        ...candidate,
+        name: normalizedName,
+        description: normalizeDescription(candidate.description)
+    };
+    const existing = catalog.get(normalizedName);
+    if (!existing) {
+        catalog.set(normalizedName, normalizedCandidate);
+        return;
+    }
+    const candidateGeneric = isGenericDescription(normalizedCandidate.description);
+    const existingGeneric = isGenericDescription(existing.description);
+    const shouldReplace = normalizedCandidate.priority > existing.priority ||
+        (normalizedCandidate.priority === existing.priority && !candidateGeneric && existingGeneric);
+    if (shouldReplace) {
+        catalog.set(normalizedName, {
+            ...normalizedCandidate,
+            implemented: existing.implemented || normalizedCandidate.implemented
+        });
+        return;
+    }
+    catalog.set(normalizedName, {
+        ...existing,
+        implemented: existing.implemented || normalizedCandidate.implemented
+    });
+}
+function loadCommandCatalog(options = {}) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const catalog = new Map();
+    for (const descriptor of RESTORED_COMMAND_DEFAULTS) {
+        upsertCatalogEntry(catalog, {
+            ...descriptor,
+            name: normalizeCommandName(descriptor.name),
+            implemented: false,
+            priority: 1
+        });
+    }
+    const toolsDir = (0, node_path_1.join)(projectRoot, "commands", "tools");
+    const skillsDir = (0, node_path_1.join)(projectRoot, "commands", "skills");
+    for (const descriptor of discoverCommands(toolsDir, "tool")) {
+        upsertCatalogEntry(catalog, descriptor);
+    }
+    for (const descriptor of discoverCommands(skillsDir, "skill")) {
+        upsertCatalogEntry(catalog, descriptor);
+    }
+    return [...catalog.values()]
+        .sort((left, right) => left.name.localeCompare(right.name))
+        .map((descriptor) => ({
+        name: descriptor.name,
+        description: descriptor.description,
+        kind: descriptor.kind,
+        implemented: descriptor.implemented
+    }));
+}

package/dist/agent/commands/commands.js

@@ -0,0 +1,418 @@
+"use strict";
+/** Slash command registry and dispatch system. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandRegistry = void 0;
+exports.parseCommand = parseCommand;
+exports.createDefaultRegistry = createDefaultRegistry;
+const command_catalog_1 = require("#agent/commands/command-catalog");
+const update_check_1 = require("#app/update-check");
+const config_1 = require("#config/config");
+const memory_store_1 = require("#agent/context/memory-store");
+const model_manager_1 = require("#models/model-manager");
+const model_downloader_1 = require("#models/model-downloader");
+const skills_1 = require("#agent/skills/skills");
+function isGenericDescription(description) {
+    const trimmed = description.trim();
+    return trimmed.length === 0 || trimmed === "Command";
+}
+class CommandRegistry {
+    commands = new Map();
+    descriptors = new Map();
+    constructor(initialDescriptors = []) {
+        for (const descriptor of initialDescriptors) {
+            const name = descriptor.name.toLowerCase();
+            this.descriptors.set(name, { ...descriptor, name });
+        }
+    }
+    register(name, handler, description, kind = "builtin") {
+        const normalizedName = name.toLowerCase();
+        const existing = this.descriptors.get(normalizedName);
+        const mergedDescription = existing && !isGenericDescription(existing.description) ? existing.description : description;
+        this.commands.set(normalizedName, {
+            name: normalizedName,
+            description: mergedDescription,
+            handler
+        });
+        this.descriptors.set(normalizedName, {
+            name: normalizedName,
+            description: mergedDescription,
+            kind: existing?.kind ?? kind,
+            implemented: true
+        });
+    }
+    async dispatch(name, args, context) {
+        const command = this.commands.get(name.toLowerCase());
+        if (command) {
+            return await command.handler(args, context);
+        }
+        if (this.descriptors.has(name.toLowerCase())) {
+            return {
+                output: `Command /${name} is recognized but not implemented in this TypeScript rewrite yet. ` +
+                    "Type /help to see implemented commands.",
+                action: "continue"
+            };
+        }
+        return {
+            output: `Unknown command: /${name}. Type /help for help.`,
+            action: "continue"
+        };
+    }
+    getHelp() {
+        const commands = this.listCommands();
+        const implemented = commands.filter((command) => command.implemented);
+        const planned = commands.filter((command) => !command.implemented);
+        const lines = ["Available commands:"];
+        lines.push("Implemented:");
+        for (const cmd of implemented) {
+            lines.push(`  /${cmd.name}  - ${cmd.description}`);
+        }
+        if (planned.length > 0) {
+            lines.push("");
+            lines.push("Recognized (not implemented in this rewrite yet):");
+            for (const cmd of planned) {
+                lines.push(`  /${cmd.name}  - ${cmd.description}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    has(name) {
+        return this.descriptors.has(name.toLowerCase());
+    }
+    getNames() {
+        return this.listCommands().map((command) => command.name);
+    }
+    listCommands() {
+        return [...this.descriptors.values()].sort((left, right) => left.name.localeCompare(right.name));
+    }
+    getAutocompleteCommands() {
+        return this.getNames().map((name) => `/${name}`);
+    }
+}
+exports.CommandRegistry = CommandRegistry;
+function splitCommandArgs(input) {
+    const matches = input.match(/"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|[^\s]+/gu);
+    if (!matches) {
+        return [];
+    }
+    return matches.map((token) => {
+        if ((token.startsWith('"') && token.endsWith('"')) ||
+            (token.startsWith("'") && token.endsWith("'"))) {
+            return token.slice(1, -1);
+        }
+        return token;
+    });
+}
+function parseTokenCountArg(input) {
+    const trimmed = input.trim().toLowerCase();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    const match = trimmed.match(/^(\d+)(k)?$/u);
+    if (!match) {
+        return null;
+    }
+    const raw = Number(match[1]);
+    if (!Number.isInteger(raw) || raw <= 0) {
+        return null;
+    }
+    const multiplier = match[2] === "k" ? 1000 : 1;
+    return raw * multiplier;
+}
+function parseCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/"))
+        return null;
+    const spaceIndex = trimmed.indexOf(" ");
+    if (spaceIndex === -1) {
+        return { command: trimmed.slice(1).toLowerCase(), args: "" };
+    }
+    return {
+        command: trimmed.slice(1, spaceIndex).toLowerCase(),
+        args: trimmed.slice(spaceIndex + 1).trim()
+    };
+}
+function createDefaultRegistry() {
+    const registry = new CommandRegistry((0, command_catalog_1.loadCommandCatalog)());
+    const downloadUsage = [
+        "Model downloader:",
+        "  /download                    Open interactive downloader",
+        "  /download <hf_url>           Download directly from hf.co/huggingface URL",
+        "  /dl ...                      Alias for /download"
+    ].join("\n");
+    const handleDownload = async (args) => {
+        const trimmed = args.trim();
+        const tokens = trimmed.length > 0 ? trimmed.split(/\s+/u) : [];
+        try {
+            if (tokens.length === 0) {
+                return {
+                    action: "continue",
+                    uiAction: { type: "open-downloader" }
+                };
+            }
+            const inputArg = tokens.join(" ");
+            if (inputArg.toLowerCase() === "help") {
+                return { output: downloadUsage, action: "continue" };
+            }
+            if (!(0, model_downloader_1.isHfDownloadUrl)(inputArg)) {
+                return {
+                    output: `Invalid /download argument. Only direct Hugging Face URLs are supported.\n\n${downloadUsage}`,
+                    action: "continue"
+                };
+            }
+            const parsed = (0, model_downloader_1.parseHfDownloadUrl)(inputArg);
+            const result = await (0, model_downloader_1.downloadModelFile)(parsed);
+            const modelsDir = (0, model_downloader_1.resolveDefaultModelsDir)();
+            return {
+                output: `Downloaded ${parsed.filename} from ${parsed.repoId}.\n` +
+                    `Saved to: ${result.localPath}\n` +
+                    `Models dir: ${modelsDir}\n` +
+                    `Use with: /model ${parsed.repoId}/${parsed.filename}`,
+                action: "continue"
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                output: `Download command failed: ${message}`,
+                action: "continue"
+            };
+        }
+    };
+    const memorizeUsage = [
+        "Memory commands:",
+        "  /memorize <fact>              Save a memory",
+        "  /memorize list [limit]        List recent memories (default 10)",
+        "  /memorize read <memory_id>    Read a saved memory",
+        "  /memorize help                Show this help"
+    ].join("\n");
+    registry.register("help", () => ({
+        output: registry.getHelp(),
+        action: "continue"
+    }), "Show this help");
+    registry.register("exit", () => ({ output: "Goodbye.", action: "exit" }), "Exit Yips");
+    registry.register("quit", () => ({ output: "Goodbye.", action: "exit" }), "Exit Yips");
+    registry.register("restart", () => ({ output: "Restarting Yips.", action: "restart" }), "Restart Yips");
+    registry.register("clear", () => ({ action: "clear" }), "Clear the screen");
+    registry.register("new", () => ({ action: "clear" }), "Start a new conversation");
+    registry.register("model", async (args, context) => {
+        try {
+            const trimmed = args.trim();
+            if (trimmed.length === 0) {
+                return { action: "continue", uiAction: { type: "open-model-manager" } };
+            }
+            let selectedModel = trimmed;
+            const localModels = await (0, model_manager_1.listLocalModels)({ nicknames: context.config.nicknames });
+            const matched = (0, model_manager_1.findMatchingModel)(localModels, trimmed);
+            if (matched) {
+                selectedModel = matched.id;
+            }
+            context.config.backend = "llamacpp";
+            context.config.model = selectedModel;
+            await (0, config_1.saveConfig)(context.config);
+            const matchSuffix = matched ? ` (matched from '${trimmed}')` : " (free-form fallback)";
+            return { output: `Model set to: ${selectedModel}${matchSuffix}`, action: "continue" };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                output: `Model command failed: ${message}`,
+                action: "continue"
+            };
+        }
+    }, "View or set the current model");
+    registry.register("sessions", async () => {
+        return { action: "continue", uiAction: { type: "open-sessions" } };
+    }, "Interactively select and load a session");
+    registry.register("vt", async () => ({ action: "continue", uiAction: { type: "open-vt" } }), "Open Virtual Terminal");
+    registry.register("stream", (_args, context) => {
+        context.config.streaming = !context.config.streaming;
+        const state = context.config.streaming ? "enabled" : "disabled";
+        return { output: `Streaming ${state}.`, action: "continue" };
+    }, "Toggle streaming mode");
+    registry.register("verbose", (_args, context) => {
+        context.config.verbose = !context.config.verbose;
+        const state = context.config.verbose ? "enabled" : "disabled";
+        return { output: `Verbose mode ${state}.`, action: "continue" };
+    }, "Toggle verbose mode");
+    registry.register("update", async () => {
+        const currentVersion = await (0, update_check_1.getInstalledPackageVersion)();
+        const result = await (0, update_check_1.checkForUpdates)(currentVersion);
+        const guidance = [
+            "Update options:",
+            "  npm global (canonical): npm install -g @sheepbun/yips@latest",
+            "  npm global (legacy/unscoped): npm install -g yips@latest (may be unavailable)",
+            "  local source: git pull --ff-only && ./install.sh",
+            "  docs: https://yips.dev"
+        ];
+        if (result.status === "update-available" && result.latestVersion) {
+            return {
+                output: [
+                    `Update available: ${result.currentVersion} -> ${result.latestVersion}`,
+                    ...guidance
+                ].join("\n"),
+                action: "continue"
+            };
+        }
+        if (result.status === "up-to-date" && result.latestVersion) {
+            return {
+                output: [
+                    `You are up to date (${result.currentVersion}). Latest: ${result.latestVersion}.`,
+                    ...guidance
+                ].join("\n"),
+                action: "continue"
+            };
+        }
+        const unknownReason = result.error ? ` (${result.error})` : "";
+        return {
+            output: [
+                `Could not verify latest version${unknownReason}`,
+                `Current version: ${result.currentVersion}`,
+                ...guidance
+            ].join("\n"),
+            action: "continue"
+        };
+    }, "Check for updates and show upgrade commands");
+    registry.register("tokens", async (args, context) => {
+        const trimmed = args.trim();
+        if (trimmed.length === 0) {
+            if (context.config.tokensMode === "auto") {
+                return { output: "Tokens mode: auto (dynamic).", action: "continue" };
+            }
+            return {
+                output: `Tokens mode: manual (${context.config.tokensManualMax}).`,
+                action: "continue"
+            };
+        }
+        if (trimmed.toLowerCase() === "auto") {
+            context.config.tokensMode = "auto";
+            await (0, config_1.saveConfig)(context.config);
+            return {
+                output: "Token limit mode set to auto.",
+                action: "continue"
+            };
+        }
+        const parsed = parseTokenCountArg(trimmed);
+        if (parsed === null) {
+            return {
+                output: "Usage: /tokens auto | /tokens <positive_number|numberk>",
+                action: "continue"
+            };
+        }
+        context.config.tokensMode = "manual";
+        context.config.tokensManualMax = parsed;
+        await (0, config_1.saveConfig)(context.config);
+        return {
+            output: `Token limit set to ${parsed} (manual).`,
+            action: "continue"
+        };
+    }, "Show or set token counter mode and max");
+    registry.register("download", (args) => handleDownload(args), "Open the model downloader");
+    registry.register("dl", (args) => handleDownload(args), "Alias for /download");
+    registry.register("search", async (args) => {
+        const query = args.trim();
+        if (query.length === 0) {
+            return { action: "continue", output: "Usage: /search <query>" };
+        }
+        try {
+            const output = await (0, skills_1.executeSearchSkill)({ query });
+            return { action: "continue", output };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { action: "continue", output: `Search command failed: ${message}` };
+        }
+    }, "Search the web (DuckDuckGo)");
+    registry.register("fetch", async (args) => {
+        const url = args.trim();
+        if (url.length === 0) {
+            return { action: "continue", output: "Usage: /fetch <url>" };
+        }
+        try {
+            const output = await (0, skills_1.executeFetchSkill)({ url });
+            return { action: "continue", output };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { action: "continue", output: `Fetch command failed: ${message}` };
+        }
+    }, "Retrieve and display content from a URL");
+    registry.register("memorize", async (args) => {
+        const trimmed = args.trim();
+        if (trimmed.length === 0 || trimmed.toLowerCase() === "help") {
+            return { output: memorizeUsage, action: "continue" };
+        }
+        const tokens = trimmed.split(/\s+/u);
+        const subcommand = (tokens[0] ?? "").toLowerCase();
+        try {
+            if (subcommand === "list") {
+                const limitRaw = tokens[1] ?? "10";
+                const limit = Number.parseInt(limitRaw, 10);
+                if (!Number.isInteger(limit) || limit <= 0) {
+                    return { output: "Usage: /memorize list [positive_limit]", action: "continue" };
+                }
+                const memories = await (0, memory_store_1.listMemories)(limit);
+                if (memories.length === 0) {
+                    return { output: "No saved memories yet.", action: "continue" };
+                }
+                const lines = ["Saved memories:"];
+                for (const memory of memories) {
+                    lines.push(`- ${memory.id}: ${memory.preview}`);
+                }
+                return { output: lines.join("\n"), action: "continue" };
+            }
+            if (subcommand === "read") {
+                const memoryId = tokens.slice(1).join(" ").trim();
+                if (memoryId.length === 0) {
+                    return { output: "Usage: /memorize read <memory_id>", action: "continue" };
+                }
+                const memory = await (0, memory_store_1.readMemory)(memoryId);
+                return {
+                    output: [`Memory ${memory.id}:`, memory.content].join("\n\n"),
+                    action: "continue"
+                };
+            }
+            const saved = await (0, memory_store_1.saveMemory)(trimmed);
+            return {
+                output: `Saved memory: ${saved.id}`,
+                action: "continue"
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { output: `Memorize command failed: ${message}`, action: "continue" };
+        }
+    }, "Save, list, and read long-term memories");
+    registry.register("nick", async (args, context) => {
+        try {
+            const tokens = splitCommandArgs(args.trim());
+            if (tokens.length < 2) {
+                return {
+                    output: "Usage: /nick <model_name_or_filename> <nickname>",
+                    action: "continue"
+                };
+            }
+            const [target, ...nicknameTokens] = tokens;
+            const nickname = nicknameTokens.join(" ").trim();
+            if (!target || nickname.length === 0) {
+                return {
+                    output: "Usage: /nick <model_name_or_filename> <nickname>",
+                    action: "continue"
+                };
+            }
+            context.config.nicknames[target] = nickname;
+            await (0, config_1.saveConfig)(context.config);
+            return {
+                output: `Nickname set: ${target} -> ${nickname}`,
+                action: "continue"
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                output: `Nick command failed: ${message}`,
+                action: "continue"
+            };
+        }
+    }, "Set a custom nickname for a model");
+    return registry;
+}