ygl-trees 0.66.0 → 0.69.0

package/dist/bundle/mcp-C27lIHd1.cjs

@@ -0,0 +1,276 @@
+const require_rolldown_runtime = require("./rolldown-runtime-C96Ew50Q.cjs");
+let node_readline = require("node:readline");
+node_readline = require_rolldown_runtime.__toESM(node_readline);
+//#region packages/ops/tools/src/mcp.ts
+/**
+* MCP (Model Context Protocol) Server — stdio transport.
+*
+* Eight-tool surface designed by the unified three-pillar theory (R8 research):
+*   agent_brief · agent_match · kb_search · claim_evaluate
+*   tree_state  · produce_report · doctor · task_advance
+*
+* Each tool routes to the CLI --json backend, inheriting its frozen contracts
+* (idempotent writes, pure JSON errors, snake_case fields). Agents call tools
+* directly — no command-line parsing layer.
+*
+* Protocol: JSON-RPC 2.0 over stdio (one message per line).
+*   → {"jsonrpc":"2.0","id":1,"method":"initialize","params":{...}}
+*   ← {"jsonrpc":"2.0","id":1,"result":{...}}
+*
+* @module @ygl/ops-tools/mcp
+*/
+/** Build a CLI invocation and capture JSON stdout.
+*  Uses process.argv[1] (the running script — bundle or source) to re-invoke
+*  the CLI as a child process. This works in both dev (dist/apps/...) and
+*  bundle (dist/bundle/bin.cjs) contexts. */
+function cliJson(parts) {
+	const { spawn } = require("node:child_process");
+	const self = process.argv[1];
+	return new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, [
+			self,
+			"--json",
+			...parts
+		], {
+			env: {
+				...process.env,
+				YGL_SERVE: "1",
+				YGL_MCP_CHILD: "1"
+			},
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let out = "";
+		let err = "";
+		child.stdout.on("data", (d) => out += d);
+		child.stderr.on("data", (d) => err += d);
+		child.on("close", (code) => {
+			if (out.trim()) try {
+				resolve(JSON.parse(out));
+				return;
+			} catch {}
+			reject(/* @__PURE__ */ new Error(`CLI rc=${code}: ${err.slice(0, 200) || out.slice(0, 200)}`));
+		});
+		child.on("error", (e) => reject(e));
+	});
+}
+function buildTools() {
+	return [
+		{
+			name: "agent_brief",
+			description: "Current workspace state: project, progress, counts, next actions, available skills. Always start here.",
+			inputSchema: {
+				type: "object",
+				properties: {}
+			},
+			execute: () => cliJson(["agent", "brief"])
+		},
+		{
+			name: "agent_match",
+			description: "Discover which skill handles a task. Returns matched skills with relevance scores.",
+			inputSchema: {
+				type: "object",
+				properties: { query: {
+					type: "string",
+					description: "Task description to match"
+				} },
+				required: ["query"]
+			},
+			execute: (a) => cliJson([
+				"agent",
+				"match",
+				String(a.query)
+			])
+		},
+		{
+			name: "kb_search",
+			description: "Search knowledge notes (CJK full-text). Returns notes with title, body, tags, confidence.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					query: {
+						type: "string",
+						description: "Search query (Chinese supported)"
+					},
+					eval: {
+						type: "boolean",
+						description: "Enable decision-model semantic re-ranking"
+					}
+				},
+				required: ["query"]
+			},
+			execute: (a) => {
+				const parts = [
+					"kb",
+					"search",
+					String(a.query)
+				];
+				if (a.eval) parts.push("--eval");
+				return cliJson(parts);
+			}
+		},
+		{
+			name: "claim_evaluate",
+			description: "Decision model evaluates a claim's confidence (score 0-5 → grade A/B/C/D).",
+			inputSchema: {
+				type: "object",
+				properties: { claim_id: {
+					type: "string",
+					description: "Claim ID to evaluate"
+				} },
+				required: ["claim_id"]
+			},
+			execute: (a) => cliJson([
+				"research",
+				"claim",
+				"evaluate",
+				String(a.claim_id)
+			])
+		},
+		{
+			name: "tree_state",
+			description: "All trees with node states (locked/unlocked). Visualize the dependency graph.",
+			inputSchema: {
+				type: "object",
+				properties: { tree: {
+					type: "string",
+					description: "Optional tree name (omit for all)"
+				} }
+			},
+			execute: (a) => cliJson([
+				"node",
+				"list",
+				...a.tree ? [String(a.tree)] : []
+			])
+		},
+		{
+			name: "produce_report",
+			description: "Assemble claims + evidence into a markdown report. Returns report ID and content.",
+			inputSchema: {
+				type: "object",
+				properties: {}
+			},
+			execute: () => cliJson(["produce", "report"])
+		},
+		{
+			name: "doctor",
+			description: "9-item workspace health check. Pass fix=true to auto-fix safe issues.",
+			inputSchema: {
+				type: "object",
+				properties: { fix: {
+					type: "boolean",
+					description: "Auto-fix dirty index + stale locks"
+				} }
+			},
+			execute: (a) => cliJson(["doctor", ...a.fix ? ["--fix"] : []])
+		},
+		{
+			name: "task_advance",
+			description: "Advance a task through the state machine: todo → doing → done (or roll back).",
+			inputSchema: {
+				type: "object",
+				properties: {
+					task_id: {
+						type: "string",
+						description: "Task artifact ID"
+					},
+					action: {
+						type: "string",
+						enum: [
+							"doing",
+							"done",
+							"todo"
+						],
+						description: "Target status"
+					}
+				},
+				required: ["task_id", "action"]
+			},
+			execute: (a) => cliJson([
+				"task",
+				String(a.action),
+				String(a.task_id)
+			])
+		}
+	];
+}
+/** Run the MCP server on stdio. */
+function serveMcp() {
+	const tools = buildTools();
+	const rl = node_readline.createInterface({ input: process.stdin });
+	const respond = (id, result) => {
+		process.stdout.write(JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			result
+		}) + "\n");
+	};
+	const respondErr = (id, code, message) => {
+		process.stdout.write(JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			error: {
+				code,
+				message
+			}
+		}) + "\n");
+	};
+	rl.on("line", (line) => {
+		if (!line.trim()) return;
+		let msg;
+		try {
+			msg = JSON.parse(line);
+		} catch {
+			return;
+		}
+		const { id, method, params } = msg;
+		switch (method) {
+			case "initialize":
+				respond(id, {
+					protocolVersion: "2024-11-05",
+					capabilities: { tools: {} },
+					serverInfo: {
+						name: "ygl-trees",
+						version: "0.69.0"
+					}
+				});
+				break;
+			case "tools/list":
+				respond(id, { tools: tools.map((t) => ({
+					name: t.name,
+					description: t.description,
+					inputSchema: t.inputSchema
+				})) });
+				break;
+			case "tools/call": {
+				const name = params?.name;
+				const tool = tools.find((t) => t.name === name);
+				if (!tool) {
+					respondErr(id, -32602, `Unknown tool: ${name}`);
+					break;
+				}
+				tool.execute(params?.arguments || {}).then((data) => respond(id, { content: [{
+					type: "text",
+					text: JSON.stringify(data, null, 2)
+				}] })).catch((e) => respond(id, {
+					content: [{
+						type: "text",
+						text: `Error: ${e?.message || e}`
+					}],
+					isError: true
+				}));
+				break;
+			}
+			case "ping":
+				respond(id, {});
+				break;
+			default: if (id !== void 0) respondErr(id, -32601, `Method not found: ${method}`);
+		}
+	});
+	process.stderr.write("[ygl-trees MCP] stdio server ready — 8 tools\n");
+}
+//#endregion
+exports.serveMcp = serveMcp;

package/dist/bundle/rolldown-runtime-C96Ew50Q.cjs

@@ -0,0 +1,64 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res, err) => () => {
+	if (err) throw err[0];
+	try {
+		return fn && (res = fn(fn = 0)), res;
+	} catch (e) {
+		throw err = [e], e;
+	}
+};
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+//#endregion
+Object.defineProperty(exports, "__esmMin", {
+	enumerable: true,
+	get: function() {
+		return __esmMin;
+	}
+});
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "__toCommonJS", {
+	enumerable: true,
+	get: function() {
+		return __toCommonJS;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});