smoothie-code 1.0.0

package/dist/blend-cli.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/**
+ * blend-cli.ts — Standalone blend runner for hooks.
+ *
+ * Usage:
+ *   node dist/blend-cli.js "Review this plan: ..."
+ *   echo "plan text" | node dist/blend-cli.js
+ *
+ * Queries Codex + OpenRouter models in parallel, prints JSON results to stdout.
+ * Progress goes to stderr so it doesn't interfere with hook JSON output.
+ */
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { execFile as execFileCb } from 'child_process';
+import { promisify } from 'util';
+import { createInterface } from 'readline';
+const execFile = promisify(execFileCb);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = join(__dirname, '..');
+// ---------------------------------------------------------------------------
+// .env loader
+// ---------------------------------------------------------------------------
+function loadEnv() {
+    try {
+        const env = readFileSync(join(PROJECT_ROOT, '.env'), 'utf8');
+        for (const line of env.split('\n')) {
+            const [key, ...val] = line.split('=');
+            if (key && val.length)
+                process.env[key.trim()] = val.join('=').trim();
+        }
+    }
+    catch {
+        // no .env
+    }
+}
+loadEnv();
+// ---------------------------------------------------------------------------
+// Model queries (same as index.ts)
+// ---------------------------------------------------------------------------
+async function queryCodex(prompt) {
+    try {
+        const tmpFile = join(PROJECT_ROOT, `.codex-out-${Date.now()}.txt`);
+        await execFile('codex', ['exec', '--full-auto', '-o', tmpFile, prompt], {
+            timeout: 90_000,
+        });
+        let response;
+        try {
+            response = readFileSync(tmpFile, 'utf8').trim();
+            const { unlinkSync } = await import('fs');
+            unlinkSync(tmpFile);
+        }
+        catch {
+            response = '';
+        }
+        return { model: 'Codex', response: response || '(empty response)' };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { model: 'Codex', response: `Error: ${message}` };
+    }
+}
+async function queryOpenRouter(prompt, modelId, modelLabel) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 60_000);
+        const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${process.env.OPENROUTER_API_KEY}`,
+                'HTTP-Referer': 'https://hotairbag.github.io/smoothie',
+                'X-Title': 'Smoothie',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: modelId,
+                messages: [{ role: 'user', content: prompt }],
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        const data = (await res.json());
+        const text = data.choices?.[0]?.message?.content ?? 'No response content';
+        return { model: modelLabel, response: text };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { model: modelLabel, response: `Error: ${message}` };
+    }
+}
+// ---------------------------------------------------------------------------
+// Read prompt from arg or stdin
+// ---------------------------------------------------------------------------
+async function getPrompt() {
+    if (process.argv[2])
+        return process.argv[2];
+    // Read from stdin
+    const rl = createInterface({ input: process.stdin });
+    const lines = [];
+    for await (const line of rl) {
+        lines.push(line);
+    }
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+    const args = process.argv.slice(2);
+    const deep = args.includes('--deep');
+    const filteredArgs = args.filter(a => a !== '--deep');
+    // Temporarily override argv for getPrompt
+    process.argv = [process.argv[0], process.argv[1], ...filteredArgs];
+    const prompt = await getPrompt();
+    if (!prompt.trim()) {
+        process.stderr.write('blend-cli: no prompt provided\n');
+        process.exit(1);
+    }
+    let finalPrompt = prompt;
+    if (deep) {
+        // Read context file
+        for (const name of ['GEMINI.md', 'CLAUDE.md', 'AGENTS.md']) {
+            try {
+                const content = readFileSync(join(process.cwd(), name), 'utf8');
+                if (content.trim()) {
+                    finalPrompt = `## Context File\n${content}\n\n## Prompt\n${prompt}`;
+                    break;
+                }
+            }
+            catch {
+                // file not found, try next
+            }
+        }
+        // Add git diff
+        try {
+            const { execFileSync } = await import('child_process');
+            const diff = execFileSync('git', ['diff', 'HEAD~3'], { encoding: 'utf8', maxBuffer: 100 * 1024, timeout: 10000 });
+            if (diff)
+                finalPrompt += `\n\n## Recent Git Diff\n${diff.slice(0, 40000)}`;
+        }
+        catch {
+            // no git diff available
+        }
+    }
+    let config;
+    try {
+        config = JSON.parse(readFileSync(join(PROJECT_ROOT, 'config.json'), 'utf8'));
+    }
+    catch {
+        config = { openrouter_models: [] };
+    }
+    const models = [
+        { fn: () => queryCodex(finalPrompt), label: 'Codex' },
+        ...config.openrouter_models.map((m) => ({
+            fn: () => queryOpenRouter(finalPrompt, m.id, m.label),
+            label: m.label,
+        })),
+    ];
+    process.stderr.write('\n🧃 Smoothie blending...\n\n');
+    for (const { label } of models) {
+        process.stderr.write(`  ⏳ ${label.padEnd(26)} waiting...\n`);
+    }
+    process.stderr.write('\n');
+    const startTimes = {};
+    const promises = models.map(({ fn, label }) => {
+        startTimes[label] = Date.now();
+        return fn()
+            .then((result) => {
+            const elapsed = ((Date.now() - startTimes[label]) / 1000).toFixed(1);
+            process.stderr.write(`  ✓  ${label.padEnd(26)} done (${elapsed}s)\n`);
+            return result;
+        })
+            .catch((err) => {
+            const elapsed = ((Date.now() - startTimes[label]) / 1000).toFixed(1);
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`  ✗  ${label.padEnd(26)} failed (${elapsed}s)\n`);
+            return { model: label, response: `Error: ${message}` };
+        });
+    });
+    const results = await Promise.all(promises);
+    process.stderr.write('\n  ◆  All done.\n\n');
+    // Output JSON to stdout (for hook consumption)
+    process.stdout.write(JSON.stringify({ results }, null, 2));
+}
+main();

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,286 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { execFile as execFileCb, execFileSync } from 'child_process';
+import { promisify } from 'util';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+const execFile = promisify(execFileCb);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = join(__dirname, '..');
+// ---------------------------------------------------------------------------
+// .env loader (no dotenv dependency)
+// ---------------------------------------------------------------------------
+function loadEnv() {
+    try {
+        const env = readFileSync(join(PROJECT_ROOT, '.env'), 'utf8');
+        for (const line of env.split('\n')) {
+            const [key, ...val] = line.split('=');
+            if (key && val.length)
+                process.env[key.trim()] = val.join('=').trim();
+        }
+    }
+    catch {
+        // .env file not found or unreadable — that's fine
+    }
+}
+loadEnv();
+// ---------------------------------------------------------------------------
+// Model query helpers
+// ---------------------------------------------------------------------------
+async function queryCodex(prompt) {
+    try {
+        const tmpFile = join(PROJECT_ROOT, `.codex-out-${Date.now()}.txt`);
+        await execFile('codex', ['exec', '--full-auto', '-o', tmpFile, prompt], {
+            timeout: 90_000,
+        });
+        let response;
+        try {
+            response = readFileSync(tmpFile, 'utf8').trim();
+            const { unlinkSync } = await import('fs');
+            unlinkSync(tmpFile);
+        }
+        catch {
+            response = '';
+        }
+        return { model: 'Codex', response: response || '(empty response)' };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { model: 'Codex', response: `Error: ${message}` };
+    }
+}
+async function queryOpenRouter(prompt, modelId, modelLabel) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 60_000);
+        const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${process.env.OPENROUTER_API_KEY}`,
+                'HTTP-Referer': 'https://hotairbag.github.io/smoothie',
+                'X-Title': 'Smoothie',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: modelId,
+                messages: [{ role: 'user', content: prompt }],
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok) {
+            return { model: modelLabel, response: `Error: HTTP ${res.status} (${res.statusText})` };
+        }
+        const data = (await res.json());
+        const text = data.choices?.[0]?.message?.content ?? 'No response content';
+        return { model: modelLabel, response: text };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { model: modelLabel, response: `Error: ${message}` };
+    }
+}
+// ---------------------------------------------------------------------------
+// Platform helpers
+// ---------------------------------------------------------------------------
+function isCodexInstalled() {
+    try {
+        execFileSync('which', ['codex'], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function findContextFile() {
+    for (const name of ['GEMINI.md', 'CLAUDE.md', 'AGENTS.md']) {
+        try {
+            const content = readFileSync(join(process.cwd(), name), 'utf8');
+            if (content.trim())
+                return content;
+        }
+        catch { }
+    }
+    return null;
+}
+function buildDeepContext(prompt) {
+    const TOKEN_CAP = 16000;
+    const CHAR_CAP = TOKEN_CAP * 4; // ~4 chars per token
+    const parts = [`## Prompt\n${prompt}`];
+    let totalLen = parts[0].length;
+    // Context file
+    const ctxFile = findContextFile();
+    if (ctxFile && totalLen + ctxFile.length < CHAR_CAP) {
+        parts.push(`## Context File\n${ctxFile}`);
+        totalLen += ctxFile.length;
+    }
+    // Git diff (recent changes, capped at 100KB)
+    try {
+        const diff = execFileSync('git', ['diff', 'HEAD~3'], {
+            encoding: 'utf8',
+            maxBuffer: 100 * 1024,
+            timeout: 10_000,
+        });
+        if (diff && totalLen + diff.length < CHAR_CAP) {
+            parts.push(`## Recent Git Diff\n${diff}`);
+            totalLen += diff.length;
+        }
+        else if (diff) {
+            const truncated = diff.slice(0, CHAR_CAP - totalLen - 100);
+            parts.push(`## Recent Git Diff (truncated)\n${truncated}`);
+            totalLen += truncated.length;
+        }
+    }
+    catch { }
+    // Directory listing (git tracked files only - respects .gitignore)
+    try {
+        const files = execFileSync('git', ['ls-files'], {
+            encoding: 'utf8',
+            timeout: 5_000,
+        });
+        // Filter out sensitive files
+        const SENSITIVE = ['.env', '.pem', '.key', 'secret', 'credential', 'token'];
+        const filtered = files.split('\n').filter((f) => f && !SENSITIVE.some(s => f.toLowerCase().includes(s))).join('\n');
+        if (filtered && totalLen + filtered.length < CHAR_CAP) {
+            parts.push(`## Project Files\n${filtered}`);
+        }
+    }
+    catch { }
+    return parts.join('\n\n');
+}
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
+const server = new McpServer({ name: 'smoothie', version: '1.0.0' });
+server.tool('smoothie_blend', {
+    prompt: z.string().describe('The prompt to send to all models'),
+    deep: z.boolean().optional().describe('Full context mode with project files and git diff'),
+}, async ({ prompt, deep }) => {
+    // Read config on every request so edits take effect immediately
+    let config;
+    try {
+        config = JSON.parse(readFileSync(join(PROJECT_ROOT, 'config.json'), 'utf8'));
+    }
+    catch {
+        config = { openrouter_models: [] };
+    }
+    const finalPrompt = deep ? buildDeepContext(prompt) : prompt;
+    // Build model array based on platform
+    const platform = process.env.SMOOTHIE_PLATFORM || 'claude';
+    const models = [];
+    // Add platform-specific models
+    if (platform !== 'codex' && isCodexInstalled()) {
+        models.push({ fn: () => queryCodex(finalPrompt), label: 'Codex' });
+    }
+    if (platform === 'codex' || platform === 'gemini') {
+        // Add Claude via OpenRouter as a reviewer (not the judge)
+        models.push({
+            fn: () => queryOpenRouter(finalPrompt, 'anthropic/claude-sonnet-4', 'Claude Sonnet'),
+            label: 'Claude Sonnet',
+        });
+    }
+    // Add OpenRouter models from config
+    for (const m of config.openrouter_models) {
+        models.push({
+            fn: () => queryOpenRouter(finalPrompt, m.id, m.label),
+            label: m.label,
+        });
+    }
+    // Print initial progress
+    process.stderr.write('\n\u{1F9C3} Smoothie blending...\n\n');
+    for (const { label } of models) {
+        process.stderr.write(`  \u23F3 ${label.padEnd(26)} waiting...\n`);
+    }
+    process.stderr.write('\n');
+    // Run all in parallel with progress tracking
+    const startTimes = {};
+    const promises = models.map(({ fn, label }) => {
+        startTimes[label] = Date.now();
+        return fn()
+            .then((result) => {
+            const elapsed = ((Date.now() - startTimes[label]) / 1000).toFixed(1);
+            process.stderr.write(`  \u2713  ${label.padEnd(26)} done (${elapsed}s)\n`);
+            return result;
+        })
+            .catch((err) => {
+            const elapsed = ((Date.now() - startTimes[label]) / 1000).toFixed(1);
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`  \u2717  ${label.padEnd(26)} failed (${elapsed}s)\n`);
+            return { model: label, response: `Error: ${message}` };
+        });
+    });
+    const results = await Promise.all(promises);
+    const judgeNames = { claude: 'Claude', codex: 'Codex', gemini: 'Gemini' };
+    const judgeName = judgeNames[platform] || 'the judge';
+    process.stderr.write(`\n  \u25C6  All done. Handing to ${judgeName}...\n\n`);
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ results }, null, 2) }],
+    };
+});
+server.tool('smoothie_estimate', {
+    prompt: z.string().describe('The prompt to estimate costs for'),
+    deep: z.boolean().optional().describe('Estimate for deep mode'),
+}, async ({ prompt, deep }) => {
+    let config;
+    try {
+        config = JSON.parse(readFileSync(join(PROJECT_ROOT, 'config.json'), 'utf8'));
+    }
+    catch {
+        config = { openrouter_models: [] };
+    }
+    const contextPayload = deep ? buildDeepContext(prompt) : prompt;
+    const tokenCount = Math.ceil(contextPayload.length / 4);
+    // Fetch pricing from OpenRouter
+    let pricingMap = {};
+    try {
+        const res = await fetch('https://openrouter.ai/api/v1/models', {
+            headers: { Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}` },
+        });
+        const data = (await res.json());
+        if (data.data) {
+            for (const m of data.data) {
+                pricingMap[m.id] = parseFloat(m.pricing?.prompt || '0');
+            }
+        }
+    }
+    catch {
+        // Pricing unavailable — continue with zeros
+    }
+    const platform = process.env.SMOOTHIE_PLATFORM || 'claude';
+    const rows = [];
+    if (platform === 'claude') {
+        if (isCodexInstalled()) {
+            rows.push({ label: 'Codex', tokens: tokenCount, cost: 0, note: 'free (subscription)' });
+        }
+    }
+    if (platform === 'codex' || platform === 'gemini') {
+        const price = pricingMap['anthropic/claude-sonnet-4'] || 0;
+        rows.push({ label: 'Claude Sonnet', tokens: tokenCount, cost: tokenCount * price });
+    }
+    if (platform === 'gemini' && isCodexInstalled()) {
+        rows.push({ label: 'Codex', tokens: tokenCount, cost: 0, note: 'free (subscription)' });
+    }
+    for (const model of config.openrouter_models) {
+        const price = pricingMap[model.id] || 0;
+        rows.push({
+            label: model.label,
+            tokens: tokenCount,
+            cost: tokenCount * price,
+            note: price === 0 && Object.keys(pricingMap).length === 0 ? 'pricing unavailable' : undefined,
+        });
+    }
+    const totalCost = rows.reduce((sum, r) => sum + (r.cost || 0), 0);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({ rows, totalCost, tokenCount, note: 'Token estimates are approximate (~4 chars/token)' }, null, 2),
+            }],
+    };
+});
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/select-models.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};