smoothie-code 1.1.0 → 1.2.0

package/icon.svg

@@ -1,17 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
-  <rect width="64" height="64" rx="14" fill="#0d1117"/>
-  <g transform="translate(12, 10)" stroke="#f0f6fc" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" fill="none">
-    <!-- Straw (inside viewBox now) -->
-    <line x1="24" y1="8" x2="32" y2="2"/>
-    <line x1="32" y1="2" x2="36" y2="2"/>
-    <!-- Dome -->
-    <path d="M 8 20 C 8 12 14 6 20 6 C 26 6 32 12 32 20"/>
-    <!-- Lid -->
-    <path d="M 2 20 L 38 20 C 38 20 38 24 20 24 C 2 24 2 20 2 20"/>
-    <!-- Cup body -->
-    <path d="M 6 24 L 10 46 L 30 46 L 34 24"/>
-    <!-- Drips -->
-    <path d="M 13 24 C 13 28 17 28 17 24" opacity="0.4" stroke-width="1.8"/>
-    <path d="M 23 24 C 23 28 27 28 27 24" opacity="0.4" stroke-width="1.8"/>
-  </g>
-</svg>

package/src/blend-cli.ts

@@ -1,219 +0,0 @@
-#!/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, '..');
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-interface Config {
-  openrouter_models: Array<{ id: string; label: string }>;
-  auto_blend?: boolean;
-}
-
-interface ModelResult {
-  model: string;
-  response: string;
-}
-
-interface OpenRouterResponse {
-  choices?: Array<{ message: { content: string } }>;
-}
-
-// ---------------------------------------------------------------------------
-// .env loader
-// ---------------------------------------------------------------------------
-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 {
-    // no .env
-  }
-}
-loadEnv();
-
-// ---------------------------------------------------------------------------
-// Model queries (same as index.ts)
-// ---------------------------------------------------------------------------
-
-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: 0,
-    });
-    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);
-    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}` };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Read prompt from arg or stdin
-// ---------------------------------------------------------------------------
-
-async function getPrompt(): Promise<string> {
-  if (process.argv[2]) return process.argv[2];
-
-  // Read from stdin
-  const rl = createInterface({ input: process.stdin });
-  const lines: string[] = [];
-  for await (const line of rl) {
-    lines.push(line);
-  }
-  return lines.join('\n');
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-
-async function main(): Promise<void> {
-  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: Config;
-  try {
-    config = JSON.parse(
-      readFileSync(join(PROJECT_ROOT, 'config.json'), 'utf8'),
-    ) as Config;
-  } catch {
-    config = { openrouter_models: [] };
-  }
-
-  const models: Array<{ fn: () => Promise<ModelResult>; label: string }> = [
-    { 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: Record<string, number> = {};
-  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: unknown) => {
-        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/src/index.ts

@@ -1,367 +0,0 @@
-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: 0,
-    });
-    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);