tribunal-kit 6.0.1 → 8.0.0

package/dist/commands/validate.js

@@ -1,22 +1,25 @@
-"use strict";
+'use strict';
+
 /**
- * validate.js — CLI command handler for `tk validate` (JS Fallback)
- *
- * Validates JSON payloads or .agent/ structure against strict schemas.
+ * validate.js — CLI command handler for `tk validate` (JS Engine)
+ * Validates JSON payloads or .agent/ structure against strict schemas with live reviewer grid.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.cmdValidate = cmdValidate;
 
-const fs = require("fs");
-const path = require("path");
-const logger_1 = require("../utils/logger");
+const fs = require('fs');
+const path = require('path');
+const { color, bold, dim, RGB, GLYPHS, renderReviewerGrid, ActionTree } = require('../tui');
 
 async function cmdValidate(flags, quiet = false) {
   const projectRoot = flags.path ? path.resolve(flags.path) : process.cwd();
-  const agentDir = path.join(projectRoot, ".agent");
+  const agentDir = path.join(projectRoot, '.agent');
+  const g = GLYPHS;
+  const tree = new ActionTree();
 
   if (!fs.existsSync(agentDir)) {
-    (0, logger_1.err)("No .agent/ directory found. Run `tk init` first.");
+    console.error(`  ${color(RGB.ROSE, g.failure)} ${bold('No .agent/ directory found.')} Run ${color(RGB.CYAN, 'tk init')} first.`);
     process.exit(1);
   }
 
@@ -25,43 +28,31 @@ async function cmdValidate(flags, quiet = false) {
   if (fileToValidate) {
     const fullPath = path.resolve(fileToValidate);
     if (!fs.existsSync(fullPath)) {
-      (0, logger_1.err)(`File not found for validation: ${fileToValidate}`);
+      console.error(`  ${color(RGB.ROSE, g.failure)} ${bold('File not found for validation:')} ${fileToValidate}`);
       process.exit(1);
     }
     try {
-      const content = fs.readFileSync(fullPath, "utf8");
-      if (fullPath.endsWith(".json")) {
+      const content = fs.readFileSync(fullPath, 'utf8');
+      if (fullPath.endsWith('.json')) {
         JSON.parse(content);
         if (!quiet) {
-          (0, logger_1.log)(`  ${(0, logger_1.c)("green", "✔")} ${(0, logger_1.bold)("Valid JSON payload:")} ${fullPath}`);
+          console.log(`  ${color(RGB.EMERALD, g.success)} ${bold('Valid JSON payload:')} ${color(RGB.CYAN, fullPath)}`);
         }
       } else {
         if (!quiet) {
-          (0, logger_1.log)(`  ${(0, logger_1.c)("green", "✔")} ${(0, logger_1.bold)("File validated successfully:")} ${fullPath}`);
+          console.log(`  ${color(RGB.EMERALD, g.success)} ${bold('File validated successfully:')} ${color(RGB.CYAN, fullPath)}`);
         }
       }
       return;
     } catch (err) {
-      (0, logger_1.err)(`Validation failed for ${fileToValidate}: ${err.message}`);
+      console.error(`  ${color(RGB.ROSE, g.failure)} ${bold('Validation failed:')} ${err.message}`);
       process.exit(1);
     }
   }
 
-  // General .agent validation
-  const scriptPath = path.join(agentDir, "scripts", "guardrail_engine.js");
-  if (fs.existsSync(scriptPath)) {
-    try {
-      const { runScan } = require(scriptPath);
-      if (typeof runScan === "function") {
-        await runScan({ projectRoot, quiet });
-        return;
-      }
-    } catch (_e) {
-      // Fallback below
-    }
-  }
-
+  // General .agent validation with parallel reviewer swarm display
   if (!quiet) {
-    (0, logger_1.log)(`  ${(0, logger_1.c)("green", "✔")} ${(0, logger_1.bold)(".agent payload structure validated successfully")}`);
+    renderReviewerGrid(28);
+    tree.complete('.agent/ payload structure & 28 parallel reviewers verified successfully');
   }
 }

package/dist/index.d.ts

@@ -151,6 +151,12 @@ export function generateIDEBridges(cwd: string, agentDest: string, quiet?: boole
  */
 export function cmdGuardrail(flags: CliFlags, argv: string[], quiet?: boolean): Promise<void>;
 
