@sheepbun/yips 0.1.1 → 0.1.46

package/dist/agent/commands/commands.js

@@ -1,418 +0,0 @@
-"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;
-}

package/dist/agent/conductor.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runConductorTurn = runConductorTurn;
-const tool_protocol_1 = require("#agent/protocol/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 &&
-            parsed.skillCalls.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.skillCalls.length > 0) {
-            if (!dependencies.executeSkillCalls) {
-                dependencies.onWarning("Skill invocation requested, but no skill runner is configured.");
-                const fallbackResults = parsed.skillCalls.map((call) => ({
-                    callId: call.id,
-                    skill: call.name,
-                    status: "error",
-                    output: "Skill invocation is unavailable in this runtime."
-                }));
-                dependencies.history.push({
-                    role: "system",
-                    content: `Skill results: ${JSON.stringify(fallbackResults)}`
-                });
-            }
-            else {
-                const skillResults = await dependencies.executeSkillCalls(parsed.skillCalls);
-                dependencies.history.push({
-                    role: "system",
-                    content: `Skill results: ${JSON.stringify(skillResults)}`
-                });
-            }
-        }
-        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
-    };
-}

package/dist/agent/context/code-context.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findCodeMdCandidates = findCodeMdCandidates;
-exports.loadCodeContext = loadCodeContext;
-exports.toCodeContextSystemMessage = toCodeContextSystemMessage;
-const promises_1 = require("node:fs/promises");
-const node_path_1 = require("node:path");
-const CODE_MD_FILENAME = "CODE.md";
-const MAX_CODE_MD_CHARS = 24_000;
-function truncateContent(content, maxChars) {
-    if (content.length <= maxChars) {
-        return { content, truncated: false };
-    }
-    return {
-        content: `${content.slice(0, maxChars)}\n\n[CODE.md truncated to ${maxChars} characters]`,
-        truncated: true
-    };
-}
-async function isReadable(path) {
-    try {
-        await (0, promises_1.access)(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function findCodeMdCandidates(startDir) {
-    const candidates = [];
-    let current = (0, node_path_1.resolve)(startDir);
-    for (;;) {
-        candidates.push((0, node_path_1.join)(current, CODE_MD_FILENAME));
-        const parent = (0, node_path_1.dirname)(current);
-        if (parent === current) {
-            break;
-        }
-        current = parent;
-    }
-    return candidates;
-}
-async function loadCodeContext(startDir = process.cwd()) {
-    const candidates = findCodeMdCandidates(startDir);
-    for (const candidate of candidates) {
-        if (!(await isReadable(candidate))) {
-            continue;
-        }
-        try {
-            const raw = await (0, promises_1.readFile)(candidate, "utf8");
-            const trimmed = raw.trim();
-            if (trimmed.length === 0) {
-                continue;
-            }
-            const truncated = truncateContent(trimmed, MAX_CODE_MD_CHARS);
-            return {
-                path: candidate,
-                content: truncated.content,
-                truncated: truncated.truncated
-            };
-        }
-        catch {
-            // continue to parent candidate
-        }
-    }
-    return null;
-}
-function toCodeContextSystemMessage(context) {
-    return [`Project context from CODE.md (${context.path}):`, "", context.content].join("\n");
-}