@samoradc/tetrad 0.1.6

package/README.md

@@ -0,0 +1,137 @@
+# Tetrad
+
+[![npm](https://img.shields.io/npm/v/tetrad.svg)](https://www.npmjs.com/package/tetrad)
+[![CI](https://github.com/SamoraDC/Tetrad/actions/workflows/ci.yml/badge.svg)](https://github.com/SamoraDC/Tetrad/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+> Quadruple Consensus MCP Server for Claude Code
+
+**Tetrad** is a high-performance MCP (Model Context Protocol) server that orchestrates three AI-powered CLI tools (Codex, Gemini CLI, Qwen) to validate all code produced by Claude Code.
+
+## Quick Start
+
+### 1. Initialize in your project
+
+```bash
+npx tetrad init
+```
+
+This will:
+- Create `tetrad.toml` configuration file
+- Create `.tetrad/` directory for the database
+- Add `.tetrad/` to your `.gitignore`
+
+### 2. Add to Claude Code
+
+```bash
+# Add as MCP server (available in all projects)
+claude mcp add --scope user tetrad -- npx tetrad serve
+
+# Or for current project only
+claude mcp add tetrad -- npx tetrad serve
+```
+
+### 3. Verify
+
+```bash
+# Check version
+npx tetrad version
+
+# Check CLI availability
+npx tetrad status
+
+# Diagnose issues
+npx tetrad doctor
+```
+
+## Commands
+
+```bash
+npx tetrad init              # Initialize config in current directory
+npx tetrad serve             # Start MCP server (used by Claude Code)
+npx tetrad status            # Show CLI status (codex, gemini, qwen)
+npx tetrad config            # Interactive configuration
+npx tetrad doctor            # Diagnose configuration issues
+npx tetrad version           # Show version
+npx tetrad evaluate -c CODE  # Manual code evaluation (without MCP)
+npx tetrad history           # Show evaluation history from ReasoningBank
+```
+
+## Manual MCP Configuration
+
+Add to your `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "tetrad": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["tetrad", "serve"]
+    }
+  }
+}
+```
+
+## Requirements
+
+Tetrad requires at least one of these AI CLI tools:
+
+- **Codex CLI** (OpenAI): `npm install -g @openai/codex`
+- **Gemini CLI** (Google): `npm install -g @google/gemini-cli`
+- **Qwen CLI** (Alibaba): `pip install dashscope`
+
+## Features
+
+- **Quadruple Consensus**: 4 AI models must agree to approve code
+- **ReasoningBank**: Continuous learning system with SQLite
+- **High Performance**: Written in Rust
+- **LRU Cache**: Result caching with configurable TTL
+- **Hook System**: Pre/post evaluation callbacks
+- **Auto .gitignore**: Automatically ignores local data
+
+## Configuration
+
+After `npx tetrad init`, edit `tetrad.toml`:
+
+```toml
+[general]
+log_level = "info"
+timeout_secs = 60
+
+[executors.codex]
+enabled = true
+command = "codex"
+args = ["exec", "--json"]
+
+[executors.gemini]
+enabled = true
+command = "gemini"
+args = ["-o", "json"]
+
+[executors.qwen]
+enabled = true
+command = "qwen"
+
+[consensus]
+default_rule = "strong"  # golden, strong, weak
+min_score = 70
+max_loops = 3
+
+[reasoning]
+enabled = true
+db_path = ".tetrad/tetrad.db"
+
+[cache]
+enabled = true
+capacity = 1000
+ttl_secs = 300
+```
+
+## Documentation
+
+Full documentation: [GitHub Repository](https://github.com/SamoraDC/Tetrad)
+
+## License
+
+MIT

package/bin/tetrad.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+/**
+ * Tetrad MCP - CLI wrapper
+ *
+ * This script executes the Tetrad binary with the provided arguments.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const BINARY_NAME = process.platform === 'win32' ? 'tetrad.exe' : 'tetrad';
+const binaryPath = path.join(__dirname, BINARY_NAME);
+
+// Check if binary exists
+if (!fs.existsSync(binaryPath)) {
+  console.error('Error: Tetrad binary not found.');
+  console.error('');
+  console.error('The binary should have been installed during npm install.');
+  console.error('Try reinstalling: npm install -g tetrad');
+  console.error('');
+  console.error('Or install manually:');
+  console.error('  cargo install tetrad');
+  console.error('  sudo cp ~/.cargo/bin/tetrad /usr/local/bin/');
+  process.exit(1);
+}
+
+// Pass all arguments to the binary
+const args = process.argv.slice(2);
+
+const child = spawn(binaryPath, args, {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+child.on('error', (err) => {
+  console.error(`Failed to start Tetrad: ${err.message}`);
+  process.exit(1);
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.exit(1);
+  }
+  process.exit(code || 0);
+});

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@samoradc/tetrad",
+  "version": "0.1.6",
+  "description": "Quadruple Consensus MCP Server for Claude Code - Validates code using Codex, Gemini and Qwen",
+  "keywords": [
+    "mcp",
+    "claude",
+    "claude-code",
+    "code-review",
+    "ai",
+    "consensus",
+    "codex",
+    "gemini",
+    "qwen"
+  ],
+  "author": "SamoraDC",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SamoraDC/Tetrad.git"
+  },
+  "homepage": "https://github.com/SamoraDC/Tetrad#readme",
+  "bugs": {
+    "url": "https://github.com/SamoraDC/Tetrad/issues"
+  },
+  "bin": {
+    "tetrad": "bin/tetrad.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js"
+  },
+  "dependencies": {
+    "tar": "^6.2.0",
+    "adm-zip": "^0.5.10"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}

package/scripts/install.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+/**
+ * Tetrad MCP - Binary installer
+ *
+ * Downloads the correct pre-compiled binary for the current platform
+ * from GitHub Releases.
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const zlib = require('zlib');
+
+const PACKAGE_VERSION = require('../package.json').version;
+const GITHUB_REPO = 'SamoraDC/Tetrad';
+const BINARY_NAME = process.platform === 'win32' ? 'tetrad.exe' : 'tetrad';
+
+// Map Node.js platform/arch to Rust target triples
+const PLATFORM_MAP = {
+  'darwin-x64': 'x86_64-apple-darwin',
+  'darwin-arm64': 'aarch64-apple-darwin',
+  'linux-x64': 'x86_64-unknown-linux-gnu',
+  'linux-arm64': 'aarch64-unknown-linux-gnu',
+  'win32-x64': 'x86_64-pc-windows-msvc',
+};
+
+function getPlatformKey() {
+  return `${process.platform}-${process.arch}`;
+}
+
+function getTargetTriple() {
+  const key = getPlatformKey();
+  const triple = PLATFORM_MAP[key];
+
+  if (!triple) {
+    console.error(`Unsupported platform: ${key}`);
+    console.error(`Supported platforms: ${Object.keys(PLATFORM_MAP).join(', ')}`);
+    process.exit(1);
+  }
+
+  return triple;
+}
+
+function getDownloadUrl(version, target) {
+  const ext = process.platform === 'win32' ? 'zip' : 'tar.gz';
+  return `https://github.com/${GITHUB_REPO}/releases/download/v${version}/tetrad-${target}.${ext}`;
+}
+
+function downloadFile(url) {
+  return new Promise((resolve, reject) => {
+    const followRedirects = (url, redirectCount = 0) => {
+      if (redirectCount > 5) {
+        reject(new Error('Too many redirects'));
+        return;
+      }
+
+      https.get(url, (response) => {
+        if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+          followRedirects(response.headers.location, redirectCount + 1);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
+          return;
+        }
+
+        const chunks = [];
+        response.on('data', (chunk) => chunks.push(chunk));
+        response.on('end', () => resolve(Buffer.concat(chunks)));
+        response.on('error', reject);
+      }).on('error', reject);
+    };
+
+    followRedirects(url);
+  });
+}
+
+async function extractTarGz(buffer, destDir) {
+  const tar = require('tar');
+  const tmpFile = path.join(destDir, 'temp.tar.gz');
+
+  // Write buffer to temp file
+  fs.writeFileSync(tmpFile, buffer);
+
+  // Extract using tar
+  await tar.extract({
+    file: tmpFile,
+    cwd: destDir,
+  });
+
+  // Clean up temp file
+  fs.unlinkSync(tmpFile);
+}
+
+async function extractZip(buffer, destDir) {
+  const AdmZip = require('adm-zip');
+  const zip = new AdmZip(buffer);
+  zip.extractAllTo(destDir, true);
+}
+
+async function installBinaryFromCargo() {
+  console.log('Attempting to install via cargo...');
+  try {
+    execSync('cargo install tetrad', { stdio: 'inherit' });
+
+    // Find the installed binary
+    const cargoHome = process.env.CARGO_HOME || path.join(require('os').homedir(), '.cargo');
+    const cargoBin = path.join(cargoHome, 'bin', BINARY_NAME);
+
+    if (fs.existsSync(cargoBin)) {
+      const destPath = path.join(__dirname, '..', 'bin', BINARY_NAME);
+      fs.copyFileSync(cargoBin, destPath);
+      fs.chmodSync(destPath, 0o755);
+      console.log('Successfully installed tetrad via cargo');
+      return true;
+    }
+  } catch (err) {
+    console.log('Cargo installation failed, will try GitHub releases...');
+  }
+  return false;
+}
+
+async function main() {
+  const binDir = path.join(__dirname, '..', 'bin');
+  const binaryPath = path.join(binDir, BINARY_NAME);
+
+  // Skip if binary already exists
+  if (fs.existsSync(binaryPath)) {
+    console.log('Tetrad binary already installed');
+    return;
+  }
+
+  // Ensure bin directory exists
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
+
+  const target = getTargetTriple();
+  const url = getDownloadUrl(PACKAGE_VERSION, target);
+
+  console.log(`Installing Tetrad v${PACKAGE_VERSION} for ${target}...`);
+  console.log(`Downloading from: ${url}`);
+
+  try {
+    const buffer = await downloadFile(url);
+
+    if (process.platform === 'win32') {
+      await extractZip(buffer, binDir);
+    } else {
+      await extractTarGz(buffer, binDir);
+    }
+
+    // Make binary executable
+    if (process.platform !== 'win32') {
+      fs.chmodSync(binaryPath, 0o755);
+    }
+
+    console.log('Tetrad installed successfully!');
+
+  } catch (err) {
+    console.error(`Failed to download pre-built binary: ${err.message}`);
+    console.log('');
+    console.log('Trying fallback installation via cargo...');
+
+    const cargoInstalled = await installBinaryFromCargo();
+
+    if (!cargoInstalled) {
+      console.error('');
+      console.error('Could not install Tetrad automatically.');
+      console.error('');
+      console.error('Please install manually:');
+      console.error('  1. Install Rust: https://rustup.rs/');
+      console.error('  2. Run: cargo install tetrad');
+      console.error('  3. Copy binary: sudo cp ~/.cargo/bin/tetrad /usr/local/bin/');
+      console.error('');
+      process.exit(1);
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error('Installation failed:', err);
+  process.exit(1);
+});