@sheepbun/yips 0.1.1

package/dist/token-counter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeAutoMaxTokens = computeAutoMaxTokens;
+exports.resolveEffectiveMaxTokens = resolveEffectiveMaxTokens;
+exports.formatTitleTokenUsage = formatTitleTokenUsage;
+exports.estimateConversationTokens = estimateConversationTokens;
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function computeAutoMaxTokens(input) {
+    const safeRamGb = Number.isFinite(input.ramGb) && input.ramGb > 0 ? input.ramGb : 0;
+    const safeModelBytes = Number.isFinite(input.modelSizeBytes) && input.modelSizeBytes > 0 ? input.modelSizeBytes : 0;
+    const modelSizeGb = safeModelBytes / 1024 ** 3;
+    const availableGb = Math.max(0, safeRamGb - modelSizeGb - 2);
+    const rawTokens = Math.floor(availableGb * 1500);
+    return clamp(rawTokens, 4096, 128000);
+}
+function resolveEffectiveMaxTokens(tokensMode, manualMax, autoMax) {
+    if (tokensMode === "manual") {
+        return Number.isFinite(manualMax) && manualMax > 0 ? Math.floor(manualMax) : autoMax;
+    }
+    return autoMax;
+}
+function formatTokenCount(value) {
+    if (value < 1000) {
+        return String(Math.floor(value));
+    }
+    const rounded = Number((value / 1000).toFixed(1));
+    const compact = Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+    return `${compact}k`;
+}
+function formatTitleTokenUsage(usedTokens, maxTokens) {
+    const safeUsed = Number.isFinite(usedTokens) && usedTokens > 0 ? usedTokens : 0;
+    const safeMax = Number.isFinite(maxTokens) && maxTokens > 0 ? maxTokens : 0;
+    return `${formatTokenCount(safeUsed)}/${formatTokenCount(safeMax)} tks`;
+}
+function estimateConversationTokens(messages) {
+    let total = 0;
+    for (const message of messages) {
+        const chars = Array.from(message.content).length;
+        if (chars === 0) {
+            continue;
+        }
+        total += Math.max(1, Math.ceil(chars / 4));
+    }
+    return total;
+}