+/**
+ * AI Agent Behavioral Contract Testing (init, verify, list, trace, replay).
+ * Equivalent to `npx tribunal-kit contract`.
+ */
+export function cmdContract(flags: CliFlags, argv: string[], quiet?: boolean): Promise<void>;
+
 /**
  * Optimize project skills using SkillOpt validation gates.
  * Equivalent to `npx tribunal-kit optimize-skill`.
@@ -325,7 +331,8 @@ export type McpToolName =
   | 'recall_memory'
   | 'store_memory'
   | 'get_sparse_context'
-  | 'align_output';
+  | 'align_output'
+  | 'verify_contracts';
 
 // ── Main Entry Point ─────────────────────────────────────────────────────────
 

package/dist/tui/banner.js

@@ -0,0 +1,77 @@
+'use strict';
+
+/**
+ * Minimalist framed header cards and status banners.
+ * Parity with Brainless & Claude Code design tokens.
+ */
+
+const { isTTY, hasColor, hasTrueColor, RGB, GLYPHS, color, bold, getColumns } = require('./theme');
+
+function renderBanner(version = '8.0.0', quiet = false) {
+  if (quiet) return;
+  if (!isTTY && !hasColor) {
+    console.error(`TRIBUNAL-KIT v${version} — Anti-Hallucination Governance Layer`);
+    return;
+  }
+
+  const g = GLYPHS;
+  const cols = getColumns();
+  const width = Math.min(84, Math.max(64, cols));
+  const innerWidth = width - 4;
+
+  const titleLeft = `🛡️  TRIBUNAL-KIT  v${version}`;
+  const rightPill = '[Fortress Mode · ⚡ Rust Core]';
+  const leftLen = titleLeft.length; // emojis and text
+  const rightLen = rightPill.length;
+
+  const spaces = innerWidth > leftLen + rightLen ? innerWidth - (leftLen + rightLen) : 2;
+
+  const borderTop = `  ${g.boxTl}${g.boxH.repeat(innerWidth + 2)}${g.boxTr}`;
+  const borderBottom = `  ${g.boxBl}${g.boxH.repeat(innerWidth + 2)}${g.boxBr}`;
+
+  const coloredBorderTop = color(RGB.SLATE_700, borderTop);
+  const coloredBorderBottom = color(RGB.SLATE_700, borderBottom);
+  const pipe = color(RGB.SLATE_700, g.boxV);
+
+  // Gradient title line
+  let boldTitle;
+  if (hasTrueColor) {
+    let res = '🛡️  ';
+    const text = `TRIBUNAL-KIT  v${version}`;
+    const len = text.length;
+    for (let i = 0; i < len; i++) {
+      const ratio = i / len;
+      const r = 255;
+      const gVal = Math.floor(105 + ratio * 80);
+      const bVal = Math.floor(74 - ratio * 30);
+      res += `\x1b[38;2;${r};${gVal};${bVal}m\x1b[1m${text[i]}\x1b[0m`;
+    }
+    boldTitle = res;
+  } else {
+    boldTitle = bold(titleLeft);
+  }
+
+  const coloredRightPill = color(RGB.ZINC_500, rightPill);
+  const subtitle = 'Autonomous Anti-Hallucination Governance Layer for AI Coding Agents';
+  const subSpaces = Math.max(0, innerWidth - subtitle.length);
+  const coloredSubtitle = color(RGB.ZINC_400, subtitle);
+
+  console.log();
+  console.log(coloredBorderTop);
+  console.log(`  ${pipe} ${boldTitle}${' '.repeat(spaces)}${coloredRightPill} ${pipe}`);
+  console.log(`  ${pipe} ${coloredSubtitle}${' '.repeat(subSpaces)} ${pipe}`);
+  console.log(coloredBorderBottom);
+  console.log();
+}
+
+function renderSectionHeader(title) {
+  const g = GLYPHS;
+  const prefix = color(RGB.FLAME, g.chevron);
+  const boldTitle = bold(title);
+  console.log(`  ${prefix} ${boldTitle}`);
+}
+
+module.exports = {
+  renderBanner,
+  renderSectionHeader,
+};

