@frumu/tandem 0.3.3

package/README.md

@@ -0,0 +1,121 @@
+# Tandem Engine CLI (npm Wrapper)
+
+```text
+TTTTT   A   N   N DDDD  EEEEE M   M
+  T    A A  NN  N D   D E     MM MM
+  T   AAAAA N N N D   D EEEE  M M M
+  T   A   A N  NN D   D E     M   M
+  T   A   A N   N DDDD  EEEEE M   M
+```
+
+## What This Is
+
+Prebuilt npm distribution of the Tandem engine for macOS, Linux, and Windows.  
+Installing this package gives you the `tandem-engine` CLI binary without compiling Rust locally.
+
+If you want to build from Rust source instead, use the crate docs in `engine/README.md`.
+
+## Install
+
+```bash
+npm install -g @frumu/tandem
+```
+
+The installer downloads the release asset that matches this package version. Tags and package versions are expected to match (for example, `v0.3.3`).
+
+## Quick Start
+
+Start the engine server:
+
+```bash
+tandem-engine serve --hostname 127.0.0.1 --port 39731
+```
+
+In a second terminal, you can start the TUI:
+
+```bash
+tandem-tui
+```
+
+## Commands
+
+### Serve
+
+```bash
+tandem-engine serve --hostname 127.0.0.1 --port 39731
+```
+
+Options include:
+
+- `--hostname` or `--host`
+- `--port`
+- `--state-dir`
+- `--provider`
+- `--model`
+- `--api-key`
+- `--config`
+- `--api-token`
+
+### Run a Single Prompt
+
+```bash
+tandem-engine run "What is the capital of France?"
+```
+
+### Run a Concurrent Batch
+
+```bash
+cat > tasks.json << 'JSON'
+{
+  "tasks": [
+    { "id": "plan", "prompt": "Create a 3-step rollout plan." },
+    { "id": "risks", "prompt": "List top 5 rollout risks." },
+    { "id": "comms", "prompt": "Draft a short launch update." }
+  ]
+}
+JSON
+
+tandem-engine parallel --json @tasks.json --concurrency 3
+```
+
+### Execute a Tool Directly
+
+```bash
+tandem-engine tool --json '{"tool":"workspace_list_files","args":{"path":"."}}'
+```
+
+### List Providers
+
+```bash
+tandem-engine providers
+```
+
+## Configuration
+
+Tandem Engine merges config from:
+
+1. Environment variables
+2. `managed_config.json`
+3. Project config at `.tandem/config.json`
+4. Global config:
+   - macOS/Linux: `~/.config/tandem/config.json`
+   - Windows: `%APPDATA%\tandem\config.json`
+
+Common provider keys:
+
+- `OPENAI_API_KEY`
+- `ANTHROPIC_API_KEY`
+- `OPENROUTER_API_KEY`
+- `GROQ_API_KEY`
+- `MISTRAL_API_KEY`
+- `TOGETHER_API_KEY`
+- `COHERE_API_KEY`
+- `GITHUB_TOKEN` (Copilot)
+- `AZURE_OPENAI_API_KEY`
+- `VERTEX_API_KEY`
+- `BEDROCK_API_KEY`
+
+## Documentation
+
+- Project docs: https://tandem.frumu.ai/docs
+- GitHub releases: https://github.com/frumu-ai/tandem/releases

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@frumu/tandem",
+  "version": "0.3.3",
+  "description": "Tandem Engine binary distribution",
+  "homepage": "https://tandem.frumu.ai",
+  "bin": {
+    "tandem-engine": "bin/tandem-engine"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js"
+  },
+  "files": [
+    "bin",
+    "scripts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frumu-ai/tandem.git"
+  },
+  "author": "Frumu Ltd",
+  "license": "MIT OR Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}

package/scripts/install.js

