@sheepbun/yips 0.1.1

package/dist/commands.js

@@ -0,0 +1,350 @@
+"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("./command-catalog");
+const config_1 = require("./config");
+const memory_store_1 = require("./memory-store");
+const model_manager_1 = require("./model-manager");
+const model_downloader_1 = require("./model-downloader");
+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("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("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;
+}

package/dist/conductor.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runConductorTurn = runConductorTurn;
+const tool_protocol_1 = require("./tool-protocol");
+const TOOL_FAILURE_STATUSES = new Set(["error", "denied", "timeout"]);
+const CONSECUTIVE_TOOL_FAILURE_PIVOT_THRESHOLD = 2;
+function shouldCountAsFailureRound(toolResults) {
+    if (toolResults.length === 0) {
+        return false;
+    }
+    return toolResults.every((result) => TOOL_FAILURE_STATUSES.has(result.status));
+}
+async function runConductorTurn(dependencies) {
+    const maxRounds = dependencies.maxRounds ?? 6;
+    let rounds = 0;
+    let finished = false;
+    let latestOutputTokensPerSecond = null;
+    let usedTokensExact = null;
+    let consecutiveFailureRounds = 0;
+    while (!finished && rounds < maxRounds) {
+        rounds += 1;
+        const reply = await dependencies.requestAssistant();
+        const parsed = (0, tool_protocol_1.parseToolProtocol)(reply.text);
+        const assistantText = parsed.assistantText.trim();
+        if (assistantText.length > 0) {
+            dependencies.onAssistantText(assistantText, reply.rendered);
+            dependencies.history.push({ role: "assistant", content: assistantText });
+        }
+        const completionTokens = typeof reply.completionTokens === "number" && reply.completionTokens > 0
+            ? reply.completionTokens
+            : dependencies.estimateCompletionTokens(reply.text);
+        latestOutputTokensPerSecond = dependencies.computeTokensPerSecond(completionTokens, reply.generationDurationMs ?? 0);
+        usedTokensExact =
+            typeof reply.totalTokens === "number" && reply.totalTokens >= 0
+                ? reply.totalTokens
+                : dependencies.estimateHistoryTokens(dependencies.history);
+        if (parsed.toolCalls.length === 0 && parsed.subagentCalls.length === 0) {
+            finished = true;
+            break;
+        }
+        if (parsed.toolCalls.length > 0) {
+            const toolResults = await dependencies.executeToolCalls(parsed.toolCalls);
+            dependencies.history.push({
+                role: "system",
+                content: `Tool results: ${JSON.stringify(toolResults)}`
+            });
+            if (shouldCountAsFailureRound(toolResults)) {
+                consecutiveFailureRounds += 1;
+                if (consecutiveFailureRounds >= CONSECUTIVE_TOOL_FAILURE_PIVOT_THRESHOLD) {
+                    dependencies.history.push({
+                        role: "system",
+                        content: "Automatic pivot: consecutive tool failures detected. Try a different approach, use different tools, or ask the user for clarification."
+                    });
+                    dependencies.onWarning("Consecutive tool failures detected. Attempting an alternative approach.");
+                    consecutiveFailureRounds = 0;
+                }
+            }
+            else {
+                consecutiveFailureRounds = 0;
+            }
+        }
+        if (parsed.subagentCalls.length > 0) {
+            if (!dependencies.executeSubagentCalls) {
+                dependencies.onWarning("Subagent delegation requested, but no subagent runner is configured.");
+                const fallbackResults = parsed.subagentCalls.map((call) => ({
+                    callId: call.id,
+                    status: "error",
+                    output: "Subagent delegation is unavailable in this runtime."
+                }));
+                dependencies.history.push({
+                    role: "system",
+                    content: `Subagent results: ${JSON.stringify(fallbackResults)}`
+                });
+            }
+            else {
+                const subagentResults = await dependencies.executeSubagentCalls(parsed.subagentCalls);
+                dependencies.history.push({
+                    role: "system",
+                    content: `Subagent results: ${JSON.stringify(subagentResults)}`
+                });
+            }
+        }
+        dependencies.onRoundComplete?.();
+    }
+    if (!finished) {
+        dependencies.onWarning("Stopped tool chaining after max depth (6 rounds).");
+    }
+    return {
+        finished,
+        rounds,
+        latestOutputTokensPerSecond,
+        usedTokensExact
+    };
+}