package/dist/tui/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+/**
+ * Tribunal-Kit TUI Primitives & Design System.
+ */
+
+const theme = require('./theme');
+const banner = require('./banner');
+const tree = require('./tree');
+const shimmer = require('./shimmer');
+const reviewerGrid = require('./reviewer-grid');
+const wizard = require('./wizard');
+
+module.exports = {
+  ...theme,
+  ...banner,
+  ...tree,
+  ...shimmer,
+  ...reviewerGrid,
+  ...wizard,
+};

package/dist/tui/reviewer-grid.js

@@ -0,0 +1,90 @@
+'use strict';
+
+/**
+ * Multi-column live parallel reviewer status matrix.
+ * Animates all 28 Tribunal reviewers running concurrently.
+ */
+
+const { isTTY, hasColor, RGB, GLYPHS, color, bold, getColumns } = require('./theme');
+
+const ALL_REVIEWERS = [
+  ['logic-auditor', 'Logic & Correctness'],
+  ['security-scanner', 'Security / OWASP'],
+  ['type-safety-gate', 'Type Safety'],
+  ['schema-reviewer', 'Schema / Database'],
+  ['resilience-guard', 'Fault Tolerance'],
+  ['sql-injection-gate', 'SQL Parameterization'],
+  ['dependency-analyzer', 'Supply Chain / Deps'],
+  ['prompt-injection-def', 'Prompt Defense'],
+  ['complexity-reviewer', 'Code Complexity'],
+  ['memory-leak-auditor', 'Resource Leaks'],
+  ['pipeline-checker', 'CI/CD Workflows'],
+  ['cognitive-boundary', 'Fabel Protocol'],
+  ['accessibility-eval', 'WCAG 2.2 AA'],
+  ['auth-boundary-gate', 'Auth & RBAC'],
+  ['jwt-algorithm-guard', 'JWT Algorithms'],
+  ['anti-hallucination-p0', 'Package Verification'],
+  ['rate-limit-reviewer', 'API Throttling'],
+  ['error-handling-gate', 'Async Error Traps'],
+  ['context-budget-auditor', 'Context Windows'],
+  ['model-param-validator', 'Model Signatures'],
+  ['stream-error-reviewer', 'SSE / Streaming'],
+  ['cost-explosion-guard', 'Token Runaway'],
+  ['case-law-enforcer', 'Precedent Engine'],
+  ['behavioral-contract', 'Contract Tests'],
+  ['sanitization-auditor', 'Input Sanitization'],
+  ['secrets-leak-guard', 'Zero Hardcoded Keys'],
+  ['dag-cycle-detector', 'DAG Schedules'],
+  ['vbc-evidence-auditor', 'Evidence Gate'],
+];
+
+function renderReviewerGrid(completedCount = 28) {
+  if (!isTTY && !hasColor) {
+    console.log('  ✔ 28/28 Reviewers passed verification gates.');
+    return;
+  }
+
+  const g = GLYPHS;
+  const cols = getColumns();
+  const numCols = cols >= 100 ? 3 : (cols >= 68 ? 2 : 1);
+  const colWidth = Math.floor(Math.max(20, cols - 6) / numCols);
+
+  console.log();
+  const headerTitle = `  🛡️  Tribunal Parallel Reviewer Swarm (28 Reviewers)`;
+  console.log(bold(headerTitle));
+  console.log(`  ${color(RGB.SLATE_700, g.boxH.repeat(Math.min(84, cols - 4)))}`);
+
+  for (let r = 0; r < Math.ceil(ALL_REVIEWERS.length / numCols); r++) {
+    let line = '  ';
+    for (let c = 0; c < numCols; c++) {
+      const idx = r * numCols + c;
+      if (idx >= ALL_REVIEWERS.length) break;
+
+      const [name] = ALL_REVIEWERS[idx];
+      const isDone = idx < completedCount;
+
+      const icon = isDone
+        ? color(RGB.EMERALD, g.success)
+        : color(RGB.FLAME, '⠋');
+
+      const nameColored = isDone
+        ? color(RGB.WHITE, name)
+        : color(RGB.ZINC_500, name);
+
+      const itemStr = `${icon} ${nameColored}`;
+      const rawLen = 2 + name.length;
+      const pad = Math.max(1, colWidth - rawLen);
+
+      line += itemStr + ' '.repeat(pad);
+    }
+    console.log(line);
+  }
+
+  console.log(`  ${color(RGB.SLATE_700, g.boxH.repeat(Math.min(84, cols - 4)))}`);
+  console.log();
+}
+
+module.exports = {
+  renderReviewerGrid,
+  ALL_REVIEWERS,
+};

