@krapht/ork 0.2.0 → 0.3.0

package/dist/mcp-BWsdQyri.mjs

@@ -0,0 +1,91 @@
+import "./src-Cz1yOUTg.mjs";
+import { n as ORK_VERSION } from "./__build_info__-CXXMLvjt.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-D5ruZFgD.mjs";
+import { n as explainNode, p as isNewer } from "./context-BFGC_C02.mjs";
+import { p as runMarkerIn } from "./src-DtN1k-B3.mjs";
+import { defineCommand } from "citty";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+// src/commands/mcp.ts
+/**
+* @file `ork mcp`: Ork's tools for Claude Code over stdio (RFC-012), on the
+*   same handlers as `ork ui`'s API and the same checks as `ork validate`. They
+*   read, check a draft, explain a node's context, and start a run; none
+*   answers a decision or acts on a run. Inside a run nothing starts another,
+*   and an `ork` older than its caller expects says so on every call. It opens
+*   no port and holds no token, and stdout carries only the protocol.
+*/
+const INSTRUCTIONS = "Ork runs workflows of Claude sessions and programs on this machine. These tools read what Ork has (projects, workflows, the workflow format, runs, their events and cost, the decisions waiting on a person), check a workflow as `ork validate` does, and explain what a node's session loads. None answers a decision: a person does, in `ork ui` or their own terminal.";
+const STARTS = " `start_run` starts a run in the background.";
+const explainTool = (opened, home) => tool("explain_context", "What one node's session would load, as `ork context explain` shows it: its agent, instructions, skills and files, layer by layer, with their tokens.", {
+	project: z.string().min(1),
+	workflow: z.string().min(1).describe("A workflow's name, or a path"),
+	node: z.string().min(1)
+}, ({ project, workflow, node }) => {
+	const found = opened.fileOf(project, workflow);
+	if ("error" in found) return refused(found.error);
+	const result = explainNode(found.file, node, found.project.root, home);
+	return result.ok ? answer(result.explanation) : refused(result.lines.join("\n"));
+});
+/** Every call refused, when this `ork` is older than its caller needs. */
+const tooOld = (tools, expects) => tools.map((each) => ({
+	...each,
+	call: () => Promise.resolve(refused(`This needs Ork ${expects} or newer, and this is ${ORK_VERSION}. Ask the person to upgrade, with \`ork upgrade\`.`))
+}));
+/** The server with Ork's tools on it, for stdio here and in tests. */
+const orkMcpServer = (options = {}) => {
+	const start = runMarkerIn(options.env ?? process.env) === null;
+	const opened = openMcp({
+		version: ORK_VERSION,
+		start,
+		...options.home === void 0 ? {} : { home: options.home },
+		...options.script === void 0 ? {} : { script: options.script }
+	});
+	const all = [...opened.tools, explainTool(opened, options.home)];
+	const tools = options.expects !== void 0 && isNewer(options.expects, "0.3.0") ? tooOld(all, options.expects) : all;
+	const server = new McpServer({
+		name: "ork",
+		version: ORK_VERSION
+	}, { instructions: start ? `${INSTRUCTIONS}${STARTS}` : INSTRUCTIONS });
+	for (const each of tools) server.registerTool(each.name, {
+		description: each.description,
+		inputSchema: z.strictObject(each.shape),
+		annotations: {
+			readOnlyHint: each.readOnly,
+			openWorldHint: false
+		}
+	}, async (args) => {
+		const { text, isError } = await each.call(args);
+		return {
+			content: [{
+				type: "text",
+				text
+			}],
+			...isError === true ? { isError } : {}
+		};
+	});
+	return {
+		server,
+		close: opened.close
+	};
+};
+const mcp = defineCommand({
+	meta: {
+		name: "mcp",
+		description: "Serve Ork's tools to Claude Code over stdio (MCP)"
+	},
+	args: { expects: {
+		type: "string",
+		description: "The oldest Ork the caller works with, such as a plugin"
+	} },
+	run: async ({ args }) => {
+		const { server, close } = orkMcpServer(args.expects === void 0 ? {} : { expects: args.expects });
+		const transport = new StdioServerTransport();
+		transport.onclose = () => {
+			close();
+		};
+		await server.connect(transport);
+	}
+});
+export { mcp };