tribunal-kit 5.8.4 → 5.8.5

package/dist/mcp/server.js

@@ -1,142 +1,8 @@
 #!/usr/bin/env node
 "use strict";
+
 /**
- * Tribunal-Kit MCP Server (dist/ version — Performance-Optimized)
- *
- * Uses in-process require() for commands instead of spawning child processes.
- * Protocol: MCP 2024-11-05 over JSON-RPC 2.0 / stdio
+ * Compatibility entry point for the historical dist/mcp/server.js path.
+ * bin/mcp-server.js is the single canonical MCP implementation.
  */
-const { spawnSync } = require('child_process');
-const path = require('path');
-
-const PKG = require('../../package.json');
-
-// Timeout for spawned processes (30 seconds)
-const SPAWN_TIMEOUT_MS = 30000;
-
-const readline = require('readline');
-const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: false
-});
-
-function handleRequest(req) {
-    if (req.method === 'initialize') {
-        return {
-            protocolVersion: "2024-11-05",
-            capabilities: { tools: {} },
-            serverInfo: {
-                name: "tribunal-kit-mcp",
-                version: PKG.version
-            }
-        };
-    }
-
-    if (req.method === 'tools/list') {
-        return {
-            tools: [
-                {
-                    name: "run_tribunal_audit",
-                    description: "Runs a full anti-hallucination audit across the workspace.",
-                    inputSchema: { type: "object", properties: {}, additionalProperties: false }
-                },
-                {
-                    name: "sync_ide_bridges",
-                    description: "Synchronize IDE bridge files with the current GEMINI.md rules.",
-                    inputSchema: { type: "object", properties: {}, additionalProperties: false }
-                },
-                {
-                    name: "search_case_law",
-                    description: "Search historical code rejections and legal precedent.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            query: { type: "string", description: "Search query" }
-                        },
-                        required: ["query"],
-                        additionalProperties: false
-                    }
-                }
-            ]
-        };
-    }
-
-    if (req.method === 'tools/call') {
-        const toolName = req.params && req.params.name;
-        if (!toolName) {
-            throw { code: -32602, message: "Missing required parameter: params.name" };
-        }
-
-        if (toolName === 'run_tribunal_audit') {
-            // Validate uses the Rust binary — still needs spawn
-            const CLI = path.resolve(__dirname, '../../bin/wrapper.js');
-            const result = spawnSync(process.execPath, [CLI, 'validate', '--quiet'], {
-                encoding: 'utf8',
-                timeout: SPAWN_TIMEOUT_MS,
-            });
-            return { content: [{ type: "text", text: result.stdout || result.stderr || "No output" }] };
-        }
-
-        if (toolName === 'sync_ide_bridges') {
-            // In-process — no spawn needed
-            const CLI = path.resolve(__dirname, '../../bin/wrapper.js');
-            const result = spawnSync(process.execPath, [CLI, 'sync', '--quiet'], {
-                encoding: 'utf8',
-                timeout: SPAWN_TIMEOUT_MS,
-            });
-            return { content: [{ type: "text", text: result.stdout || result.stderr || "Sync complete" }] };
-        }
-
-        if (toolName === 'search_case_law') {
-            const query = req.params && req.params.arguments && req.params.arguments.query;
-            if (!query || typeof query !== 'string') {
-                throw { code: -32602, message: "Missing or invalid required argument: query (string)" };
-            }
-            const script = path.resolve(__dirname, '../../.agent/scripts/case_law_manager.js');
-            const result = spawnSync(process.execPath, [script, 'search-cases', '--query', query], {
-                encoding: 'utf8',
-                timeout: SPAWN_TIMEOUT_MS,
-            });
-            return { content: [{ type: "text", text: result.stdout || result.stderr || "No results" }] };
-        }
-
-        throw { code: -32601, message: `Unknown tool: ${toolName}` };
-    }
-
-    throw { code: -32601, message: `Unknown method: ${req.method}` };
-}
-
-rl.on('line', (line) => {
-    if (!line.trim()) return;
-
-    let req;
-    try {
-        req = JSON.parse(line);
-    } catch (parseErr) {
-        const errorRes = {
-            jsonrpc: "2.0", id: null,
-            error: { code: -32700, message: "Parse error: " + parseErr.message }
-        };
-        console.log(JSON.stringify(errorRes));
-        return;
-    }
-
-    try {
-        const result = handleRequest(req);
-        const res = { jsonrpc: "2.0", id: req.id, result };
-        console.log(JSON.stringify(res));
-
-        if (req.method === 'initialize') {
-            console.log(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }));
-        }
-    } catch (e) {
-        const code = (e && typeof e.code === 'number') ? e.code : -32603;
-        const message = (e && e.message) ? e.message : "Internal server error";
-        const errorRes = {
-            jsonrpc: "2.0", id: req.id || null,
-            error: { code, message }
-        };
-        console.log(JSON.stringify(errorRes));
-    }
-});
+module.exports = require("../../bin/mcp-server.js");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tribunal-kit",
-  "version": "5.8.4",
-  "description": "The operating system for AI software engineering — governance, memory, review pipelines, and reusable skills for every coding agent. 44 specialist agents, 34 workflows, 20 parallel Tribunal code reviewers, MCP server, Rust core engine, and long-running autonomous agent harness for Cursor, VSCode, Windsurf, Claude Code, and Aider.",
+  "version": "5.8.5",
+  "description": "The operating system for AI software engineering — governance, memory, review pipelines, and reusable skills for every coding agent. 44 specialist agents, 34 workflows, 19 parallel Tribunal code reviewers, MCP server, Rust core engine, and long-running autonomous agent harness for Cursor, VSCode, Windsurf, Claude Code, and Aider.",
   "keywords": [
     "ai",
     "ai-agent",
@@ -93,7 +93,7 @@
     "benchmark:rust": "cargo build --release && node scripts/benchmark.js",
     "build:rust": "cargo build --release",
     "test:rust": "cargo test --manifest-path crates/core/Cargo.toml",
-    "build": "echo 'No build step required for this project'"
+    "build": "npm run build:rust"
   },
   "devDependencies": {
     "eslint": "^9.1.1",
@@ -101,12 +101,12 @@
     "typescript": "^5.4.5"
   },
   "optionalDependencies": {
-    "@tribunal-kit/core-darwin-arm64": "^5.8.4",
-    "@tribunal-kit/core-darwin-x64": "^5.8.4",
-    "@tribunal-kit/core-linux-arm64": "^5.8.4",
-    "@tribunal-kit/core-linux-x64": "^5.8.4",
-    "@tribunal-kit/core-win32-arm64": "^5.8.4",
-    "@tribunal-kit/core-win32-x64": "^5.8.4"
+    "@tribunal-kit/core-darwin-arm64": "^5.8.5",
+    "@tribunal-kit/core-darwin-x64": "^5.8.5",
+    "@tribunal-kit/core-linux-arm64": "^5.8.5",
+    "@tribunal-kit/core-linux-x64": "^5.8.5",
+    "@tribunal-kit/core-win32-arm64": "^5.8.5",
+    "@tribunal-kit/core-win32-x64": "^5.8.5"
   },
   "jest": {
     "testMatch": [
@@ -115,7 +115,8 @@
     "testEnvironment": "node",
     "coverageDirectory": "coverage",
     "collectCoverageFrom": [
-      "bin/**/*.js"
+      "bin/**/*.js",
+      ".agent/scripts/**/*.js"
     ]
   }
 }