package/dist/tui/shimmer.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * Shimmering gradient text animation & zero-flicker Braille spinner.
+ * Mirrors the Brainless CSS shimmer effect in Node.js ANSI TrueColor.
+ */
+
+const { isTTY, hasColor, hasTrueColor, RGB, GLYPHS, color, bold } = require('./theme');
+
+function renderShimmerText(text, frame) {
+  let out = '';
+  const numChars = text.length;
+  const wavePos = ((frame * 0.18) % (numChars + 4)) - 2;
+
+  for (let i = 0; i < numChars; i++) {
+    const dist = Math.abs(i - wavePos);
+    const intensity = Math.max(0, Math.min(1, 1.0 - dist / 3.0));
+
+    // Interpolate between FLAME #cd694a and bright CORAL #ffe4d6
+    const r = Math.floor(205 + intensity * 50);
+    const g = Math.floor(105 + intensity * 123);
+    const b = Math.floor(74 + intensity * 140);
+
+    out += `\x1b[38;2;${r};${g};${b}m\x1b[1m${text[i]}\x1b[0m`;
+  }
+  return out;
+}
+
+class ShimmerSpinner {
+  constructor(verb, details = '') {
+    this.verb = verb;
+    this.details = details;
+    this.timer = null;
+    this.frame = 0;
+    this.startTime = Date.now();
+  }
+
+  start() {
+    if (!isTTY || !hasColor) {
+      console.log(`  · ${this.verb} (${this.details})`);
+      return this;
+    }
+
+    const braille = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+    // Hide cursor to prevent flicker
+    process.stderr.write('\x1b[?25l');
+
+    this.timer = setInterval(() => {
+      const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
+      const spinnerChar = braille[this.frame % braille.length];
+
+      const shimmerVerb = hasTrueColor
+        ? renderShimmerText(this.verb, this.frame)
+        : bold(this.verb);
+
+      const dot = color(RGB.FLAME, '·');
+      const timerText = color(RGB.ZINC_500, `(${elapsed}s · ${this.details})`);
+      const spinColored = color(RGB.FLAME, spinnerChar);
+
+      process.stderr.write(`\r\x1b[2K  ${dot} ${spinColored} ${shimmerVerb} ${timerText}`);
+      this.frame++;
+    }, 60);
+
+    return this;
+  }
+
+  finish(successMsg = null) {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+
+    if (isTTY && hasColor) {
+      // Clear line and restore cursor
+      process.stderr.write('\r\x1b[2K\x1b[?25h');
+    }
+
+    if (successMsg) {
+      const g = GLYPHS;
+      const check = color(RGB.EMERALD, g.success);
+      const boldMsg = bold(successMsg);
+      console.log(`  ${check} ${color(RGB.WHITE, boldMsg)}`);
+    }
+  }
+}
+
+module.exports = {
+  ShimmerSpinner,
+  renderShimmerText,
+};

