@sheepbun/yips 0.1.1

package/dist/agent/protocol/tool-protocol.js

@@ -0,0 +1,160 @@
+"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"
+]);
+const ALLOWED_SKILLS = new Set([
+    "search",
+    "fetch",
+    "build",
+    "todos",
+    "virtual_terminal"
+]);
+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 normalizeSkillCall(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_SKILLS.has(name)) {
+        return null;
+    }
+    if (!isRecord(args)) {
+        return null;
+    }
+    return {
+        id: id.trim(),
+        name: name,
+        arguments: args
+    };
+}
+function parseToolProtocol(input) {
+    const match = input.match(TOOL_BLOCK_REGEX);
+    if (!match) {
+        return {
+            assistantText: input,
+            toolCalls: [],
+            subagentCalls: [],
+            skillCalls: []
+        };
+    }
+    const jsonBody = (match[1] ?? "").trim();
+    if (jsonBody.length === 0) {
+        return {
+            assistantText: input,
+            toolCalls: [],
+            subagentCalls: [],
+            skillCalls: []
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonBody);
+    }
+    catch {
+        return {
+            assistantText: input,
+            toolCalls: [],
+            subagentCalls: [],
+            skillCalls: []
+        };
+    }
+    if (!isRecord(parsed)) {
+        return {
+            assistantText: input,
+            toolCalls: [],
+            subagentCalls: [],
+            skillCalls: []
+        };
+    }
+    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 normalizedSkills = Array.isArray(parsed["skill_calls"])
+        ? parsed["skill_calls"]
+            .map((item) => normalizeSkillCall(item))
+            .filter((call) => call !== null)
+        : [];
+    const assistantText = input.replace(match[0], "").trim();
+    return {
+        assistantText,
+        toolCalls: normalizedTools,
+        subagentCalls: normalizedSubagents,
+        skillCalls: normalizedSkills
+    };
+}