package/scripts/benchmark.js

@@ -142,6 +142,48 @@ async function main() {
   );
   results.push(initRealResult);
 
+  // 5. DAG scheduling benchmark
+  console.log(c("cyan", "  ▸ Benchmarking: DAG scheduling calculation"));
+  const dagResult = await benchmark(
+    "DAG wave scheduling",
+    () => {
+      const workers = [
+        { task_id: "w1", dependencies: [] },
+        { task_id: "w2", dependencies: ["w1"] },
+        { task_id: "w3", dependencies: ["w1"] },
+        { task_id: "w4", dependencies: ["w2", "w3"] },
+      ];
+      const inDegree = {};
+      const adjList = {};
+      workers.forEach((w) => {
+        inDegree[w.task_id] = 0;
+        adjList[w.task_id] = [];
+      });
+      workers.forEach((w) => {
+        w.dependencies.forEach((dep) => {
+          adjList[dep].push(w.task_id);
+          inDegree[w.task_id] += 1;
+        });
+      });
+      let currentWave = Object.keys(inDegree).filter((id) => inDegree[id] === 0);
+      const waves = [];
+      while (currentWave.length > 0) {
+        waves.push(currentWave);
+        const next = [];
+        currentWave.forEach((id) => {
+          adjList[id].forEach((nbr) => {
+            inDegree[nbr] -= 1;
+            if (inDegree[nbr] === 0) next.push(nbr);
+          });
+        });
+        currentWave = next;
+      }
+    },
+    100,
+  );
+  results.push(dagResult);
+
+
   // Print results table
   console.log();
   console.log(bold(`  Results`));

package/scripts/sync-version.js

@@ -1,94 +1,147 @@
 #!/usr/bin/env node
 /**
- * sync-version.js — Version Sync for Tribunal Kit
+ * sync-version.js — Release metadata consistency check for Tribunal Kit.
  *
- * Reads the version and counts from package.json and the .agent/ directory,
- * then updates all stale references across documentation files.
- *
- * Run manually or as a preversion npm script:
- *   node scripts/sync-version.js
+ * Verifies the package version, native package metadata, lockfile metadata,
+ * and public asset-count claims before a release. It intentionally performs
+ * no implicit writes: a failed check makes stale release metadata visible.
  */
 