package/dist/tui/theme.js

@@ -0,0 +1,130 @@
+'use strict';
+
+/**
+ * Terminal theme, TrueColor palette, and Unicode glyph tokens.
+ * Parity with Rust core TUI & Brainless (Claude Code / Codex / Grok) design system.
+ */
+
+const isTTY = Boolean(process.stdout && process.stdout.isTTY);
+const noColor = Boolean(process.env.NO_COLOR || process.env.CI);
+const colorTerm = (process.env.COLORTERM || '').toLowerCase();
+const term = (process.env.TERM || '').toLowerCase();
+
+const hasColor = !noColor && (isTTY || Boolean(process.env.FORCE_COLOR));
+const hasTrueColor = hasColor && (
+  colorTerm === 'truecolor' ||
+  colorTerm === '24bit' ||
+  term.includes('256color') ||
+  term.includes('xterm') ||
+  process.platform === 'win32'
+);
+
+const isUtf8 = !noColor && (
+  Boolean(process.env.WT_SESSION) ||
+  Boolean(process.env.TERM_PROGRAM) ||
+  (process.env.LANG || '').toLowerCase().includes('utf') ||
+  process.platform !== 'win32'
+);
+
+const RGB = {
+  SLATE_900: [13, 13, 15],
+  SLATE_800: [30, 30, 34],
+  SLATE_700: [47, 47, 51],
+  ZINC_600: [86, 95, 137],
+  ZINC_500: [122, 122, 122],
+  ZINC_400: [161, 161, 170],
+  ZINC_200: [228, 228, 231],
+  WHITE: [237, 237, 237],
+
+  // Accents (Flame / Amber / Coral)
+  FLAME: [205, 105, 74],        // #cd694a
+  CORAL_BRIGHT: [231, 148, 117], // #e79475
+  AMBER: [245, 158, 11],        // #f59e0b
+  GOLD: [255, 215, 0],          // #ffd700
+
+  // Status
+  EMERALD: [78, 169, 111],      // #4ea96f
+  CYAN: [125, 207, 255],        // #7dcfff
+  ROSE: [244, 63, 94],          // #f43f5e
+  PURPLE: [177, 167, 255],      // #b1a7ff
+};
+
+const UTF8_GLYPHS = {
+  bullet: '⏺',
+  success: '✔',
+  failure: '✖',
+  warning: '⚠',
+  branch: '⎿',
+  treeMid: '├──',
+  treeEnd: '└──',
+  chevron: '❯',
+  diamond: '◆',
+  boxTl: '╭',
+  boxTr: '╮',
+  boxBl: '╰',
+  boxBr: '╯',
+  boxH: '─',
+  boxV: '│',
+  dot: '·',
+  check: '[✔]',
+  uncheck: '[ ]',
+};
+
+const ASCII_GLYPHS = {
+  bullet: '*',
+  success: '+',
+  failure: 'x',
+  warning: '!',
+  branch: '\\-',
+  treeMid: '|--',
+  treeEnd: '`--',
+  chevron: '>',
+  diamond: '*',
+  boxTl: '+',
+  boxTr: '+',
+  boxBl: '+',
+  boxBr: '+',
+  boxH: '-',
+  boxV: '|',
+  dot: '.',
+  check: '[x]',
+  uncheck: '[ ]',
+};
+
+const GLYPHS = isUtf8 ? UTF8_GLYPHS : ASCII_GLYPHS;
+
+function color(rgb, text) {
+  if (!hasColor) return String(text);
+  if (hasTrueColor && Array.isArray(rgb)) {
+    return `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m${text}\x1b[0m`;
+  }
+  // Fallback ANSI 16-color
+  return `\x1b[96m${text}\x1b[0m`;
+}
+
+function bold(text) {
+  if (!hasColor) return String(text);
+  return `\x1b[1m${text}\x1b[0m`;
+}
+
+function dim(text) {
+  if (!hasColor) return String(text);
+  return `\x1b[90m${text}\x1b[0m`;
+}
+
+function getColumns() {
+  return (process.stdout && process.stdout.columns) || 80;
+}
+
+module.exports = {
+  isTTY,
+  hasColor,
+  hasTrueColor,
+  isUtf8,
+  RGB,
+  GLYPHS,
+  color,
+  bold,
+  dim,
+  getColumns,
+};

