tribunal-kit 4.6.1 → 5.8.0

package/bin/wrapper.js

@@ -1,107 +1,138 @@
 #!/usr/bin/env node
 /**
  * Tribunal-Kit Core Wrapper
- * 
+ *
  * This script routes commands to the ultra-fast Rust binary if available and supported.
  * For legacy commands (or if the binary isn't available/compiled yet), it gracefully
  * falls back to the original JavaScript implementation.
  */
 
-const fs = require('fs');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const os = require('os');
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const os = require("os");
 
 // Commands that have been fully ported to Rust so far
-const RUST_COMMANDS = new Set(['init', 'validate', 'status']);
+const RUST_COMMANDS = new Set([
+  "init",
+  "validate",
+  "status",
+  "sync",
+  "hook",
+  "uninstall",
+]);
 
 // Determine the path to the compiled Rust binary
 // In a full production release, this checks optionalDependencies in node_modules
 // For development, it checks the local target/release folder
 function getBinaryPath() {
-    const isWindows = os.platform() === 'win32';
-    const ext = isWindows ? '.exe' : '';
-    const platform = os.platform();
-    const arch = os.arch();
-    
-    // First, try production resolution (from optionalDependencies)
-    const pkgName = `@tribunal-kit/core-${platform}-${arch}`;
-    try {
-        // Try to resolve the binary from the optional dependency package
-        const pkgPath = require.resolve(`${pkgName}/package.json`);
-        const binPath = path.resolve(path.dirname(pkgPath), `bin/tribunal-core${ext}`);
-        if (fs.existsSync(binPath)) {
-            return binPath;
-        }
-    } catch (e) {
-        // Package not found, ignore and fall back to local dev targets
-    }
+  const isWindows = os.platform() === "win32";
+  const ext = isWindows ? ".exe" : "";
+  const platform = os.platform();
+  const arch = os.arch();
 
-    // Second, try to find the binary compiled from crates/core/Cargo.toml (Local dev)
-    const devPath = path.resolve(__dirname, '..', 'target', 'release', `tribunal-core${ext}`);
-    if (fs.existsSync(devPath)) {
-        return devPath;
+  // First, try production resolution (from optionalDependencies)
+  const pkgName = `@tribunal-kit/core-${platform}-${arch}`;
+  try {
+    // Try to resolve the binary from the optional dependency package
+    const pkgPath = require.resolve(`${pkgName}/package.json`);
+    const binPath = path.resolve(
+      path.dirname(pkgPath),
+      `bin/tribunal-core${ext}`,
+    );
+    if (fs.existsSync(binPath)) {
+      return binPath;
     }
+  } catch {
+    // Package not found, ignore and fall back to local dev targets
+  }
 
-    // Third, try target/debug (if they ran `cargo build` instead of `--release`)
-    const debugPath = path.resolve(__dirname, '..', 'target', 'debug', `tribunal-core${ext}`);
-    if (fs.existsSync(debugPath)) {
-        return debugPath;
-    }
+  // Second, try to find the binary compiled from crates/core/Cargo.toml (Local dev)
+  const devPath = path.resolve(
+    __dirname,
+    "..",
+    "target",
+    "release",
+    `tribunal-core${ext}`,
+  );
+  if (fs.existsSync(devPath)) {
+    return devPath;
+  }
+
+  // Third, try target/debug (if they ran `cargo build` instead of `--release`)
+  const debugPath = path.resolve(
+    __dirname,
+    "..",
+    "target",
+    "debug",
+    `tribunal-core${ext}`,
+  );
+  if (fs.existsSync(debugPath)) {
+    return debugPath;
+  }
 
-    return null;
+  return null;
 }
 
 function runRustBinary(binPath, args) {
-    const stdio = ['inherit', process.stdout.isTTY ? 'ignore' : 'inherit', 'inherit'];
-    const result = spawnSync(binPath, args, {
-        stdio: stdio,
-        env: process.env
-    });
-
-    if (result.error) {
-        console.error(`\x1b[91m✖ Failed to execute Rust engine:\x1b[0m ${result.error.message}`);
-        process.exit(1);
-    }
+  const stdio = [
+    "inherit",
+    process.stdout.isTTY ? "ignore" : "inherit",
+    "inherit",
+  ];
+  const result = spawnSync(binPath, args, {
+    stdio: stdio,
+    env: process.env,
+  });
+
+  if (result.error) {
+    console.error(
+      `\x1b[91m✖ Failed to execute Rust engine:\x1b[0m ${result.error.message}`,
+    );
+    process.exit(1);
+  }
 
-    process.exit(result.status || 0);
+  process.exit(result.status || 0);
 }
 
 function runLegacyFallback() {
-    // Graceful fallback to the original JS implementation
-    // We do this by modifying process.argv so it appears normal to the legacy script
-    require('./tribunal-kit.js');
+  // Use the modular dist/ CLI with lazy-loaded commands for faster cold-start.
+  // Each command module is require()'d only when invoked (~70% fewer files loaded).
+  const { main } = require("../dist/cli.js");
+  main();
 }
 
 function main() {
-    // Skip 'node' and 'wrapper.js'
-    const args = process.argv.slice(2);
-    
-    // Extract the command (the first non-flag argument)
-    const command = args.find(a => !a.startsWith('-'));
-
-    if (command && RUST_COMMANDS.has(command)) {
-        const binPath = getBinaryPath();
-        
-        if (binPath) {
-            // For the init command, Rust needs to know where the .agent template folder is.
-            if (command === 'init') {
-                const sourceDir = path.resolve(__dirname, '..', '.agent');
-                args.push('--source-dir', sourceDir);
-            }
-
-            // Route to Rust engine
-            // console.log('\x1b[90m⚡ Executing via Rust Core Engine\x1b[0m');
-            runRustBinary(binPath, args);
-            return;
-        } else {
-            // Warn if Rust command was requested but binary is missing
-            console.warn('\x1b[93m⚠ Rust binary not found in target/. Falling back to JS engine.\x1b[0m');
-        }
+  // Skip 'node' and 'wrapper.js'
+  const args = process.argv.slice(2);
+
+  // Extract the command (the first non-flag argument)
+  const command = args.find((a) => !a.startsWith("-"));
+
+  if (command && RUST_COMMANDS.has(command)) {
+    const binPath = getBinaryPath();
+
+    if (binPath) {
+      // For the init command, Rust needs to know where the .agent template folder is.
+      if (command === "init") {
+        const sourceDir = path.resolve(__dirname, "..", ".agent");
+        args.push("--source-dir", sourceDir);
+      }
+
+      // Route to Rust engine
+      // console.log('\x1b[90m⚡ Executing via Rust Core Engine\x1b[0m');
+      runRustBinary(binPath, args);
+      return;
+    } else {
+      // Warn if Rust command was requested but binary is missing
+      console.warn(
+        "\x1b[93m⚠ Rust binary not found in target/. Falling back to JS engine.\x1b[0m",
+      );
     }
+  }
 
-    // Fall back to JS logic for un-ported commands (e.g. `learn`, `case`, `marathon`)
-    runLegacyFallback();
+  // Fall back to JS logic for un-ported commands (e.g. `learn`, `case`, `marathon`)
+  runLegacyFallback();
 }
 
 main();

package/dist/cli.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * tribunal-kit CLI Core (TypeScript version)
+ *
+ * Commands are lazy-loaded: only the invoked command's module is require()'d.
+ * This means `tk status` loads ~4 files instead of ~17, cutting startup I/O by ~70%.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const logger_1 = require("./utils/logger");
+const helpers_1 = require("./utils/helpers");
+const PKG = require('../package.json');
+const CURRENT_VERSION = PKG.version;
+// ── Arg Parser ───────────────────────────────────────────
+function parseArgs(argv) {
+    const args = { command: null, flags: {} };
+    const raw = argv.slice(2);
+    // First non-flag arg is the command
+    for (const arg of raw) {
+        if (!arg.startsWith('--') && !args.command) {
+            args.command = arg;
+            continue;
+        }
+        if (arg === '--force') {
+            args.flags.force = true;
+            continue;
+        }
+        if (arg === '--quiet') {
+            args.flags.quiet = true;
+            continue;
+        }
+        if (arg === '--verbose') {
+            args.flags.verbose = true;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            args.flags.dryRun = true;
+            continue;
+        }
+        if (arg === '--minimal') {
+            args.flags.minimal = true;
+            continue;
+        }
+        if (arg === '--skip-update-check') {
+            args.flags.skipUpdateCheck = true;
+            continue;
+        }
+        if (arg === '--head') {
+            args.flags.head = true;
+            continue;
+        }
+        if (arg.startsWith('--path=')) {
+            args.flags.path = arg.split('=').slice(1).join('=');
+        }
+        if (arg === '--path') {
+            const idx = raw.indexOf('--path');
+            const nextVal = raw[idx + 1];
+            if (!nextVal || nextVal.startsWith('--')) {
+                console.error(`  \x1b[91m✖ --path requires a directory argument\x1b[0m`);
+                process.exit(1);
+            }
+            args.flags.path = nextVal;
+        }
+        if (arg.startsWith('--target=')) {
+            args.flags.target = arg.split('=').slice(1).join('=');
+        }
+        if (arg === '--target') {
+            const idx = raw.indexOf('--target');
+            const nextVal = raw[idx + 1];
+            if (!nextVal || nextVal.startsWith('--')) {
+                console.error(`  \x1b[91m✖ --target requires an argument\x1b[0m`);
+                process.exit(1);
+            }
+            args.flags.target = nextVal;
+        }
+        if (arg.startsWith('--branch=')) {
+            args.flags.branch = arg.split('=').slice(1).join('=');
+        }
+    }
+    return args;
+}
+function cmdHelp(quiet = false) {
+    (0, helpers_1.banner)(quiet);
+    const cmd = (name, desc) => `  ${(0, logger_1.c)('cyan', name.padEnd(10))}  ${(0, logger_1.c)('gray', desc)}`;
+    const opt = (flag, desc) => `  ${(0, logger_1.c)('yellow', flag.padEnd(22))}  ${(0, logger_1.c)('gray', desc)}`;
+    const ex = (s) => `  ${(0, logger_1.c)('gray', '▸')} ${(0, logger_1.c)('white', s)}`;
+    (0, logger_1.log)((0, logger_1.bold)('  Commands'));
+    (0, logger_1.log)(`  ${(0, logger_1.c)('gray', '─'.repeat(40))}`);
+    (0, logger_1.log)(cmd('init', 'Install .agent/ into current project'));
+    (0, logger_1.log)(cmd('update', 'Re-install to get latest version'));
+    (0, logger_1.log)(cmd('status', 'Check if .agent/ is installed'));
+    (0, logger_1.log)(cmd('learn', 'Evolve project idioms based on git diffs'));
+    (0, logger_1.log)(cmd('case', 'Manage Case Law precedents (add, search, list, show, stats, overrule)'));
+    (0, logger_1.log)(cmd('graph', 'Build and visualize the architecture graph'));
+    (0, logger_1.log)(cmd('mutate', 'Run the Mutation Engine to test test-suite reliability'));
+    (0, logger_1.log)(cmd('context', 'Retrieve a highly-optimized Context Snapshot for a file'));
+    (0, logger_1.log)(cmd('sync', 'Synchronize IDE bridge files with current rules'));
+    (0, logger_1.log)(cmd('marathon', 'Long-running agent harness (init, status, next, mark)'));
+    (0, logger_1.log)(cmd('hook', 'Install pre-push git hook for auto-learning'));
+    (0, logger_1.log)(cmd('compile', 'Compile rules into a static instruction file for terminal agents'));
+    (0, logger_1.log)(cmd('memory', '4-Type Taxonomy Persistent Memory Engine (store, recall, gc, stats, export)'));
+    (0, logger_1.log)(cmd('uninstall', 'Remove .agent/ folder from project'));
+    console.log();
+    (0, logger_1.log)((0, logger_1.bold)('  Options'));
+    (0, logger_1.log)(`  ${(0, logger_1.c)('gray', '─'.repeat(40))}`);
+    (0, logger_1.log)(opt('--force', 'Overwrite existing .agent/ folder'));
+    (0, logger_1.log)(opt('--path <dir>', 'Install in specific directory'));
+    (0, logger_1.log)(opt('--target <name>', 'Target terminal agent for compile (e.g. aider)'));
+    (0, logger_1.log)(opt('--quiet', 'Suppress all output'));
+    (0, logger_1.log)(opt('--verbose', 'Show detailed debug logging'));
+    (0, logger_1.log)(opt('--dry-run', 'Preview actions without executing'));
+    (0, logger_1.log)(opt('--minimal', 'Install core agents/skills only (~13 agents)'));
+    (0, logger_1.log)(opt('--skip-update-check', 'Skip auto-update version check'));
+    (0, logger_1.log)(opt('--head', '(learn) Diff against last commit instead of staged'));
+    console.log();
+    (0, logger_1.log)((0, logger_1.bold)('  Aliases'));
+    (0, logger_1.log)(`  ${(0, logger_1.c)('gray', '─'.repeat(40))}`);
+    (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', 'tk')}  ${(0, logger_1.c)('gray', 'Shorthand for tribunal-kit (e.g., tk init, tk status)')}`);
+    console.log();
+    (0, logger_1.log)((0, logger_1.bold)('  Examples'));
+    (0, logger_1.log)(`  ${(0, logger_1.c)('gray', '─'.repeat(40))}`);
+    (0, logger_1.log)(ex('npx tribunal-kit init'));
+    (0, logger_1.log)(ex('tk init --force'));
+    (0, logger_1.log)(ex('tk init --path ./my-app'));
+    (0, logger_1.log)(ex('npx tribunal-kit init --dry-run'));
+    (0, logger_1.log)(ex('tk update'));
+    (0, logger_1.log)(ex('tk status'));
+    (0, logger_1.log)(ex('tk learn'));
+    (0, logger_1.log)(ex('tk learn --dry-run'));
+    (0, logger_1.log)(ex('tk learn --head'));
+    (0, logger_1.log)(ex('tk case add'));
+    (0, logger_1.log)(ex('tk case search "useEffect"'));
+    (0, logger_1.log)(ex('tk case list'));
+    (0, logger_1.log)(ex('tk case show --id 1'));
+    (0, logger_1.log)(ex('tk case stats'));
+    (0, logger_1.log)(ex('tk case export'));
+    (0, logger_1.log)(ex('tk case overrule --id 1'));
+    (0, logger_1.log)(ex('tk graph'));
+    (0, logger_1.log)(ex('tk mutate src/utils.js "npm test"'));
+    (0, logger_1.log)(ex('tk marathon init "Build a todo app"'));
+    (0, logger_1.log)(ex('tk marathon status'));
+    (0, logger_1.log)(ex('tk marathon next'));
+    (0, logger_1.log)(ex('tk marathon mark 5 pass'));
+    (0, logger_1.log)(ex('tk hook'));
+    (0, logger_1.log)(ex('tk compile'));
+    (0, logger_1.log)(ex('tk memory store --type semantic --content "Uses PostgreSQL" --tags db,orm'));
+    (0, logger_1.log)(ex('tk memory recall --query "database" --budget 2000'));
+    (0, logger_1.log)(ex('tk memory gc'));
+    (0, logger_1.log)(ex('tk memory stats'));
+    (0, logger_1.log)(ex('tk memory export'));
+    (0, logger_1.log)(ex('tk uninstall'));
+    console.log();
+}
+// ── Lazy Loaders ─────────────────────────────────────────
+// Each command module is require()'d only when invoked.
+// Running `tk status` loads ~4 files instead of ~17.
+function loadCmd(modulePath, exportName) {
+    return require(modulePath)[exportName];
+}
+async function runWithUpdateCheck(command, flags) {
+    const shouldSkip = flags.skipUpdateCheck || process.env.TK_SKIP_UPDATE_CHECK === '1';
+    if (!shouldSkip && (command === 'init' || command === 'update')) {
+        // version.ts is only loaded for init/update — not every command
+        const { autoUpdateCheck } = require('./utils/version');
+        const originalArgs = process.argv.slice(2);
+        const didReInvoke = await autoUpdateCheck(originalArgs, CURRENT_VERSION);
+        if (didReInvoke) {
+            process.exit(0);
+        }
+    }
+    const quiet = flags.quiet || false;
+    switch (command) {
+        case 'init': {
+            const cmdInit = loadCmd('./commands/init', 'cmdInit');
+            await cmdInit(flags, quiet);
+            break;
+        }
+        case 'update': {
+            const cmdUpdate = loadCmd('./commands/update', 'cmdUpdate');
+            await cmdUpdate(flags);
+            break;
+        }
+        case 'status': {
+            const cmdStatus = loadCmd('./commands/status', 'cmdStatus');
+            cmdStatus(flags, quiet);
+            break;
+        }
+        case 'learn': {
+            const cmdLearn = loadCmd('./commands/learn', 'cmdLearn');
+            await cmdLearn(flags, quiet);
+            break;
+        }
+        case 'case': {
+            const cmdCase = loadCmd('./commands/case', 'cmdCase');
+            await cmdCase(flags, process.argv, quiet);
+            break;
+        }
+        case 'hook': {
+            const cmdHook = loadCmd('./commands/hook', 'cmdHook');
+            cmdHook(flags);
+            break;
+        }
+        case 'graph': {
+            const cmdGraph = loadCmd('./commands/graph', 'cmdGraph');
+            await cmdGraph(flags, quiet);
+            break;
+        }
+        case 'mutate': {
+            const cmdMutate = loadCmd('./commands/mutate', 'cmdMutate');
+            await cmdMutate(flags, process.argv);
+            break;
+        }
+        case 'context': {
+            const cmdContext = loadCmd('./commands/context', 'cmdContext');
+            cmdContext(flags, process.argv);
+            break;
+        }
+        case 'sync': {
+            const cmdSync = loadCmd('./commands/sync', 'cmdSync');
+            await cmdSync();
+            break;
+        }
+        case 'marathon': {
+            const cmdMarathon = loadCmd('./commands/marathon', 'cmdMarathon');
+            await cmdMarathon(flags, process.argv, quiet);
+            break;
+        }
+        case 'compile': {
+            const cmdCompile = loadCmd('./commands/compile', 'cmdCompile');
+            await cmdCompile(flags, quiet);
+            break;
+        }
+        case 'uninstall': {
+            const cmdUninstall = loadCmd('./commands/uninstall', 'cmdUninstall');
+            cmdUninstall(flags, quiet);
+            break;
+        }
+        case 'memory': {
+            const cmdMemory = loadCmd('./commands/memory', 'cmdMemory');
+            await cmdMemory(flags, process.argv, quiet);
+            break;
+        }
+        case 'help':
+        case '--help':
+        case '-h':
+        case null:
+            cmdHelp(quiet);
+            break;
+        default:
+            (0, logger_1.err)(`Unknown command: "${command}"`);
+            console.log();
+            (0, logger_1.dim)('Run tribunal-kit --help for usage');
+            process.exit(1);
+    }
+}
+// ── Main ──────────────────────────────────────────────────
+async function main() {
+    const { command, flags } = parseArgs(process.argv);
+    (0, logger_1.setLogLevels)(flags.quiet || false, flags.verbose || false);
+    await runWithUpdateCheck(command, flags);
+}
+if (require.main === module) {
+    main();
+}

package/dist/commands/case.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdCase = cmdCase;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../utils/logger");
+const helpers_1 = require("../utils/helpers");
+async function cmdCase(flags, processArgs, quiet = false) {
+    const targetDir = flags.path ? path_1.default.resolve(flags.path) : process.cwd();
+    const agentDest = path_1.default.join(targetDir, '.agent');
+    if (!fs_1.default.existsSync(agentDest)) {
+        (0, logger_1.err)('.agent/ not found. Run: npx tribunal-kit init');
+        process.exit(1);
+    }
+    const args = processArgs.slice(3).join(' ');
+    if (!args || args === 'help' || args === '--help' || args === '-h') {
+        (0, helpers_1.banner)(quiet);
+        (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', '\u2554' + '\u2550'.repeat(60) + '\u2557')}`);
+        (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', '\u2551')}${(0, logger_1.bold)((0, logger_1.c)('white', '  Tribunal Case Law Engine \u2014 Supreme Court             '))}${(0, logger_1.c)('cyan', '\u2551')}`);
+        (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', '\u255a' + '\u2550'.repeat(60) + '\u255d')}`);
+        console.log();
+        (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', 'add'.padEnd(10))}  ${(0, logger_1.c)('gray', 'Record a new Case Law rejection pattern')}`);
+        (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', 'search'.padEnd(10))}  ${(0, logger_1.c)('gray', 'Search existing cases (e.g., search "query")')}`);
+        (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', 'list'.padEnd(10))}  ${(0, logger_1.c)('gray', 'List all recorded case law')}`);
+        (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', 'show'.padEnd(10))}  ${(0, logger_1.c)('gray', 'Show full diff for a case (e.g., show --id 1)')}`);
+        (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', 'stats'.padEnd(10))}  ${(0, logger_1.c)('gray', 'Show case law stats by domain/verdict')}`);
+        (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', 'export'.padEnd(10))}  ${(0, logger_1.c)('gray', 'Export all cases to Markdown')}`);
+        (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', 'overrule'.padEnd(10))}  ${(0, logger_1.c)('gray', 'Overrule a past precedent (e.g., overrule --id 1)')}`);
+        console.log();
+        process.exit(1);
+    }
+    const caseLawScript = path_1.default.join(agentDest, 'scripts', 'case_law_manager.js');
+    // Make shorthand aliases
+    let pyArgs = args;
+    if (pyArgs.startsWith('add'))
+        pyArgs = pyArgs.replace(/^add/, 'add-case');
+    if (pyArgs.startsWith('search'))
+        pyArgs = pyArgs.replace(/^search/, 'search-cases');
+    try {
+        await (0, helpers_1.runShellAsync)(`node "${caseLawScript}" ${pyArgs}`, { stdio: 'inherit', cwd: targetDir });
+        // Memory Bridge: When a case is added, auto-store a SEMANTIC memory
+        if (args.startsWith('add')) {
+            try {
+                const { _memoryStore } = require('./memory');
+                // Extract a summary from the add-case args (best effort)
+                const contentMatch = args.match(/--violation\s+"([^"]+)"/i) || args.match(/--violation\s+(\S+)/i);
+                const domainMatch = args.match(/--domain\s+"([^"]+)"/i) || args.match(/--domain\s+(\S+)/i);
+                const violation = contentMatch ? contentMatch[1] : 'Unknown violation';
+                const domain = domainMatch ? domainMatch[1] : 'general';
+                _memoryStore(
+                    agentDest,
+                    'semantic',
+                    `CASE LAW REJECTION: ${violation} (domain: ${domain})`,
+                    ['case-law', domain, 'rejection'],
+                    null
+                );
+                if (!quiet) {
+                    (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', '\u25b8')} Memory bridge: case law rejection stored to memory index`);
+                }
+            } catch {
+                // Non-critical — case law was still saved, memory bridge is a bonus
+            }
+        }
+    }
+    catch {
+        process.exit(1); // Script already prints errors
+    }
+}

package/dist/commands/compile.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdCompile = cmdCompile;
+
+const fs = require("fs");
+const path = require("path");
+const { log, err, ok, c, bold, dbg } = require("../utils/logger");
+
+async function cmdCompile(flags, quiet) {
+    const cwd = process.cwd();
+    const agentDir = path.join(cwd, ".agent");
+    
+    if (!fs.existsSync(agentDir)) {
+        err("Tribunal Kit is not installed in this directory (.agent folder missing). Run 'tk init' first.");
+        process.exit(1);
+    }
+
+    log(bold("Compiling Tribunal Kit rules..."));
+    
+    let compiledContext = "# Tribunal Kit Context\n\n";
+    compiledContext += "The following are rules, agents, and skills from the Tribunal Kit.\n\n";
+
+    // 1. Read GEMINI.md
+    const geminiPath = path.join(agentDir, "rules", "GEMINI.md");
+    if (fs.existsSync(geminiPath)) {
+        compiledContext += "## Global Rules (GEMINI.md)\n\n";
+        compiledContext += fs.readFileSync(geminiPath, "utf-8") + "\n\n";
+    }
+
+    // 2. Read Agents
+    const agentsDir = path.join(agentDir, "agents");
+    if (fs.existsSync(agentsDir)) {
+        compiledContext += "## Agents\n\n";
+        const agents = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+        for (const file of agents) {
+            const content = fs.readFileSync(path.join(agentsDir, file), "utf-8");
+            compiledContext += `### Agent: ${file}\n\n`;
+            compiledContext += content + "\n\n";
+        }
+    }
+
+    // 3. Read Skills
+    const skillsDir = path.join(agentDir, "skills");
+    if (fs.existsSync(skillsDir)) {
+        compiledContext += "## Skills\n\n";
+        const skills = fs.readdirSync(skillsDir, { withFileTypes: true });
+        for (const dirent of skills) {
+            if (dirent.isDirectory()) {
+                const skillPath = path.join(skillsDir, dirent.name, "SKILL.md");
+                if (fs.existsSync(skillPath)) {
+                    const content = fs.readFileSync(skillPath, "utf-8");
+                    compiledContext += `### Skill: ${dirent.name}\n\n`;
+                    compiledContext += content + "\n\n";
+                }
+            }
+        }
+    }
+
+    // 4. Read Workflows
+    const workflowsDir = path.join(agentDir, "workflows");
+    if (fs.existsSync(workflowsDir)) {
+        compiledContext += "## Workflows\n\n";
+        const workflows = fs.readdirSync(workflowsDir).filter(f => f.endsWith('.md'));
+        for (const file of workflows) {
+            const content = fs.readFileSync(path.join(workflowsDir, file), "utf-8");
+            compiledContext += `### Workflow: ${file}\n\n`;
+            compiledContext += content + "\n\n";
+        }
+    }
+
+    let targetFile = ".tribunal-compiled.md";
+    if (flags.target) {
+        if (flags.target === "aider") targetFile = ".aider.conf.yml";
+        if (flags.target === "claude") targetFile = ".claude.json";
+    }
+    
+    const outputPath = path.join(cwd, targetFile);
+    fs.writeFileSync(outputPath, compiledContext, "utf-8");
+    
+    ok(`Compiled rules written to ${c('cyan', targetFile)}`);
+    if (!quiet) {
+        log(`  ${c('gray', 'Load this file into your terminal agent (e.g. Claude Code, Aider, OpenCode)')}`);
+    }
+}