tribunal-kit 4.2.0 → 4.3.1

package/.agent/scripts/checklist.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+/**
+ * checklist.js — Priority-based project audit runner for the Tribunal Agent Kit.
+ *
+ * Runs a tiered audit sequence:
+ *   Priority 1: Security
+ *   Priority 2: Lint
+ *   Priority 3: Schema validation
+ *   Priority 4: Tests
+ *   Priority 5: UX / Accessibility
+ *   Priority 6: SEO
+ *   Priority 7: Lighthouse / E2E (requires --url)
+ *
+ * Usage:
+ *   node .agent/scripts/checklist.js .
+ *   node .agent/scripts/checklist.js . --url http://localhost:3000
+ *   node .agent/scripts/checklist.js . --skip security,seo
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+// ━━━ ANSI color output ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+const RED    = '\x1b[91m';
+const GREEN  = '\x1b[92m';
+const YELLOW = '\x1b[93m';
+const BLUE   = '\x1b[94m';
+const BOLD   = '\x1b[1m';
+const RESET  = '\x1b[0m';
+
+
+function printHeader(title) {
+    console.log(`\n${BOLD}${BLUE}━━━ ${title} ━━━${RESET}`);
+}
+
+function printOk(msg) {
+    console.log(`  ${GREEN}✅ ${msg}${RESET}`);
+}
+
+function printFail(msg) {
+    console.log(`  ${RED}❌ ${msg}${RESET}`);
+}
+
+function printSkip(msg) {
+    console.log(`  ${YELLOW}⏭️  Skipped: ${msg}${RESET}`);
+}
+
+
+/**
+ * Run a shell command and return true if it exits with code 0.
+ * @param {string} label - Human-readable label for the check.
+ * @param {string[]} cmd - Command and arguments array.
+ * @param {string} cwd - Working directory.
+ * @returns {boolean}
+ */
+function runCheck(label, cmd, cwd) {
+    try {
+        execFileSync(cmd[0], cmd.slice(1), {
+            cwd,
+            stdio: 'pipe',
+            timeout: 60000,
+            encoding: 'utf8',
+        });
+        printOk(`${label} passed`);
+        return true;
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+            printSkip(`${label} — command not found (tool not installed)`);
+            return true; // Don't block on tools that aren't installed
+        }
+        if (err.killed) {
+            printFail(`${label} — timed out after 60s`);
+            return false;
+        }
+        printFail(`${label} failed`);
+        const output = (err.stdout || '') + (err.stderr || '');
+        if (output.trim()) {
+            console.log(`    ${output.trim().slice(0, 500)}`);
+        }
+        return false;
+    }
+}
+
+
+/**
+ * Scan for hardcoded secrets in source files.
+ * @param {string} projectRoot - Project root directory.
+ * @returns {boolean} True if no secrets found.
+ */
+function checkSecrets(projectRoot) {
+    printHeader('Security — Secret Scan');
+    const dangerousPatterns = [
+        'password=', 'secret=', 'api_key=',
+        'apikey=', 'auth_token=', 'private_key=',
+    ];
+    let foundIssues = false;
+    const sourceExtensions = new Set(['.ts', '.tsx', '.js', '.jsx', '.py', '.env']);
+    const skipDirs = new Set(['node_modules', '.git', '.agent', 'dist', '__pycache__']);
+
+    function walk(dir) {
+        let entries;
+        try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!skipDirs.has(entry.name)) walk(fullPath);
+            } else if (entry.isFile()) {
+                const ext = path.extname(entry.name);
+                if (!sourceExtensions.has(ext)) continue;
+                if (entry.name.startsWith('.env')) continue; // .env files are allowed
+
+                let content;
+                try { content = fs.readFileSync(fullPath, 'utf8'); } catch { continue; }
+
+                const lines = content.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    const lineLower = lines[i].toLowerCase().trim();
+                    const hasPattern = dangerousPatterns.some(p => lineLower.includes(p));
+                    if (hasPattern && lineLower.includes('=') && !lineLower.startsWith('#')) {
+                        const rel = path.relative(projectRoot, fullPath);
+                        printFail(`Possible secret: ${rel}:${i + 1} → ${lines[i].trim().slice(0, 80)}`);
+                        foundIssues = true;
+                    }
+                }
+            }
+        }
+    }
+
+    walk(projectRoot);
+
+    if (!foundIssues) {
+        printOk('No hardcoded secrets detected');
+    }
+    return !foundIssues;
+}
+
+
+/**
+ * Run all checklist tiers. Returns number of failures.
+ * @param {string} projectRoot - Project root.
+ * @param {string|null} url - URL for Lighthouse/E2E checks.
+ * @param {string[]} skip - Tiers to skip.
+ * @returns {number}
+ */
+function runAll(projectRoot, url, skip) {
+    let failures = 0;
+
+    // Priority 1 — Security
+    if (!skip.includes('security')) {
+        printHeader('Priority 1 — Security');
+        if (!checkSecrets(projectRoot)) failures++;
+    } else {
+        printSkip('Security tier');
+    }
+
+    // Priority 2 — Lint
+    if (!skip.includes('lint')) {
+        printHeader('Priority 2 — Lint');
+        if (!runCheck('ESLint', ['npx', 'eslint', '.', '--max-warnings=0'], projectRoot)) failures++;
+        if (!runCheck('TypeScript', ['npx', 'tsc', '--noEmit'], projectRoot)) failures++;
+    } else {
+        printSkip('Lint tier');
+    }
+
+    // Priority 3 — Schema
+    if (!skip.includes('schema')) {
+        printHeader('Priority 3 — Schema');
+        printSkip('Schema check — run manually if you have DB migrations');
+    } else {
+        printSkip('Schema tier');
+    }
+
+    // Priority 4 — Tests
+    if (!skip.includes('tests')) {
+        printHeader('Priority 4 — Tests');
+        if (!runCheck('Test suite', ['npm', 'test', '--', '--passWithNoTests'], projectRoot)) failures++;
+    } else {
+        printSkip('Tests tier');
+    }
+
+    // Priority 5 — UX
+    if (!skip.includes('ux')) {
+        printHeader('Priority 5 — UX / Accessibility');
+        printSkip('UX audit — run /preview start then check manually or with Lighthouse');
+    } else {
+        printSkip('UX tier');
+    }
+
+    // Priority 6 — SEO
+    if (!skip.includes('seo')) {
+        printHeader('Priority 6 — SEO');
+        printSkip('SEO check — use /ui-ux-pro-max for SEO-sensitive pages');
+    } else {
+        printSkip('SEO tier');
+    }
+
+    // Priority 7 — Lighthouse / E2E
+    if (url && !skip.includes('e2e')) {
+        printHeader('Priority 7 — Lighthouse / E2E');
+        if (!runCheck('Playwright E2E', ['npx', 'playwright', 'test'], projectRoot)) failures++;
+    } else if (!url) {
+        printSkip('E2E / Lighthouse — pass --url to enable');
+    }
+
+    // ━━━ Summary ━━━
+    console.log(`\n${BOLD}━━━ Checklist Summary ━━━${RESET}`);
+    if (failures === 0) {
+        printOk('All checks passed — ready to proceed');
+    } else {
+        printFail(`${failures} tier(s) failed — fix Critical issues before proceeding`);
+    }
+
+    return failures;
+}
+
+
+/**
+ * Parse CLI arguments manually (no external dependencies).
+ */
+function parseArgs(argv) {
+    const args = { path: null, url: null, skip: [] };
+    const raw = argv.slice(2);
+
+    for (let i = 0; i < raw.length; i++) {
+        if (raw[i] === '--url' && raw[i + 1]) {
+            args.url = raw[++i];
+        } else if (raw[i] === '--skip' && raw[i + 1]) {
+            args.skip = raw[++i].split(',').map(s => s.trim().toLowerCase()).filter(Boolean);
+        } else if (!raw[i].startsWith('--') && !args.path) {
+            args.path = raw[i];
+        }
+    }
+    return args;
+}
+
+
+function main() {
+    const args = parseArgs(process.argv);
+
+    if (!args.path) {
+        console.error(`Usage: node checklist.js <path> [--url <url>] [--skip security,lint,schema,tests,ux,seo,e2e]`);
+        process.exit(1);
+    }
+
+    const projectRoot = path.resolve(args.path);
+    if (!fs.existsSync(projectRoot) || !fs.statSync(projectRoot).isDirectory()) {
+        printFail(`Directory not found: ${projectRoot}`);
+        process.exit(1);
+    }
+
+    console.log(`${BOLD}Tribunal Checklist — ${projectRoot}${RESET}`);
+    const failures = runAll(projectRoot, args.url, args.skip);
+    process.exit(failures > 0 ? 1 : 0);
+}
+
+
+// ━━━ Exports for testing & programmatic use ━━━
+module.exports = { runCheck, checkSecrets, runAll };
+
+if (require.main === module) {
+    main();
+}