package/dist/tui/tree.js

@@ -0,0 +1,93 @@
+'use strict';
+
+/**
+ * Hierarchical action tree nodes (⏺ / ⎿) matching the Brainless agent specification.
+ */
+
+const { isTTY, RGB, GLYPHS, color, bold } = require('./theme');
+
+class ActionTree {
+  constructor(options = {}) {
+    this.staggerMs = isTTY ? (options.staggerMs ?? 15) : 0;
+  }
+
+  sleep(ms) {
+    if (ms <= 0) return Promise.resolve();
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  async action(verb, target = null) {
+    const g = GLYPHS;
+    const bullet = color(RGB.EMERALD, g.bullet);
+    const coloredVerb = color(RGB.WHITE, bold(verb));
+
+    if (target) {
+      const openParen = color(RGB.ZINC_600, '(');
+      const coloredTarget = color(RGB.CYAN, target);
+      const closeParen = color(RGB.ZINC_600, ')');
+      console.log(`  ${bullet} ${coloredVerb}${openParen}${coloredTarget}${closeParen}`);
+    } else {
+      console.log(`  ${bullet} ${coloredVerb}`);
+    }
+
+    if (this.staggerMs > 0) {
+      await this.sleep(this.staggerMs);
+    }
+  }
+
+  async branch(message) {
+    const g = GLYPHS;
+    const branchGlyph = color(RGB.ZINC_600, g.branch);
+    const coloredMsg = color(RGB.ZINC_400, message);
+    console.log(`    ${branchGlyph} ${coloredMsg}`);
+
+    if (this.staggerMs > 0) {
+      await this.sleep(this.staggerMs);
+    }
+  }
+
+  async itemSuccess(title, detail = null) {
+    const g = GLYPHS;
+    const check = color(RGB.EMERALD, g.success);
+    const coloredTitle = color(RGB.WHITE, title);
+
+    if (detail) {
+      const coloredDetail = color(RGB.ZINC_500, detail);
+      console.log(`    ${check} ${coloredTitle} ${coloredDetail}`);
+    } else {
+      console.log(`    ${check} ${coloredTitle}`);
+    }
+
+    if (this.staggerMs > 0) {
+      await this.sleep(this.staggerMs);
+    }
+  }
+
+  itemWarning(message) {
+    const g = GLYPHS;
+    const warn = color(RGB.AMBER, g.warning);
+    const coloredMsg = color(RGB.AMBER, message);
+    console.log(`    ${warn} ${coloredMsg}`);
+  }
+
+  itemError(message) {
+    const g = GLYPHS;
+    const err = color(RGB.ROSE, g.failure);
+    const coloredMsg = color(RGB.ROSE, message);
+    console.log(`    ${err} ${coloredMsg}`);
+  }
+
+  complete(message) {
+    const g = GLYPHS;
+    const check = color(RGB.EMERALD, g.success);
+    const boldMsg = bold(message);
+    const colored = color(RGB.WHITE, boldMsg);
+    console.log();
+    console.log(`  ${check} ${colored}`);
+    console.log();
+  }
+}
+
+module.exports = {
+  ActionTree,
+};