tribunal-kit 4.2.0 → 4.3.1

package/.agent/scripts/deep_compress.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * deep_compress.js - Deep surgical compression for .agent/ markdown files (skills, agents, workflows).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const BASE_DIRS = ['.agent/skills', '.agent/agents', '.agent/workflows'];
+
+const REMOVE_SECTIONS = [
+    /^## 🏛️ Tribunal Integration[\s\S]*?(?=\n## |$)/gm,
+    /^## Tribunal Integration[\s\S]*?(?=\n## |$)/gm,
+    /^### ✅ Pre-Flight Self-Audit[\s\S]*?(?=\n### |\n## |$)/gm,
+    /^## Pre-Flight Self-Audit[\s\S]*?(?=\n## |$)/gm,
+    /^## Cross-Workflow Navigation[\s\S]*?(?=\n## |$)/gm,
+    /^## LLM Traps[\s\S]*?(?=\n## |$)/gm,
+    /^## VBC Protocol[\s\S]*?(?=\n## |$)/gm,
+    /^## Output Format\n```[\s\S]*?```\n/gm,
+    /^## 🤖 LLM-Specific Traps[\s\S]*?(?=\n## |$)/gm,
+];
+
+const VERBOSE_COMMENT_PATTERNS = [
+    /^(\s*)\/\/\s*(?:Any HTML or SVG element|motion\.div, motion\.span|The MAGIC of|This is the key performance|The pattern that|Compound components share|Note that children|The action receives|Children inherit the|Import first|Parent controls when|It's always motion)\b[^\n]*\n/gm,
+    /^(\s*)#\s*(?:TypedDict gives you|Usage:|Note:|Return user|Return None|Automatically)\b[^\n]*\n/gm,
+    /^\s*\/\/\s*Usage:\s*\n(?=\s*[<{])/gm,
+    /^\s*#\s*Usage:\s*\n(?=\s*[{])/gm,
+    /^\s*\/\/\s*When (?:server responds|a component|React can interrupt|the React Compiler)[^\n]*\n/gm,
+];
+
+function stripChattyOpeners(content) {
+    return content.replace(/(^# .+\n)\n.{60,}\n.{30,}\n(?:\n---)/gm, '$1\n---');
+}
+
+function compressLegacyModernBlocks(content) {
+    const pattern = /```(\w+)\n((?:.*\n)*?.*(?:\/\/|#) ❌ LEGACY[^\n]*\n(?:.*\n)*?)```\n\n```\w+\n((?:.*\n)*?.*(?:\/\/|#) ✅ MODERN[^\n]*\n(?:.*\n)*?)```/gm;
+    return content.replace(pattern, (match, lang, legacy, modern) => {
+        const totalLines = (legacy.match(/\n/g) || []).length + (modern.match(/\n/g) || []).length;
+        if (totalLines > 28) return match;
+        return `\`\`\`${lang}\n// ❌ LEGACY\n${legacy.trim()}\n\n// ✅ MODERN\n${modern.trim()}\n\`\`\``;
+    });
+}
+
+function stripEmptyComments(content) {
+    content = content.replace(/^\s*\/\/\s*$\n/gm, '');
+    content = content.replace(/^\s*#\s*$\n/gm, '');
+    return content;
+}
+
+function dedupBulletPoints(content) {
+    const lines = content.split('\n');
+    const seenBullets = {};
+    const output = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const stripped = line.trim();
+        if (/^(✅|❌|- ✅|- ❌)/.test(stripped)) {
+            if (seenBullets[stripped] !== undefined && (i - seenBullets[stripped]) < 80) {
+                continue;
+            }
+            seenBullets[stripped] = i;
+        }
+        output.push(line);
+    }
+    return output.join('\n');
+}
+
+function collapseBlanks(content) {
+    return content.replace(/\n{3,}/g, '\n\n');
+}
+
+function compressFile(filePath) {
+    const original = fs.readFileSync(filePath, 'utf8');
+    let content = original;
+
+    for (const pattern of REMOVE_SECTIONS) {
+        content = content.replace(pattern, '');
+    }
+
+    content = stripChattyOpeners(content);
+    content = compressLegacyModernBlocks(content);
+
+    for (const pattern of VERBOSE_COMMENT_PATTERNS) {
+        content = content.replace(pattern, '');
+    }
+
+    content = stripEmptyComments(content);
+    content = dedupBulletPoints(content);
+    content = collapseBlanks(content);
+
+    if (content.trim() !== original.trim()) {
+        fs.writeFileSync(filePath, content.trim() + '\n', 'utf8');
+    }
+
+    return [Buffer.byteLength(original, 'utf8'), Buffer.byteLength(content, 'utf8')];
+}
+
+function main() {
+    let totalOrig = 0;
+    let totalNew = 0;
+    const fileResults = [];
+
+    function walkDir(dir) {
+        let items;
+        try { items = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+        for (const item of items) {
+            const fpath = path.join(dir, item.name);
+            if (item.isDirectory()) walkDir(fpath);
+            else if (item.name.endsWith('.md')) {
+                const [orig, newL] = compressFile(fpath);
+                totalOrig += orig;
+                totalNew += newL;
+                const saved = orig - newL;
+                if (saved > 200) {
+                    fileResults.push([saved, fpath]);
+                }
+            }
+        }
+    }
+
+    for (const base of BASE_DIRS) {
+        if (fs.existsSync(base)) walkDir(base);
+    }
+
+    fileResults.sort((a, b) => b[0] - a[0]);
+
+    const savedTotal = totalOrig - totalNew;
+    const pct = totalOrig ? (savedTotal / totalOrig * 100) : 0;
+
+    console.log(`\n${'='.repeat(58)}`);
+    console.log(`  Deep Compression Complete`);
+    console.log(`${'='.repeat(58)}`);
+    console.log(`  Original : ${totalOrig} bytes (${Math.floor(totalOrig / 1024)}KB)`);
+    console.log(`  After    : ${totalNew} bytes (${Math.floor(totalNew / 1024)}KB)`);
+    console.log(`  Saved    : ${savedTotal} bytes (${Math.floor(savedTotal / 1024)}KB) — ${pct.toFixed(1)}%`);
+    console.log(`\n  Top savings:`);
+    
+    for (const [saved, filePath] of fileResults.slice(0, 20)) {
+        const parts = filePath.split(path.sep);
+        const skill = parts.length >= 2 ? `${parts[parts.length - 2]}/${parts[parts.length - 1]}` : filePath;
+        console.log(`    -${Math.floor(saved / 1024).toString().padStart(2, ' ')}KB  ${skill}`);
+    }
+    console.log();
+}
+
+if (require.main === module) {
+    main();
+}

package/.agent/scripts/dependency_analyzer.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+/**
+ * dependency_analyzer.js — Dependency health checker for the Tribunal Agent Kit.
+ *
+ * Analyzes project dependencies for:
+ *   - Unused packages (in package.json but never imported)
+ *   - Phantom imports (imported but not in package.json)
+ *   - npm audit / pip-audit results
+ *   - Duplicate/overlapping packages
+ *
+ * Usage:
+ *   node .agent/scripts/dependency_analyzer.js .
+ *   node .agent/scripts/dependency_analyzer.js . --audit
+ *   node .agent/scripts/dependency_analyzer.js . --check-unused
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const { RED, GREEN, YELLOW, BLUE, BOLD, RESET } = require('./colors.js');
+
+const SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", ".agent", "__pycache__"]);
+
+const NODE_BUILTINS = new Set([
+    "fs", "path", "os", "crypto", "http", "https", "url", "util",
+    "stream", "events", "child_process", "cluster", "net", "dns",
+    "tls", "readline", "zlib", "buffer", "querystring", "string_decoder",
+    "assert", "perf_hooks", "worker_threads", "timers", "v8",
+    "node:fs", "node:path", "node:os", "node:crypto", "node:http",
+    "node:https", "node:url", "node:util", "node:stream", "node:events",
+    "node:child_process", "node:net", "node:dns", "node:tls",
+    "node:readline", "node:zlib", "node:buffer", "node:assert",
+    "node:perf_hooks", "node:worker_threads", "node:timers"
+]);
+
+function header(title) {
+    console.log(`\n${BOLD}${BLUE}━━━ ${title} ━━━${RESET}`);
+}
+
+function ok(msg) {
+    console.log(`  ${GREEN}✅ ${msg}${RESET}`);
+}
+
+function fail(msg) {
+    console.log(`  ${RED}❌ ${msg}${RESET}`);
+}
+
+function warn(msg) {
+    console.log(`  ${YELLOW}⚠️  ${msg}${RESET}`);
+}
+
+function skip(msg) {
+    console.log(`  ${YELLOW}⏭️  ${msg}${RESET}`);
+}
+
+function loadPackageJson(projectRoot) {
+    const pkgPath = path.resolve(projectRoot, "package.json");
+    if (!fs.existsSync(pkgPath)) return null;
+    try {
+        return JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    } catch {
+        return null;
+    }
+}
+
+function extractImports(projectRoot) {
+    const imports = new Set();
+    const importPatterns = [
+        /(?:import|export)\s+.*?\s+from\s+["']([^"'.][^"']*)["']/g,
+        /require\s*\(\s*["']([^"'.][^"']*)["']/g,
+        /import\s*\(\s*["']([^"'.][^"']*)["']/g
+    ];
+
+    function walk(dir) {
+        let items;
+        try {
+            items = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+            return;
+        }
+
+        for (const item of items) {
+            if (item.isDirectory()) {
+                if (!SKIP_DIRS.has(item.name)) walk(path.join(dir, item.name));
+            } else {
+                const ext = path.extname(item.name);
+                if (SOURCE_EXTENSIONS.has(ext)) {
+                    try {
+                        const content = fs.readFileSync(path.join(dir, item.name), 'utf8');
+                        for (const pattern of importPatterns) {
+                            let match;
+                            while ((match = pattern.exec(content)) !== null) {
+                                let pkg = match[1];
+                                if (pkg.startsWith("@")) {
+                                    const parts = pkg.split("/");
+                                    pkg = parts.length >= 2 ? `${parts[0]}/${parts[1]}` : pkg;
+                                } else {
+                                    pkg = pkg.split("/")[0];
+                                }
+                                imports.add(pkg);
+                            }
+                        }
+                    } catch {}
+                }
+            }
+        }
+    }
+
+    walk(projectRoot);
+    return imports;
+}
+
+function checkUnused(pkg, usedImports) {
+    const allDeps = new Set([
+        ...Object.keys(pkg.dependencies || {}),
+        ...Object.keys(pkg.devDependencies || {})
+    ]);
+
+    const implicitPackages = new Set([
+        "typescript", "eslint", "prettier", "vitest", "jest", "ts-node",
+        "@types/node", "@types/react", "tailwindcss", "postcss", "autoprefixer",
+        "nodemon", "tsx", "vite", "next", "webpack", "babel", "@babel/core"
+    ]);
+
+    const unused = [];
+    for (const d of allDeps) {
+        if (!implicitPackages.has(d) && !d.startsWith("@types/") && !usedImports.has(d)) {
+            unused.push(d);
+        }
+    }
+    return unused.sort();
+}
+
+function checkPhantom(pkg, usedImports) {
+    const allDeps = new Set([
+        ...Object.keys(pkg.dependencies || {}),
+        ...Object.keys(pkg.devDependencies || {})
+    ]);
+
+    const phantom = [];
+    for (const imp of usedImports) {
+        if (!NODE_BUILTINS.has(imp) && !allDeps.has(imp)) {
+            phantom.push(imp);
+        }
+    }
+    return phantom.sort();
+}
+
+function runNpmAudit(projectRoot) {
+    try {
+        const executable = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        const result = spawnSync(executable, ["audit", "--json"], {
+            cwd: projectRoot,
+            encoding: 'utf8',
+            timeout: 60000,
+            shell: process.platform === 'win32'
+        });
+
+        try {
+            const auditData = JSON.parse(result.stdout);
+            const vulns = (auditData.metadata && auditData.metadata.vulnerabilities) || {};
+            const critical = vulns.critical || 0;
+            const high = vulns.high || 0;
+            const moderate = vulns.moderate || 0;
+            const low = vulns.low || 0;
+
+            if (critical + high > 0) {
+                fail(`npm audit: ${critical} critical, ${high} high, ${moderate} moderate, ${low} low`);
+                return false;
+            } else if (moderate + low > 0) {
+                warn(`npm audit: ${moderate} moderate, ${low} low vulnerabilities`);
+                return true;
+            } else {
+                ok("npm audit — no known vulnerabilities");
+                return true;
+            }
+        } catch {
+            if (result.status === 0) {
+                ok("npm audit — clean");
+                return true;
+            }
+            fail("npm audit returned errors");
+            return false;
+        }
+    } catch {
+        skip("npm not installed — skipping audit");
+        return true;
+    }
+}
+
+function main() {
+    const args = process.argv.slice(2);
+    let targetPath = null;
+    let auditFlag = false;
+    let checkUnusedFlag = false;
+
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--audit') auditFlag = true;
+        else if (args[i] === '--check-unused') checkUnusedFlag = true;
+        else if (args[i] === '-h' || args[i] === '--help') {
+            console.log("Usage: node dependency_analyzer.js <path> [--audit] [--check-unused]");
+            process.exit(0);
+        } else if (!args[i].startsWith('-') && !targetPath) {
+            targetPath = args[i];
+        }
+    }
+
+    if (!targetPath) {
+        console.log("Usage: node dependency_analyzer.js <path> [--audit] [--check-unused]");
+        process.exit(1);
+    }
+
+    const projectRoot = path.resolve(targetPath);
+    if (!fs.existsSync(projectRoot) || !fs.statSync(projectRoot).isDirectory()) {
+        fail(`Directory not found: ${projectRoot}`);
+        process.exit(1);
+    }
+
+    console.log(`${BOLD}Tribunal — dependency_analyzer.js${RESET}`);
+    console.log(`Project: ${projectRoot}`);
+
+    const pkg = loadPackageJson(projectRoot);
+    if (!pkg) {
+        skip("No package.json found — dependency analysis requires a Node.js project");
+        process.exit(0);
+    }
+
+    let issues = 0;
+    const usedImports = extractImports(projectRoot);
+    console.log(`\n  Found ${usedImports.size} unique external imports in source code`);
+
+    if (!checkUnusedFlag) {
+        header("Phantom Imports (not in package.json)");
+        const phantom = checkPhantom(pkg, usedImports);
+        if (phantom.length > 0) {
+            for (const p of phantom) fail(`'${p}' is imported but not in package.json — possible hallucination`);
+            issues += phantom.length;
+        } else {
+            ok("All imports found in package.json");
+        }
+    }
+
+    header("Unused Dependencies");
+    const unused = checkUnused(pkg, usedImports);
+    if (unused.length > 0) {
+        for (const u of unused) warn(`'${u}' is in package.json but never imported — may be unused`);
+    } else {
+        ok("No obviously unused dependencies found");
+    }
+
+    if (auditFlag) {
+        header("Vulnerability Audit");
+        if (!runNpmAudit(projectRoot)) issues += 1;
+    }
+
+    console.log(`\n${BOLD}━━━ Dependency Analysis Summary ━━━${RESET}`);
+    if (issues === 0) {
+        ok("All dependency checks passed");
+    } else {
+        fail(`${issues} issue(s) found — review above`);
+    }
+
+    process.exit(issues > 0 ? 1 : 0);
+}
+
+if (require.main === module) {
+    main();
+}

package/.agent/scripts/graph_builder.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/**
+ * graph_builder.js — Tribunal Kit Macro Graph Mapper
+ * Parses project structure for imports, exports, and dependencies
+ * using incremental caching and zero external dependencies.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+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'
+]);
+
+function loadGitIgnore() {
+    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('#'))
+        // simplistic conversion from gitignore line to path check
+        .map(line => line.replace(/\/$/, '').replace(/^\//, '')); 
+}
+
+const customExclusions = loadGitIgnore();
+
+function isExcluded(filePath) {
+    const parts = filePath.split(path.sep);
+    
+    // 1. Check against critical defaults (OOM prevention)
+    if (parts.some(p => DEFAULT_EXCLUSIONS.has(p))) return true;
+    
+    // 2. Check against .gitignore rules
+    const relativePath = path.relative(process.cwd(), filePath).replace(/\\/g, '/');
+    for (const pattern of customExclusions) {
+        if (relativePath.includes(pattern)) return true;
+    }
+    return false;
+}
+
+// ── Traversal ─────────────────────────────────────────────────────────────────
+function walkDir(dir, fileList = []) {
+    if (!fs.existsSync(dir) || isExcluded(dir)) return fileList;
+
+    let files;
+    try {
+        files = fs.readdirSync(dir);
+    } catch (err) {
+        return fileList; // Permission denied or similar
+    }
+
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        if (isExcluded(filePath)) continue;
+
+        if (fs.statSync(filePath).isDirectory()) {
+            walkDir(filePath, fileList);
+        } else {
+            // Target standard JS/TS ecosystem files
+            if (/\.(js|jsx|ts|tsx|mjs|cjs)$/.test(file)) {
+                fileList.push(filePath);
+            }
+        }
+    }
+    return fileList;
+}
+
+// ── Regex AST Extraction ──────────────────────────────────────────────────────
+function parseFile(content) {
+    const imports = new Set();
+    const exports = new Set();
+
+    // Strip comments to prevent false positives in regex
+    const cleanContent = content.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
+
+    // Import extractors
+    const importRegex = /import(?:(?:[\w*\s{},]*)\sfrom\s+)?['"]([^'"]+)['"]/g;
+    const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
+    const dynamicImportRegex = /import\(['"]([^'"]+)['"]\)/g;
+
+    // Export extractors
+    const exportRegex = /export\s+(?:const|let|var|function|class)\s+([a-zA-Z0-9_]+)/g;
+    const moduleExportRegex = /module\.exports\s*=\s*\{([^}]+)\}/g;
+    const defaultExportRegex = /export\s+default\s+([a-zA-Z0-9_]+)/g;
+
+    let match;
+    while ((match = importRegex.exec(cleanContent)) !== null) imports.add(match[1]);
+    while ((match = requireRegex.exec(cleanContent)) !== null) imports.add(match[1]);
+    while ((match = dynamicImportRegex.exec(cleanContent)) !== null) imports.add(match[1]);
+
+    while ((match = exportRegex.exec(cleanContent)) !== null) exports.add(match[1]);
+    while ((match = defaultExportRegex.exec(cleanContent)) !== null) exports.add(match[1]);
+    
+    // Extractor for module.exports = { a, b, c }
+    while ((match = moduleExportRegex.exec(cleanContent)) !== null) {
+        const tokens = match[1].split(',').map(s => s.trim().split(':')[0].trim());
+        tokens.forEach(t => t && exports.add(t));
+    }
+
+    return {
+        imports: Array.from(imports),
+        exports: Array.from(exports)
+    };
+}
+
+// ── 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';
+    
+    for (const [file, info] of Object.entries(data)) {
+        // Only include files that actually export or import things to reduce noise
+        if (info.imports.length === 0 && info.exports.length === 0) continue;
+
+        yaml += `"${file}":\n`;
+        if (info.imports && info.imports.length > 0) {
+            yaml += `  imports:\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`);
+        }
+    }
+    return yaml;
+}
+
+// ── Main Execution ────────────────────────────────────────────────────────────
+function main() {
+    if (!fs.existsSync(AGENT_DIR)) {
+        console.error('\x1b[31m✖ Error: .agent directory not found. Please run tribunal-kit init first.\x1b[0m');
+        process.exit(1);
+    }
+
+    if (!fs.existsSync(HISTORY_DIR)) {
+        fs.mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+
+    // 1. Load incremental cache
+    let cache = {};
+    if (fs.existsSync(CACHE_FILE)) {
+        try { cache = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8')); } catch(e) {}
+    }
+
+    console.log('\x1b[96m✦ Building Architecture Graph...\x1b[0m');
+    const files = walkDir(process.cwd());
+    const graphData = {};
+
+    let parsedCount = 0;
+    let cachedCount = 0;
+
+    // 2. Parse or hit cache
+    for (const file of files) {
+        const stat = fs.statSync(file);
+        const relativePath = path.relative(process.cwd(), file).replace(/\\/g, '/');
+
+        if (cache[relativePath] && cache[relativePath].mtimeMs === stat.mtimeMs) {
+            graphData[relativePath] = { imports: cache[relativePath].imports, exports: cache[relativePath].exports };
+            cachedCount++;
+        } else {
+            try {
+                const content = fs.readFileSync(file, 'utf8');
+                const parsed = parseFile(content);
+                graphData[relativePath] = parsed;
+                
+                cache[relativePath] = {
+                    mtimeMs: stat.mtimeMs,
+                    imports: parsed.imports,
+                    exports: parsed.exports
+                };
+                parsedCount++;
+            } catch (err) {
+                // Graceful fallback on unreadable files
+                console.warn(`\x1b[33m  ⚠ Skipping unreadable file: ${relativePath}\x1b[0m`);
+            }
+        }
+    }
+
+    // 3. Save states
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+    const yamlOutput = generateYAML(graphData);
+    fs.writeFileSync(GRAPH_FILE, yamlOutput);
+
+    console.log(`\n\x1b[32m✔ Graph successfully built.\x1b[0m`);
+    console.log(`  \x1b[2mParsed: ${parsedCount} files | Cached: ${cachedCount} files\x1b[0m`);
+    console.log(`  \x1b[2mSaved to: ${GRAPH_FILE}\x1b[0m`);
+}
+
+main();