behaviortrees 0.0.0-stage → 0.1.0

package/dist/chunks/mcp-CHN7W7L5.js

@@ -0,0 +1,8 @@
+import {
+  createMcpServer
+} from "./chunk-7LANS4ZA.js";
+import "./chunk-QW4NPMSB.js";
+import "./chunk-VTXL3OVS.js";
+export {
+  createMcpServer
+};

package/dist/cli.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import {
+  VERSION
+} from "./chunks/chunk-QW4NPMSB.js";
+import {
+  CONVERT_TARGETS,
+  InvalidTreeError,
+  convertTree,
+  createEditorLink,
+  getExample,
+  listExamples,
+  listGuides,
+  listNodeTypes,
+  readGuide,
+  validateTree
+} from "./chunks/chunk-VTXL3OVS.js";
+
+// src/cli.ts
+import { spawn } from "node:child_process";
+import { readFile, writeFile } from "node:fs/promises";
+import { parseArgs } from "node:util";
+var HELP = `behaviortrees ${VERSION}: validate, convert and share behavior trees
+
+Usage: behaviortrees <command> [file] [options]
+
+Commands:
+  validate [file]          Check a tree for errors (exits 1 if there are any)
+  convert [file] --to <f>  Convert to behavior3, btcpp-v4 or btcpp-v3
+  link [file]              Print a link that opens the tree in the editor
+  nodes                    List the built-in behavior3 node types
+  examples [id]            List example trees, or print one as JSON
+  guides [slug]            List the behaviortrees.com guides, or print one
+  mcp                      Run the MCP server over stdio
+
+Files can be behavior3 JSON (a tree or a project) or BehaviorTree.CPP XML.
+Leave out the file, or pass -, to read from stdin.
+
+Options:
+  --to <format>    convert: behavior3, btcpp-v4 or btcpp-v3
+  -o, --out <path> convert: write to a file instead of stdout
+  --open           link: also open it in your browser
+  --json           print machine-readable JSON
+  -h, --help       show this help
+  -v, --version    show the version
+
+Docs: https://www.behaviortrees.com/llms.txt`;
+var UsageError = class extends Error {
+};
+var readInput = async (file) => {
+  if (file && file !== "-") return readFile(file, "utf8");
+  if (process.stdin.isTTY) throw new UsageError("Give a file, or pipe a tree into stdin");
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+};
+var print = (value) => process.stdout.write(`${typeof value === "string" ? value : JSON.stringify(value, null, 2)}
+`);
+var formatFinding = (finding) => `${finding.level.padEnd(7)}  ${finding.tree ? `${finding.tree}: ` : ""}${finding.message}`;
+var openInBrowser = (url) => {
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", '""', url.replace(/&/g, "^&")]] : ["xdg-open", [url]];
+  spawn(command, args, { detached: true, stdio: "ignore" }).unref();
+};
+async function main(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      to: { type: "string" },
+      out: { type: "string", short: "o" },
+      open: { type: "boolean" },
+      json: { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+  const [command, arg] = positionals;
+  if (values.version) return print(VERSION), 0;
+  if (values.help || !command || command === "help") return print(HELP), command || values.help ? 0 : 1;
+  switch (command) {
+    case "validate": {
+      const result = await validateTree(await readInput(arg));
+      if (values.json) {
+        print(result);
+      } else {
+        for (const tree of result.trees) {
+          print(`${tree.title} (${tree.nodes} node${tree.nodes === 1 ? "" : "s"})`);
+        }
+        for (const finding of result.findings) print(formatFinding(finding));
+        const errors = result.findings.filter((finding) => finding.level === "error").length;
+        print(result.valid ? "Valid." : `${errors} error${errors === 1 ? "" : "s"}.`);
+      }
+      return result.valid ? 0 : 1;
+    }
+    case "convert": {
+      if (!values.to || !CONVERT_TARGETS.includes(values.to)) {
+        throw new UsageError(`convert needs --to ${CONVERT_TARGETS.join(" | ")}`);
+      }
+      const result = await convertTree(await readInput(arg), values.to);
+      if (values.out) await writeFile(values.out, result.output);
+      else process.stdout.write(result.output);
+      for (const issue of result.issues) process.stderr.write(`${formatFinding(issue)}
+`);
+      return 0;
+    }
+    case "link": {
+      try {
+        const link = await createEditorLink(await readInput(arg));
+        if (values.json) print(link);
+        else print(link.url);
+        for (const finding of link.findings.filter((f) => f.level !== "info")) {
+          process.stderr.write(`${formatFinding(finding)}
+`);
+        }
+        if (values.open) openInBrowser(link.url);
+        return 0;
+      } catch (error) {
+        if (!(error instanceof InvalidTreeError)) throw error;
+        process.stderr.write(`${error.message}
+`);
+        return 1;
+      }
+    }
+    case "nodes": {
+      const nodes = listNodeTypes();
+      if (values.json) return print(nodes), 0;
+      for (const node of nodes) print(`${node.name.padEnd(20)} ${node.category.padEnd(10)} ${node.description ?? ""}`);
+      return 0;
+    }
+    case "examples": {
+      if (arg) {
+        const example = getExample(arg);
+        if (!example) throw new UsageError(`No example "${arg}". Run "behaviortrees examples" to list them.`);
+        return print(example), 0;
+      }
+      const examples = listExamples();
+      if (values.json) return print(examples), 0;
+      for (const example of examples) print(`${example.id.padEnd(26)} ${example.title}`);
+      return 0;
+    }
+    case "guides": {
+      if (arg) return print(await readGuide(arg)), 0;
+      const guides = await listGuides();
+      if (values.json) return print(guides), 0;
+      for (const guide of guides) print(`${guide.slug.padEnd(36)} ${guide.title}`);
+      return 0;
+    }
+    case "mcp": {
+      const [{ StdioServerTransport }, { createMcpServer }] = await Promise.all([
+        import("@modelcontextprotocol/sdk/server/stdio.js"),
+        import("./chunks/mcp-CHN7W7L5.js")
+      ]);
+      await createMcpServer().connect(new StdioServerTransport());
+      return -1;
+    }
+    default:
+      throw new UsageError(`Unknown command "${command}". Run "behaviortrees --help".`);
+  }
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    if (code >= 0) process.exitCode = code;
+  },
+  (error) => {
+    process.stderr.write(`behaviortrees: ${error instanceof Error ? error.message : String(error)}
+`);
+    if (error instanceof UsageError) process.stderr.write('Run "behaviortrees --help" for usage.\n');
+    process.exitCode = error instanceof UsageError ? 2 : 1;
+  }
+);

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+export type TreeInput = string | Record<string, unknown> | unknown[];
+
+export type Finding = { level: 'error' | 'warning' | 'info'; message: string; tree?: string };
+
+export type ValidationResult = {
+	valid: boolean;
+	format?: 'behavior3' | 'btcpp';
+	kind?: 'tree' | 'project';
+	trees: { title: string; nodes: number }[];
+	findings: Finding[];
+};
+export declare function validateTree(input: TreeInput): Promise<ValidationResult>;
+
+export type ConvertTarget = 'behavior3' | 'btcpp-v4' | 'btcpp-v3';
+export declare const CONVERT_TARGETS: ConvertTarget[];
+export type ConvertResult = { output: string; format: ConvertTarget; issues: Finding[] };
+export declare function convertTree(input: TreeInput, to: ConvertTarget): Promise<ConvertResult>;
+
+export type EditorLink = { url: string; title: string; findings: Finding[] };
+export declare class InvalidTreeError extends Error {
+	readonly findings: Finding[];
+}
+export declare function createEditorLink(input: TreeInput): Promise<EditorLink>;
+
+export type NodeType = {
+	name: string;
+	category: string;
+	title?: string;
+	description?: string;
+	properties: Record<string, unknown>;
+};
+export declare function listNodeTypes(): NodeType[];
+export declare function listExamples(): { id: string; title: string; description: string; editorUrl: string }[];
+export declare function getExample(id: string): Record<string, unknown> | undefined;
+
+export type Guide = { slug: string; title: string; description: string; url: string; markdownUrl: string };
+export declare function listGuides(): Promise<Guide[]>;
+export declare function readGuide(slug: string): Promise<string>;

