tribunal-kit 4.2.0 → 4.3.1

package/.agent/scripts/auto_preview.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+/**
+ * auto_preview.js — Start, stop, or check a local development server.
+ *
+ * Usage:
+ *   node .agent/scripts/auto_preview.js start
+ *   node .agent/scripts/auto_preview.js stop
+ *   node .agent/scripts/auto_preview.js status
+ *   node .agent/scripts/auto_preview.js restart
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+const net = require('net');
+
+const PID_FILE = ".preview.pid";
+const DEFAULT_PORT = 3000;
+const TIMEOUT_SECONDS = 30;
+
+const { GREEN, RED, YELLOW, BOLD, RESET } = require('./colors.js');
+
+function findStartCommand() {
+    const pkgPath = path.resolve("package.json");
+    if (!fs.existsSync(pkgPath)) return { cmd: [], found: false };
+
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        const scripts = pkg.scripts || {};
+        if (scripts.dev) return { cmd: ["npm", "run", "dev"], found: true };
+        if (scripts.start) return { cmd: ["npm", "run", "start"], found: true };
+    } catch {
+        // Ignore
+    }
+    return { cmd: [], found: false };
+}
+
+function getPortFromEnv() {
+    const envPath = path.resolve(".env");
+    if (fs.existsSync(envPath)) {
+        try {
+            const data = fs.readFileSync(envPath, 'utf8');
+            for (const line of data.split('\n')) {
+                if (line.trim().startsWith("PORT=")) {
+                    return parseInt(line.split("=")[1].trim(), 10);
+                }
+            }
+        } catch {}
+    }
+    return DEFAULT_PORT;
+}
+
+function isPortOpen(port) {
+    return new Promise(resolve => {
+        const client = new net.Socket();
+        client.setTimeout(1000);
+        client.once('connect', () => {
+            client.destroy();
+            resolve(true);
+        }).once('timeout', () => {
+            client.destroy();
+            resolve(false);
+        }).once('error', () => {
+            resolve(false);
+        }).connect(port, 'localhost');
+    });
+}
+
+function readPid() {
+    if (fs.existsSync(PID_FILE)) {
+        try {
+            return parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+        } catch {}
+    }
+    return null;
+}
+
+function writePid(pid) {
+    fs.writeFileSync(PID_FILE, String(pid), 'utf8');
+}
+
+function clearPid() {
+    if (fs.existsSync(PID_FILE)) {
+        fs.unlinkSync(PID_FILE);
+    }
+}
+
+async function startServer() {
+    const port = getPortFromEnv();
+
+    if (await isPortOpen(port)) {
+        console.log(`${YELLOW}⚠️  Port ${port} is already in use.${RESET}`);
+        const pid = readPid();
+        if (pid) console.log(`   Known PID: ${pid}`);
+        return;
+    }
+
+    const { cmd, found } = findStartCommand();
+    if (!found) {
+        console.log(`${RED}❌ No dev/start script found.${RESET}`);
+        console.log(`   This project has no package.json, or its package.json has no 'dev' or 'start' script.`);
+        console.log(`   Add a script to package.json, or start your server manually.`);
+        return;
+    }
+
+    console.log(`${BOLD}Starting: ${cmd.join(' ')}${RESET}`);
+    // Adjust command for windows (npm.cmd instead of npm)
+    const executable = process.platform === 'win32' ? `${cmd[0]}.cmd` : cmd[0];
+    
+    const proc = spawn(executable, cmd.slice(1), {
+        stdio: 'pipe',
+        detached: true
+    });
+    
+    // Ignore children stdout inside detached mode to let node exit
+    proc.stdout.unref();
+    proc.stderr.unref();
+    proc.unref();
+
+    writePid(proc.pid);
+
+    process.stdout.write(`Waiting for port ${port}…`);
+    for (let i = 0; i < TIMEOUT_SECONDS; i++) {
+        if (await isPortOpen(port)) {
+            console.log(`\n${GREEN}✅ Server started${RESET}`);
+            console.log(`   URL:     http://localhost:${port}`);
+            console.log(`   PID:     ${proc.pid}`);
+            console.log(`   Command: ${cmd.join(' ')}`);
+            console.log(`\nStop with: node .agent/scripts/auto_preview.js stop`);
+            return;
+        }
+        process.stdout.write(".");
+        await new Promise(r => setTimeout(r, 1000));
+    }
+
+    console.log(`\n${RED}❌ Server did not start within ${TIMEOUT_SECONDS}s${RESET}`);
+    try {
+        process.kill(proc.pid, 'SIGTERM');
+    } catch {}
+    clearPid();
+}
+
+function stopServer() {
+    const pid = readPid();
+    if (!pid) {
+        console.log(`${YELLOW}⚠️  No stored server PID found${RESET}`);
+        return;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+        console.log(`${GREEN}✅ Server stopped (PID ${pid})${RESET}`);
+    } catch {
+        console.log(`${YELLOW}Process ${pid} was not running${RESET}`);
+    } finally {
+        clearPid();
+    }
+}
+
+async function showStatus() {
+    const port = getPortFromEnv();
+    const pid = readPid();
+    if (await isPortOpen(port)) {
+        console.log(`${GREEN}🟢 Running — http://localhost:${port}${RESET}`);
+        if (pid) console.log(`   PID: ${pid}`);
+    } else {
+        console.log(`${RED}🔴 Not running on port ${port}${RESET}`);
+    }
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+    const actions = new Set(["start", "stop", "status", "restart"]);
+    
+    if (args.length < 1 || !actions.has(args[0])) {
+        console.log(`Usage: node auto_preview.js [start|stop|status|restart]`);
+        process.exit(1);
+    }
+
+    const action = args[0];
+    if (action === "start") {
+        await startServer();
+    } else if (action === "stop") {
+        stopServer();
+    } else if (action === "status") {
+        await showStatus();
+    } else if (action === "restart") {
+        stopServer();
+        await new Promise(r => setTimeout(r, 1000));
+        await startServer();
+    }
+}
+
+if (require.main === module) {
+    main();
+}

package/.agent/scripts/bundle_analyzer.js

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+/**
+ * bundle_analyzer.js — JS/TS bundle size analyzer for the Tribunal Agent Kit.
+ *
+ * Analyzes build output for:
+ *   - Total bundle size
+ *   - Largest files in dist/
+ *   - Suggested tree-shaking opportunities
+ *   - Bundler-specific analysis (Vite / Webpack)
+ *
+ * Usage:
+ *   node .agent/scripts/bundle_analyzer.js .
+ *   node .agent/scripts/bundle_analyzer.js . --build
+ *   node .agent/scripts/bundle_analyzer.js . --threshold 500
+ */
+
+'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 HEAVY_PACKAGES = {
+    "moment": "Use date-fns or dayjs instead (~2KB vs ~230KB)",
+    "lodash": "Import specific functions: lodash/debounce instead of full lodash",
+    "rxjs": "Import specific operators to enable tree-shaking",
+    "aws-sdk": "Use @aws-sdk/client-* v3 modular imports",
+    "firebase": "Use modular imports: firebase/auth, firebase/firestore",
+    "chart.js": "Register only needed components",
+    "three": "Import specific modules from three/examples/jsm/",
+    "@mui/material": "Ensure babel-plugin-import or modular imports",
+    "@mui/icons-material": "Import specific icons, never the barrel",
+    "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`;
+    return `${(sizeBytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+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 {}
+
+    return null;
+}
+
+function findDistDir(projectRoot) {
+    const candidates = ["dist", "build", ".next", "out", "public/build"];
+    for (const c of candidates) {
+        const d = path.join(projectRoot, c);
+        if (fs.existsSync(d) && fs.statSync(d).isDirectory()) return d;
+    }
+    return null;
+}
+
+function analyzeDist(distDir, thresholdKb) {
+    const files = [];
+    let total = 0;
+
+    function walkDir(dir) {
+        const items = fs.readdirSync(dir, { withFileTypes: true });
+        for (const item of items) {
+            const fpath = path.join(dir, item.name);
+            if (item.isDirectory()) {
+                walkDir(fpath);
+            } else {
+                const size = fs.statSync(fpath).size;
+                total += size;
+                files.push([path.relative(distDir, fpath), size]);
+            }
+        }
+    }
+
+    try {
+        walkDir(distDir);
+    } catch {}
+
+    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]);
+            }
+        }
+        return found;
+    } catch {
+        return [];
+    }
+}
+
+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 {}
+    }
+
+    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;
+        }
+
+        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}`);
+            }
+        }
+        return false;
+    } catch (e) {
+        failPrint(`Execution error: ${e.message}`);
+        return false;
+    }
+}
+
+function main() {
+    const args = process.argv.slice(2);
+    
+    let targetPath = null;
+    let buildFlag = false;
+    let threshold = 250;
+
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--build') buildFlag = true;
+        else if (args[i] === '--threshold' && i + 1 < args.length) {
+            threshold = parseInt(args[++i], 10);
+        } else if (args[i].startsWith('-')) {
+            console.log("Usage: node bundle_analyzer.js <path> [--build] [--threshold <kb>]");
+            process.exit(1);
+        } else if (!targetPath) {
+            targetPath = args[i];
+        }
+    }
+
+    if (!targetPath) {
+        console.log("Usage: node bundle_analyzer.js <path> [--build] [--threshold <kb>]");
+        process.exit(1);
+    }
+
+    const projectRoot = path.resolve(targetPath);
+    if (!fs.existsSync(projectRoot) || !fs.statSync(projectRoot).isDirectory()) {
+        failPrint(`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}`);
+
+    if (buildFlag) {
+        header("Building project");
+        if (!runBuild(projectRoot)) {
+            process.exit(1);
+        }
+    }
+
+    const distDir = findDistDir(projectRoot);
+    const heavy = checkHeavyDependencies(projectRoot);
+
+    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}`);
+
+        const thresholdBytes = threshold * 1024;
+        console.log(`\n  ${BOLD}Top files by size:${RESET}`);
+        let count = 0;
+        for (const [filepath, size] of files) {
+            if (count++ >= 10) break;
+            const sizeStr = formatSize(size).padStart(10, ' ');
+            if (size > thresholdBytes) {
+                warn(`${sizeStr}  ${filepath}`);
+            } else {
+                console.log(`      ${sizeStr}  ${filepath}`);
+            }
+        }
+
+        const largeJs = 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");
+    if (heavy.length > 0) {
+        for (const [pkgName, suggestion] of heavy) {
+            warn(`'${pkgName}' is a heavy dependency`);
+            console.log(`      → ${suggestion}`);
+        }
+    } else {
+        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) {
+            warn(`Total bundle: ${sizeStr} — review for optimization opportunities`);
+        } else {
+            ok(`Total bundle: ${sizeStr}`);
+        }
+    }
+
+    if (heavy.length > 0) {
+        warn(`${heavy.length} heavy dependency suggestion(s) — see above`);
+    } else if (distDir && heavy.length === 0) {
+        ok("No optimization suggestions");
+    }
+}
+
+if (require.main === module) {
+    main();
+}