@neuroverseos/governance 0.6.1 → 0.7.0

package/dist/server-BXMC5NOE.js

@@ -0,0 +1,271 @@
+import {
+  createAnthropicAI,
+  emergent,
+  parseRepoScope,
+  think
+} from "./chunk-T6EQ7ZBG.js";
+import "./chunk-VGFDMPVB.js";
+import "./chunk-I4RTIMLX.js";
+import "./chunk-ZAF6JH23.js";
+import "./chunk-QLPTHTVB.js";
+import "./chunk-QWGCMQQD.js";
+
+// src/radiant/mcp/server.ts
+import { readFileSync, readdirSync, statSync, existsSync } from "fs";
+import { resolve, join, extname } from "path";
+var TOOLS = [
+  {
+    name: "radiant_think",
+    description: "Send a query through the loaded worldmodel + rendering lens and get an Auki-framed response. Use this for strategic questions, decision evaluation, or any question that should be interpreted through the organization's behavioral model.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The question or prompt to interpret through the worldmodel + lens."
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "radiant_emergent",
+    description: "Run a behavioral read on a GitHub repository. Fetches recent activity, classifies events, extracts signals, identifies patterns, computes alignment scores, and produces the EMERGENT / MEANING / MOVE / ALIGNMENT output. Use this when asked about team activity, coordination patterns, or alignment with the worldmodel.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        scope: {
+          type: "string",
+          description: 'GitHub repository in "owner/repo" format (e.g. "aukiverse/posemesh").'
+        },
+        exocortex_dir: {
+          type: "string",
+          description: "Optional path to an exocortex directory for stated-intent-vs-observed-behavior comparison."
+        }
+      },
+      required: ["scope"]
+    }
+  }
+];
+var RadiantMcpServer = class {
+  config;
+  worldmodelContent;
+  buffer = "";
+  constructor(config) {
+    this.config = config;
+    this.worldmodelContent = loadWorldmodelContent(config.worldsPath);
+  }
+  async start() {
+    process.stderr.write(
+      `Radiant MCP server starting
+  Worlds: ${this.config.worldsPath}
+  Lens:   ${this.config.lensId}
+  Tools:  radiant_think, radiant_emergent
+`
+    );
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      this.buffer += chunk;
+      this.processBuffer();
+    });
+    process.stdin.on("end", () => {
+      process.exit(0);
+    });
+  }
+  processBuffer() {
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const request = JSON.parse(trimmed);
+        this.handleRequest(request).catch((err) => {
+          this.sendError(request.id, -32603, String(err));
+        });
+      } catch {
+      }
+    }
+  }
+  async handleRequest(req) {
+    switch (req.method) {
+      case "initialize":
+        this.sendResult(req.id, {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: {
+            name: "radiant",
+            version: "0.6.1"
+          }
+        });
+        break;
+      case "notifications/initialized":
+        break;
+      case "tools/list":
+        this.sendResult(req.id, { tools: TOOLS });
+        break;
+      case "tools/call":
+        await this.handleToolCall(req);
+        break;
+      default:
+        this.sendError(req.id, -32601, `Unknown method: ${req.method}`);
+    }
+  }
+  async handleToolCall(req) {
+    const params = req.params;
+    if (!params?.name) {
+      this.sendError(req.id, -32602, "Missing tool name");
+      return;
+    }
+    const args = params.arguments ?? {};
+    try {
+      switch (params.name) {
+        case "radiant_think":
+          await this.handleThink(req.id, args);
+          break;
+        case "radiant_emergent":
+          await this.handleEmergent(req.id, args);
+          break;
+        default:
+          this.sendError(req.id, -32602, `Unknown tool: ${params.name}`);
+      }
+    } catch (err) {
+      this.sendResult(req.id, {
+        content: [{ type: "text", text: `Error: ${err}` }],
+        isError: true
+      });
+    }
+  }
+  async handleThink(id, args) {
+    const query = String(args.query ?? "");
+    if (!query) {
+      this.sendResult(id, {
+        content: [{ type: "text", text: "Error: query is required" }],
+        isError: true
+      });
+      return;
+    }
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      this.sendResult(id, {
+        content: [{ type: "text", text: "Error: ANTHROPIC_API_KEY not set" }],
+        isError: true
+      });
+      return;
+    }
+    const ai = createAnthropicAI(apiKey, this.config.model || void 0);
+    const result = await think({
+      worldmodelContent: this.worldmodelContent,
+      lensId: this.config.lensId,
+      query,
+      ai
+    });
+    let text = result.response;
+    if (!result.voiceClean) {
+      text += `
+
+\u26A0 Voice violations detected: ${result.voiceViolations.map((v) => v.phrase).join(", ")}`;
+    }
+    this.sendResult(id, {
+      content: [{ type: "text", text }]
+    });
+  }
+  async handleEmergent(id, args) {
+    const scopeStr = String(args.scope ?? "");
+    if (!scopeStr) {
+      this.sendResult(id, {
+        content: [{ type: "text", text: 'Error: scope is required (e.g. "aukiverse/posemesh")' }],
+        isError: true
+      });
+      return;
+    }
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    const githubToken = process.env.GITHUB_TOKEN;
+    if (!apiKey) {
+      this.sendResult(id, {
+        content: [{ type: "text", text: "Error: ANTHROPIC_API_KEY not set" }],
+        isError: true
+      });
+      return;
+    }
+    if (!githubToken) {
+      this.sendResult(id, {
+        content: [{ type: "text", text: "Error: GITHUB_TOKEN not set" }],
+        isError: true
+      });
+      return;
+    }
+    const scope = parseRepoScope(scopeStr);
+    const ai = createAnthropicAI(apiKey, this.config.model || void 0);
+    const exocortexPath = args.exocortex_dir ? String(args.exocortex_dir) : void 0;
+    const result = await emergent({
+      scope,
+      githubToken,
+      worldmodelContent: this.worldmodelContent,
+      lensId: this.config.lensId,
+      ai,
+      windowDays: 14,
+      exocortexPath
+    });
+    let text = result.text;
+    if (!result.voiceClean) {
+      text += `
+
+\u26A0 Voice violations: ${result.voiceViolations.map((v) => v.phrase).join(", ")}`;
+    }
+    this.sendResult(id, {
+      content: [{ type: "text", text }]
+    });
+  }
+  sendResult(id, result) {
+    const response = { jsonrpc: "2.0", id, result };
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+  sendError(id, code, message) {
+    const response = {
+      jsonrpc: "2.0",
+      id: id ?? null,
+      error: { code, message }
+    };
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+};
+function loadWorldmodelContent(worldsPath) {
+  const resolved = resolve(worldsPath);
+  if (!existsSync(resolved)) {
+    throw new Error(`Worlds path not found: ${resolved}`);
+  }
+  const stat = statSync(resolved);
+  if (stat.isFile()) {
+    return readFileSync(resolved, "utf-8");
+  }
+  if (stat.isDirectory()) {
+    const files = readdirSync(resolved).filter(
+      (f) => extname(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    ).sort();
+    if (files.length === 0) {
+      throw new Error(`No worldmodel files found in ${resolved}`);
+    }
+    return files.map((f) => readFileSync(join(resolved, f), "utf-8")).join("\n\n---\n\n");
+  }
+  throw new Error(`Worlds path is neither a file nor directory: ${resolved}`);
+}
+async function startRadiantMcp(args) {
+  function parseArg(flag) {
+    const idx = args.indexOf(flag);
+    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : void 0;
+  }
+  const worldsPath = parseArg("--worlds") ?? process.env.RADIANT_WORLDS;
+  const lensId = parseArg("--lens") ?? process.env.RADIANT_LENS ?? "auki-builder";
+  const model = parseArg("--model") ?? process.env.RADIANT_MODEL;
+  if (!worldsPath) {
+    process.stderr.write("Error: --worlds <dir> or RADIANT_WORLDS required.\n");
+    process.exit(1);
+  }
+  const server = new RadiantMcpServer({ worldsPath, lensId, model });
+  await server.start();
+}
+export {
+  RadiantMcpServer,
+  startRadiantMcp
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuroverseos/governance",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Deterministic governance engine for AI agents — enforce worlds (permanent rules) and plans (mission constraints) with full audit trace",
   "license": "Apache-2.0",
   "type": "module",