package/dist/agent/skills/skills.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeSearchSkill = executeSearchSkill;
+exports.executeFetchSkill = executeFetchSkill;
+exports.executeSkillCall = executeSkillCall;
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_path_1 = require("node:path");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const SEARCH_ENDPOINT = "https://duckduckgo.com/html/";
+const MAX_SKILL_TIMEOUT_MS = 300_000;
+function normalizeString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function normalizePositiveInt(value, fallback, max) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+        return Math.min(value, max);
+    }
+    if (typeof value === "string") {
+        const parsed = Number.parseInt(value.trim(), 10);
+        if (Number.isInteger(parsed) && parsed > 0) {
+            return Math.min(parsed, max);
+        }
+    }
+    return fallback;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function stripHtml(input) {
+    return input
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script>/giu, " ")
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style>/giu, " ")
+        .replace(/<[^>]+>/gu, " ");
+}
+function decodeEntities(input) {
+    return input
+        .replace(/&amp;/gu, "&")
+        .replace(/&quot;/gu, '"')
+        .replace(/&#39;/gu, "'")
+        .replace(/&apos;/gu, "'")
+        .replace(/&lt;/gu, "<")
+        .replace(/&gt;/gu, ">")
+        .replace(/&nbsp;/gu, " ");
+}
+function normalizeText(input) {
+    return decodeEntities(stripHtml(input)).replace(/\s+/gu, " ").trim();
+}
+function decodeDuckDuckGoHref(href) {
+    try {
+        const parsed = new URL(href, SEARCH_ENDPOINT);
+        if (parsed.hostname.endsWith("duckduckgo.com") && parsed.pathname === "/l/") {
+            const redirected = parsed.searchParams.get("uddg");
+            if (redirected && redirected.trim().length > 0) {
+                return decodeURIComponent(redirected);
+            }
+        }
+        return parsed.toString();
+    }
+    catch {
+        return href;
+    }
+}
+function parseSearchResults(html, maxResults) {
+    const results = [];
+    const anchorPattern = /<a\b[^>]*class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/giu;
+    let match = anchorPattern.exec(html);
+    while (match && results.length < maxResults) {
+        const rawHref = match[1] ?? "";
+        const rawTitle = match[2] ?? "";
+        const title = normalizeText(rawTitle);
+        const url = decodeDuckDuckGoHref(rawHref);
+        if (title.length > 0 && url.length > 0) {
+            results.push({ title, url });
+        }
+        match = anchorPattern.exec(html);
+    }
+    return results;
+}
+async function executeSearchSkill(args, fetchImpl = fetch) {
+    const query = normalizeString(args["query"]) ?? normalizeString(args["q"]);
+    if (!query) {
+        return "search skill requires a non-empty 'query' argument.";
+    }
+    const maxResults = normalizePositiveInt(args["maxResults"], 5, 10);
+    const url = `${SEARCH_ENDPOINT}?q=${encodeURIComponent(query)}`;
+    const response = await fetchImpl(url, {
+        method: "GET",
+        headers: {
+            "user-agent": "yips/0"
+        }
+    });
+    if (!response.ok) {
+        return `search skill failed: HTTP ${response.status} ${response.statusText}`;
+    }
+    const html = await response.text();
+    const results = parseSearchResults(html, maxResults);
+    if (results.length === 0) {
+        return `No search results found for: ${query}`;
+    }
+    const lines = [`Search results for: ${query}`];
+    for (const [index, result] of results.entries()) {
+        lines.push(`${index + 1}. ${result.title}`);
+        lines.push(`   ${result.url}`);
+    }
+    return lines.join("\n");
+}
+async function executeFetchSkill(args, fetchImpl = fetch) {
+    const rawUrl = normalizeString(args["url"]);
+    if (!rawUrl) {
+        return "fetch skill requires a non-empty 'url' argument.";
+    }
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        return "fetch skill requires a valid absolute URL.";
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return "fetch skill only supports http/https URLs.";
+    }
+    const maxChars = normalizePositiveInt(args["maxChars"], 6000, 20000);
+    const response = await fetchImpl(parsed.toString(), {
+        method: "GET",
+        headers: {
+            "user-agent": "yips/0"
+        }
+    });
+    if (!response.ok) {
+        return `fetch skill failed: HTTP ${response.status} ${response.statusText}`;
+    }
+    const contentType = response.headers.get("content-type") ?? "unknown";
+    const body = await response.text();
+    const normalized = normalizeText(body);
+    const clipped = normalized.slice(0, maxChars);
+    const truncated = clipped.length < normalized.length;
+    const lines = [
+        `Fetched: ${parsed.toString()}`,
+        `Content-Type: ${contentType}`,
+        "",
+        clipped.length > 0 ? clipped : "(empty response body)"
+    ];
+    if (truncated) {
+        lines.push("");
+        lines.push(`[truncated at ${maxChars} chars]`);
+    }
+    return lines.join("\n");
+}
+function detectBuildCommand(workingDirectory) {
+    const packageJsonPath = (0, node_path_1.resolve)(workingDirectory, "package.json");
+    if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+        return "npm run build";
+    }
+    const makefilePath = (0, node_path_1.resolve)(workingDirectory, "Makefile");
+    if ((0, node_fs_1.existsSync)(makefilePath)) {
+        return "make";
+    }
+    return "npm run build";
+}
+async function executeBuildSkill(args, context) {
+    const command = normalizeString(args["command"]) ?? detectBuildCommand(context.workingDirectory);
+    const cwdArg = normalizeString(args["cwd"]) ?? ".";
+    const cwd = (0, node_path_1.resolve)(context.workingDirectory, cwdArg);
+    const timeoutMs = normalizePositiveInt(args["timeoutMs"], 120_000, MAX_SKILL_TIMEOUT_MS);
+    const run = await context.vtSession.runCommand(command, {
+        cwd,
+        timeoutMs
+    });
+    return {
+        callId: "",
+        skill: "build",
+        status: run.exitCode === 0 ? "ok" : run.timedOut ? "timeout" : "error",
+        output: `Build command: ${command}\n${run.output}`.trim(),
+        metadata: {
+            cwd,
+            command,
+            exitCode: run.exitCode,
+            timedOut: run.timedOut
+        }
+    };
+}
+async function executeTodosSkill(args, context) {
+    const pathArg = normalizeString(args["path"]) ?? ".";
+    const pattern = normalizeString(args["pattern"]) ?? "TODO|FIXME|HACK|BUG";
+    const maxMatches = normalizePositiveInt(args["maxMatches"], 200, 2000);
+    const targetPath = (0, node_path_1.resolve)(context.workingDirectory, pathArg);
+    try {
+        const { stdout } = await execFileAsync("rg", [
+            "--line-number",
+            "--color",
+            "never",
+            "--max-count",
+            String(maxMatches),
+            pattern,
+            targetPath
+        ]);
+        const trimmed = stdout.trim();
+        return {
+            callId: "",
+            skill: "todos",
+            status: "ok",
+            output: trimmed.length > 0 ? trimmed : "No TODO markers found.",
+            metadata: { path: targetPath, pattern, maxMatches }
+        };
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null) {
+            const maybeCode = error.code;
+            const maybeStdout = error.stdout;
+            if (maybeCode === 1) {
+                return {
+                    callId: "",
+                    skill: "todos",
+                    status: "ok",
+                    output: "No TODO markers found.",
+                    metadata: { path: targetPath, pattern, maxMatches }
+                };
+            }
+            if (typeof maybeStdout === "string" && maybeStdout.trim().length > 0) {
+                return {
+                    callId: "",
+                    skill: "todos",
+                    status: "ok",
+                    output: maybeStdout.trim(),
+                    metadata: { path: targetPath, pattern, maxMatches }
+                };
+            }
+        }
+        return {
+            callId: "",
+            skill: "todos",
+            status: "error",
+            output: `todos skill failed: ${toErrorMessage(error)}`,
+            metadata: { path: targetPath, pattern, maxMatches }
+        };
+    }
+}
+async function executeVirtualTerminalSkill(args, context) {
+    const command = normalizeString(args["command"]);
+    if (!command) {
+        return {
+            callId: "",
+            skill: "virtual_terminal",
+            status: "error",
+            output: "virtual_terminal skill requires a non-empty 'command' argument."
+        };
+    }
+    const cwdArg = normalizeString(args["cwd"]) ?? ".";
+    const cwd = (0, node_path_1.resolve)(context.workingDirectory, cwdArg);
+    const timeoutMs = normalizePositiveInt(args["timeoutMs"], 60_000, MAX_SKILL_TIMEOUT_MS);
+    const run = await context.vtSession.runCommand(command, {
+        cwd,
+        timeoutMs
+    });
+    return {
+        callId: "",
+        skill: "virtual_terminal",
+        status: run.exitCode === 0 ? "ok" : run.timedOut ? "timeout" : "error",
+        output: run.output,
+        metadata: {
+            cwd,
+            command,
+            exitCode: run.exitCode,
+            timedOut: run.timedOut
+        }
+    };
+}
+async function executeSkillCall(call, context) {
+    try {
+        if (call.name === "search") {
+            const output = await executeSearchSkill(call.arguments, context.fetchImpl ?? fetch);
+            return {
+                callId: call.id,
+                skill: call.name,
+                status: output.startsWith("search skill failed:") || output.startsWith("search skill requires")
+                    ? "error"
+                    : "ok",
+                output
+            };
+        }
+        if (call.name === "fetch") {
+            const output = await executeFetchSkill(call.arguments, context.fetchImpl ?? fetch);
+            return {
+                callId: call.id,
+                skill: call.name,
+                status: output.startsWith("fetch skill failed:") ||
+                    output.startsWith("fetch skill requires") ||
+                    output.startsWith("fetch skill only supports")
+                    ? "error"
+                    : "ok",
+                output
+            };
+        }
+        if (call.name === "build") {
+            const result = await executeBuildSkill(call.arguments, context);
+            return { ...result, callId: call.id, skill: call.name };
+        }
+        if (call.name === "todos") {
+            const result = await executeTodosSkill(call.arguments, context);
+            return { ...result, callId: call.id, skill: call.name };
+        }
+        if (call.name === "virtual_terminal") {
+            const result = await executeVirtualTerminalSkill(call.arguments, context);
+            return { ...result, callId: call.id, skill: call.name };
+        }
+        return {
+            callId: call.id,
+            skill: call.name,
+            status: "error",
+            output: `Unsupported skill: ${call.name}`
+        };
+    }
+    catch (error) {
+        return {
+            callId: call.id,
+            skill: call.name,
+            status: "error",
+            output: `${call.name} skill failed: ${toErrorMessage(error)}`
+        };
+    }
+}