package/dist/tool-executor.js

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeToolCall = executeToolCall;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const hooks_1 = require("./hooks");
+const tool_safety_1 = require("./tool-safety");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function normalizePositiveInt(value, fallback, max) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+        return Math.min(value, max);
+    }
+    return fallback;
+}
+function normalizeString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function toLines(text) {
+    return text.split("\n");
+}
+function buildDiffPreview(before, after, maxBodyLines = 80) {
+    if (before === after) {
+        return "No content changes.";
+    }
+    const oldLines = toLines(before);
+    const newLines = toLines(after);
+    let prefix = 0;
+    while (prefix < oldLines.length &&
+        prefix < newLines.length &&
+        oldLines[prefix] === newLines[prefix]) {
+        prefix += 1;
+    }
+    let oldSuffix = oldLines.length - 1;
+    let newSuffix = newLines.length - 1;
+    while (oldSuffix >= prefix &&
+        newSuffix >= prefix &&
+        oldLines[oldSuffix] === newLines[newSuffix]) {
+        oldSuffix -= 1;
+        newSuffix -= 1;
+    }
+    const removed = oldLines.slice(prefix, oldSuffix + 1);
+    const added = newLines.slice(prefix, newSuffix + 1);
+    const hunkLines = [];
+    for (const line of removed) {
+        hunkLines.push(`-${line}`);
+    }
+    for (const line of added) {
+        hunkLines.push(`+${line}`);
+    }
+    const truncated = hunkLines.length > maxBodyLines;
+    const shown = truncated ? hunkLines.slice(0, maxBodyLines) : hunkLines;
+    const header = [
+        "--- before",
+        "+++ after",
+        `@@ -${prefix + 1},${removed.length} +${prefix + 1},${added.length} @@`
+    ];
+    if (truncated) {
+        shown.push(`... truncated ${hunkLines.length - maxBodyLines} additional diff lines ...`);
+    }
+    return [...header, ...shown].join("\n");
+}
+function summarizeHookResult(hookResult) {
+    return {
+        status: hookResult.status,
+        message: hookResult.message,
+        eventId: hookResult.eventId,
+        durationMs: hookResult.durationMs,
+        exitCode: hookResult.exitCode,
+        timedOut: hookResult.timedOut,
+        stdout: hookResult.stdout,
+        stderr: hookResult.stderr
+    };
+}
+async function runFileWriteHook(context, payload) {
+    if (!context.runHook) {
+        return null;
+    }
+    try {
+        return await context.runHook("on-file-write", payload);
+    }
+    catch (error) {
+        const message = toErrorMessage(error);
+        return {
+            hook: "on-file-write",
+            status: "error",
+            command: null,
+            cwd: context.workingDirectory,
+            message: `Hook execution failed: ${message}`,
+            durationMs: 0,
+            eventId: "unknown",
+            timestamp: new Date().toISOString(),
+            stdout: "",
+            stderr: message,
+            exitCode: null,
+            signal: null,
+            timedOut: false
+        };
+    }
+}
+async function executeReadFile(call, context) {
+    const pathArg = normalizeString(call.arguments["path"]);
+    if (!pathArg) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: "read_file requires a non-empty 'path' argument."
+        };
+    }
+    const maxBytes = normalizePositiveInt(call.arguments["maxBytes"], 200_000, 500_000);
+    const absolutePath = (0, tool_safety_1.resolveToolPath)(pathArg, context.workingDirectory);
+    try {
+        const content = await (0, promises_1.readFile)(absolutePath, "utf8");
+        const clipped = content.slice(0, maxBytes);
+        const truncated = clipped.length < content.length;
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "ok",
+            output: truncated ? `${clipped}\n\n[truncated at ${maxBytes} bytes]` : clipped,
+            metadata: { path: absolutePath, maxBytes, truncated }
+        };
+    }
+    catch (error) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: `read_file failed: ${toErrorMessage(error)}`,
+            metadata: { path: absolutePath }
+        };
+    }
+}
+async function executeWriteFile(call, context) {
+    const pathArg = normalizeString(call.arguments["path"]);
+    if (!pathArg) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: "write_file requires a non-empty 'path' argument."
+        };
+    }
+    const content = typeof call.arguments["content"] === "string" ? call.arguments["content"] : null;
+    if (content === null) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: "write_file requires a string 'content' argument."
+        };
+    }
+    const absolutePath = (0, tool_safety_1.resolveToolPath)(pathArg, context.workingDirectory);
+    const parentDir = (0, node_path_1.resolve)(absolutePath, "..");
+    let before = "";
+    try {
+        before = await (0, promises_1.readFile)(absolutePath, "utf8");
+    }
+    catch {
+        before = "";
+    }
+    try {
+        await (0, promises_1.mkdir)(parentDir, { recursive: true });
+        await (0, promises_1.writeFile)(absolutePath, content, "utf8");
+        const diffPreview = buildDiffPreview(before, content);
+        const hookResult = await runFileWriteHook(context, {
+            operation: "write_file",
+            path: absolutePath,
+            bytesAfter: content.length
+        });
+        const hookWarning = hookResult && hookResult.status !== "ok" && hookResult.status !== "skipped"
+            ? `\n${(0, hooks_1.formatHookFailure)(hookResult)}`
+            : "";
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "ok",
+            output: `Wrote ${absolutePath}\n${diffPreview}${hookWarning}`,
+            metadata: {
+                path: absolutePath,
+                bytes: content.length,
+                diffPreview,
+                hook: hookResult ? summarizeHookResult(hookResult) : undefined
+            }
+        };
+    }
+    catch (error) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: `write_file failed: ${toErrorMessage(error)}`,
+            metadata: { path: absolutePath }
+        };
+    }
+}
+async function executeEditFile(call, context) {
+    const pathArg = normalizeString(call.arguments["path"]);
+    if (!pathArg) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: "edit_file requires a non-empty 'path' argument."
+        };
+    }
+    const oldText = typeof call.arguments["oldText"] === "string" ? call.arguments["oldText"] : null;
+    const newText = typeof call.arguments["newText"] === "string" ? call.arguments["newText"] : null;
+    if (oldText === null || newText === null) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: "edit_file requires string arguments 'oldText' and 'newText'."
+        };
+    }
+    const replaceAll = call.arguments["replaceAll"] === true;
+    const absolutePath = (0, tool_safety_1.resolveToolPath)(pathArg, context.workingDirectory);
+    let before;
+    try {
+        before = await (0, promises_1.readFile)(absolutePath, "utf8");
+    }
+    catch (error) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: `edit_file failed: ${toErrorMessage(error)}`,
+            metadata: { path: absolutePath }
+        };
+    }
+    if (!before.includes(oldText)) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: "edit_file failed: 'oldText' was not found in file.",
+            metadata: { path: absolutePath }
+        };
+    }
+    const after = replaceAll ? before.split(oldText).join(newText) : before.replace(oldText, newText);
+    try {
+        await (0, promises_1.writeFile)(absolutePath, after, "utf8");
+        const diffPreview = buildDiffPreview(before, after);
+        const hookResult = await runFileWriteHook(context, {
+            operation: "edit_file",
+            path: absolutePath,
+            replaced: replaceAll ? "all" : "first",
+            bytesAfter: after.length
+        });
+        const hookWarning = hookResult && hookResult.status !== "ok" && hookResult.status !== "skipped"
+            ? `\n${(0, hooks_1.formatHookFailure)(hookResult)}`
+            : "";
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "ok",
+            output: `Edited ${absolutePath}\n${diffPreview}${hookWarning}`,
+            metadata: {
+                path: absolutePath,
+                replaceAll,
+                diffPreview,
+                hook: hookResult ? summarizeHookResult(hookResult) : undefined
+            }
+        };
+    }
+    catch (error) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: `edit_file failed: ${toErrorMessage(error)}`,
+            metadata: { path: absolutePath }
+        };
+    }
+}
+async function executeListDir(call, context) {
+    const pathArg = normalizeString(call.arguments["path"]) ?? ".";
+    const absolutePath = (0, tool_safety_1.resolveToolPath)(pathArg, context.workingDirectory);
+    try {
+        const entries = await (0, promises_1.readdir)(absolutePath, { withFileTypes: true });
+        const lines = entries
+            .map((entry) => `${entry.isDirectory() ? "dir " : "file"} ${entry.name}`)
+            .sort((a, b) => a.localeCompare(b));
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "ok",
+            output: lines.join("\n"),
+            metadata: { path: absolutePath, count: lines.length }
+        };
+    }
+    catch (error) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: `list_dir failed: ${toErrorMessage(error)}`,
+            metadata: { path: absolutePath }
+        };
+    }
+}
+async function executeGrep(call, context) {
+    const pattern = normalizeString(call.arguments["pattern"]);
+    if (!pattern) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: "grep requires a non-empty 'pattern' argument."
+        };
+    }
+    const pathArg = normalizeString(call.arguments["path"]) ?? ".";
+    const absolutePath = (0, tool_safety_1.resolveToolPath)(pathArg, context.workingDirectory);
+    const maxMatches = normalizePositiveInt(call.arguments["maxMatches"], 200, 2_000);
+    try {
+        const { stdout } = await execFileAsync("rg", [
+            "--line-number",
+            "--color",
+            "never",
+            "--max-count",
+            String(maxMatches),
+            pattern,
+            absolutePath
+        ]);
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "ok",
+            output: stdout.trim(),
+            metadata: { path: absolutePath, maxMatches }
+        };
+    }
+    catch (error) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: `grep failed: ${toErrorMessage(error)}`,
+            metadata: { path: absolutePath, maxMatches }
+        };
+    }
+}
+async function executeRunCommand(call, context) {
+    const command = normalizeString(call.arguments["command"]);
+    if (!command) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: "run_command requires a non-empty 'command' argument."
+        };
+    }
+    const cwdArg = normalizeString(call.arguments["cwd"]) ?? ".";
+    const cwd = (0, node_path_1.resolve)((0, tool_safety_1.resolveToolPath)(cwdArg, context.workingDirectory));
+    const timeoutMs = normalizePositiveInt(call.arguments["timeoutMs"], 60_000, 120_000);
+    try {
+        const result = await context.vtSession.runCommand(command, { cwd, timeoutMs });
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: result.exitCode === 0 ? "ok" : result.timedOut ? "timeout" : "error",
+            output: result.output,
+            metadata: {
+                exitCode: result.exitCode,
+                timedOut: result.timedOut,
+                cwd
+            }
+        };
+    }
+    catch (error) {
+        return {
+            callId: call.id,
+            tool: call.name,
+            status: "error",
+            output: `run_command failed: ${toErrorMessage(error)}`,
+            metadata: { cwd }
+        };
+    }
+}
+async function executeToolCall(call, context) {
+    if (call.name === "read_file") {
+        return await executeReadFile(call, context);
+    }
+    if (call.name === "write_file") {
+        return await executeWriteFile(call, context);
+    }
+    if (call.name === "edit_file") {
+        return await executeEditFile(call, context);
+    }
+    if (call.name === "list_dir") {
+        return await executeListDir(call, context);
+    }
+    if (call.name === "grep") {
+        return await executeGrep(call, context);
+    }
+    if (call.name === "run_command") {
+        return await executeRunCommand(call, context);
+    }
+    return {
+        callId: call.id,
+        tool: call.name,
+        status: "error",
+        output: `Unsupported tool: ${call.name}`
+    };
+}