package/dist/index.js

@@ -0,0 +1,24 @@
+import {
+  CONVERT_TARGETS,
+  InvalidTreeError,
+  convertTree,
+  createEditorLink,
+  getExample,
+  listExamples,
+  listGuides,
+  listNodeTypes,
+  readGuide,
+  validateTree
+} from "./chunks/chunk-VTXL3OVS.js";
+export {
+  CONVERT_TARGETS,
+  InvalidTreeError,
+  convertTree,
+  createEditorLink,
+  getExample,
+  listExamples,
+  listGuides,
+  listNodeTypes,
+  readGuide,
+  validateTree
+};

package/dist/mcp.d.ts

@@ -0,0 +1,7 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+export declare function createMcpServer(): McpServer;
+// Stateless Streamable HTTP handler; pass the parsed JSON body if the host
+// already read it (Vercel does)
+export declare function handleMcpRequest(req: IncomingMessage & { body?: unknown }, res: ServerResponse): Promise<void>;

package/dist/mcp.js

@@ -0,0 +1,43 @@
+import {
+  createMcpServer
+} from "./chunks/chunk-7LANS4ZA.js";
+import "./chunks/chunk-QW4NPMSB.js";
+import "./chunks/chunk-VTXL3OVS.js";
+
+// src/http.ts
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+var CORS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Accept, Authorization, Mcp-Session-Id, Mcp-Protocol-Version, Last-Event-ID",
+  "Access-Control-Expose-Headers": "Mcp-Session-Id, Mcp-Protocol-Version"
+};
+async function handleMcpRequest(req, res) {
+  for (const [key, value] of Object.entries(CORS)) res.setHeader(key, value);
+  if (req.method === "OPTIONS") {
+    res.writeHead(204).end();
+    return;
+  }
+  if (req.method !== "POST") {
+    res.writeHead(405, { "Content-Type": "application/json", Allow: "POST, OPTIONS" }).end(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        error: { code: -32e3, message: "This MCP server is stateless: send JSON-RPC requests with POST." },
+        id: null
+      })
+    );
+    return;
+  }
+  const server = createMcpServer();
+  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0, enableJsonResponse: true });
+  res.on("close", () => {
+    void transport.close();
+    void server.close();
+  });
+  await server.connect(transport);
+  await transport.handleRequest(req, res, req.body);
+}
+export {
+  createMcpServer,
+  handleMcpRequest
+};

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "behaviortrees",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Validate, convert and share behavior trees (behavior3 JSON, BehaviorTree.CPP XML) from the command line or any MCP client.",
+  "license": "AGPL-3.0-only",
+  "homepage": "https://www.behaviortrees.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/behaviortrees/behaviortrees.git",
+    "directory": "packages/cli"
+  },
+  "bugs": "https://github.com/behaviortrees/behaviortrees/issues",
+  "keywords": [
+    "behavior-tree",
+    "behavior3",
+    "behaviortree-cpp",
+    "groot",
+    "ros2",
+    "nav2",
+    "game-ai",
+    "mcp",
+    "cli"
+  ],
+  "mcpName": "io.github.behaviortrees/behaviortrees",
+  "type": "module",
+  "bin": {
+    "behaviortrees": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp.d.ts",
+      "default": "./dist/mcp.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "LICENSE-MIT"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "@xmldom/xmldom": "^0.9.12",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "esbuild": "^0.28.1",
+    "typescript": "~5.7.3",
+    "uuid": "^11.1.1",
+    "vitest": "^4.1.12",
+    "@behaviortrees/examples": "0.0.0"
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "test": "vitest run",
+    "lint": "tsc --noEmit -p tsconfig.json"
+  }
 }