tribunal-kit 4.4.0 → 4.4.2

package/.agent/scripts/bundle_analyzer.js

@@ -18,9 +18,14 @@
 
 const fs = require('fs');
 const path = require('path');
-const { spawnSync } = require('child_process');
 
-const { RED, GREEN, YELLOW, BLUE, BOLD, RESET } = require('./colors.js');
+const {
+    RED, GREEN, YELLOW, BLUE, BOLD, DIM, CYAN, RESET,
+    banner, sectionHeader, timer, formatMs,
+    ok, fail, warn, skip,
+} = require('./_colors');
+
+const { loadJson, runCommand } = require('./_utils');
 
 const HEAVY_PACKAGES = {
     "moment": "Use date-fns or dayjs instead (~2KB vs ~230KB)",
@@ -35,26 +40,6 @@ const HEAVY_PACKAGES = {
     "antd": "Use modular imports with babel-plugin-import",
 };
 
-function header(title) {
-    console.log(`\n${BOLD}${BLUE}━━━ ${title} ━━━${RESET}`);
-}
-
-function ok(msg) {
-    console.log(`  ${GREEN}✅ ${msg}${RESET}`);
-}
-
-function failPrint(msg) {
-    console.log(`  ${RED}❌ ${msg}${RESET}`);
-}
-
-function warn(msg) {
-    console.log(`  ${YELLOW}⚠️  ${msg}${RESET}`);
-}
-
-function skip(msg) {
-    console.log(`  ${YELLOW}⏭️  ${msg}${RESET}`);
-}
-
 function formatSize(sizeBytes) {
     if (sizeBytes < 1024) return `${sizeBytes}B`;
     if (sizeBytes < 1024 * 1024) return `${(sizeBytes / 1024).toFixed(1)}KB`;
@@ -62,22 +47,19 @@ function formatSize(sizeBytes) {
 }
 
 function detectBundler(projectRoot) {
-    const pkgPath = path.join(projectRoot, "package.json");
-    if (!fs.existsSync(pkgPath)) return null;
-
-    try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-        const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-
-        if (deps.vite) return "vite";
-        if (deps.next) return "next";
-        if (deps.webpack) return "webpack";
-        
-        if (fs.existsSync(path.join(projectRoot, "webpack.config.js")) || 
-            fs.existsSync(path.join(projectRoot, "webpack.config.ts"))) {
-            return "webpack";
-        }
-    } catch {}
+    const pkg = loadJson(path.join(projectRoot, "package.json"));
+    if (!pkg) return null;
+
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+
+    if (deps.vite) return "vite";
+    if (deps.next) return "next";
+    if (deps.webpack) return "webpack";
+
+    if (fs.existsSync(path.join(projectRoot, "webpack.config.js")) ||
+        fs.existsSync(path.join(projectRoot, "webpack.config.ts"))) {
+        return "webpack";
+    }
 
     return null;
 }
@@ -91,16 +73,21 @@ function findDistDir(projectRoot) {
     return null;
 }
 
-function analyzeDist(distDir, thresholdKb) {
+/**
+ * Analyze dist directory. Uses inline walker (not shared _utils.walkDir)
+ * because it needs to collect file sizes and totals in one pass.
+ */
+function analyzeDist(distDir) {
     const files = [];
     let total = 0;
 
-    function walkDir(dir) {
-        const items = fs.readdirSync(dir, { withFileTypes: true });
+    function _walk(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);
+                _walk(fpath);
             } else {
                 const size = fs.statSync(fpath).size;
                 total += size;
@@ -109,82 +96,58 @@ function analyzeDist(distDir, thresholdKb) {
         }
     }
 
-    try {
-        walkDir(distDir);
-    } catch {}
-
+    _walk(distDir);
     files.sort((a, b) => b[1] - a[1]);
     return { total, files };
 }
 
 function checkHeavyDependencies(projectRoot) {
-    const pkgPath = path.join(projectRoot, "package.json");
-    if (!fs.existsSync(pkgPath)) return [];
-
-    try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-        const deps = Object.keys(pkg.dependencies || {});
-        const found = [];
-        
-        for (const [pkgName, suggestion] of Object.entries(HEAVY_PACKAGES)) {
-            if (deps.includes(pkgName)) {
-                found.push([pkgName, suggestion]);
-            }
+    const pkg = loadJson(path.join(projectRoot, "package.json"));
+    if (!pkg) return [];
+
+    const deps = Object.keys(pkg.dependencies || {});
+    const found = [];
+
+    for (const [pkgName, suggestion] of Object.entries(HEAVY_PACKAGES)) {
+        if (deps.includes(pkgName)) {
+            found.push([pkgName, suggestion]);
         }
-        return found;
-    } catch {
-        return [];
     }
+    return found;
 }
 
 function runBuild(projectRoot) {
-    const pkgPath = path.join(projectRoot, "package.json");
-    if (fs.existsSync(pkgPath)) {
-        try {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-            if (!pkg.scripts || !pkg.scripts.build) {
-                skip("No 'build' script found in package.json");
-                return true;
-            }
-        } catch {}
+    const pkg = loadJson(path.join(projectRoot, "package.json"));
+    if (pkg && (!pkg.scripts || !pkg.scripts.build)) {
+        skip("No 'build' script found in package.json");
+        return true;
     }
 
-    try {
-        const executable = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-        const result = spawnSync(executable, ["run", "build"], {
-            cwd: projectRoot,
-            encoding: 'utf8',
-            timeout: 300000,
-            shell: process.platform === 'win32'
-        });
-
-        if (result.status === 0) {
-            ok("Build completed successfully");
-            return true;
-        }
+    const elapsed = timer();
+    const result = runCommand('npm', ['run', 'build'], {
+        cwd: projectRoot,
+        timeout: 300000,
+    });
 
-        failPrint("Build failed");
-        if (result.error) {
-            console.log(`    Error: ${result.error.message}`);
-        }
-        const out = result.stdout ? result.stdout.toString() : '';
-        const err = result.stderr ? result.stderr.toString() : '';
-        const output = (out + "\n" + err).trim();
-        if (output) {
-            for (const line of output.split("\n").slice(0, 10)) {
-                console.log(`    ${line}`);
-            }
+    const ms = elapsed();
+    if (result.ok) {
+        ok(`Build completed successfully ${DIM}(${formatMs(ms)})${RESET}`);
+        return true;
+    }
+
+    fail(`Build failed ${DIM}(${formatMs(ms)})${RESET}`);
+    const output = (result.stdout + "\n" + result.stderr).trim();
+    if (output) {
+        for (const line of output.split("\n").slice(0, 10)) {
+            console.log(`    ${line}`);
         }
-        return false;
-    } catch (e) {
-        failPrint(`Execution error: ${e.message}`);
-        return false;
     }
+    return false;
 }
 
 function main() {
     const args = process.argv.slice(2);
-    
+
     let targetPath = null;
     let buildFlag = false;
     let threshold = 250;
@@ -193,6 +156,9 @@ function main() {
         if (args[i] === '--build') buildFlag = true;
         else if (args[i] === '--threshold' && i + 1 < args.length) {
             threshold = parseInt(args[++i], 10);
+        } else if (args[i] === '-h' || args[i] === '--help') {
+            console.log("Usage: node bundle_analyzer.js <path> [--build] [--threshold <kb>]");
+            process.exit(0);
         } else if (args[i].startsWith('-')) {
             console.log("Usage: node bundle_analyzer.js <path> [--build] [--threshold <kb>]");
             process.exit(1);
@@ -208,18 +174,19 @@ function main() {
 
     const projectRoot = path.resolve(targetPath);
     if (!fs.existsSync(projectRoot) || !fs.statSync(projectRoot).isDirectory()) {
-        failPrint(`Directory not found: ${projectRoot}`);
+        fail(`Directory not found: ${projectRoot}`);
         process.exit(1);
     }
 
-    console.log(`${BOLD}Tribunal — bundle_analyzer.js${RESET}`);
-    console.log(`Project: ${projectRoot}`);
-
     const bundler = detectBundler(projectRoot);
-    if (bundler) console.log(`  Bundler: ${bundler}`);
+    console.log(banner('bundle_analyzer.js', {
+        Project: projectRoot,
+        Bundler: bundler || 'auto-detect',
+        Threshold: `${threshold}KB`,
+    }));
 
     if (buildFlag) {
-        header("Building project");
+        console.log(sectionHeader('Building Project'));
         if (!runBuild(projectRoot)) {
             process.exit(1);
         }
@@ -228,18 +195,21 @@ function main() {
     const distDir = findDistDir(projectRoot);
     const heavy = checkHeavyDependencies(projectRoot);
 
+    // PERFORMANCE FIX: Cache analyzeDist result — was called TWICE before
+    let distResult = null;
+
     if (!distDir) {
         skip("No build output directory found (dist/, build/, .next/, out/)");
         skip("Run with --build to create a build first, or build manually");
     } else {
-        header(`Bundle Size Analysis (${path.relative(projectRoot, distDir)}/)`);
-        const { total, files } = analyzeDist(distDir, threshold);
-        console.log(`\n  Total bundle size: ${BOLD}${formatSize(total)}${RESET}`);
+        console.log(sectionHeader(`Bundle Size Analysis (${path.relative(projectRoot, distDir)}/)`));
+        distResult = analyzeDist(distDir);
+        console.log(`\n  Total bundle size: ${BOLD}${formatSize(distResult.total)}${RESET}`);
 
         const thresholdBytes = threshold * 1024;
         console.log(`\n  ${BOLD}Top files by size:${RESET}`);
         let count = 0;
-        for (const [filepath, size] of files) {
+        for (const [filepath, size] of distResult.files) {
             if (count++ >= 10) break;
             const sizeStr = formatSize(size).padStart(10, ' ');
             if (size > thresholdBytes) {
@@ -249,13 +219,13 @@ function main() {
             }
         }
 
-        const largeJs = files.filter(([f, s]) => (f.endsWith('.js') || f.endsWith('.mjs')) && s > thresholdBytes);
+        const largeJs = distResult.files.filter(([f, s]) => (f.endsWith('.js') || f.endsWith('.mjs')) && s > thresholdBytes);
         if (largeJs.length > 0) {
             console.log(`\n  ${YELLOW}${largeJs.length} JS file(s) exceed ${threshold}KB threshold${RESET}`);
         }
     }
 
-    header("Dependency Weight Check");
+    console.log(sectionHeader('Dependency Weight Check'));
     if (heavy.length > 0) {
         for (const [pkgName, suggestion] of heavy) {
             warn(`'${pkgName}' is a heavy dependency`);
@@ -265,13 +235,13 @@ function main() {
         ok("No known-heavy packages detected");
     }
 
-    console.log(`\n${BOLD}━━━ Bundle Analysis Summary ━━━${RESET}`);
-    if (distDir) {
-        const { total } = analyzeDist(distDir, threshold);
-        const sizeStr = formatSize(total);
-        if (total > 5 * 1024 * 1024) {
-            failPrint(`Total bundle: ${sizeStr} — consider code splitting`);
-        } else if (total > 2 * 1024 * 1024) {
+    // ━━━ Summary ━━━ (reuses cached distResult instead of re-scanning)
+    console.log(`\n${BOLD}${CYAN}━━━ Bundle Analysis Summary ━━━${RESET}`);
+    if (distResult) {
+        const sizeStr = formatSize(distResult.total);
+        if (distResult.total > 5 * 1024 * 1024) {
+            fail(`Total bundle: ${sizeStr} — consider code splitting`);
+        } else if (distResult.total > 2 * 1024 * 1024) {
             warn(`Total bundle: ${sizeStr} — review for optimization opportunities`);
         } else {
             ok(`Total bundle: ${sizeStr}`);
@@ -280,9 +250,10 @@ function main() {
 
     if (heavy.length > 0) {
         warn(`${heavy.length} heavy dependency suggestion(s) — see above`);
-    } else if (distDir && heavy.length === 0) {
+    } else if (distResult && heavy.length === 0) {
         ok("No optimization suggestions");
     }
+    console.log();
 }
 
 if (require.main === module) {

package/.agent/scripts/case_law_manager.js

@@ -26,14 +26,7 @@ const crypto   = require('crypto');
 const readline = require('readline');
 
 // ── Colours ──────────────────────────────────────────────────────────────────
-const GREEN   = '\x1b[92m';
-const YELLOW  = '\x1b[93m';
-const CYAN    = '\x1b[96m';
-const RED     = '\x1b[91m';
-const BLUE    = '\x1b[94m';
-const BOLD    = '\x1b[1m';
-const DIM     = '\x1b[2m';
-const RESET   = '\x1b[0m';
+const { GREEN, YELLOW, CYAN, RED, BOLD, DIM, RESET } = require('./_colors');
 
 // ── Find .agent directory ─────────────────────────────────────────────────────
 function findAgentDir() {
@@ -48,10 +41,17 @@ function findAgentDir() {
     process.exit(1);
 }
 
-const AGENT_DIR   = findAgentDir();
-const HISTORY_DIR = path.join(AGENT_DIR, 'history', 'case-law');
-const CASES_DIR   = path.join(HISTORY_DIR, 'cases');
-const INDEX_FILE  = path.join(HISTORY_DIR, 'index.json');
+// ── Lazy path resolution (avoids side effects at require-time) ───────────────
+let _paths = null;
+function getPaths() {
+    if (_paths) return _paths;
+    const agentDir   = findAgentDir();
+    const historyDir = path.join(agentDir, 'history', 'case-law');
+    const casesDir   = path.join(historyDir, 'cases');
+    const indexFile  = path.join(historyDir, 'index.json');
+    _paths = { AGENT_DIR: agentDir, HISTORY_DIR: historyDir, CASES_DIR: casesDir, INDEX_FILE: indexFile };
+    return _paths;
+}
 
 const VALID_DOMAINS  = new Set(['backend', 'frontend', 'database', 'security', 'performance', 'mobile', 'testing', 'devops', 'general']);
 const VALID_VERDICTS = new Set(['REJECTED', 'APPROVED_WITH_CONDITIONS', 'PRECEDENT_SET', 'OVERRULED']);
@@ -108,12 +108,14 @@ function contentHash(text) {
 
 // ── Index helpers ─────────────────────────────────────────────────────────────
 function ensureDirs() {
+    const { HISTORY_DIR, CASES_DIR } = getPaths();
     fs.mkdirSync(HISTORY_DIR, { recursive: true });
     fs.mkdirSync(CASES_DIR,   { recursive: true });
 }
 
 function loadIndex() {
     ensureDirs();
+    const { INDEX_FILE } = getPaths();
     if (fs.existsSync(INDEX_FILE)) {
         try { return JSON.parse(fs.readFileSync(INDEX_FILE, 'utf8')); } catch { /* fallthrough */ }
     }
@@ -122,18 +124,21 @@ function loadIndex() {
 
 function saveIndex(index) {
     ensureDirs();
+    const { INDEX_FILE } = getPaths();
     const tmp = INDEX_FILE + '.tmp';
     fs.writeFileSync(tmp, JSON.stringify(index, null, 2), 'utf8');
     fs.renameSync(tmp, INDEX_FILE);
 }
 
 function loadCase(caseId) {
+    const { CASES_DIR } = getPaths();
     const p = path.join(CASES_DIR, `case-${String(caseId).padStart(4, '0')}.json`);
     if (!fs.existsSync(p)) return null;
     try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
 }
 
 function saveCase(caseRecord) {
+    const { CASES_DIR } = getPaths();
     const p = path.join(CASES_DIR, `case-${String(caseRecord.id).padStart(4, '0')}.json`);
     fs.writeFileSync(p, JSON.stringify(caseRecord, null, 2), 'utf8');
 }
@@ -497,7 +502,7 @@ function cmdExport(args) {
     const content = lines.join('\n');
     if (toStdout) { console.log(content); return; }
 
-    const outPath = path.join(HISTORY_DIR, 'case-law-export.md');
+    const outPath = path.join(getPaths().HISTORY_DIR, 'case-law-export.md');
     fs.writeFileSync(outPath, content, 'utf8');
     console.log(`${GREEN}✔ Exported ${cases.length} cases to ${outPath}${RESET}`);
 }