+"use strict";
+
 const fs = require("fs");
 const path = require("path");
 
 const ROOT = path.resolve(__dirname, "..");
-const PKG = JSON.parse(
-  fs.readFileSync(path.join(ROOT, "package.json"), "utf8"),
-);
-
-// Count actual installed items
-function countItems(dir) {
-  const fullPath = path.join(ROOT, ".agent", dir);
-  if (!fs.existsSync(fullPath)) return "?";
-  return fs.readdirSync(fullPath).filter((f) => !f.startsWith(".")).length;
+const PKG_PATH = path.join(ROOT, "package.json");
+const PKG = JSON.parse(fs.readFileSync(PKG_PATH, "utf8"));
+const VERSION = PKG.version;
+
+function readText(relativePath) {
+  return fs.readFileSync(path.join(ROOT, relativePath), "utf8");
+}
+
+function readJson(relativePath) {
+  return JSON.parse(readText(relativePath));
+}
+
+function countDirectory(relativePath, predicate) {
+  const directory = path.join(ROOT, relativePath);
+  if (!fs.existsSync(directory)) return 0;
+  return fs.readdirSync(directory, { withFileTypes: true }).filter(predicate).length;
+}
+
+function countReviewers() {
+  const agentsDir = path.join(ROOT, ".agent", "agents");
+  return countDirectory(".agent/agents", (entry) => {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) return false;
+    const content = fs.readFileSync(path.join(agentsDir, entry.name), "utf8");
+    return /reviewer|auditor|tester|throughput-optimizer/i.test(entry.name) || /^role:\s*reviewer\s*$/im.test(content);
+  });
 }
 
