kiriya 0.1.0

package/dist/src/core/presentation/mcp/tool-definitions.js

@@ -0,0 +1,149 @@
+import { UsageError } from "../../domain/errors.js";
+import { message } from "../../domain/message.js";
+import { isObject } from "./protocol.js";
+const MESSAGES = { type: "array", items: { type: "object" } };
+/** The JSON document `--json` prints, for a result and for an error alike, plus what the server adds. */
+export const OUTPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        ok: { type: "boolean" },
+        command: { type: "string" },
+        kind: { type: "string", enum: ["done", "preview"] },
+        applyFlag: { type: "string" },
+        data: {},
+        warnings: MESSAGES,
+        failures: MESSAGES,
+        error: { type: "object" },
+        output: { type: "string", description: "What a program the command ran printed" },
+        truncated: {
+            type: "array",
+            items: { type: "object" },
+            description: "Where the result was cut to fit, and how much",
+        },
+    },
+    required: ["ok"],
+};
+const READING = { sensitive: false, changes: false };
+export function toolAccess(spec, allowWrite) {
+    return { sensitive: allowWrite, changes: spec.safety !== "read" };
+}
+/** The options a tool takes: never those only for a terminal, and the others as access allows. */
+function toolOptions(input, access) {
+    return Object.entries(input.options).filter(([, option]) => option.terminalOnly !== true &&
+        (option.sensitive !== true || access.sensitive) &&
+        (option.reachesHidden !== true || !access.changes));
+}
+/** All four annotations, always, because a client assumes the worst for any left out. */
+export function annotationsOf(spec) {
+    return {
+        readOnlyHint: spec.safety === "read",
+        destructiveHint: spec.safety === "destroy",
+        idempotentHint: spec.idempotent,
+        openWorldHint: spec.usesNetwork,
+    };
+}
+/** One property per argument and option, named as in help; arguments a command needs are required. */
+export function inputSchemaOf(commandId, input, translator, access = READING) {
+    const properties = {};
+    const required = [];
+    const claim = (name, schema) => {
+        if (Object.hasOwn(properties, name))
+            throw new Error(`${commandId}: ${name} is both an argument and an option`);
+        properties[name] = schema;
+    };
+    for (const positional of input.positionals) {
+        const description = translator.text(message(positional.description));
+        const value = {
+            type: "string",
+            ...(positional.choices === undefined ? {} : { enum: [...positional.choices] }),
+        };
+        claim(positional.name, positional.variadic
+            ? { type: "array", items: value, ...(positional.required ? { minItems: 1 } : {}), description }
+            : { ...value, description });
+        if (positional.required)
+            required.push(positional.name);
+    }
+    for (const [name, option] of toolOptions(input, access)) {
+        const text = translator.text(message(option.description));
+        const description = option.valueName === undefined ? text : `${text} ${option.valueName}`;
+        if (option.type === "boolean")
+            claim(name, { type: "boolean", description });
+        else if (option.multiple === true)
+            claim(name, { type: "array", items: { type: "string" }, description });
+        else
+            claim(name, { type: "string", description });
+    }
+    return { type: "object", properties, ...(required.length > 0 ? { required } : {}), additionalProperties: false };
+}
+export function toolDefinition(spec, translator, allowWrite) {
+    return {
+        name: spec.id,
+        description: translator.text(message(spec.summary)),
+        inputSchema: inputSchemaOf(spec.id, spec.input, translator, toolAccess(spec, allowWrite)),
+        outputSchema: OUTPUT_SCHEMA,
+        annotations: annotationsOf(spec),
+    };
+}
+function text(value, name) {
+    if (typeof value !== "string")
+        throw new UsageError("core.mcp.expects-text", { name });
+    return value;
+}
+function textList(value, name) {
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+        throw new UsageError("core.mcp.expects-list", { name });
+    }
+    return value;
+}
+/**
+ * The JSON arguments of a call as the command's raw input, checked against the schema
+ * the tool publishes. The command's own parse checks the values next, as it does for argv.
+ */
+export function rawInputOf(input, args, access = READING) {
+    const given = args ?? {};
+    if (!isObject(given))
+        throw new UsageError("core.mcp.arguments-not-object");
+    const options = new Map(toolOptions(input, access));
+    for (const name of Object.keys(given)) {
+        if (!options.has(name) && !input.positionals.some((positional) => positional.name === name)) {
+            throw new UsageError("core.mcp.unknown-argument", { name });
+        }
+    }
+    const positionals = [];
+    let skipped;
+    for (const positional of input.positionals) {
+        const value = given[positional.name];
+        const values = value === undefined
+            ? []
+            : positional.variadic
+                ? textList(value, positional.name)
+                : [text(value, positional.name)];
+        if (values.length === 0) {
+            if (positional.required)
+                throw new UsageError("core.usage.missing-argument", { name: positional.name });
+            skipped ??= positional.name;
+            continue;
+        }
+        // Arguments are positional underneath, so a later one cannot stand in for an earlier one left out.
+        if (skipped !== undefined)
+            throw new UsageError("core.usage.missing-argument", { name: skipped });
+        positionals.push(...values);
+    }
+    const raw = {};
+    for (const [name, option] of options) {
+        const value = given[name];
+        if (value === undefined)
+            continue;
+        if (option.type === "boolean") {
+            if (typeof value !== "boolean")
+                throw new UsageError("core.mcp.expects-boolean", { name });
+            if (value)
+                raw[name] = true;
+        }
+        else {
+            raw[name] = option.multiple === true ? textList(value, name) : text(value, name);
+        }
+    }
+    return { positionals, options: raw };
+}
+//# sourceMappingURL=tool-definitions.js.map