package/.agent/scripts/colors.js

@@ -0,0 +1,17 @@
+/**
+ * colors.js
+ * Shared ANSI color constants for Tribunal Kit Node scripts.
+ */
+'use strict';
+
+module.exports = {
+    GREEN: "\x1b[92m",
+    YELLOW: "\x1b[93m",
+    CYAN: "\x1b[96m",
+    RED: "\x1b[91m",
+    BLUE: "\x1b[94m",
+    MAGENTA: "\x1b[95m",
+    BOLD: "\x1b[1m",
+    DIM: "\x1b[2m",
+    RESET: "\x1b[0m"
+};

package/.agent/scripts/compress_skills.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+// compress_skills.js - Aggressive token reduction for .agent/skills/**/*.md files
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SECTION_PATTERNS = [
+    /^## 🏛️ Tribunal Integration[\s\S]*?(?=\n## |\n# |$)/gm,
+    /^## Tribunal Integration[\s\S]*?(?=\n## |\n# |$)/gm,
+    /^### ✅ Pre-Flight Self-Audit[\s\S]*?(?=\n## |\n### |\n# |$)/gm,
+    /^## Pre-Flight Self-Audit[\s\S]*?(?=\n## |\n# |$)/gm,
+    /^## Cross-Workflow Navigation[\s\S]*?(?=\n## |\n# |$)/gm,
+    /^## Output Format\s*\n```[\s\S]*?```\s*\n/gm,
+    /^## VBC Protocol[\s\S]*?(?=\n## |\n# |$)/gm,
+    /^## LLM Traps[\s\S]*?(?=\n## |\n# |$)/gm,
+];
+
+const CHATTY_INTRO = /(^# .+\n)\n[A-Z][^#\n]{60,}\n[A-Z][^#\n]{40,}\n\n---/gm;
+
+function stripChattyIntro(content) {
+    return content.replace(CHATTY_INTRO, '$1\n---');
+}
+
+const OBVIOUS_COMMENT = /^(\s*)(\/\/ (default for most properties|shorthand|number of repeats|default: \d+|spring tension|resistance|weight|approximate duration|deceleration rate)[^\n]*)\n/gm;
+
+function stripObviousComments(content) {
+    return content.replace(OBVIOUS_COMMENT, '');
+}
+
+const PERF_TEXT_BLOCK = /^```\n(✅ Use \w[^\n]*\n   → [^\n]*\n\n?){3,}```\n/gm;
+
+function compressPerfBlocks(content) {
+    return content.replace(PERF_TEXT_BLOCK, (match) => {
+        const lines = match.replace(/`|\n$/g, '').split('\n');
+        const bullets = [];
+        for (const line of lines) {
+            const stripped = line.trim();
+            if (stripped.startsWith('✅') || stripped.startsWith('❌')) {
+                bullets.push(`- ${stripped}`);
+            } else if (stripped.startsWith('→')) {
+                bullets[bullets.length - 1] += ` (${stripped.substring(1).trim()})`;
+            }
+        }
+        return bullets.join('\n') + '\n';
+    });
+}
+
+function collapseBlanks(content) {
+    return content.replace(/\n{3,}/g, '\n\n');
+}
+
+const FILLER_BEFORE_SECTION = /(^# .+\n\n)([A-Z][^\n]+\n){1,4}(\n---\n)/gm;
+
+function removeFillerBetweenTitleAndHr(content) {
+    return content.replace(FILLER_BEFORE_SECTION, '$1$3');
+}
+
+const REDUNDANT_NOTE = /^\/\/ (motion\.\w+|Any HTML|Note:|Variant names propagate|\/\/ )[^\n]*\n/gm;
+
+function stripRedundantNotes(content) {
+    return content.replace(REDUNDANT_NOTE, '');
+}
+
+function compressFile(filePath) {
+    const original = fs.readFileSync(filePath, 'utf8');
+    let content = original;
+
+    for (const pattern of SECTION_PATTERNS) {
+        content = content.replace(pattern, '');
+    }
+
+    content = stripChattyIntro(content);
+    content = removeFillerBetweenTitleAndHr(content);
+    content = stripObviousComments(content);
+    content = stripRedundantNotes(content);
+    content = compressPerfBlocks(content);
+    content = collapseBlanks(content);
+
+    const originalLen = Buffer.byteLength(original, 'utf8');
+    const newLen = Buffer.byteLength(content.trim() + '\n', 'utf8');
+
+    fs.writeFileSync(filePath, content.trim() + '\n', 'utf8');
+    return [originalLen, newLen, originalLen - newLen];
+}
+
+function main() {
+    const base = '.agent/skills';
+    if (!fs.existsSync(base)) {
+        console.error(`ERROR: '${base}' not found. Run from tribunal-kit root.`);
+        process.exit(1);
+    }
+
+    let totalOrig = 0;
+    let totalNew = 0;
+    const results = [];
+
+    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 if (item.name.endsWith('.md')) {
+                const [orig, newL, saved] = compressFile(fpath);
+                totalOrig += orig;
+                totalNew += newL;
+                if (saved > 0) {
+                    results.push([saved, fpath]);
+                }
+            }
+        }
+    }
+
+    walkDir(base);
+    results.sort((a, b) => b[0] - a[0]);
+
+    console.log(`\n${'='.repeat(55)}`);
+    console.log(`  Skill Compression Complete`);
+    console.log(`${'='.repeat(55)}`);
+    console.log(`  Original : ${totalOrig} bytes (${Math.floor(totalOrig / 1024)}KB)`);
+    console.log(`  After    : ${totalNew} bytes (${Math.floor(totalNew / 1024)}KB)`);
+    
+    const savedTotal = totalOrig - totalNew;
+    const pct = totalOrig ? (savedTotal / totalOrig * 100) : 0;
+    console.log(`  Saved    : ${savedTotal} bytes (${Math.floor(savedTotal / 1024)}KB) — ${pct.toFixed(1)}%`);
+    console.log(`\n  Top savings:`);
+    
+    for (const [saved, filePath] of results.slice(0, 15)) {
+        const parts = filePath.split(path.sep);
+        const skill = parts[parts.length - 2];
+        const fname = parts[parts.length - 1];
+        console.log(`    -${Math.floor(saved / 1024).toString().padStart(2, ' ')}KB  ${skill}/${fname}`);
+    }
+    console.log();
+}
+
+if (require.main === module) {
+    main();
+}

package/.agent/scripts/consolidate_skills.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+/**
+ * consolidate_skills.js
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const BASE = '.agent/skills';
+
+const STRIP_PATTERNS = [
+    /^## 🏛️ Tribunal Integration.*?(?=\n## |$)/gms,
+    /^## Tribunal Integration.*?(?=\n## |$)/gms,
+    /^### ✅ Pre-Flight Self-Audit.*?(?=\n###|\n## |$)/gms,
+    /^## Pre-Flight Self-Audit.*?(?=\n## |$)/gms,
+    /^## Output Format\b.*?(?=\n## |$)/gms,
+    /^## 🔧 Runtime Scripts.*?(?=\n## |$)/gms,
+    /^## 🔴 MANDATORY.*?(?=\n## |$)/gms,
+    /^## ⚠️ CRITICAL: ASK BEFORE ASSUMING.*?(?=\n## |$)/gms,
+    /^## 📝 CHECKPOINT \(MANDATORY.*?(?=\n## |$)/gms,
+    /^## Output Format.*?```\n[^`]*```\n?(?=\n## |$)/gms,
+    /^\*\*Execute these for validation.*?---\n/gms,
+    /^\*\*VBC \(Verification-Before-Completion\).*?\n/gms,
+    /^\*\*⛔ DO NOT start.*?---\n?/gms,
+    /^> 🧠 \*\*mobile-design.*?\n/gms,
+    /^> \*\*STOP.*?\n/gms,
+];
+
+function adjustHeadings(content, offset = 1) {
+    const lines = content.split('\n');
+    const out = [];
+    for (let line of lines) {
+        const m = line.match(/^(#{1,5}) /);
+        if (m) {
+            const level = m[1].length;
+            const newLevel = Math.min(level + offset, 6);
+            line = '#'.repeat(newLevel) + line.substring(level);
+        }
+        out.push(line);
+    }
+    return out.join('\n');
+}
+
+function cleanContent(content) {
+    for (const p of STRIP_PATTERNS) {
+        content = content.replace(p, '');
+    }
+    content = content.replace(/\n{3,}/g, '\n\n');
+    return content.trim();
+}
+
+function extractFrontmatter(content) {
+    const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+    if (m) {
+        return [m[1], content.substring(m[0].length)];
+    }
+    return ['', content];
+}
+
+function consolidate(skillDir) {
+    const skillName = path.basename(skillDir);
+    const mainPath = path.join(skillDir, 'SKILL.md');
+    if (!fs.existsSync(mainPath)) return false;
+
+    const files = fs.readdirSync(skillDir);
+    const subFiles = files.filter(f => f.endsWith('.md') && f !== 'SKILL.md').sort();
+
+    if (subFiles.length === 0) return false;
+
+    console.log(`\n  → Consolidating: ${skillName} (${subFiles.length} sub-files)`);
+
+    const mainContent = fs.readFileSync(mainPath, 'utf8');
+    let [frontmatter, mainBody] = extractFrontmatter(mainContent);
+
+    const fmLines = frontmatter.split('\n');
+    const newFm = [];
+    for (const line of fmLines) {
+        if (line.startsWith('version:')) newFm.push('version: 3.1.0');
+        else if (line.startsWith('last-updated:')) newFm.push('last-updated: 2026-04-06');
+        else newFm.push(line);
+    }
+    frontmatter = newFm.join('\n');
+
+    mainBody = cleanContent(mainBody);
+    mainBody = mainBody.replace(/\|.*?\.md.*?\|.*?\|.*?\|\n/g, '');
+    mainBody = mainBody.replace(/^\|[-| ]+\|\n/gm, '');
+    mainBody = mainBody.replace(/\n{3,}/g, '\n\n');
+
+    const mergedSections = [];
+    for (const fname of subFiles) {
+        const fpath = path.join(skillDir, fname);
+        const raw = fs.readFileSync(fpath, 'utf8');
+        let [, body] = extractFrontmatter(raw);
+        body = cleanContent(body);
+        body = adjustHeadings(body, 1);
+        if (body.trim()) {
+            mergedSections.push(body.trim());
+        }
+    }
+
+    let combined = `---\n${frontmatter}\n---\n\n${mainBody}`;
+    if (mergedSections.length > 0) {
+        combined += '\n\n---\n\n' + mergedSections.join('\n\n---\n\n');
+    }
+
+    combined = combined.replace(/\n{3,}/g, '\n\n');
+    combined = combined.trim() + '\n';
+
+    let totalSubBytes = 0;
+    for (const f of subFiles) totalSubBytes += fs.statSync(path.join(skillDir, f)).size;
+    console.log(`     Sub-files total: ${Math.floor(totalSubBytes / 1024)}KB`);
+
+    fs.writeFileSync(mainPath, combined, 'utf8');
+    const newSize = fs.statSync(mainPath).size;
+    console.log(`     New SKILL.md:    ${Math.floor(newSize / 1024)}KB  (from ${Math.floor(Buffer.byteLength(mainContent, 'utf8') / 1024)}KB main + ${Math.floor(totalSubBytes / 1024)}KB subs → ${Math.floor(newSize / 1024)}KB)`);
+
+    for (const fname of subFiles) {
+        fs.unlinkSync(path.join(skillDir, fname));
+        console.log(`     Deleted: ${fname}`);
+    }
+
+    return true;
+}
+
+function main() {
+    const target = process.argv.length > 2 ? process.argv[2] : null;
+
+    let processed = 0;
+    if (!fs.existsSync(BASE)) return;
+
+    for (const skillName of fs.readdirSync(BASE)) {
+        const skillDir = path.join(BASE, skillName);
+        if (!fs.statSync(skillDir).isDirectory()) continue;
+        if (target && skillName !== target) continue;
+        if (consolidate(skillDir)) processed++;
+    }
+
+    if (processed === 0) {
+        console.log('No skills with sub-files found (or target not matched).');
+    } else {
+        console.log(`\n✅ Consolidated ${processed} skills.`);
+    }
+}
+
+if (require.main === module) {
+    main();
+}