tribunal-kit 5.7.0 → 5.8.0

package/bin/wrapper.js

@@ -1,108 +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', 'sync', 'hook', 'uninstall']);
+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() {
-    // 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();
+  // 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

@@ -62,6 +62,18 @@ function parseArgs(argv) {
             }
             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('=');
         }
@@ -86,12 +98,15 @@ function cmdHelp(quiet = false) {
     (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'));
@@ -128,6 +143,12 @@ function cmdHelp(quiet = false) {
     (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();
 }
@@ -205,11 +226,21 @@ async function runWithUpdateCheck(command, flags) {
             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':

package/dist/commands/case.js

@@ -41,6 +41,29 @@ async function cmdCase(flags, processArgs, quiet = false) {
         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)')}`);
+    }
+}

package/dist/commands/init.js

@@ -281,6 +281,47 @@ async function generateIDEBridges(targetDir, agentDest, dryRun = false) {
 # Auto-generated by tribunal-kit init. Do not edit manually.
 # Source: .agent/rules/GEMINI.md
 
+${rulesContent}
+`;
+    // ── 2. Windsurf (.windsurfrules) ─────────────────────
+    const windsurfRules = `# Tribunal Kit — Windsurf Bridge
+# Auto-generated by tribunal-kit init. Do not edit manually.
+# Source: .agent/rules/GEMINI.md
+
+${rulesContent}
+`;
+    // ── 3. Gemini / Antigravity (.gemini/settings.json) ──
+    const geminiSettings = JSON.stringify({
+        "rules": [
+            { "path": "../.agent/rules/GEMINI.md", "trigger": "always_on" }
+        ],
+        "agents": { "directory": "../.agent/agents" },
+        "skills": { "directory": "../.agent/skills" },
+        "workflows": { "directory": "../.agent/workflows" }
+    }, null, 2) + '\n';
+    // ── Also create .gemini/GEMINI.md as a direct rules file ──
+    const geminiRulesBridge = `---
+trigger: always_on
+---
+
+# Tribunal Kit — Gemini Bridge
+# Auto-generated by tribunal-kit init.
+# Full rules: .agent/rules/GEMINI.md
+
+${rulesContent}
+`;
+    // ── 4. GitHub Copilot (.github/copilot-instructions.md) ──
+    const copilotInstructions = `# Tribunal Kit — Copilot Bridge
+# Auto-generated by tribunal-kit init. Do not edit manually.
+# Source: .agent/rules/GEMINI.md
+
+${rulesContent}
+`;
+    // ── 5. Claude (.claude/CLAUDE.md) ─────────────────────
+    const claudeRules = `# Tribunal Kit — Claude Bridge
+# Auto-generated by tribunal-kit init. Do not edit manually.
+# Source: .agent/rules/GEMINI.md
+
 ${rulesContent}
 `;
     // Fire ALL bridge writes concurrently via Promise.all
@@ -295,3 +336,4 @@ ${rulesContent}
     await Promise.all(bridges.map(b => writeBridge(b.path, b.content, b.label)));
     console.log();
 }
+

package/dist/commands/learn.js

@@ -55,6 +55,63 @@ async function cmdLearn(flags, quiet = false) {
     (0, logger_1.log)(`  ${(0, logger_1.c)('gray', '\u25b8')} Search existing case law:`);
     (0, logger_1.log)(`    ${(0, logger_1.c)('white', 'npx tribunal-kit case search "your query"')}`);
     console.log();
+    // Phase 3: Memory Distillation
+    (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', '\u229b')} ${(0, logger_1.bold)('Phase 3')} \u2014 Memory Distillation (storing project knowledge)`);
+    try {
+        const { _memoryStore } = require('./memory');
+        // Auto-extract SEMANTIC memories from project-idioms if it exists
+        const idiomsPath = path_1.default.join(agentDest, 'skills', 'project-idioms', 'SKILL.md');
+        let memoriesStored = 0;
+        if (fs_1.default.existsSync(idiomsPath)) {
+            const idiomsContent = fs_1.default.readFileSync(idiomsPath, 'utf8');
+            // Extract lines that look like project rules (lines starting with - or * that contain actionable content)
+            const ruleLines = idiomsContent.split('\n')
+                .filter(line => /^[\s]*[-*]\s+/.test(line) && line.trim().length > 20)
+                .map(line => line.replace(/^[\s]*[-*]\s+/, '').trim())
+                .slice(0, 10); // Cap at 10 to prevent bloat
+
+            for (const rule of ruleLines) {
+                try {
+                    _memoryStore(agentDest, 'semantic', rule, ['project-idiom', 'auto-learned'], null);
+                    memoriesStored++;
+                } catch {
+                    // Skip duplicates or capacity errors silently
+                }
+            }
+        }
+        // Auto-extract PROCEDURAL memories from package.json scripts
+        const pkgPath = path_1.default.join(targetDir, 'package.json');
+        if (fs_1.default.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+                if (pkg.scripts) {
+                    const importantScripts = ['build', 'test', 'dev', 'start', 'deploy', 'lint'];
+                    for (const key of importantScripts) {
+                        if (pkg.scripts[key]) {
+                            try {
+                                _memoryStore(agentDest, 'procedural',
+                                    `Run \`${pkg.scripts[key]}\` to ${key} the project`,
+                                    ['build-script', key, 'auto-learned'], null);
+                                memoriesStored++;
+                            } catch {
+                                // Skip
+                            }
+                        }
+                    }
+                }
+            } catch {
+                // Unreadable package.json
+            }
+        }
+        if (memoriesStored > 0) {
+            (0, logger_1.log)(`    ${(0, logger_1.c)('green', '\u2714')} ${memoriesStored} memories auto-stored (semantic + procedural)`);
+        } else {
+            (0, logger_1.log)(`    ${(0, logger_1.c)('gray', '\u25b8')} No new memories to distill (run again after committing changes)`);
+        }
+    } catch (e) {
+        (0, logger_1.log)(`    ${(0, logger_1.c)('yellow', '\u26a0')} Memory distillation skipped: ${e.message || String(e)}`);
+    }
+    console.log();
     (0, logger_1.log)(`  ${(0, logger_1.c)('green', '\u2714')} ${(0, logger_1.bold)('Learn cycle complete.')} Your Tribunal grows smarter with every commit.`);
     console.log();
 }