smoothie-code 1.0.0

package/src/index.ts

@@ -0,0 +1,367 @@
+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, '..');
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface OpenRouterModel {
+  id: string;
+  label: string;
+}
+
+interface Config {
+  openrouter_models: OpenRouterModel[];
+}
+
+interface ModelResult {
+  model: string;
+  response: string;
+}
+
+interface ModelEntry {
+  fn: () => Promise<ModelResult>;
+  label: string;
+}
+
+interface OpenRouterMessage {
+  role: string;
+  content: string;
+}
+
+interface OpenRouterChoice {
+  message: OpenRouterMessage;
+}
+
+interface OpenRouterResponse {
+  choices?: OpenRouterChoice[];
+}
+
+// ---------------------------------------------------------------------------
+// .env loader (no dotenv dependency)
+// ---------------------------------------------------------------------------
+function loadEnv(): void {
+  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: string): Promise<ModelResult> {
+  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: string;
+    try {
+      response = readFileSync(tmpFile, 'utf8').trim();
+      const { unlinkSync } = await import('fs');
+      unlinkSync(tmpFile);
+    } catch {
+      response = '';
+    }
+    return { model: 'Codex', response: response || '(empty response)' };
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { model: 'Codex', response: `Error: ${message}` };
+  }
+}
+
+async function queryOpenRouter(
+  prompt: string,
+  modelId: string,
+  modelLabel: string,
+): Promise<ModelResult> {
+  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()) as OpenRouterResponse;
+    const text = data.choices?.[0]?.message?.content ?? 'No response content';
+    return { model: modelLabel, response: text };
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { model: modelLabel, response: `Error: ${message}` };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Platform helpers
+// ---------------------------------------------------------------------------
+
+function isCodexInstalled(): boolean {
+  try {
+    execFileSync('which', ['codex'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function findContextFile(): string | null {
+  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: string): string {
+  const TOKEN_CAP = 16000;
+  const CHAR_CAP = TOKEN_CAP * 4; // ~4 chars per token
+
+  const parts: string[] = [`## 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: string) =>
+      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: Config;
+    try {
+      config = JSON.parse(
+        readFileSync(join(PROJECT_ROOT, 'config.json'), 'utf8'),
+      ) as Config;
+    } 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: ModelEntry[] = [];
+
+    // 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: Record<string, number> = {};
+    const promises = models.map(({ fn, label }) => {
+      startTimes[label] = Date.now();
+      return fn()
+        .then((result: ModelResult) => {
+          const elapsed = ((Date.now() - startTimes[label]) / 1000).toFixed(1);
+          process.stderr.write(
+            `  \u2713  ${label.padEnd(26)} done (${elapsed}s)\n`,
+          );
+          return result;
+        })
+        .catch((err: unknown) => {
+          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}` } as ModelResult;
+        });
+    });
+
+    const results: ModelResult[] = await Promise.all(promises);
+    const judgeNames: Record<string, string> = { 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' as const, 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: Config;
+    try {
+      config = JSON.parse(readFileSync(join(PROJECT_ROOT, 'config.json'), 'utf8')) as Config;
+    } catch {
+      config = { openrouter_models: [] };
+    }
+
+    const contextPayload = deep ? buildDeepContext(prompt) : prompt;
+    const tokenCount = Math.ceil(contextPayload.length / 4);
+
+    // Fetch pricing from OpenRouter
+    let pricingMap: Record<string, number> = {};
+    try {
+      const res = await fetch('https://openrouter.ai/api/v1/models', {
+        headers: { Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}` },
+      });
+      const data = (await res.json()) as { data?: Array<{ id: string; pricing?: { prompt?: string } }> };
+      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: Array<{ label: string; tokens: number; cost: number; note?: string }> = [];
+
+    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' as const,
+        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/src/select-models.ts

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { createInterface, Interface } from 'readline';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = join(__dirname, '..');
+
+interface OpenRouterModel {
+  id: string;
+  name?: string;
+  context_length?: number;
+}
+
+interface ModelEntry {
+  id: string;
+  label: string;
+}
+
+interface Config {
+  openrouter_models: ModelEntry[];
+  auto_blend?: boolean;
+}
+
+const FALLBACK_MODELS: ModelEntry[] = [
+  { id: 'google/gemini-2.5-pro-preview', label: 'Gemini 2.5 Pro' },
+  { id: 'deepseek/deepseek-r2', label: 'DeepSeek R2' },
+  { id: 'x-ai/grok-3', label: 'Grok 3' },
+  { id: 'qwen/qwen-2.5-coder-32b-instruct', label: 'Qwen 2.5 Coder' },
+  { id: 'mistralai/codestral-2501', label: 'Codestral' },
+];
+
+const CODING_PROVIDERS = [
+  'anthropic', 'google', 'openai', 'x-ai', 'deepseek',
+  'qwen', 'mistralai', 'meta-llama', 'cohere', 'amazon',
+];
+
+function loadEnv(): void {
+  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 {}
+}
+
+function formatLabel(model: OpenRouterModel): string {
+  if (model.name) return model.name;
+  const raw = model.id.includes('/') ? model.id.split('/').slice(1).join('/') : model.id;
+  return raw.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+function loadConfig(configPath: string): Config {
+  try {
+    return JSON.parse(readFileSync(configPath, 'utf8')) as Config;
+  } catch {
+    return { openrouter_models: [] };
+  }
+}
+
+function saveConfig(configPath: string, config: Config): void {
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+
+async function fetchModels(apiKey: string): Promise<OpenRouterModel[] | null> {
+  try {
+    const res = await fetch('https://openrouter.ai/api/v1/models?order=throughput', {
+      headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+    const json = (await res.json()) as { data?: OpenRouterModel[] };
+    return json.data || [];
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.warn(`\n  Could not fetch models (${message}). Using defaults.\n`);
+    return null;
+  }
+}
+
+function isCodingModel(model: OpenRouterModel): boolean {
+  if ((model.context_length || 0) < 32000) return false;
+  if (model.id.includes('embed')) return false;
+  if (model.id.includes('vision') && !model.id.includes('omni')) return false;
+  const provider = model.id.includes('/') ? model.id.split('/')[0] : model.id;
+  return CODING_PROVIDERS.includes(provider);
+}
+
+function dedupeAndFilter(models: OpenRouterModel[]): OpenRouterModel[] {
+  const coding = models.filter(isCodingModel);
+
+  // Deduplicate by provider family
+  const seen = new Set<string>();
+  const deduped: OpenRouterModel[] = [];
+  for (const m of coding) {
+    const provider = m.id.includes('/') ? m.id.split('/')[0] : m.id;
+    if (seen.has(provider)) continue;
+    seen.add(provider);
+    deduped.push(m);
+  }
+
+  return deduped.slice(0, 8);
+}
+
+async function lookupModel(apiKey: string, modelId: string): Promise<ModelEntry | null> {
+  try {
+    const res = await fetch('https://openrouter.ai/api/v1/models?order=throughput', {
+      headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok) return null;
+    const json = (await res.json()) as { data?: OpenRouterModel[] };
+    const found = json.data?.find((m) => m.id === modelId);
+    if (found) return { id: found.id, label: formatLabel(found) };
+    // If not found but looks like a valid ID, accept it anyway
+    if (modelId.includes('/')) {
+      return { id: modelId, label: formatLabel({ id: modelId }) };
+    }
+    return null;
+  } catch {
+    if (modelId.includes('/')) {
+      return { id: modelId, label: formatLabel({ id: modelId }) };
+    }
+    return null;
+  }
+}
+
+function promptQ(rl: Interface, question: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(question, (answer: string) => resolve(answer));
+  });
+}
+
+// ── CLI: add <model_id> ─────────────────────────────────────────────
+async function cmdAdd(apiKey: string, configPath: string, modelId: string): Promise<void> {
+  const config = loadConfig(configPath);
+  if (config.openrouter_models.some((m) => m.id === modelId)) {
+    console.log(`  Already added: ${modelId}`);
+    return;
+  }
+  const entry = await lookupModel(apiKey, modelId);
+  if (!entry) {
+    console.error(`  Could not find model: ${modelId}`);
+    process.exit(1);
+  }
+  config.openrouter_models.push(entry);
+  saveConfig(configPath, config);
+  console.log(`  ✓ Added ${entry.label} (${entry.id})`);
+}
+
+// ── CLI: remove <model_id> ──────────────────────────────────────────
+function cmdRemove(configPath: string, modelId: string): void {
+  const config = loadConfig(configPath);
+  const before = config.openrouter_models.length;
+  config.openrouter_models = config.openrouter_models.filter((m) => m.id !== modelId);
+  if (config.openrouter_models.length === before) {
+    console.log(`  Not found: ${modelId}`);
+    return;
+  }
+  saveConfig(configPath, config);
+  console.log(`  ✓ Removed ${modelId}`);
+}
+
+// ── CLI: list ───────────────────────────────────────────────────────
+function cmdList(configPath: string): void {
+  const config = loadConfig(configPath);
+  if (config.openrouter_models.length === 0) {
+    console.log('  No models configured. Run: node dist/select-models.js');
+    return;
+  }
+  console.log('  Current models:');
+  for (const m of config.openrouter_models) {
+    console.log(`    ${m.label} (${m.id})`);
+  }
+}
+
+// ── Interactive picker (default / install mode) ─────────────────────
+async function cmdPick(apiKey: string, configPath: string): Promise<void> {
+  let topModels: ModelEntry[];
+  const rawModels = await fetchModels(apiKey);
+
+  if (rawModels === null) {
+    topModels = FALLBACK_MODELS.map((m) => ({ ...m }));
+  } else {
+    const deduped = dedupeAndFilter(rawModels);
+    topModels =
+      deduped.length > 0
+        ? deduped.map((m) => ({ id: m.id, label: formatLabel(m) }))
+        : FALLBACK_MODELS.map((m) => ({ ...m }));
+  }
+
+  // Exclude the judge's own model family
+  const platform = process.env.SMOOTHIE_PLATFORM || 'claude';
+  const excludePrefixes: Record<string, string[]> = {
+    claude: ['anthropic'],
+    codex: ['openai'],
+    gemini: ['google'],
+  };
+  const excluded = excludePrefixes[platform] || [];
+  topModels = topModels.filter(m => !excluded.some(prefix => m.id.startsWith(prefix + '/')));
+
+  // Default selection: first 3
+  const selected = new Set([0, 1, 2]);
+
+  // Print list with selection markers
+  console.log('');
+  for (let i = 0; i < topModels.length; i++) {
+    const check = selected.has(i) ? '\x1b[32m✓\x1b[0m' : ' ';
+    const num = String(i + 1).padStart(2, ' ');
+    console.log(`  ${check} ${num}. ${topModels[i].label}`);
+  }
+  console.log('');
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  const answer = await promptQ(
+    rl,
+    '  Toggle numbers, paste model ID, or Enter to confirm: ',
+  );
+  rl.close();
+
+  const input = answer.trim();
+
+  // Collect any pasted model IDs (contain '/')
+  const pastedIds: ModelEntry[] = [];
+  const toggleNums: number[] = [];
+
+  if (input) {
+    for (const token of input.split(/\s+/)) {
+      if (token.includes('/')) {
+        // Looks like a model ID
+        const entry = await lookupModel(apiKey, token);
+        if (entry) {
+          pastedIds.push(entry);
+          console.log(`  ✓ Added ${entry.label}`);
+        } else {
+          console.log(`  ✗ Unknown: ${token}`);
+        }
+      } else {
+        const n = parseInt(token, 10);
+        if (n >= 1 && n <= topModels.length) toggleNums.push(n);
+      }
+    }
+  }
+
+  // If user typed numbers, use exactly those (not toggle, just select)
+  let finalSelection: ModelEntry[];
+  if (toggleNums.length > 0) {
+    finalSelection = toggleNums.map((n) => topModels[n - 1]);
+  } else if (pastedIds.length > 0) {
+    // Keep defaults + add pasted
+    finalSelection = [...selected].map((i) => topModels[i]);
+  } else {
+    // Enter with no input → use defaults
+    finalSelection = [...selected].map((i) => topModels[i]);
+  }
+
+  // Merge pasted IDs
+  for (const p of pastedIds) {
+    if (!finalSelection.some((m) => m.id === p.id)) {
+      finalSelection.push(p);
+    }
+  }
+
+  // Preserve existing config fields (like auto_blend)
+  const existing = loadConfig(configPath);
+  existing.openrouter_models = finalSelection;
+  saveConfig(configPath, existing);
+
+  console.log(`  ✓ ${finalSelection.map((m) => m.label).join(', ')}`);
+}
+
+// ── Main ────────────────────────────────────────────────────────────
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  loadEnv();
+
+  const apiKey = process.env.OPENROUTER_API_KEY || '';
+  const configPath =
+    args.find((a) => a.endsWith('.json')) || join(PROJECT_ROOT, 'config.json');
+
+  // Subcommands
+  if (args[0] === 'add' && args[1]) {
+    if (!apiKey) {
+      console.error('  Set OPENROUTER_API_KEY in .env first');
+      process.exit(1);
+    }
+    await cmdAdd(apiKey, configPath, args[1]);
+    return;
+  }
+
+  if (args[0] === 'remove' && args[1]) {
+    cmdRemove(configPath, args[1]);
+    return;
+  }
+
+  if (args[0] === 'list') {
+    cmdList(configPath);
+    return;
+  }
+
+  // Interactive picker (default behavior / install mode)
+  const key = args[0] && !args[0].endsWith('.json') ? args[0] : apiKey;
+  if (!key) {
+    console.error('  No API key. Usage: node dist/select-models.js <key>');
+    console.error('  Or set OPENROUTER_API_KEY in .env');
+    process.exit(1);
+  }
+  // If called with positional key, set it for fetching
+  if (args[0] && !args[0].endsWith('.json') && args[0] !== 'add' && args[0] !== 'remove' && args[0] !== 'list') {
+    process.env.OPENROUTER_API_KEY = args[0];
+  }
+
+  await cmdPick(key, configPath);
+}
+
+main();

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "sourceMap": false
+  }
+}