tribunal-kit 4.4.4 → 4.5.0

package/bin/wrapper.js

@@ -0,0 +1,98 @@
+#!/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');
+
+// Commands that have been fully ported to Rust so far
+const RUST_COMMANDS = new Set(['init', 'validate', 'status']);
+
+// 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' : '';
+    
+    // First, check bin/ directory (postinstall downloaded binary)
+    const binPath = path.resolve(__dirname, `tribunal-core${ext}`);
+    if (fs.existsSync(binPath)) {
+        return binPath;
+    }
+
+    // Second, try to find the binary compiled from crates/core/Cargo.toml
+    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;
+    }
+
+    // Production resolution (from optionalDependencies) would go here
+    return null;
+}
+
+function runRustBinary(binPath, args) {
+    const result = spawnSync(binPath, args, {
+        stdio: 'inherit',
+        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);
+}
+
+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');
+}
+
+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');
+        }
+    }
+
+    // Fall back to JS logic for un-ported commands (e.g. `learn`, `case`, `marathon`)
+    runLegacyFallback();
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tribunal-kit",
-    "version": "4.4.4",
+    "version": "4.5.0",
     "description": "Anti-Hallucination AI Agent Kit — 40 specialist agents, 32 slash commands, 16 parallel Tribunal reviewers, Performance Swarm engine, Supreme Court case law pipeline, and long-running agent harness.",
     "keywords": [
         "ai",
@@ -42,8 +42,8 @@
     },
     "license": "MIT",
     "bin": {
-        "tribunal-kit": "bin/tribunal-kit.js",
-        "tk": "bin/tribunal-kit.js"
+        "tribunal-kit": "bin/wrapper.js",
+        "tk": "bin/wrapper.js"
     },
     "files": [
         "bin/",
@@ -65,6 +65,7 @@
         "changelog:preview": "node scripts/changelog.js --preview",
         "sync": "node scripts/sync-version.js",
         "validate-payload": "node scripts/validate-payload.js",
+        "postinstall": "node scripts/postinstall.js",
         "build": "echo 'No build step required for this project'"
     },
     "devDependencies": {

package/scripts/postinstall.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/**
+ * postinstall.js — Binary Download Script
+ * 
+ * After `npm install`, this script downloads the pre-compiled Rust binary
+ * for the user's platform from the latest GitHub Release.
+ * 
+ * If the download fails (offline, unsupported platform, etc.), it's a soft failure.
+ * The wrapper.js will detect the missing binary and fall back to the JS engine.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const os = require('os');
+const crypto = require('crypto');
+
+const PKG = require(path.resolve(__dirname, '..', 'package.json'));
+const VERSION = PKG.version;
+
+const BINARY_DIR = path.resolve(__dirname, '..', 'bin');
+const REPO = 'Harmitx7/tribunal-kit';
+
+function getPlatformBinary() {
+    const platform = os.platform();
+    const arch = os.arch();
+
+    const map = {
+        'win32-x64':    'tribunal-core-win-x64.exe',
+        'win32-arm64':  'tribunal-core-win-arm64.exe',
+        'darwin-x64':   'tribunal-core-darwin-x64',
+        'darwin-arm64': 'tribunal-core-darwin-arm64',
+        'linux-x64':    'tribunal-core-linux-x64',
+        'linux-arm64':  'tribunal-core-linux-arm64',
+    };
+
+    const key = `${platform}-${arch}`;
+    return map[key] || null;
+}
+
+function getLocalBinaryPath() {
+    const isWindows = os.platform() === 'win32';
+    return path.join(BINARY_DIR, `tribunal-core${isWindows ? '.exe' : ''}`);
+}
+
+function download(url) {
+    return new Promise((resolve, reject) => {
+        const request = https.get(url, { headers: { 'User-Agent': `tribunal-kit/${VERSION}` } }, (res) => {
+            // Handle redirects (GitHub sends 302 to the actual download URL)
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                download(res.headers.location).then(resolve).catch(reject);
+                return;
+            }
+
+            if (res.statusCode !== 200) {
+                reject(new Error(`HTTP ${res.statusCode}`));
+                return;
+            }
+
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks)));
+            res.on('error', reject);
+        });
+
+        request.on('error', reject);
+        request.setTimeout(30000, () => { request.destroy(); reject(new Error('Timeout')); });
+    });
+}
+
+async function main() {
+    const binaryName = getPlatformBinary();
+
+    if (!binaryName) {
+        console.log(`[tribunal-kit] No pre-built binary for ${os.platform()}-${os.arch()}. Using JS fallback.`);
+        return;
+    }
+
+    const localPath = getLocalBinaryPath();
+
+    // Skip if binary already exists (e.g. dev environment with cargo build)
+    if (fs.existsSync(localPath)) {
+        return;
+    }
+
+    const url = `https://github.com/${REPO}/releases/download/v${VERSION}/${binaryName}`;
+    const checksumsUrl = `https://github.com/${REPO}/releases/download/v${VERSION}/checksums.txt`;
+    
+    console.log(`[tribunal-kit] Downloading native binary for ${os.platform()}-${os.arch()}...`);
+
+    try {
+        // 1. Download checksums file
+        const checksumsData = await download(checksumsUrl);
+        const checksumsText = checksumsData.toString('utf-8');
+        
+        // 2. Extract expected hash
+        const hashMatch = checksumsText.split('\n').find(line => line.includes(binaryName));
+        if (!hashMatch) {
+            throw new Error(`Checksum for ${binaryName} not found in checksums.txt`);
+        }
+        const expectedHash = hashMatch.split(' ')[0].trim();
+
+        // 3. Download binary
+        const data = await download(url);
+
+        // 4. Verify checksum
+        const actualHash = crypto.createHash('sha256').update(data).digest('hex');
+        if (actualHash !== expectedHash) {
+            throw new Error(`Checksum mismatch! Expected ${expectedHash}, got ${actualHash}. Potential tamper detected.`);
+        }
+
+        // 5. Write to disk
+        fs.writeFileSync(localPath, data);
+
+        // Make executable on Unix
+        if (os.platform() !== 'win32') {
+            fs.chmodSync(localPath, 0o755);
+        }
+
+        console.log(`[tribunal-kit] Native binary installed and verified successfully.`);
+    } catch (e) {
+        // Soft failure — wrapper.js will use the JS engine
+        console.log(`[tribunal-kit] Binary download skipped (${e.message}). Using JS fallback.`);
+    }
+}
+
+main();