package/dist/tool-protocol.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseToolProtocol = parseToolProtocol;
+const TOOL_BLOCK_REGEX = /```yips-tools\s*\n([\s\S]*?)```/u;
+const ALLOWED_TOOLS = new Set([
+    "read_file",
+    "write_file",
+    "edit_file",
+    "list_dir",
+    "grep",
+    "run_command"
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function normalizeToolCall(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const id = value["id"];
+    const name = value["name"];
+    const args = value["arguments"];
+    if (typeof id !== "string" || id.trim().length === 0) {
+        return null;
+    }
+    if (typeof name !== "string" || !ALLOWED_TOOLS.has(name)) {
+        return null;
+    }
+    if (!isRecord(args)) {
+        return null;
+    }
+    return {
+        id: id.trim(),
+        name: name,
+        arguments: args
+    };
+}
+function normalizeSubagentCall(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const id = value["id"];
+    const task = value["task"];
+    if (typeof id !== "string" || id.trim().length === 0) {
+        return null;
+    }
+    if (typeof task !== "string" || task.trim().length === 0) {
+        return null;
+    }
+    const contextRaw = value["context"];
+    const context = typeof contextRaw === "string" && contextRaw.trim().length > 0 ? contextRaw : undefined;
+    const allowedToolsRaw = value["allowed_tools"];
+    const allowedTools = Array.isArray(allowedToolsRaw)
+        ? allowedToolsRaw
+            .filter((item) => typeof item === "string" && ALLOWED_TOOLS.has(item))
+            .map((item) => item)
+        : undefined;
+    const maxRoundsRaw = value["max_rounds"];
+    const maxRounds = typeof maxRoundsRaw === "number" && Number.isInteger(maxRoundsRaw) && maxRoundsRaw > 0
+        ? Math.min(maxRoundsRaw, 6)
+        : undefined;
+    return {
+        id: id.trim(),
+        task: task.trim(),
+        context,
+        allowedTools,
+        maxRounds
+    };
+}
+function parseToolProtocol(input) {
+    const match = input.match(TOOL_BLOCK_REGEX);
+    if (!match) {
+        return {
+            assistantText: input,
+            toolCalls: [],
+            subagentCalls: []
+        };
+    }
+    const jsonBody = (match[1] ?? "").trim();
+    if (jsonBody.length === 0) {
+        return {
+            assistantText: input,
+            toolCalls: [],
+            subagentCalls: []
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonBody);
+    }
+    catch {
+        return {
+            assistantText: input,
+            toolCalls: [],
+            subagentCalls: []
+        };
+    }
+    if (!isRecord(parsed)) {
+        return {
+            assistantText: input,
+            toolCalls: [],
+            subagentCalls: []
+        };
+    }
+    const normalizedTools = Array.isArray(parsed["tool_calls"])
+        ? parsed["tool_calls"]
+            .map((item) => normalizeToolCall(item))
+            .filter((call) => call !== null)
+        : [];
+    const normalizedSubagents = Array.isArray(parsed["subagent_calls"])
+        ? parsed["subagent_calls"]
+            .map((item) => normalizeSubagentCall(item))
+            .filter((call) => call !== null)
+        : [];
+    const assistantText = input.replace(match[0], "").trim();
+    return {
+        assistantText,
+        toolCalls: normalizedTools,
+        subagentCalls: normalizedSubagents
+    };
+}

package/dist/tool-safety.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveToolPath = resolveToolPath;
+exports.isWithinWorkingZone = isWithinWorkingZone;
+exports.assessCommandRisk = assessCommandRisk;
+exports.assessPathRisk = assessPathRisk;
+const node_path_1 = require("node:path");
+const DESTRUCTIVE_COMMAND_PATTERNS = [
+    /(^|\s)rm\s+-rf(\s|$)/u,
+    /(^|\s)rm\s+-fr(\s|$)/u,
+    /(^|\s)mkfs(\.|\s|$)/u,
+    /(^|\s)dd\s+if=/u,
+    /(^|\s)reboot(\s|$)/u,
+    /(^|\s)shutdown(\s|$)/u,
+    /(^|\s)poweroff(\s|$)/u,
+    /(^|\s)halt(\s|$)/u
+];
+function normalizeBase(base) {
+    return (0, node_path_1.resolve)(base);
+}
+function resolveToolPath(path, workingZone) {
+    const trimmed = path.trim();
+    if (trimmed.length === 0) {
+        return normalizeBase(workingZone);
+    }
+    return (0, node_path_1.resolve)(normalizeBase(workingZone), trimmed);
+}
+function isWithinWorkingZone(path, workingZone) {
+    const absolutePath = (0, node_path_1.resolve)(path);
+    const absoluteZone = normalizeBase(workingZone);
+    const rel = (0, node_path_1.relative)(absoluteZone, absolutePath);
+    return rel === "" || (!rel.startsWith("..") && rel !== ".." && !rel.startsWith("../"));
+}
+function assessCommandRisk(command, cwd, workingZone) {
+    const destructive = DESTRUCTIVE_COMMAND_PATTERNS.some((pattern) => pattern.test(command));
+    const resolvedCwd = resolveToolPath(cwd, workingZone);
+    const outOfZone = !isWithinWorkingZone(resolvedCwd, workingZone);
+    return {
+        destructive,
+        outOfZone,
+        requiresConfirmation: destructive || outOfZone
+    };
+}
+function assessPathRisk(path, workingZone) {
+    const resolved = resolveToolPath(path, workingZone);
+    const outOfZone = !isWithinWorkingZone(resolved, workingZone);
+    return {
+        destructive: false,
+        outOfZone,
+        requiresConfirmation: outOfZone
+    };
+}