package/dist/src/core/presentation/mcp/tool-results.js

@@ -0,0 +1,56 @@
+import { errorJson, resultJson } from "../cli/json-output.js";
+import { isObject } from "./protocol.js";
+/** Roughly ten thousand tokens: enough for a model to act on, small enough for its context. */
+export const OUTPUT_LIMITS = { items: 200, characters: 40_000 };
+function trim(value, at, items, characters, cuts) {
+    if (typeof value === "string") {
+        if (value.length <= characters)
+            return value;
+        cuts.push({ at, omitted: value.length - characters, unit: "characters" });
+        return value.slice(0, characters);
+    }
+    if (Array.isArray(value)) {
+        if (value.length > items)
+            cuts.push({ at, omitted: value.length - items, unit: "items" });
+        return value.slice(0, items).map((item, index) => trim(item, `${at}[${index}]`, items, characters, cuts));
+    }
+    if (isObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            trim(item, at === "" ? key : `${at}.${key}`, items, characters, cuts),
+        ]));
+    }
+    return value;
+}
+/** Long lists keep their first items and long texts their start, tighter each round, until the document fits. */
+export function limitDocument(document, limits) {
+    let items = limits.items;
+    let characters = limits.characters;
+    for (;;) {
+        const cuts = [];
+        const trimmed = trim(document, "", items, characters, cuts);
+        const limited = cuts.length === 0 ? trimmed : { ...trimmed, truncated: cuts };
+        if (JSON.stringify(limited).length <= limits.characters || (items === 10 && characters === 1000))
+            return limited;
+        items = Math.max(10, Math.floor(items / 2));
+        characters = Math.max(1000, Math.floor(characters / 2));
+    }
+}
+function toolResult(document, isError, limits) {
+    const structuredContent = limitDocument(document, limits);
+    return { content: [{ type: "text", text: JSON.stringify(structuredContent) }], structuredContent, isError };
+}
+/**
+ * The document `--json` prints, as structured content and repeated as text. Output a
+ * program printed on the way, such as docker's, is added; failures make it an error.
+ */
+export function commandToolResult(commandId, result, output, translator, limits = OUTPUT_LIMITS) {
+    const document = JSON.parse(resultJson(commandId, result, translator));
+    const failed = result.kind === "done" && result.failures.length > 0;
+    return toolResult(output === "" ? document : { ...document, output }, failed, limits);
+}
+/** A typed error as the document `--json` prints, so the model reads what to change. */
+export function errorToolResult(error, translator, limits = OUTPUT_LIMITS) {
+    return toolResult(JSON.parse(errorJson(error, translator)), true, limits);
+}
+//# sourceMappingURL=tool-results.js.map