-const version = PKG.version;
-const agents = countItems("agents");
-const skills = countItems("skills");
-const workflows = countItems("workflows");
-const scripts = countItems("scripts");
-
-console.log(`\n  📊 Tribunal Kit v${version} — Actual Counts`);
-console.log(`  ──────────────────────────────────────`);
-console.log(`  Agents:    ${agents}`);
-console.log(`  Skills:    ${skills}`);
-console.log(`  Workflows: ${workflows}`);
-console.log(`  Scripts:   ${scripts}`);
-console.log();
-
-// Files to check for stale numbers
-const FILES_TO_CHECK = ["README.md", "AGENT_FLOW.md", ".agent/ARCHITECTURE.md"];
-
-let staleFound = 0;
-
-for (const relPath of FILES_TO_CHECK) {
-  const filePath = path.join(ROOT, relPath);
-  if (!fs.existsSync(filePath)) continue;
-
-  const content = fs.readFileSync(filePath, "utf8");
-
-  // Check for common stale patterns
-  const checks = [
-    {
-      regex: /(\d+)\s*(specialist\s+)?agents/gi,
-      expected: agents,
-      label: "agents",
-    },
-    { regex: /(\d+)\s*skill\s*modules/gi, expected: skills, label: "skills" },
-    {
-      regex: /(\d+)\s*slash\s*command/gi,
-      expected: workflows,
-      label: "workflows",
-    },
-  ];
-
-  for (const check of checks) {
-    let match;
-    while ((match = check.regex.exec(content)) !== null) {
-      const found = parseInt(match[1]);
-      if (found !== check.expected && found > 5) {
-        // ignore tiny numbers
-        staleFound++;
-        const line = content.substring(0, match.index).split("\n").length;
-        console.log(
-          `  ⚠️  ${relPath}:${line} — says ${found} ${check.label}, actual is ${check.expected}`,
-        );
+
+const COUNTS = {
+  agents: countDirectory(".agent/agents", (entry) => entry.isFile() && entry.name.endsWith(".md")),
+  reviewers: countReviewers(),
+  skills: countDirectory(".agent/skills", (entry) => entry.isDirectory() && fs.existsSync(path.join(ROOT, ".agent", "skills", entry.name, "SKILL.md"))),
+  workflows: countDirectory(".agent/workflows", (entry) => entry.isFile() && entry.name.endsWith(".md")),
+  scripts: countDirectory(".agent/scripts", (entry) => entry.isFile() && /\.(?:js|py)$/.test(entry.name)),
+};
+
+const failures = [];
+
+function fail(message) {
+  failures.push(message);
+}
+
+function checkVersionMetadata() {
+  const expectedOptionalVersion = `^${VERSION}`;
+  for (const [name, declaredVersion] of Object.entries(PKG.optionalDependencies || {})) {
+    if (declaredVersion !== expectedOptionalVersion) {
+      fail(`package.json optional dependency ${name} is ${declaredVersion}, expected ${expectedOptionalVersion}`);
+    }
+  }
+
+  const lock = readJson("package-lock.json");
+  if (lock.version !== VERSION || lock.packages?.[""]?.version !== VERSION) {
+    fail(`package-lock.json root version does not match package.json (${VERSION})`);
+  }
+  for (const [name, declaredVersion] of Object.entries(lock.packages?.[""]?.optionalDependencies || {})) {
+    if (declaredVersion !== expectedOptionalVersion) {
+      fail(`package-lock.json optional dependency ${name} is ${declaredVersion}, expected ${expectedOptionalVersion}`);
+    }
+  }
+
+  const cargoToml = readText("crates/core/Cargo.toml");
+  const cargoTomlVersion = cargoToml.match(/^version\s*=\s*"([^"]+)"/m)?.[1];
+  if (cargoTomlVersion !== VERSION) {
+    fail(`crates/core/Cargo.toml version is ${cargoTomlVersion || "missing"}, expected ${VERSION}`);
+  }
+
+  const cargoLock = readText("Cargo.lock");
+  const cargoLockVersion = cargoLock.match(/name\s*=\s*"tribunal-core"\s*\nversion\s*=\s*"([^"]+)"/)?.[1];
+  if (cargoLockVersion !== VERSION) {
+    fail(`Cargo.lock tribunal-core version is ${cargoLockVersion || "missing"}, expected ${VERSION}`);
+  }
+
+  const readmeRelease = readText("README.md").match(/Release-v([0-9]+\.[0-9]+\.[0-9]+)/)?.[1];
+  if (readmeRelease !== VERSION) {
+    fail(`README release badge is ${readmeRelease || "missing"}, expected ${VERSION}`);
+  }
+}
+
+const DOCUMENTS = [
+  "README.md",
+  ".agent/ARCHITECTURE.md",
+  ".agent/rules/GEMINI.md",
+  "CONTRIBUTING.md",
+];
+
+const CLAIM_PATTERNS = [
+  { entity: "agents", regex: /(\d+)\s*(?:specialist\s+)?agents?\b/gi },
+  {
+    entity: "reviewers",
+    regex: /(\d+)\s*(?:-\s*)?(?:(?:parallel|domain(?:-specific)?|tribunal|code)\s+)*reviewers?\b/gi,
+  },
+  { entity: "skills", regex: /(\d+)\s*(?:valid\s+|modular\s+)?skills?(?:\s+(?:packages?|modules?))?\b/gi },
+  { entity: "workflows", regex: /(\d+)\s*(?:slash\s+)?workflows?\b/gi },
+  { entity: "scripts", regex: /(\d+)\s*(?:JS\s+)?(?:automation\s+)?scripts?\b/gi },
+];
+
+function checkDocumentCounts() {
+  for (const relativePath of DOCUMENTS) {
+    const content = readText(relativePath);
+    for (const { entity, regex } of CLAIM_PATTERNS) {
+      regex.lastIndex = 0;
+      let match;
+      while ((match = regex.exec(content)) !== null) {
+        const claimed = Number.parseInt(match[1], 10);
+        if (claimed < 5 || claimed > 500) continue;
+        if (claimed !== COUNTS[entity]) {
+          const line = content.slice(0, match.index).split(/\r?\n/).length;
+          fail(`${relativePath}:${line} says ${claimed} ${entity}, actual is ${COUNTS[entity]}`);
+        }
       }
     }
   }
 }
 
-if (staleFound === 0) {
-  console.log(
-    `  ✅ All counts are in sync across ${FILES_TO_CHECK.length} files.`,
-  );
+console.log(`\n  Tribunal Kit v${VERSION} — Release Metadata Check`);
+console.log("  ────────────────────────────────────────────────");
+console.log(`  Agents:    ${COUNTS.agents} (${COUNTS.reviewers} reviewers)`);
+console.log(`  Skills:    ${COUNTS.skills}`);
+console.log(`  Workflows: ${COUNTS.workflows}`);
+console.log(`  Scripts:   ${COUNTS.scripts}`);
+
+checkVersionMetadata();
+checkDocumentCounts();
+
+if (failures.length > 0) {
+  console.log();
+  for (const message of failures) console.log(`  ✗ ${message}`);
+  console.log(`\n  Found ${failures.length} release metadata inconsistency${failures.length === 1 ? "" : "ies"}.`);
+  process.exitCode = 1;
 } else {
-  console.log(
-    `\n  ❌ Found ${staleFound} stale reference(s). Update manually or run the sync tool.`,
-  );
-  process.exit(1);
+  console.log(`\n  ✓ Version metadata and public count claims are in sync across ${DOCUMENTS.length} documents.\n`);
 }
-
-console.log();