@@ -0,0 +1,178 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+
+// Configuration
+const REPO = "frumu-ai/tandem";
+const MIN_SIZE = 1024 * 1024; // 1MB
+
+// Platform mapping
+const PLATFORM_MAP = {
+    'win32': { os: 'windows', ext: '.exe' },
+    'darwin': { os: 'darwin', ext: '' },
+    'linux': { os: 'linux', ext: '' }
+};
+
+const ARCH_MAP = {
+    'x64': 'x64',
+    'arm64': 'arm64'
+};
+
+function getArtifactInfo() {
+    const platform = PLATFORM_MAP[process.platform];
+    const arch = ARCH_MAP[process.arch];
+
+    if (!platform || !arch) {
+        throw new Error(`Unsupported platform: ${process.platform}-${process.arch}`);
+    }
+
+    let artifactName = `tandem-engine-${platform.os}-${arch}`;
+    // Handle specific artifact naming conventions (zip vs tar.gz)
+    if (platform.os === 'windows') {
+        artifactName += '.zip';
+    } else if (platform.os === 'darwin') {
+        artifactName += '.zip';
+    } else {
+        artifactName += '.tar.gz';
+    }
+
+    return {
+        artifactName,
+        binaryName: `tandem-engine${platform.ext}`,
+        isWindows: platform.os === 'windows'
+    };
+}
+
+const { artifactName, binaryName, isWindows } = getArtifactInfo();
+const binDir = path.join(__dirname, '..', 'bin');
+const destPath = path.join(binDir, binaryName);
+
+if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+}
+
+if (fs.existsSync(destPath)) {
+    console.log("Binary already present.");
+    process.exit(0);
+}
+
+// Helper to fetch JSON from GitHub API
+function fetchJson(url) {
+    return new Promise((resolve, reject) => {
+        https.get(url, { headers: { 'User-Agent': 'tandem-engine-installer' } }, (res) => {
+            if (res.statusCode !== 200) {
+                if (res.statusCode === 302 || res.statusCode === 301) {
+                    return fetchJson(res.headers.location).then(resolve).catch(reject);
+                }
+                return reject(new Error(`GitHub API HTTP ${res.statusCode}`));
+            }
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try { resolve(JSON.parse(data)); } catch (e) { reject(e); }
+            });
+        }).on('error', reject);
+    });
+}
+
+// Simplified download
+async function download() {
+    console.log(`Checking releases for ${REPO}...`);
+    const releases = await fetchJson(`https://api.github.com/repos/${REPO}/releases`);
+
+    // Get the version from package.json
+    const packageVersion = require('../package.json').version;
+    const targetTag = `v${packageVersion}`;
+
+    console.log(`Filtering releases for ${REPO} (Target: ${targetTag})...`);
+    // const releases = await fetchJson... <--- REMOVED DUPLICATE
+
+    // 1. Try to find the exact release for this package version
+    let release = releases.find(r => r.tag_name === targetTag);
+
+    if (!release) {
+        console.warn(`Warning: No release found for tag ${targetTag}. Checking for latest compatible assets...`);
+        // 2. Fallback: Find LATEST release that contains our asset (useful for nightly/beta where tags might differ)
+        release = releases.find(r => r.assets.some(a => a.name === artifactName));
+    }
+
+    if (!release) {
+        // Fallback: Check prereleases explicitly if strict filtering was on (it wasn't here)
+        // If not found, maybe name changed?
+        console.error(`Status: No release found with asset ${artifactName}`);
+        console.error("Available assets in latest:", releases[0]?.assets?.map(a => a.name));
+        process.exit(1);
+    }
+
+    const asset = release.assets.find(a => a.name === artifactName);
+    console.log(`Downloading ${asset.name} from ${release.tag_name}...`);
+
+    const file = fs.createWriteStream(path.join(binDir, artifactName));
+
+    return new Promise((resolve, reject) => {
+        const downloadUrl = asset.browser_download_url;
+
+        const request = (url) => {
+            https.get(url, { headers: { 'User-Agent': 'tandem-installer' } }, (res) => {
+                if (res.statusCode === 302 || res.statusCode === 301) {
+                    return request(res.headers.location);
+                }
+                if (res.statusCode !== 200) return reject(new Error(`Download failed: HTTP ${res.statusCode}`));
+                res.pipe(file);
+                file.on('finish', () => {
+                    file.close();
+                    resolve(path.join(binDir, artifactName));
+                });
+            }).on('error', err => {
+                fs.unlink(path.join(binDir, artifactName), () => { }); // cleanup
+                reject(err);
+            });
+        };
+        request(downloadUrl);
+    });
+}
+
+// Extract
+async function extract(archivePath) {
+    console.log("Extracting...");
+    if (isWindows) {
+        execSync(`powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${binDir}' -Force"`);
+    } else {
+        if (artifactName.endsWith('.zip')) {
+            execSync(`unzip -o "${archivePath}" -d "${binDir}"`);
+        } else {
+            execSync(`tar -xzf "${archivePath}" -C "${binDir}"`);
+        }
+    }
+
+    // Cleanup archive
+    fs.unlinkSync(archivePath);
+
+    // Locate binary (it might be inside a folder?)
+    // Our release workflow:
+    // Windows: dist/tandem-engine.exe -> zipped -> dist/tandem-engine.exe
+    // Linux: dist/tandem-engine -> tar -> dist/tandem-engine
+    // So on extraction, it might extract 'dist/tandem-engine' or just 'tandem-engine'.
+    // We should check.
+
+    // If extraction creates a folder (common behavior), we need to find it.
+    // Assuming root extraction for now based on GHA inspect.
+    // 'dist' folder? Yes. The GHA zips "dist/*". So it extracts "tandem-engine.exe" directly if zip didn't preserve root?
+    // "Compress-Archive -Path "dist/*" ... " -> This usually puts files at root of zip.
+
+    if (fs.existsSync(destPath)) {
+        console.log("Verified binary extracted.");
+        if (!isWindows) fs.chmodSync(destPath, 0o755);
+    } else {
+        console.error("Binary not found at expected path:", destPath);
+        // List files
+        console.log("Files in bin:", fs.readdirSync(binDir));
+        process.exit(1);
+    }
+}
+
+download().then(extract).catch(err => {
+    console.error("Install failed:", err);
+    process.exit(1);
+});