tribunal-kit 6.0.0 → 7.0.0

package/.agent/scripts/graph_builder.js

@@ -6,61 +6,50 @@
  * Now includes Blast Radius calculation and robust token stripping.
  */
 
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const crypto = require("crypto");
-
-const {
-  RED,
-  GREEN,
-  BOLD,
-  DIM,
-  CYAN,
-  RESET,
-  timer,
-  formatMs,
-} = require("./_colors");
-
-const AGENT_DIR = path.join(process.cwd(), ".agent");
-const HISTORY_DIR = path.join(AGENT_DIR, "history");
-const CACHE_FILE = path.join(HISTORY_DIR, "graph-cache.json");
-const GRAPH_FILE = path.join(HISTORY_DIR, "architecture-graph.yaml");
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const { RED, GREEN, BOLD, DIM, CYAN, RESET, timer, formatMs } = require('./_colors');
+
+const AGENT_DIR = path.join(process.cwd(), '.agent');
+const HISTORY_DIR = path.join(AGENT_DIR, 'history');
+const CACHE_FILE = path.join(HISTORY_DIR, 'graph-cache.json');
+const GRAPH_FILE = path.join(HISTORY_DIR, 'architecture-graph.yaml');
 
 // ── Exclusions & Safety ───────────────────────────────────────────────────────
 const DEFAULT_EXCLUSIONS = new Set([
-  "node_modules",
-  ".git",
-  ".next",
-  "dist",
-  "build",
-  "coverage",
-  ".agent",
-  "artifacts",
+  'node_modules',
+  '.git',
+  '.next',
+  'dist',
+  'build',
+  'coverage',
+  '.agent',
+  'artifacts',
 ]);
 
 function loadGitIgnore() {
-  const gitignorePath = path.join(process.cwd(), ".gitignore");
+  const gitignorePath = path.join(process.cwd(), '.gitignore');
   if (!fs.existsSync(gitignorePath)) return [];
 
   return fs
-    .readFileSync(gitignorePath, "utf8")
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line && !line.startsWith("#"))
-    .map((line) => line.replace(/\/$/, "").replace(/^\//, ""));
+    .readFileSync(gitignorePath, 'utf8')
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line && !line.startsWith('#'))
+    .map(line => line.replace(/\/$/, '').replace(/^\//, ''));
 }
 
 const customExclusions = loadGitIgnore();
 
 function isExcluded(filePath) {
   const parts = filePath.split(path.sep);
-  if (parts.some((p) => DEFAULT_EXCLUSIONS.has(p))) return true;
+  if (parts.some(p => DEFAULT_EXCLUSIONS.has(p))) return true;
 
-  const relativePath = path
-    .relative(process.cwd(), filePath)
-    .replace(/\\/g, "/");
+  const relativePath = path.relative(process.cwd(), filePath).replace(/\\/g, '/');
   for (const pattern of customExclusions) {
     if (relativePath.includes(pattern)) return true;
   }
@@ -70,7 +59,7 @@ function isExcluded(filePath) {
 // ── Content Hashing ───────────────────────────────────────────────────────────
 function getFileHash(filePath) {
   const content = fs.readFileSync(filePath);
-  return crypto.createHash("sha1").update(content).digest("hex");
+  return crypto.createHash('sha1').update(content).digest('hex');
 }
 
 // ── Traversal ─────────────────────────────────────────────────────────────────
@@ -119,38 +108,27 @@ function parseFile(content) {
 
   // I'll define an inner function to just strip comments to be safe for imports.
   // Let's stick to the simple `.replace` for comments for now, and rely on regex boundaries.
-  const semiCleanContent = content
-    .replace(/\/\*[\s\S]*?\*\//g, "")
-    .replace(/\/\/.*$/gm, "");
+  const semiCleanContent = content.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
 
-  const importRegex2 =
-    /^[\s]*import(?:(?:[\w*\s{},]*)\sfrom\s+)?['"]([^'"]+)['"]/gm;
+  const importRegex2 = /^[\s]*import(?:(?:[\w*\s{},]*)\sfrom\s+)?['"]([^'"]+)['"]/gm;
   const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
   const dynamicImportRegex = /import\(['"]([^'"]+)['"]\)/g;
 
-  const exportRegex =
-    /^[\s]*export\s+(?:const|let|var|function|class)\s+([a-zA-Z0-9_]+)/gm;
+  const exportRegex = /^[\s]*export\s+(?:const|let|var|function|class)\s+([a-zA-Z0-9_]+)/gm;
   const moduleExportRegex = /module\.exports\s*=\s*\{([^}]+)\}/g;
   const defaultExportRegex = /^[\s]*export\s+default\s+([a-zA-Z0-9_]+)/gm;
 
   let match;
-  while ((match = importRegex2.exec(semiCleanContent)) !== null)
-    imports.add(match[1]);
-  while ((match = requireRegex.exec(semiCleanContent)) !== null)
-    imports.add(match[1]);
-  while ((match = dynamicImportRegex.exec(semiCleanContent)) !== null)
-    imports.add(match[1]);
-
-  while ((match = exportRegex.exec(semiCleanContent)) !== null)
-    exports.add(match[1]);
-  while ((match = defaultExportRegex.exec(semiCleanContent)) !== null)
-    exports.add(match[1]);
+  while ((match = importRegex2.exec(semiCleanContent)) !== null) imports.add(match[1]);
+  while ((match = requireRegex.exec(semiCleanContent)) !== null) imports.add(match[1]);
+  while ((match = dynamicImportRegex.exec(semiCleanContent)) !== null) imports.add(match[1]);
+
+  while ((match = exportRegex.exec(semiCleanContent)) !== null) exports.add(match[1]);
+  while ((match = defaultExportRegex.exec(semiCleanContent)) !== null) exports.add(match[1]);
 
   while ((match = moduleExportRegex.exec(semiCleanContent)) !== null) {
-    const tokens = match[1]
-      .split(",")
-      .map((s) => s.trim().split(":")[0].trim());
-    tokens.forEach((t) => t && exports.add(t));
+    const tokens = match[1].split(',').map(s => s.trim().split(':')[0].trim());
+    tokens.forEach(t => t && exports.add(t));
   }
 
   return {
@@ -161,8 +139,8 @@ function parseFile(content) {
 
 // ── YAML Generation ───────────────────────────────────────────────────────────
 function generateYAML(data) {
-  let yaml = "# Auto-generated Architecture Graph by Tribunal Kit\n";
-  yaml += "# DO NOT EDIT MANUALLY - Auto-updates via incremental cache\n\n";
+  let yaml = '# Auto-generated Architecture Graph by Tribunal Kit\n';
+  yaml += '# DO NOT EDIT MANUALLY - Auto-updates via incremental cache\n\n';
 
   for (const [file, info] of Object.entries(data)) {
     if (
@@ -173,20 +151,20 @@ function generateYAML(data) {
       continue;
 
     yaml += `"${file}":\n`;
-    yaml += `  riskScore: "${info.riskScore || "Low"}"\n`;
+    yaml += `  riskScore: "${info.riskScore || 'Low'}"\n`;
     yaml += `  blastRadius: ${info.blastRadius || 0}\n`;
 
     if (info.imports && info.imports.length > 0) {
       yaml += `  imports:\n`;
-      info.imports.forEach((i) => (yaml += `    - "${i}"\n`));
+      info.imports.forEach(i => (yaml += `    - "${i}"\n`));
     }
     if (info.exports && info.exports.length > 0) {
       yaml += `  exports:\n`;
-      info.exports.forEach((e) => (yaml += `    - "${e}"\n`));
+      info.exports.forEach(e => (yaml += `    - "${e}"\n`));
     }
     if (info.dependents && info.dependents.length > 0) {
       yaml += `  dependents:\n`;
-      info.dependents.forEach((d) => (yaml += `    - "${d}"\n`));
+      info.dependents.forEach(d => (yaml += `    - "${d}"\n`));
     }
   }
   return yaml;
@@ -199,13 +177,12 @@ function main() {
     process.exit(1);
   }
 
-  if (!fs.existsSync(HISTORY_DIR))
-    fs.mkdirSync(HISTORY_DIR, { recursive: true });
+  if (!fs.existsSync(HISTORY_DIR)) fs.mkdirSync(HISTORY_DIR, { recursive: true });
 
   let cache = {};
   if (fs.existsSync(CACHE_FILE)) {
     try {
-      cache = JSON.parse(fs.readFileSync(CACHE_FILE, "utf8"));
+      cache = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
     } catch {
       /* ignore */
     }
@@ -221,7 +198,7 @@ function main() {
   const changedFiles = new Set();
 
   for (const file of files) {
-    const relativePath = path.relative(process.cwd(), file).replace(/\\/g, "/");
+    const relativePath = path.relative(process.cwd(), file).replace(/\\/g, '/');
     let fileHash;
     try {
       fileHash = getFileHash(file);
@@ -237,7 +214,7 @@ function main() {
       cachedCount++;
     } else {
       try {
-        const content = fs.readFileSync(file, "utf8");
+        const content = fs.readFileSync(file, 'utf8');
         const parsed = parseFile(content);
         graphData[relativePath] = parsed;
 
@@ -260,15 +237,15 @@ function main() {
   const fileKeys = Object.keys(graphData);
   for (const [file, info] of Object.entries(graphData)) {
     for (const imp of info.imports) {
-      if (imp.startsWith(".")) {
-        let resolved = path.posix.join(path.dirname(file), imp);
+      if (imp.startsWith('.')) {
+        const resolved = path.posix.join(path.dirname(file), imp);
         // Look for direct match or .js / index.js
-        let matchingKey = fileKeys.find(
-          (k) =>
+        const matchingKey = fileKeys.find(
+          k =>
             k === resolved ||
-            k === resolved + ".js" ||
-            k === resolved + ".ts" ||
-            k === resolved + "/index.js",
+            k === resolved + '.js' ||
+            k === resolved + '.ts' ||
+            k === resolved + '/index.js',
         );
         if (matchingKey) {
           if (!graphData[matchingKey].dependents.includes(file)) {
@@ -290,10 +267,10 @@ function main() {
     }
     visit(file);
     const radius = visited.size - 1;
-    let score = "Low";
-    if (radius > 10) score = "Critical";
-    else if (radius >= 5) score = "High";
-    else if (radius >= 2) score = "Medium";
+    let score = 'Low';
+    if (radius > 10) score = 'Critical';
+    else if (radius >= 5) score = 'High';
+    else if (radius >= 2) score = 'Medium';
     return { score, count: Math.max(0, radius) };
   }
 
@@ -314,7 +291,7 @@ function main() {
   fs.writeFileSync(GRAPH_FILE, generateYAML(graphData));
 
   // ── Pre-Computed Context Snapshots (Incremental) ─────────────────────────
-  const SNAPSHOTS_DIR = path.join(HISTORY_DIR, "snapshots");
+  const SNAPSHOTS_DIR = path.join(HISTORY_DIR, 'snapshots');
   if (!fs.existsSync(SNAPSHOTS_DIR)) {
     fs.mkdirSync(SNAPSHOTS_DIR, { recursive: true });
   }
@@ -322,12 +299,9 @@ function main() {
   // Clean up snapshots for files that no longer exist
   try {
     const existingSnapshots = fs.readdirSync(SNAPSHOTS_DIR);
-    const currentFileSet = new Set(
-      fileKeys.map((f) => f.replace(/[\\/]/g, "__") + ".json"),
-    );
+    const currentFileSet = new Set(fileKeys.map(f => f.replace(/[\\/]/g, '__') + '.json'));
     for (const snap of existingSnapshots) {
-      if (!currentFileSet.has(snap))
-        fs.unlinkSync(path.join(SNAPSHOTS_DIR, snap));
+      if (!currentFileSet.has(snap)) fs.unlinkSync(path.join(SNAPSHOTS_DIR, snap));
     }
   } catch {
     /* ignore */
@@ -338,7 +312,7 @@ function main() {
   let snapshotSkipped = 0;
   for (const file of fileKeys) {
     const info = graphData[file];
-    const snapshotFile = file.replace(/[\\/]/g, "__") + ".json";
+    const snapshotFile = file.replace(/[\\/]/g, '__') + '.json';
     const snapshotPath = path.join(SNAPSHOTS_DIR, snapshotFile);
 
     // Skip unchanged files that already have a snapshot
@@ -347,9 +321,9 @@ function main() {
       continue;
     }
 
-    let content = "";
+    let content = '';
     try {
-      content = fs.readFileSync(path.join(process.cwd(), file), "utf8");
+      content = fs.readFileSync(path.join(process.cwd(), file), 'utf8');
     } catch {
       continue;
     }
@@ -364,14 +338,14 @@ function main() {
     };
 
     for (const imp of info.imports) {
-      if (imp.startsWith(".")) {
-        let resolved = path.posix.join(path.dirname(file), imp);
-        let matchingKey = fileKeys.find(
-          (k) =>
+      if (imp.startsWith('.')) {
+        const resolved = path.posix.join(path.dirname(file), imp);
+        const matchingKey = fileKeys.find(
+          k =>
             k === resolved ||
-            k === resolved + ".js" ||
-            k === resolved + ".ts" ||
-            k === resolved + "/index.js",
+            k === resolved + '.js' ||
+            k === resolved + '.ts' ||
+            k === resolved + '/index.js',
         );
         if (matchingKey && graphData[matchingKey]) {
           snapshot.imports[imp] = graphData[matchingKey].exports;
@@ -386,9 +360,7 @@ function main() {
     fs.writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2));
     snapshotWritten++;
   }
-  console.log(
-    `  ${DIM}Snapshots: ${snapshotWritten} written | ${snapshotSkipped} cached${RESET}`,
-  );
+  console.log(`  ${DIM}Snapshots: ${snapshotWritten} written | ${snapshotSkipped} cached${RESET}`);
 
   const totalMs = totalTimer();
   console.log(`\n${GREEN}${BOLD}✔ Graph successfully built.${RESET}`);

package/.agent/scripts/graph_visualizer.js

@@ -5,27 +5,25 @@
  * Uses a native zero-dependency Canvas force-directed graph.
  */
 
-"use strict";
+'use strict';
 
-const fs = require("fs");
-const path = require("path");
+const fs = require('fs');
+const path = require('path');
 
-const { RED, GREEN, DIM, RESET } = require("./_colors");
+const { RED, GREEN, DIM, RESET } = require('./_colors');
 
-const AGENT_DIR = path.join(process.cwd(), ".agent");
-const HISTORY_DIR = path.join(AGENT_DIR, "history");
-const CACHE_FILE = path.join(HISTORY_DIR, "graph-cache.json");
-const HTML_FILE = path.join(HISTORY_DIR, "architecture-explorer.html");
+const AGENT_DIR = path.join(process.cwd(), '.agent');
+const HISTORY_DIR = path.join(AGENT_DIR, 'history');
+const CACHE_FILE = path.join(HISTORY_DIR, 'graph-cache.json');
+const HTML_FILE = path.join(HISTORY_DIR, 'architecture-explorer.html');
 
 function main() {
   if (!fs.existsSync(CACHE_FILE)) {
-    console.error(
-      `${RED}✖ Error: graph-cache.json not found. Run graph_builder.js first.${RESET}`,
-    );
+    console.error(`${RED}✖ Error: graph-cache.json not found. Run graph_builder.js first.${RESET}`);
     process.exit(1);
   }
 
-  const cacheData = fs.readFileSync(CACHE_FILE, "utf8");
+  const cacheData = fs.readFileSync(CACHE_FILE, 'utf8');
 
   const htmlContent = `<!DOCTYPE html>
 <html lang="en">

package/.agent/scripts/graph_zoom.js

@@ -5,19 +5,19 @@
  * stripping out internal logic to save tokens and prevent context bloat.
  */
 
-"use strict";
+'use strict';
 
-const fs = require("fs");
-const path = require("path");
+const fs = require('fs');
+const path = require('path');
 
-const { RED, CYAN, RESET } = require("./_colors");
+const { RED, CYAN, RESET } = require('./_colors');
 
 function getFlag(name) {
   const idx = process.argv.indexOf(name);
   return idx !== -1 && process.argv[idx + 1] ? process.argv[idx + 1] : null;
 }
 
-const targetFile = getFlag("--focus");
+const targetFile = getFlag('--focus');
 
 if (!targetFile) {
   console.error(
@@ -34,7 +34,7 @@ if (!fs.existsSync(absolutePath)) {
 }
 
 function extractSkeleton(content) {
-  const lines = content.split("\n");
+  const lines = content.split('\n');
   const skeleton = [];
 
   // State machine flags
@@ -44,15 +44,12 @@ function extractSkeleton(content) {
   // ── Regex Matchers ──
   const importRegex = /^import\s+.*$/;
   const requireRegex = /^(?:const|let|var)\s+.*require\(.*$/;
-  const classRegex =
-    /^(?:export\s+)?(?:default\s+)?class\s+(\w+)(?:\s+extends\s+[\w.]+)?/;
-  const functionRegex =
-    /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w*)\s*\(([^)]*)\)/;
+  const classRegex = /^(?:export\s+)?(?:default\s+)?class\s+(\w+)(?:\s+extends\s+[\w.]+)?/;
+  const functionRegex = /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w*)\s*\(([^)]*)\)/;
   const arrowFuncRegex =
     /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*=>/;
   // Heuristic for React Components (starts with Capital letter)
-  const reactComponentRegex =
-    /^(?:export\s+)?(?:const|let|var)\s+([A-Z]\w+)\s*=\s*(?:[^=;]+)?=>/;
+  const reactComponentRegex = /^(?:export\s+)?(?:const|let|var)\s+([A-Z]\w+)\s*=\s*(?:[^=;]+)?=>/;
   const typeInterfaceRegex = /^(?:export\s+)?(?:type|interface)\s+(\w+)/;
 
   for (let i = 0; i < lines.length; i++) {
@@ -69,18 +66,16 @@ function extractSkeleton(content) {
 
     // Keep types and interfaces
     if (typeInterfaceRegex.test(trimmed)) {
-      skeleton.push(line + (trimmed.endsWith("{") ? " /* ... */ }" : ""));
+      skeleton.push(line + (trimmed.endsWith('{') ? ' /* ... */ }' : ''));
       continue;
     }
 
     // Keep classes
     const classMatch = classRegex.exec(trimmed);
     if (classMatch) {
-      skeleton.push("\n" + line + (trimmed.endsWith("{") ? "" : " {"));
+      skeleton.push('\n' + line + (trimmed.endsWith('{') ? '' : ' {'));
       inClass = true;
-      braceDepth =
-        (trimmed.match(/\{/g) || []).length -
-        (trimmed.match(/\}/g) || []).length;
+      braceDepth = (trimmed.match(/\{/g) || []).length - (trimmed.match(/\}/g) || []).length;
       continue;
     }
 
@@ -88,11 +83,9 @@ function extractSkeleton(content) {
     const funcMatch = functionRegex.exec(trimmed);
     if (funcMatch) {
       skeleton.push(
-        "\n" +
+        '\n' +
           line +
-          (trimmed.endsWith("{")
-            ? " /* logic stripped */ }"
-            : " { /* logic stripped */ }"),
+          (trimmed.endsWith('{') ? ' /* logic stripped */ }' : ' { /* logic stripped */ }'),
       );
       continue;
     }
@@ -101,11 +94,9 @@ function extractSkeleton(content) {
     const arrowMatch = arrowFuncRegex.exec(trimmed);
     if (arrowMatch) {
       skeleton.push(
-        "\n" +
+        '\n' +
           line +
-          (trimmed.endsWith("{")
-            ? " /* logic stripped */ }"
-            : " { /* logic stripped */ }"),
+          (trimmed.endsWith('{') ? ' /* logic stripped */ }' : ' { /* logic stripped */ }'),
       );
       continue;
     }
@@ -114,11 +105,9 @@ function extractSkeleton(content) {
     const reactMatch = reactComponentRegex.exec(trimmed);
     if (reactMatch && !arrowMatch) {
       skeleton.push(
-        "\n" +
+        '\n' +
           line +
-          (trimmed.endsWith("{")
-            ? " /* logic stripped */ }"
-            : " { /* logic stripped */ }"),
+          (trimmed.endsWith('{') ? ' /* logic stripped */ }' : ' { /* logic stripped */ }'),
       );
       continue;
     }
@@ -126,18 +115,18 @@ function extractSkeleton(content) {
     // Very basic tracking of class methods (indentation heuristic)
     if (
       inClass &&
-      (line.startsWith("  ") || line.startsWith("\t")) &&
-      trimmed.includes("(") &&
-      trimmed.includes(")") &&
-      !trimmed.startsWith("//")
+      (line.startsWith('  ') || line.startsWith('\t')) &&
+      trimmed.includes('(') &&
+      trimmed.includes(')') &&
+      !trimmed.startsWith('//')
     ) {
       // Avoid pushing if it's just a deeply nested logic block
       if (
-        !trimmed.startsWith("if") &&
-        !trimmed.startsWith("for") &&
-        !trimmed.startsWith("switch")
+        !trimmed.startsWith('if') &&
+        !trimmed.startsWith('for') &&
+        !trimmed.startsWith('switch')
       ) {
-        skeleton.push("  " + trimmed + " { /* ... */ }");
+        skeleton.push('  ' + trimmed + ' { /* ... */ }');
       }
     }
 
@@ -146,52 +135,46 @@ function extractSkeleton(content) {
       braceDepth += (line.match(/\{/g) || []).length;
       braceDepth -= (line.match(/\}/g) || []).length;
       if (braceDepth <= 0) {
-        skeleton.push("}\n");
+        skeleton.push('}\n');
         inClass = false;
         braceDepth = 0;
       }
     }
   }
 
-  return skeleton.join("\n");
+  return skeleton.join('\n');
 }
 
 function main() {
   console.log(`${CYAN}✦ Zooming into: ${targetFile}${RESET}`);
 
   try {
-    const content = fs.readFileSync(absolutePath, "utf8");
+    const content = fs.readFileSync(absolutePath, 'utf8');
 
     // Strip comments to make regex parsing easier
-    const noComments = content
-      .replace(/\/\*[\s\S]*?\*\//g, "")
-      .replace(/\/\/.*$/gm, "");
+    const noComments = content.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
 
     let skeleton = extractSkeleton(noComments);
 
     // Fallback Logic: If the file produced practically no useful skeleton (e.g. pure data object or failed parsing)
     if (skeleton.trim().length < 20) {
-      const lines = content.split("\n");
+      const lines = content.split('\n');
       skeleton =
         `// [WARNING: Parser yielded little structure. Falling back to truncated raw file]\n` +
-        lines.slice(0, 100).join("\n") +
-        (lines.length > 100 ? "\n\n... (truncated)" : "");
+        lines.slice(0, 100).join('\n') +
+        (lines.length > 100 ? '\n\n... (truncated)' : '');
     }
 
-    console.log("\n--- SKELETON START ---");
+    console.log('\n--- SKELETON START ---');
     console.log(skeleton);
-    console.log("--- SKELETON END ---\n");
+    console.log('--- SKELETON END ---\n');
   } catch (e) {
     console.error(`${RED}✖ Error parsing file: ${e.message}${RESET}`);
     // Fallback Logic: Return truncated raw on hard failure
-    const rawContent = fs
-      .readFileSync(absolutePath, "utf8")
-      .split("\n")
-      .slice(0, 100)
-      .join("\n");
-    console.log("\n--- RAW FILE FALLBACK (100 lines) ---");
+    const rawContent = fs.readFileSync(absolutePath, 'utf8').split('\n').slice(0, 100).join('\n');
+    console.log('\n--- RAW FILE FALLBACK (100 lines) ---');
     console.log(rawContent);
-    console.log("-------------------------------------\n");
+    console.log('-------------------------------------\n');
   }
 }