tribunal-kit 5.8.4 → 6.0.0

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+version\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();

package/scripts/visual_audit.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+
+/**
+ * Automated UI Visual & Anti-Slop Audit Script
+ * Analyzes frontend files (JSX/TSX/CSS/HTML) for visual depth, color spaces, anti-slop rules, and interactive state completeness.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function runVisualAudit(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return {
+      status: 'ERROR',
+      score: 0,
+      message: `File not found: ${filePath}`,
+      violations: []
+    };
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const violations = [];
+  let score = 100;
+
+  // 1. Purple/Violet AI cliché color check
+  const purpleRegex = /#(?:7[cC]3[aA][eE][dD]|8[bB]5[cC][fF]6|9333ea|a855f7|c084fc)/i;
+  if (purpleRegex.test(content) || /color:\s*(?:purple|violet)/i.test(content)) {
+    violations.push({
+      rule: 'NO_PURPLE_CLICHE',
+      severity: 'REJECTED',
+      description: 'Primary color uses AI cliché purple/violet (#7C3AED, #8B5CF6). Use signal orange, acid green, slate, or OKLCH blue instead.',
+      impact: -25
+    });
+    score -= 25;
+  }
+
+  // 2. Raw Hex without OKLCH or design tokens
+  const rawHexRegex = /#[0-9a-fA-F]{6}\b/g;
+  const hexMatches = content.match(rawHexRegex) || [];
+  if (hexMatches.length > 4 && !/oklch/i.test(content) && !/var\(--/i.test(content)) {
+    violations.push({
+      rule: 'USE_OKLCH_OR_TOKENS',
+      severity: 'REJECTED',
+      description: 'Found raw hex colors without modern OKLCH color spaces or design token variables.',
+      impact: -15
+    });
+    score -= 15;
+  }
+
+  // 3. Interactive state check on clickable elements
+  if (/<button|<a\b|onClick=/i.test(content)) {
+    if (!/hover:/i.test(content) && !/:hover/i.test(content)) {
+      violations.push({
+        rule: 'MISSING_HOVER_STATE',
+        severity: 'WARNING',
+        description: 'Interactive buttons/links lack visible hover state handling.',
+        impact: -10
+      });
+      score -= 10;
+    }
+    if (!/focus-visible:/i.test(content) && !/:focus/i.test(content)) {
+      violations.push({
+        rule: 'MISSING_FOCUS_INDICATOR',
+        severity: 'WARNING',
+        description: 'Interactive elements lack focus-visible outlines for keyboard accessibility.',
+        impact: -10
+      });
+      score -= 10;
+    }
+  }
+
+  // 4. Visual depth & border check for container elements
+  if (/className=["'][^"']*(?:card|container|box|panel|wrapper)[^"']*["']/i.test(content) || /<article|<section/i.test(content)) {
+    if (!/border|shadow|hairline|depth/i.test(content)) {
+      violations.push({
+        rule: 'MISSING_SURFACE_DEPTH',
+        severity: 'WARNING',
+        description: 'Container elements lack 1px luminous border or ambient shadow depth layers.',
+        impact: -15
+      });
+      score -= 15;
+    }
+  }
+
+  // 5. Hardcoded static offsets vs dynamic math
+  if (/style=\{\{[^}]*\b(?:top|left|height|width):\s*['"]\d+px['"]/i.test(content)) {
+    violations.push({
+      rule: 'HARDCODED_PIXEL_LAYOUT',
+      severity: 'WARNING',
+      description: 'Hardcoded static pixel offsets found in inline styles. Use responsive clamp() or layout bounds.',
+      impact: -10
+    });
+    score -= 10;
+  }
+
+  const finalScore = Math.max(0, score);
+  const status = violations.some(v => v.severity === 'REJECTED') ? 'REJECTED' : (violations.length > 0 ? 'WARNING' : 'APPROVED');
+
+  return {
+    status,
+    score: finalScore,
+    file: filePath,
+    violations
+  };
+}
+
+// CLI Execution Support
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const fileArgIndex = args.indexOf('--file');
+  const targetPath = fileArgIndex !== -1 ? args[fileArgIndex + 1] : args[0];
+
+  if (!targetPath) {
+    console.error('Usage: node visual_audit.js --file <path-to-file>');
+    process.exit(1);
+  }
+
+  const result = runVisualAudit(path.resolve(targetPath));
+  console.log(JSON.stringify(result, null, 2));
+
+  if (result.status === 'REJECTED') {
+    process.exit(1);
+  }
+}
+
+module.exports = { runVisualAudit };