tribunal-kit 9.0.0 → 9.0.1

package/dist/cli.js

@@ -16,79 +16,65 @@ const CURRENT_VERSION = PKG.version;
 function parseArgs(argv) {
     const args = { command: null, flags: {} };
     const raw = argv.slice(2);
-    // First non-flag arg is the command
-    for (const arg of raw) {
-        if (!arg.startsWith('--') && !args.command) {
-            args.command = arg;
+    for (let i = 0; i < raw.length; i++) {
+        const arg = raw[i];
+        if (!arg.startsWith('-')) {
+            if (!args.command) {
+                args.command = arg;
+            }
             continue;
         }
         if (arg === '--force') {
             args.flags.force = true;
-            continue;
-        }
-        if (arg === '--quiet') {
+        } else if (arg === '--quiet') {
             args.flags.quiet = true;
-            continue;
-        }
-        if (arg === '--verbose') {
+        } else if (arg === '--verbose') {
             args.flags.verbose = true;
-            continue;
-        }
-        if (arg === '--dry-run') {
+        } else if (arg === '--dry-run') {
             args.flags.dryRun = true;
-            continue;
-        }
-        if (arg === '--minimal') {
+        } else if (arg === '--minimal') {
             args.flags.minimal = true;
-            continue;
-        }
-        if (arg.startsWith('--profile=')) {
+        } else if (arg.startsWith('--profile=')) {
             args.flags.profile = arg.split('=').slice(1).join('=');
-            continue;
-        }
-        if (arg === '--profile') {
-            const idx = raw.indexOf('--profile');
-            args.flags.profile = raw[idx + 1] || 'full';
-            continue;
-        }
-        if (arg === '--skip-update-check') {
+        } else if (arg === '--profile') {
+            const nextVal = raw[++i];
+            args.flags.profile = nextVal || 'full';
+        } else if (arg === '--skip-update-check') {
             args.flags.skipUpdateCheck = true;
-            continue;
-        }
-        if (arg === '--write') {
+        } else if (arg === '--write') {
             args.flags.write = true;
-            continue;
-        }
-        if (arg === '--head') {
+        } else if (arg === '--head') {
             args.flags.head = true;
-            continue;
-        }
-        if (arg.startsWith('--path=')) {
+        } else if (arg.startsWith('--path=')) {
             args.flags.path = arg.split('=').slice(1).join('=');
-        }
-        if (arg === '--path') {
-            const idx = raw.indexOf('--path');
-            const nextVal = raw[idx + 1];
+        } else if (arg === '--path') {
+            const nextVal = raw[++i];
             if (!nextVal || nextVal.startsWith('--')) {
                 console.error(`  \x1b[91m✖ --path requires a directory argument\x1b[0m`);
                 process.exit(1);
             }
             args.flags.path = nextVal;
-        }
-        if (arg.startsWith('--target=')) {
+        } else if (arg.startsWith('--target=')) {
             args.flags.target = arg.split('=').slice(1).join('=');
-        }
-        if (arg === '--target') {
-            const idx = raw.indexOf('--target');
-            const nextVal = raw[idx + 1];
+        } else if (arg === '--target') {
+            const nextVal = raw[++i];
             if (!nextVal || nextVal.startsWith('--')) {
                 console.error(`  \x1b[91m✖ --target requires an argument\x1b[0m`);
                 process.exit(1);
             }
             args.flags.target = nextVal;
-        }
-        if (arg.startsWith('--branch=')) {
+        } else if (arg.startsWith('--branch=')) {
             args.flags.branch = arg.split('=').slice(1).join('=');
+        } else if (arg === '--branch') {
+            args.flags.branch = raw[++i];
+        } else if (arg.startsWith('--log=')) {
+            args.flags.log = arg.split('=').slice(1).join('=');
+        } else if (arg === '--log') {
+            args.flags.log = raw[++i];
+        } else if (arg.startsWith('--strategy=')) {
+            args.flags.strategy = arg.split('=').slice(1).join('=');
+        } else if (arg === '--strategy') {
+            args.flags.strategy = raw[++i];
         }
     }
     return args;
@@ -123,6 +109,12 @@ function cmdHelp(quiet = false) {
     (0, logger_1.log)(cmd('guardrail', 'Validate .agent/ integrity (phantom refs, count mismatches, drift)'));
     (0, logger_1.log)(cmd('contract', 'AI Agent Behavioral Contract Testing (init, verify, list, trace, replay)'));
     (0, logger_1.log)(cmd('impact-tier', 'Classify task governance impact tier (0-3)'));
+    (0, logger_1.log)(cmd('browse', 'Token-efficient page reader (pruned to <4k bytes)'));
+    (0, logger_1.log)(cmd('audit-web', 'Live browser accessibility, console & vitals auditor'));
+    (0, logger_1.log)(cmd('compare-web', 'Visual regression differ for CI & release gating'));
+    (0, logger_1.log)(cmd('deconstruct', 'Reverse-engineer live web elements into React TSX + Tailwind'));
+    (0, logger_1.log)(cmd('heal', 'Runtime Sentinel error hunter & live fix verifier'));
+    (0, logger_1.log)(cmd('sdd', 'Subagent-Driven Development workspace & brief slicing (workspace, brief, diff)'));
     (0, logger_1.log)(cmd('uninstall', 'Remove .agent/ folder from project'));
     console.log();
     (0, logger_1.log)((0, logger_1.bold)('  Options'));
@@ -324,6 +316,36 @@ async function runWithUpdateCheck(command, flags) {
             cmdImpactTier(process.argv, quiet);
             break;
         }
+        case 'browse': {
+            const cmdBrowse = loadCmd('./commands/browse', 'cmdBrowse');
+            await cmdBrowse(flags, process.argv, quiet);
+            break;
+        }
+        case 'audit-web': {
+            const cmdAuditWeb = loadCmd('./commands/audit-web', 'cmdAuditWeb');
+            await cmdAuditWeb(flags, process.argv, quiet);
+            break;
+        }
+        case 'compare-web': {
+            const cmdCompareWeb = loadCmd('./commands/compare-web', 'cmdCompareWeb');
+            await cmdCompareWeb(flags, process.argv, quiet);
+            break;
+        }
+        case 'deconstruct': {
+            const cmdDeconstruct = loadCmd('./commands/deconstruct', 'cmdDeconstruct');
+            await cmdDeconstruct(flags, process.argv, quiet);
+            break;
+        }
+        case 'heal': {
+            const cmdHeal = loadCmd('./commands/heal', 'cmdHeal');
+            await cmdHeal(flags, process.argv, quiet);
+            break;
+        }
+        case 'sdd': {
+            const cmdSdd = loadCmd('./commands/sdd', 'cmdSdd');
+            await cmdSdd(flags, process.argv, quiet);
+            break;
+        }
         case 'help':
         case '--help':
         case '-h':

package/dist/commands/audit-web.js

@@ -0,0 +1,112 @@
+'use strict';
+
+/**
+ * cmdAuditWeb — Live Web Quality, Accessibility & Performance Auditor
+ *
+ * Usage:
+ *   tk audit-web https://example.com
+ *   tk audit-web http://localhost:3000 --json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { auditURL } = require('../browser');
+const { codifyAuditViolations } = require('../browser/case_bridge');
+const { c } = require('../utils/logger');
+const { banner } = require('../utils/helpers');
+
+async function cmdAuditWeb(flags, processArgs, quiet = false) {
+  const url = processArgs[3] || flags.url;
+
+  if (!url) {
+    console.error(`  ${c('red', '✖ Error:')} Missing target URL. Usage: tk audit-web <url>`);
+    process.exit(1);
+  }
+
+  if (!quiet && !flags.json) {
+    banner(quiet);
+    console.log(`  ${c('cyan', '🔍 Auditing Web Target:')} ${c('white', url)}...\n`);
+  }
+
+  try {
+    const report = await auditURL(url, flags);
+
+    let codified = null;
+    if (flags.codify || flags['codify-cases'] || flags.c) {
+      codified = codifyAuditViolations(report, flags);
+    }
+
+    if (flags.json) {
+      if (codified) {
+        report.codified = codified;
+      }
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+
+    if (flags.output) {
+      const outDir = path.resolve(flags.output);
+      fs.mkdirSync(outDir, { recursive: true });
+      fs.writeFileSync(path.join(outDir, 'audit-report.json'), JSON.stringify(report, null, 2));
+      console.log(`  ${c('gray', 'Report written to:')} ${path.join(outDir, 'audit-report.json')}`);
+    }
+
+    console.log(`  ${c('bold', 'Title:')} ${report.page.title || '(No title)'}`);
+    console.log(`  ${c('bold', 'Duration:')} ${report.durationMs}ms\n`);
+
+    // Scores
+    const a11yColor = report.scores.accessibility >= 80 ? 'green' : report.scores.accessibility >= 60 ? 'yellow' : 'red';
+    const secColor = report.scores.security >= 80 ? 'green' : report.scores.security >= 60 ? 'yellow' : 'red';
+
+    console.log(`  ${c('bold', 'Scores:')}`);
+    console.log(`    Accessibility:   ${c(a11yColor, `${report.scores.accessibility}/100`)}`);
+    console.log(`    Security Headers:${c(secColor, `${report.scores.security}/100`)}`);
+    console.log();
+
+    // Issues
+    if (report.violations.accessibility.length > 0) {
+      console.log(`  ${c('yellow', 'Accessibility Issues:')}`);
+      for (const iss of report.violations.accessibility) {
+        console.log(`    ${c('yellow', '⚠')} ${iss.message}`);
+      }
+      console.log();
+    }
+
+    if (report.violations.security.length > 0) {
+      console.log(`  ${c('yellow', 'Security Advisory:')}`);
+      for (const sec of report.violations.security) {
+        console.log(`    ${c('yellow', '⚠')} ${sec}`);
+      }
+      console.log();
+    }
+
+    if (report.violations.consoleErrors.length > 0) {
+      console.log(`  ${c('red', 'Console Errors:')}`);
+      for (const err of report.violations.consoleErrors) {
+        console.log(`    ${c('red', '✖')} [${err.level}] ${err.text}`);
+      }
+      console.log();
+    }
+
+    if (report.summary.passed) {
+      console.log(`  ${c('green', '✔ Web audit passed')} — Accessibility >= 80 and zero console errors.\n`);
+    } else {
+      console.log(`  ${c('yellow', '⚠ Web audit completed')} with ${report.summary.totalIssues} issue(s) identified.\n`);
+    }
+
+    if (codified) {
+      if (codified.codifiedCount > 0) {
+        console.log(`  ${c('green', '✔')} Case Law: Codified ${c('bold', String(codified.codifiedCount))} violation(s) into binding precedents in ${c('cyan', '.agent/history/case-law/')}.\n`);
+      } else {
+        console.log(`  ${c('gray', 'ℹ')} Case Law: No new violations to codify (or all matches already exist in precedents).\n`);
+      }
+    }
+  } catch (err) {
+    console.error(`  ${c('red', '✖ Audit failed:')} ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cmdAuditWeb,
+};

package/dist/commands/browse.js

@@ -0,0 +1,56 @@
+'use strict';
+
+/**
+ * cmdBrowse — Token-Efficient Page Navigation & Semantic Extractor
+ *
+ * Usage:
+ *   tk browse https://example.com
+ *   tk browse http://localhost:3000 --json
+ */
+
+const { browse } = require('../browser');
+const { c } = require('../utils/logger');
+const { banner } = require('../utils/helpers');
+
+async function cmdBrowse(flags, processArgs, quiet = false) {
+  const url = processArgs[3] || flags.url;
+
+  if (!url) {
+    console.error(`  ${c('red', '✖ Error:')} Missing target URL. Usage: tk browse <url>`);
+    process.exit(1);
+  }
+
+  if (!quiet && !flags.json) {
+    banner(quiet);
+    console.log(`  ${c('cyan', '🌐 Browsing:')} ${c('white', url)} (extracting semantic tokens)...\n`);
+  }
+
+  try {
+    const result = await browse(url);
+
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    if (result.threatLevel !== 'clean') {
+      console.log(`  ${c('yellow', '⚠ IDPI Warning:')} Potential prompt injection detected (${result.threatLevel}):`);
+      for (const t of result.threats) {
+        console.log(`    ${c('red', '•')} ${t}`);
+      }
+      console.log();
+    }
+
+    console.log(c('gray', '─────────────────────────────────────────────────────────────'));
+    console.log(result.markdown);
+    console.log(c('gray', '─────────────────────────────────────────────────────────────'));
+    console.log(`  ${c('green', '✔')} Extracted page content (${Buffer.byteLength(result.markdown, 'utf8')} bytes, < 1.5k tokens).\n`);
+  } catch (err) {
+    console.error(`  ${c('red', '✖ Browser error:')} ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cmdBrowse,
+};

package/dist/commands/compare-web.js

@@ -0,0 +1,61 @@
+'use strict';
+
+/**
+ * cmdCompareWeb — Visual Regression Comparison Command
+ *
+ * Usage:
+ *   tk compare-web http://localhost:3000 https://example.com
+ *   tk compare-web https://staging.site.com https://prod.site.com --max-diff 2.0
+ */
+
+const { compareURLs } = require('../browser');
+const { c } = require('../utils/logger');
+const { banner } = require('../utils/helpers');
+
+async function cmdCompareWeb(flags, processArgs, quiet = false) {
+  const url1 = processArgs[3] || flags.url1;
+  const url2 = processArgs[4] || flags.url2;
+
+  if (!url1 || !url2) {
+    console.error(`  ${c('red', '✖ Error:')} Missing target URLs. Usage: tk compare-web <url1> <url2>`);
+    process.exit(1);
+  }
+
+  const maxDiff = flags.maxDiff ? parseFloat(flags.maxDiff) : 1.0;
+
+  if (!quiet && !flags.json) {
+    banner(quiet);
+    console.log(`  ${c('cyan', '📸 Comparing Visual Viewports:')}`);
+    console.log(`    URL 1: ${c('white', url1)}`);
+    console.log(`    URL 2: ${c('white', url2)}\n`);
+  }
+
+  try {
+    const result = await compareURLs(url1, url2, { maxDiffPercent: maxDiff });
+
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(result.passed ? 0 : 1);
+    }
+
+    const diffColor = result.passed ? 'green' : 'red';
+
+    console.log(`  Visual Mismatch: ${c(diffColor, `${result.diffPercentage}%`)} (Allowed Threshold: ${maxDiff}%)`);
+    console.log(`  Compared Bytes:  ${result.totalPixelsCompared}`);
+
+    if (result.passed) {
+      console.log(`\n  ${c('green', '✔ Visual comparison passed')} — Difference is within acceptable threshold.\n`);
+      process.exit(0);
+    } else {
+      console.log(`\n  ${c('red', '✖ Visual regression detected!')} Diff ${result.diffPercentage}% exceeds max allowed ${maxDiff}%.\n`);
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(`  ${c('red', '✖ Comparison failed:')} ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cmdCompareWeb,
+};

package/dist/commands/deconstruct.js

@@ -0,0 +1,58 @@
+'use strict';
+
+/**
+ * cmdDeconstruct — Reverse-Engineer Live Web Elements into Production React Code
+ *
+ * Usage:
+ *   tk deconstruct https://example.com --selector "button.primary"
+ *   tk deconstruct http://localhost:3000 --selector "#pricing-card" --name PricingCard --output src/components/PricingCard.tsx
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { deconstructElement } = require('../browser/synapse');
+const { c } = require('../utils/logger');
+const { banner } = require('../utils/helpers');
+
+async function cmdDeconstruct(flags, processArgs, quiet = false) {
+  const url = processArgs[3] || flags.url;
+  const selector = flags.selector || processArgs[4];
+
+  if (!url || !selector) {
+    console.error(`  ${c('red', '✖ Error:')} Missing URL or selector. Usage: tk deconstruct <url> --selector "<css-selector>"`);
+    process.exit(1);
+  }
+
+  if (!quiet && !flags.json) {
+    banner(quiet);
+    console.log(`  ${c('cyan', '⚡ Component Synapse Deconstructing:')} ${c('white', selector)} on ${c('gray', url)}...\n`);
+  }
+
+  try {
+    const result = await deconstructElement(url, selector, flags);
+
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    if (flags.output) {
+      const outPath = path.resolve(flags.output);
+      fs.mkdirSync(path.dirname(outPath), { recursive: true });
+      fs.writeFileSync(outPath, result.code, 'utf8');
+      console.log(`  ${c('green', '✔ Synthesized React component saved to:')} ${c('bold', outPath)}\n`);
+    } else {
+      console.log(c('gray', '────────────────── Synthesized React TSX Component ──────────────────'));
+      console.log(result.code);
+      console.log(c('gray', '─────────────────────────────────────────────────────────────────────'));
+      console.log(`  ${c('green', '✔')} Extracted computed CSSOM and synthesized ${c('bold', result.componentName)}.\n`);
+    }
+  } catch (err) {
+    console.error(`  ${c('red', '✖ Deconstruction failed:')} ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cmdDeconstruct,
+};

package/dist/commands/heal.js

@@ -0,0 +1,99 @@
+'use strict';
+
+/**
+ * cmdHeal — Runtime Sentinel Error Hunter and Fix Verifier
+ *
+ * Usage:
+ *   tk heal http://localhost:3000
+ *   tk heal http://localhost:5173 --verify
+ *   tk heal http://localhost:3000 --json
+ */
+
+const { captureRuntimeErrors, verifyRuntimeFix } = require('../browser/sentinel');
+const { c } = require('../utils/logger');
+const { banner } = require('../utils/helpers');
+
+async function cmdHeal(flags, processArgs, quiet = false) {
+  const url = processArgs[3] || flags.url || 'http://localhost:3000';
+
+  if (!quiet && !flags.json) {
+    banner(quiet);
+    console.log(`  ${c('cyan', '🛡 Runtime Sentinel:')} Scanning ${c('white', url)} for live runtime errors...\n`);
+  }
+
+  try {
+    if (flags.verify) {
+      const verification = await verifyRuntimeFix(url, flags);
+      if (flags.json) {
+        console.log(JSON.stringify(verification, null, 2));
+        return;
+      }
+
+      if (verification.isFixed) {
+        console.log(`  ${c('green', '✔ Verification Passed!')} Runtime errors cleared on ${c('bold', url)}.\n`);
+      } else {
+        console.log(`  ${c('red', '✖ Verification Failed:')} ${verification.remainingIssues} issue(s) still remaining.\n`);
+      }
+      return;
+    }
+
+    const report = await captureRuntimeErrors(url, flags);
+
+    if (flags.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+
+    if (report.healthy) {
+      console.log(`  ${c('green', '✔ Runtime Healthy:')} Zero uncaught exceptions or error overlays detected on ${c('bold', url)}.\n`);
+      return;
+    }
+
+    console.log(`  ${c('red', '✖ Runtime Errors Detected:')}\n`);
+
+    if (report.overlay.hasOverlay) {
+      console.log(`    ${c('red', '• Dev Error Overlay Active:')} ${c('yellow', report.overlay.overlayType || 'Generic Framework Overlay')}`);
+      if (report.overlay.bodyText) {
+        console.log(`      ${c('gray', report.overlay.bodyText.slice(0, 160))}...\n`);
+      }
+    }
+
+    for (const exc of report.exceptions) {
+      console.log(`    ${c('red', '• Uncaught Exception:')} ${c('bold', exc.text)}`);
+      if (exc.locations && exc.locations.length > 0) {
+        for (const loc of exc.locations) {
+          const locStr = loc.existsLocally
+            ? `${c('green', loc.filePath)}:${loc.line}:${loc.column}`
+            : `${c('gray', loc.rawUrl)}`;
+          console.log(`      ${c('cyan', '→ Source:')} ${locStr}`);
+        }
+      }
+      console.log();
+    }
+
+    for (const cerr of report.consoleErrors) {
+      console.log(`    ${c('yellow', '• Console Error:')} ${cerr.text}`);
+      if (cerr.locations && cerr.locations.length > 0) {
+        for (const loc of cerr.locations) {
+          const locStr = loc.existsLocally
+            ? `${c('green', loc.filePath)}:${loc.line}:${loc.column}`
+            : `${c('gray', loc.rawUrl)}`;
+          console.log(`      ${c('cyan', '→ Source:')} ${locStr}`);
+        }
+      }
+      console.log();
+    }
+
+    console.log(`  ${c('yellow', 'ℹ Remedy Guidance:')}`);
+    console.log(`    1. Inspect the source file(s) listed above.`);
+    console.log(`    2. Apply targeted fix.`);
+    console.log(`    3. Run ${c('bold', `tk heal ${url} --verify`)} to confirm resolution.\n`);
+  } catch (err) {
+    console.error(`  ${c('red', '✖ Sentinel scan failed:')} ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cmdHeal,
+};

package/dist/commands/init.js

@@ -323,11 +323,18 @@ ${rulesContent}
 
 ${rulesContent}
 `;
-    // ── 5. Claude (.claude/CLAUDE.md) ─────────────────────
+    // ── 5. Claude (.claude/CLAUDE.md & CLAUDE.md) ───────
     const claudeRules = `# Tribunal Kit — Claude Bridge
 # Auto-generated by tribunal-kit init. Do not edit manually.
 # Source: .agent/rules/${rulesFilename}
 
+${rulesContent}
+`;
+    // ── 6. Codex & Universal Agents (AGENTS.md) ──────────
+    const codexRules = `# Tribunal Kit — Codex Bridge
+# Auto-generated by tribunal-kit init. Do not edit manually.
+# Source: .agent/rules/${rulesFilename}
+
 ${rulesContent}
 `;
     // Fire ALL bridge writes concurrently via Promise.all
@@ -338,6 +345,8 @@ ${rulesContent}
         { path: path_1.default.join(targetDir, '.gemini', 'GEMINI.md'), content: geminiRulesBridge, label: 'Gemini rules' },
         { path: path_1.default.join(targetDir, '.github', 'copilot-instructions.md'), content: copilotInstructions, label: 'GitHub Copilot' },
         { path: path_1.default.join(targetDir, '.claude', 'CLAUDE.md'), content: claudeRules, label: 'Claude' },
+        { path: path_1.default.join(targetDir, 'CLAUDE.md'), content: claudeRules, label: 'Claude root' },
+        { path: path_1.default.join(targetDir, 'AGENTS.md'), content: codexRules, label: 'Codex / Multi-Agent' },
     ];
     await Promise.all(bridges.map(b => writeBridge(b.path, b.content, b.label)));
     console.log();