smoothie-code 1.0.0

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "smoothie-code",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "smoothie": "./bin/smoothie"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^22.0.0"
+  }
+}

package/plan-hook.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+INPUT=$(cat)
+
+STOP_ACTIVE=$(echo "$INPUT" | python3 -c "
+import sys, json
+try:
+  d = json.load(sys.stdin)
+  print(d.get('stop_hook_active', False))
+except:
+  print(False)
+" 2>/dev/null)
+
+if [ "$STOP_ACTIVE" = "True" ]; then
+  exit 0
+fi
+
+TRANSCRIPT=$(echo "$INPUT" | python3 -c "
+import sys, json
+try:
+  d = json.load(sys.stdin)
+  print(d.get('transcript_path', ''))
+except:
+  print('')
+" 2>/dev/null)
+
+if [ -z "$TRANSCRIPT" ] || [ ! -f "$TRANSCRIPT" ]; then
+  exit 0
+fi
+
+IS_PLAN=$(tail -c 3000 "$TRANSCRIPT" | grep -c "Would you like to proceed\|## Plan\|### Plan\|Here's my plan\|Here is my plan\|Steps to\|Step 1\b\|step 1\b" 2>/dev/null || true)
+
+if [ "$IS_PLAN" -gt 0 ]; then
+  echo ""
+  echo "🧃 Smoothie: type 'smoothie' in option 5 to blend this plan before approving."
+fi
+
+exit 0

package/pr-blend-hook.sh

@@ -0,0 +1,95 @@
+#!/bin/bash
+#
+# pr-blend-hook.sh — PreToolUse hook for Bash commands
+#
+# Intercepts `gh pr create` commands, runs Smoothie blend on the
+# branch diff, and injects review results so Claude can revise
+# the PR description before creating it.
+#
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Read hook input from stdin
+INPUT=$(cat)
+
+# Check if auto-blend is enabled in config
+AUTO_ENABLED=$(node -e "
+  try {
+    const c = JSON.parse(require('fs').readFileSync('$SCRIPT_DIR/config.json','utf8'));
+    console.log(c.auto_blend === true ? 'true' : 'false');
+  } catch(e) { console.log('false'); }
+" 2>/dev/null)
+
+if [ "$AUTO_ENABLED" != "true" ]; then
+  echo '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"allow"}}'
+  exit 0
+fi
+
+# Check if this is a gh pr create command
+COMMAND=$(echo "$INPUT" | python3 -c "
+import sys, json
+try:
+  d = json.load(sys.stdin)
+  print(d.get('tool_input', {}).get('command', ''))
+except:
+  print('')
+" 2>/dev/null)
+
+if ! echo "$COMMAND" | grep -q "gh pr create"; then
+  echo '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"allow"}}'
+  exit 0
+fi
+
+# Extract cwd from hook input
+CWD=$(echo "$INPUT" | python3 -c "
+import sys, json
+try:
+  d = json.load(sys.stdin)
+  print(d.get('cwd', ''))
+except:
+  print('')
+" 2>/dev/null)
+
+# Get the diff
+DIFF=$(cd "$CWD" 2>/dev/null && git diff main...HEAD 2>/dev/null | head -c 4000)
+
+if [ -z "$DIFF" ]; then
+  echo '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"allow"}}'
+  exit 0
+fi
+
+# Build review prompt and run blend
+REVIEW_PROMPT="Review this PR diff for bugs, security issues, and improvements:
+
+$DIFF
+
+Provide concise, actionable feedback."
+
+BLEND_RESULTS=$(echo "$REVIEW_PROMPT" | node "$SCRIPT_DIR/dist/blend-cli.js" 2>/dev/stderr)
+
+if [ -z "$BLEND_RESULTS" ]; then
+  echo '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"allow"}}'
+  exit 0
+fi
+
+# Build the additionalContext string
+CONTEXT="Smoothie PR review — multiple models reviewed this diff:
+
+$BLEND_RESULTS
+
+Consider this feedback. If there are valid issues, revise the PR description to note them or fix the code before creating the PR."
+
+# Return: allow Bash but inject blend results
+node -e "
+  const ctx = $(echo "$CONTEXT" | python3 -c "import sys,json; print(json.dumps(sys.stdin.read()))" 2>/dev/null);
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'allow',
+      permissionDecisionReason: 'Smoothie PR review completed',
+      additionalContext: ctx
+    }
+  }));
+"
+
+exit 0

package/src/blend-cli.ts

@@ -0,0 +1,219 @@
+#!/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: 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);
+    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();