tribunal-kit 7.0.0 → 9.0.0

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,
+};

package/dist/tui/wizard.js

@@ -0,0 +1,148 @@
+'use strict';
+
+/**
+ * Zero-dependency interactive terminal multi-select wizard.
+ * Handles keyboard navigation, space-to-toggle, and non-TTY fallback.
+ */
+
+const readline = require('readline');
+const { isTTY, hasColor, RGB, GLYPHS, color, bold } = require('./theme');
+
+class WizardPrompt {
+  displaySummary(question, options) {
+    const g = GLYPHS;
+    const prefix = color(RGB.AMBER, '?');
+    const boldQ = bold(question);
+    console.log(`  ${prefix} ${boldQ}`);
+
+    for (const opt of options) {
+      const check = opt.selected
+        ? color(RGB.EMERALD, g.check)
+        : color(RGB.ZINC_600, g.uncheck);
+
+      const labelColored = opt.selected
+        ? color(RGB.WHITE, opt.label)
+        : color(RGB.ZINC_500, opt.label);
+
+      const detailColored = color(RGB.ZINC_600, opt.detail || '');
+
+      console.log(`    ${check} ${labelColored} ${detailColored}`);
+    }
+
+    const hint = '[Space] Toggle · [Enter] Confirm · [A] Select All';
+    console.log(`  ${color(RGB.ZINC_600, hint)}`);
+    console.log();
+  }
+
+  async selectMultiple(question, initialOptions) {
+    if (!isTTY || !process.stdin.isTTY) {
+      this.displaySummary(question, initialOptions);
+      return initialOptions;
+    }
+
+    const options = initialOptions.map(opt => ({ ...opt }));
+    let cursor = 0;
+    const g = GLYPHS;
+
+    return new Promise(resolve => {
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+      process.stdin.resume();
+
+      // Hide cursor
+      process.stdout.write('\x1b[?25l');
+
+      const render = (isFinal = false) => {
+        // Move back up lines if not initial render
+        const totalLines = options.length + 3;
+        
+        let out = '';
+        const prefix = color(RGB.AMBER, '?');
+        out += `  ${prefix} ${bold(question)}\n`;
+
+        options.forEach((opt, idx) => {
+          const isCursor = idx === cursor;
+          const pointer = isCursor ? color(RGB.FLAME, g.chevron) : ' ';
+          const check = opt.selected
+            ? color(RGB.EMERALD, g.check)
+            : color(RGB.ZINC_600, g.uncheck);
+
+          const labelColored = opt.selected
+            ? color(RGB.WHITE, bold(opt.label))
+            : color(RGB.ZINC_400, opt.label);
+
+          const detailColored = color(RGB.ZINC_600, opt.detail || '');
+          out += `  ${pointer} ${check} ${labelColored} ${detailColored}\n`;
+        });
+
+        if (isFinal) {
+          out += `  ${color(RGB.EMERALD, '✔ Configuration selected.')}\n`;
+        } else {
+          const hint = '[Space] Toggle · [Enter] Confirm · [A] All · [↑/↓] Move';
+          out += `  ${color(RGB.ZINC_600, hint)}\n`;
+        }
+
+        return { out, totalLines };
+      };
+
+      let renderedOnce = false;
+
+      const draw = (isFinal = false) => {
+        const { out } = render(isFinal);
+        if (renderedOnce) {
+          // Clear and rewrite lines
+          process.stdout.write(`\x1b[${options.length + 2}A\r`);
+        }
+        process.stdout.write(out);
+        renderedOnce = true;
+      };
+
+      draw();
+
+      const onKeypress = (str, key) => {
+        if (!key) return;
+
+        if (key.ctrl && key.name === 'c') {
+          cleanup();
+          process.exit(130);
+        }
+
+        if (key.name === 'up' || key.name === 'k') {
+          cursor = (cursor - 1 + options.length) % options.length;
+          draw();
+        } else if (key.name === 'down' || key.name === 'j') {
+          cursor = (cursor + 1) % options.length;
+          draw();
+        } else if (key.name === 'space') {
+          options[cursor].selected = !options[cursor].selected;
+          draw();
+        } else if (str === 'a' || str === 'A') {
+          const allSelected = options.every(o => o.selected);
+          options.forEach(o => (o.selected = !allSelected));
+          draw();
+        } else if (key.name === 'return' || key.name === 'enter') {
+          cleanup();
+          draw(true);
+          resolve(options);
+        }
+      };
+
+      const cleanup = () => {
+        process.stdin.removeListener('keypress', onKeypress);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        process.stdout.write('\x1b[?25h'); // restore cursor
+      };
+
+      process.stdin.on('keypress', onKeypress);
+    });
+  }
+}
+
+module.exports = {
+  WizardPrompt,
+};