clawzempic 1.0.0

package/bin/clawzempic.mjs

@@ -0,0 +1,899 @@
+#!/usr/bin/env node
+
+/**
+ * Clawzempic CLI
+ *
+ * One-command setup for the Clawzempic intelligent LLM proxy.
+ * Zero dependencies — uses Node.js built-ins only (requires Node 18+).
+ *
+ * Usage:
+ *   npx clawzempic              Interactive setup
+ *   npx clawzempic init         Set up Clawzempic in this project
+ *   npx clawzempic test         Verify your connection works
+ *   npx clawzempic status       Check usage and savings
+ *   npx clawzempic doctor       Diagnose common issues
+ */
+
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout, stderr } from 'node:process';
+import { readFileSync, writeFileSync, existsSync, copyFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
+
+// ── Constants ─────────────────────────────────────────────────────────────────
+
+const API_BASE = 'https://api.clawzempic.ai';
+const VERSION = '1.0.0';
+
+// ── ANSI Colors (no dependencies) ─────────────────────────────────────────────
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  gray: '\x1b[90m',
+  bgGreen: '\x1b[42m',
+  bgRed: '\x1b[41m',
+  white: '\x1b[37m',
+};
+
+const ok = `${c.green}✓${c.reset}`;
+const fail = `${c.red}✗${c.reset}`;
+const warn = `${c.yellow}!${c.reset}`;
+const info = `${c.blue}i${c.reset}`;
+const arrow = `${c.cyan}→${c.reset}`;
+
+// ── UI Helpers ────────────────────────────────────────────────────────────────
+
+function banner() {
+  console.log('');
+  console.log(`  ${c.bold}${c.cyan}⚡ Clawzempic${c.reset} ${c.dim}v${VERSION}${c.reset}`);
+  console.log(`  ${c.dim}Intelligent LLM API Proxy — prompt caching, smart routing, memory${c.reset}`);
+  console.log('');
+}
+
+function box(lines) {
+  const maxLen = Math.max(...lines.map(l => stripAnsi(l).length));
+  const hr = '─'.repeat(maxLen + 4);
+  console.log(`  ${c.dim}┌${hr}┐${c.reset}`);
+  for (const line of lines) {
+    const pad = maxLen - stripAnsi(line).length;
+    console.log(`  ${c.dim}│${c.reset}  ${line}${' '.repeat(pad)}  ${c.dim}│${c.reset}`);
+  }
+  console.log(`  ${c.dim}└${hr}┘${c.reset}`);
+}
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function heading(text) {
+  console.log(`\n  ${c.bold}${text}${c.reset}\n`);
+}
+
+function bullet(icon, text) {
+  console.log(`  ${icon} ${text}`);
+}
+
+function blank() {
+  console.log('');
+}
+
+class Spinner {
+  constructor(text) {
+    this.text = text;
+    this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    this.i = 0;
+    this.interval = null;
+  }
+  start() {
+    this.interval = setInterval(() => {
+      stderr.write(`\r  ${c.cyan}${this.frames[this.i++ % this.frames.length]}${c.reset} ${this.text}`);
+    }, 80);
+    return this;
+  }
+  succeed(text) {
+    this.stop();
+    console.log(`\r  ${ok} ${text || this.text}`);
+  }
+  fail(text) {
+    this.stop();
+    console.log(`\r  ${fail} ${text || this.text}`);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+      stderr.write('\r' + ' '.repeat(stripAnsi(this.text).length + 10) + '\r');
+    }
+  }
+}
+
+// ── Prompts ───────────────────────────────────────────────────────────────────
+
+let rl;
+
+function getRL() {
+  if (!rl) {
+    rl = createInterface({ input: stdin, output: stdout });
+  }
+  return rl;
+}
+
+async function ask(question, opts = {}) {
+  const { required = true, secret = false, validate, defaultVal } = opts;
+  const suffix = defaultVal ? ` ${c.dim}(${defaultVal})${c.reset}` : '';
+  const prompt = `  ${c.cyan}?${c.reset} ${question}${suffix}: `;
+
+  while (true) {
+    if (secret) {
+      // Hide input for API keys
+      stdout.write(prompt);
+      const answer = await new Promise((resolve) => {
+        let buf = '';
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        const onData = (ch) => {
+          if (ch === '\n' || ch === '\r') {
+            stdin.setRawMode(false);
+            stdin.removeListener('data', onData);
+            stdout.write('\n');
+            resolve(buf);
+          } else if (ch === '\x03') {
+            // Ctrl+C
+            stdin.setRawMode(false);
+            process.exit(1);
+          } else if (ch === '\x7f' || ch === '\b') {
+            if (buf.length > 0) {
+              buf = buf.slice(0, -1);
+              stdout.write('\b \b');
+            }
+          } else {
+            buf += ch;
+            stdout.write('*');
+          }
+        };
+        stdin.on('data', onData);
+      });
+      const trimmed = answer.trim();
+      if (!trimmed && defaultVal) return defaultVal;
+      if (!trimmed && required) {
+        bullet(warn, 'This field is required.');
+        continue;
+      }
+      if (validate) {
+        const err = validate(trimmed);
+        if (err) { bullet(warn, err); continue; }
+      }
+      return trimmed;
+    }
+
+    const answer = await getRL().question(prompt);
+    const trimmed = answer.trim();
+    if (!trimmed && defaultVal) return defaultVal;
+    if (!trimmed && required) {
+      bullet(warn, 'This field is required.');
+      continue;
+    }
+    if (!trimmed && !required) return '';
+    if (validate) {
+      const err = validate(trimmed);
+      if (err) { bullet(warn, err); continue; }
+    }
+    return trimmed;
+  }
+}
+
+async function confirm(question, defaultYes = true) {
+  const hint = defaultYes ? 'Y/n' : 'y/N';
+  const answer = await ask(`${question} ${c.dim}(${hint})${c.reset}`, { required: false });
+  if (!answer) return defaultYes;
+  return answer.toLowerCase().startsWith('y');
+}
+
+async function choose(question, options) {
+  console.log(`\n  ${c.cyan}?${c.reset} ${question}\n`);
+  options.forEach((opt, i) => {
+    console.log(`    ${c.cyan}${i + 1}${c.reset}) ${opt.label}${opt.hint ? ` ${c.dim}${opt.hint}${c.reset}` : ''}`);
+  });
+  blank();
+  while (true) {
+    const answer = await ask('Choice', { validate: (v) => {
+      const n = parseInt(v, 10);
+      if (isNaN(n) || n < 1 || n > options.length) return `Enter 1-${options.length}`;
+      return null;
+    }});
+    return options[parseInt(answer, 10) - 1].value;
+  }
+}
+
+// ── API Client ────────────────────────────────────────────────────────────────
+
+async function apiPost(path, body) {
+  const res = await fetch(`${API_BASE}${path}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const data = await res.json();
+  return { ok: res.ok, status: res.status, data };
+}
+
+async function apiGet(path, apiKey) {
+  const res = await fetch(`${API_BASE}${path}`, {
+    headers: { 'x-api-key': apiKey },
+  });
+  const data = await res.json();
+  return { ok: res.ok, status: res.status, data };
+}
+
+async function testConnection(apiKey) {
+  const start = Date.now();
+  const res = await fetch(`${API_BASE}/v1/chat`, {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: 'claude-sonnet-4-5-20250929',
+      max_tokens: 32,
+      messages: [{ role: 'user', content: 'Say "connected" and nothing else.' }],
+    }),
+  });
+  const latency = Date.now() - start;
+  const data = await res.json();
+  const model = res.headers.get('x-router-model') || 'unknown';
+  return { ok: res.ok, status: res.status, data, latency, model };
+}
+
+// ── Framework Detection ───────────────────────────────────────────────────────
+
+const FRAMEWORKS = [
+  {
+    id: 'openclaw',
+    name: 'OpenClaw',
+    detect: (dir) => {
+      // OpenClaw: docker-compose with openclaw image, or .openclaw/ dir
+      if (existsSync(join(dir, '.openclaw'))) return true;
+      for (const f of ['docker-compose.yml', 'docker-compose.yaml']) {
+        if (existsSync(join(dir, f))) {
+          try {
+            const content = readFileSync(join(dir, f), 'utf8');
+            if (content.includes('openclaw') || content.includes('open-webui') || content.includes('ghcr.io/open-webui')) return true;
+          } catch {}
+        }
+      }
+      return false;
+    },
+    envFile: '.env',
+    envVars: { ANTHROPIC_API_KEY: null, ANTHROPIC_BASE_URL: API_BASE },
+  },
+  {
+    id: 'nanobot',
+    name: 'Nanobot',
+    detect: (dir) => {
+      if (existsSync(join(dir, 'nanobot.yaml')) || existsSync(join(dir, 'nanobot.yml'))) return true;
+      if (existsSync(join(dir, 'CLAUDE.md'))) {
+        try {
+          const content = readFileSync(join(dir, 'CLAUDE.md'), 'utf8');
+          if (content.includes('nanobot')) return true;
+        } catch {}
+      }
+      return false;
+    },
+    envFile: '.env',
+    envVars: { ANTHROPIC_API_KEY: null, ANTHROPIC_BASE_URL: API_BASE },
+  },
+  {
+    id: 'python',
+    name: 'Python (Anthropic SDK)',
+    detect: (dir) => {
+      for (const f of ['requirements.txt', 'pyproject.toml', 'Pipfile']) {
+        if (existsSync(join(dir, f))) {
+          try {
+            const content = readFileSync(join(dir, f), 'utf8');
+            if (content.includes('anthropic')) return true;
+          } catch {}
+        }
+      }
+      return false;
+    },
+    envFile: '.env',
+    envVars: { ANTHROPIC_API_KEY: null, ANTHROPIC_BASE_URL: API_BASE },
+  },
+  {
+    id: 'langchain',
+    name: 'LangChain',
+    detect: (dir) => {
+      for (const f of ['requirements.txt', 'pyproject.toml', 'package.json']) {
+        if (existsSync(join(dir, f))) {
+          try {
+            const content = readFileSync(join(dir, f), 'utf8');
+            if (content.includes('langchain-anthropic') || content.includes('langchain_anthropic')) return true;
+          } catch {}
+        }
+      }
+      return false;
+    },
+    envFile: '.env',
+    envVars: { ANTHROPIC_API_KEY: null, ANTHROPIC_BASE_URL: API_BASE },
+  },
+  {
+    id: 'node',
+    name: 'Node.js (Anthropic SDK)',
+    detect: (dir) => {
+      if (existsSync(join(dir, 'package.json'))) {
+        try {
+          const content = readFileSync(join(dir, 'package.json'), 'utf8');
+          if (content.includes('@anthropic-ai/sdk') || content.includes('anthropic')) return true;
+        } catch {}
+      }
+      return false;
+    },
+    envFile: '.env',
+    envVars: { ANTHROPIC_API_KEY: null, ANTHROPIC_BASE_URL: API_BASE },
+  },
+];
+
+function detectFramework(dir) {
+  for (const fw of FRAMEWORKS) {
+    if (fw.detect(dir)) return fw;
+  }
+  return null;
+}
+
+function detectExistingConfig(dir) {
+  // Check if already configured
+  const envPath = join(dir, '.env');
+  if (existsSync(envPath)) {
+    try {
+      const content = readFileSync(envPath, 'utf8');
+      if (content.includes('clawzempic.ai') || content.includes('sk-clwz-')) {
+        return { configured: true, envPath };
+      }
+    } catch {}
+  }
+  return { configured: false, envPath };
+}
+
+// ── Config Patching ───────────────────────────────────────────────────────────
+
+function patchEnvFile(envPath, vars) {
+  let content = '';
+  let existingKeys = new Set();
+
+  if (existsSync(envPath)) {
+    // Back up first
+    const backupPath = envPath + '.backup';
+    if (!existsSync(backupPath)) {
+      copyFileSync(envPath, backupPath);
+      bullet(info, `Backed up ${c.dim}${basename(envPath)}${c.reset} ${arrow} ${c.dim}${basename(backupPath)}${c.reset}`);
+    }
+    content = readFileSync(envPath, 'utf8');
+    // Parse existing keys
+    for (const line of content.split('\n')) {
+      const match = line.match(/^([A-Z_][A-Z0-9_]*)\s*=/);
+      if (match) existingKeys.add(match[1]);
+    }
+  }
+
+  const changes = [];
+
+  for (const [key, value] of Object.entries(vars)) {
+    if (existingKeys.has(key)) {
+      // Replace existing line
+      const regex = new RegExp(`^${key}\\s*=.*$`, 'm');
+      const oldLine = content.match(regex)?.[0] || '';
+      content = content.replace(regex, `${key}=${value}`);
+      changes.push({ key, action: 'updated', old: oldLine, new: `${key}=${value}` });
+    } else {
+      // Append
+      if (content.length > 0 && !content.endsWith('\n')) content += '\n';
+      content += `${key}=${value}\n`;
+      changes.push({ key, action: 'added', new: `${key}=${value}` });
+    }
+  }
+
+  writeFileSync(envPath, content, 'utf8');
+  return changes;
+}
+
+// ── Commands ──────────────────────────────────────────────────────────────────
+
+async function cmdInit(args) {
+  banner();
+  const dir = process.cwd();
+
+  // Check existing config
+  const existing = detectExistingConfig(dir);
+  if (existing.configured) {
+    bullet(warn, `Clawzempic is already configured in ${c.dim}${basename(existing.envPath)}${c.reset}`);
+    const proceed = await confirm('Overwrite existing configuration?', false);
+    if (!proceed) {
+      bullet(info, 'No changes made. Run `npx clawzempic test` to verify your connection.');
+      return cleanup();
+    }
+  }
+
+  // Determine mode
+  const mode = args.key
+    ? 'connect'
+    : await choose('How would you like to set up?', [
+        { value: 'signup', label: 'Create a new account', hint: '(recommended)' },
+        { value: 'connect', label: 'I already have a Clawzempic API key' },
+      ]);
+
+  let clawzempicKey;
+  let provider = null;
+
+  if (mode === 'signup') {
+    // ── Signup Flow ──────────────────────────────────────────────────────────
+
+    const name = await ask('Your name or bot name');
+    const email = await ask('Email', { required: false });
+
+    const providerKey = await ask('Your LLM provider API key', {
+      secret: true,
+      validate: (v) => {
+        if (v.length < 10) return 'Key seems too short. Check your API key.';
+        return null;
+      },
+    });
+
+    // Detect provider
+    if (providerKey.startsWith('sk-ant-')) {
+      provider = 'anthropic';
+      bullet(ok, `Detected provider: ${c.bold}Anthropic${c.reset}`);
+    } else if (providerKey.startsWith('sk-or-')) {
+      provider = 'openrouter';
+      bullet(ok, `Detected provider: ${c.bold}OpenRouter${c.reset}`);
+    } else {
+      bullet(warn, 'Could not auto-detect provider from key prefix. Defaulting to Anthropic.');
+      provider = 'anthropic';
+    }
+
+    // Create account
+    const spinner = new Spinner('Creating account...').start();
+    try {
+      const res = await apiPost('/v1/signup', {
+        agent_name: name,
+        email: email || undefined,
+        framework: detectFramework(dir)?.id || 'custom',
+        upstream_key: providerKey,
+      });
+
+      if (!res.ok) {
+        spinner.fail(`Signup failed: ${res.data.error || `HTTP ${res.status}`}`);
+        if (res.status === 429) {
+          bullet(info, 'Rate limited. Try again in a few minutes, or use an existing key.');
+        }
+        return cleanup(1);
+      }
+
+      clawzempicKey = res.data.api_key;
+      spinner.succeed(`Account created ${c.dim}(${res.data.client_id})${c.reset}`);
+
+      if (res.data.key_stored) {
+        bullet(ok, `Provider key stored securely — no extra headers needed`);
+      }
+    } catch (err) {
+      spinner.fail(`Could not reach ${API_BASE}`);
+      bullet(info, `Check your internet connection and try again.`);
+      bullet(info, `Error: ${err.message}`);
+      return cleanup(1);
+    }
+  } else {
+    // ── Connect Flow ─────────────────────────────────────────────────────────
+
+    clawzempicKey = args.key || await ask('Clawzempic API key', {
+      secret: true,
+      validate: (v) => {
+        if (!v.startsWith('sk-clwz-')) return 'Key should start with sk-clwz-';
+        return null;
+      },
+    });
+  }
+
+  // ── Framework Detection ──────────────────────────────────────────────────
+
+  heading('Framework Detection');
+
+  const framework = detectFramework(dir);
+  if (framework) {
+    bullet(ok, `Detected: ${c.bold}${framework.name}${c.reset}`);
+  } else {
+    bullet(info, 'No specific framework detected. Using generic .env config.');
+  }
+
+  // ── Config Changes ───────────────────────────────────────────────────────
+
+  heading('Configuration');
+
+  const envFile = framework?.envFile || '.env';
+  const envPath = join(dir, envFile);
+  const envVars = { ...(framework?.envVars || { ANTHROPIC_API_KEY: null, ANTHROPIC_BASE_URL: API_BASE }) };
+
+  // Set the API key value
+  for (const key of Object.keys(envVars)) {
+    if (envVars[key] === null) envVars[key] = clawzempicKey;
+  }
+
+  // Show what we'll do
+  bullet(info, `Will update ${c.bold}${envFile}${c.reset}:`);
+  for (const [key, value] of Object.entries(envVars)) {
+    const display = key.includes('KEY') ? value.substring(0, 12) + '...' : value;
+    console.log(`    ${c.green}+${c.reset} ${key}=${display}`);
+  }
+  blank();
+
+  const applyChanges = await confirm('Apply these changes?');
+  if (!applyChanges) {
+    bullet(info, 'No changes made. You can set these manually:');
+    blank();
+    for (const [key, value] of Object.entries(envVars)) {
+      console.log(`    ${key}=${value}`);
+    }
+    blank();
+    return cleanup();
+  }
+
+  // Apply
+  const changes = patchEnvFile(envPath, envVars);
+  for (const change of changes) {
+    if (change.action === 'updated') {
+      bullet(ok, `Updated ${c.bold}${change.key}${c.reset}`);
+    } else {
+      bullet(ok, `Added ${c.bold}${change.key}${c.reset}`);
+    }
+  }
+
+  // ── Test Connection ──────────────────────────────────────────────────────
+
+  blank();
+  const runTest = await confirm('Test the connection?');
+  if (runTest) {
+    await runConnectionTest(clawzempicKey);
+  }
+
+  // ── Done ─────────────────────────────────────────────────────────────────
+
+  blank();
+  box([
+    `${c.green}${c.bold}Setup complete!${c.reset}`,
+    '',
+    `${c.dim}Dashboard:${c.reset}  ${API_BASE}/v1/auth/portal`,
+    `${c.dim}Insights:${c.reset}   ${API_BASE}/v1/insights`,
+    `${c.dim}Docs:${c.reset}       ${API_BASE}/docs`,
+    '',
+    `${c.yellow}Restart your app to start saving.${c.reset}`,
+  ]);
+  blank();
+
+  return cleanup();
+}
+
+async function runConnectionTest(apiKey) {
+  const spinner = new Spinner('Testing connection...').start();
+  try {
+    const result = await testConnection(apiKey);
+    if (result.ok) {
+      spinner.succeed(`Connected! Routed to ${c.bold}${result.model}${c.reset} ${c.dim}(${result.latency}ms)${c.reset}`);
+      return true;
+    } else {
+      const errMsg = result.data?.error?.message || result.data?.error || `HTTP ${result.status}`;
+      spinner.fail(`Connection failed: ${errMsg}`);
+
+      // Helpful diagnostics
+      if (result.status === 400 && errMsg.includes('MISSING_UPSTREAM_KEY')) {
+        bullet(info, 'Your provider key was not stored during signup.');
+        bullet(info, 'Either re-run setup with your provider key, or pass x-upstream-key header.');
+      } else if (result.status === 401) {
+        bullet(info, 'Invalid Clawzempic API key. Check your key and try again.');
+      } else if (result.status === 429) {
+        bullet(info, 'Rate limited. Wait a moment and try again.');
+      }
+      return false;
+    }
+  } catch (err) {
+    spinner.fail(`Could not reach ${API_BASE}`);
+    bullet(info, `Error: ${err.message}`);
+    return false;
+  }
+}
+
+async function cmdTest(args) {
+  banner();
+
+  // Find API key: arg > env > .env file
+  let apiKey = args.key;
+
+  if (!apiKey) {
+    apiKey = process.env.CLAWZEMPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
+  }
+
+  if (!apiKey) {
+    const envPath = join(process.cwd(), '.env');
+    if (existsSync(envPath)) {
+      const content = readFileSync(envPath, 'utf8');
+      const match = content.match(/^(?:CLAWZEMPIC_API_KEY|ANTHROPIC_API_KEY)\s*=\s*(.+)$/m);
+      if (match) apiKey = match[1].trim();
+    }
+  }
+
+  if (!apiKey) {
+    bullet(fail, 'No API key found. Run `npx clawzempic` to set up first.');
+    return cleanup(1);
+  }
+
+  if (!apiKey.startsWith('sk-clwz-')) {
+    bullet(warn, 'Key does not look like a Clawzempic key (expected sk-clwz-...).');
+    bullet(info, 'If you haven\'t set up yet, run `npx clawzempic` first.');
+    return cleanup(1);
+  }
+
+  const success = await runConnectionTest(apiKey);
+  blank();
+  return cleanup(success ? 0 : 1);
+}
+
+async function cmdStatus(args) {
+  banner();
+
+  // Find API key
+  let apiKey = args.key;
+  if (!apiKey) {
+    apiKey = process.env.CLAWZEMPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
+  }
+  if (!apiKey) {
+    const envPath = join(process.cwd(), '.env');
+    if (existsSync(envPath)) {
+      const content = readFileSync(envPath, 'utf8');
+      const match = content.match(/^(?:CLAWZEMPIC_API_KEY|ANTHROPIC_API_KEY)\s*=\s*(.+)$/m);
+      if (match) apiKey = match[1].trim();
+    }
+  }
+
+  if (!apiKey || !apiKey.startsWith('sk-clwz-')) {
+    bullet(fail, 'No Clawzempic API key found. Run `npx clawzempic` to set up first.');
+    return cleanup(1);
+  }
+
+  const spinner = new Spinner('Fetching usage data...').start();
+  try {
+    const res = await apiGet('/v1/insights', apiKey);
+    if (!res.ok) {
+      spinner.fail(`Failed to fetch insights: ${res.data?.error || `HTTP ${res.status}`}`);
+      return cleanup(1);
+    }
+
+    spinner.succeed('Usage data loaded');
+    blank();
+
+    const d = res.data;
+    const period = d.period || {};
+    const usage = d.usage || {};
+    const savings = d.savings || {};
+    const limits = d.limits || {};
+
+    heading('Account');
+    if (d.client_id) bullet(info, `Client: ${c.bold}${d.client_id}${c.reset}`);
+    if (d.plan) bullet(info, `Plan: ${c.bold}${d.plan}${c.reset}`);
+    if (period.start) bullet(info, `Period: ${period.start} — ${period.end || 'now'}`);
+
+    heading('Usage');
+    bullet(info, `Requests: ${c.bold}${usage.total_requests || 0}${c.reset}`);
+    bullet(info, `Input tokens: ${c.bold}${(usage.total_input_tokens || 0).toLocaleString()}${c.reset}`);
+    bullet(info, `Output tokens: ${c.bold}${(usage.total_output_tokens || 0).toLocaleString()}${c.reset}`);
+    bullet(info, `Cost: ${c.bold}$${(usage.total_cost_usd || 0).toFixed(4)}${c.reset}`);
+
+    if (savings.total_savings_usd) {
+      heading('Savings');
+      bullet(ok, `Total saved: ${c.bold}${c.green}$${savings.total_savings_usd.toFixed(4)}${c.reset}`);
+      if (savings.cache_savings_usd) bullet(ok, `From caching: $${savings.cache_savings_usd.toFixed(4)}`);
+      if (savings.routing_savings_usd) bullet(ok, `From routing: $${savings.routing_savings_usd.toFixed(4)}`);
+    }
+
+    if (limits.daily_limit_usd !== undefined) {
+      heading('Limits');
+      bullet(info, `Daily: ${limits.daily_limit_usd === null ? 'unlimited' : '$' + limits.daily_limit_usd}`);
+      bullet(info, `Monthly: ${limits.monthly_limit_usd === null ? 'unlimited' : '$' + limits.monthly_limit_usd}`);
+    }
+
+    blank();
+  } catch (err) {
+    spinner.fail(`Could not reach ${API_BASE}: ${err.message}`);
+    return cleanup(1);
+  }
+
+  return cleanup();
+}
+
+async function cmdDoctor() {
+  banner();
+  heading('Diagnostics');
+
+  const dir = process.cwd();
+
+  // 1. Check .env exists
+  const envPath = join(dir, '.env');
+  if (existsSync(envPath)) {
+    bullet(ok, `.env file found`);
+  } else {
+    bullet(fail, `No .env file in current directory`);
+    bullet(info, 'Run `npx clawzempic` to set up.');
+    return cleanup(1);
+  }
+
+  // 2. Check for Clawzempic config
+  const content = readFileSync(envPath, 'utf8');
+  const keyMatch = content.match(/^(?:CLAWZEMPIC_API_KEY|ANTHROPIC_API_KEY)\s*=\s*(.+)$/m);
+  if (keyMatch && keyMatch[1].startsWith('sk-clwz-')) {
+    bullet(ok, `Clawzempic API key found`);
+  } else if (keyMatch) {
+    bullet(warn, `API key found but does not look like a Clawzempic key (expected sk-clwz-...)`);
+    bullet(info, 'You may be using a direct Anthropic key. Run `npx clawzempic` to set up proxy routing.');
+  } else {
+    bullet(fail, 'No API key found in .env');
+    return cleanup(1);
+  }
+
+  // 3. Check base URL
+  const baseUrlMatch = content.match(/^ANTHROPIC_BASE_URL\s*=\s*(.+)$/m);
+  if (baseUrlMatch && baseUrlMatch[1].includes('clawzempic.ai')) {
+    bullet(ok, `Base URL pointing to Clawzempic`);
+  } else if (baseUrlMatch) {
+    bullet(warn, `Base URL set to ${baseUrlMatch[1]} — not pointing to Clawzempic`);
+  } else {
+    bullet(fail, `ANTHROPIC_BASE_URL not set — requests go directly to Anthropic, bypassing Clawzempic`);
+  }
+
+  // 4. Check framework
+  const fw = detectFramework(dir);
+  if (fw) {
+    bullet(ok, `Framework detected: ${fw.name}`);
+  } else {
+    bullet(info, 'No specific framework detected (generic setup)');
+  }
+
+  // 5. Check docker-compose for OpenClaw
+  for (const f of ['docker-compose.yml', 'docker-compose.yaml']) {
+    if (existsSync(join(dir, f))) {
+      const dcContent = readFileSync(join(dir, f), 'utf8');
+      if (dcContent.includes('env_file') && dcContent.includes('.env')) {
+        bullet(ok, `docker-compose uses .env file`);
+      } else if (dcContent.includes('ANTHROPIC_API_KEY')) {
+        bullet(warn, `docker-compose has hardcoded ANTHROPIC_API_KEY — should use env_file instead`);
+      }
+    }
+  }
+
+  // 6. Test connection
+  blank();
+  if (keyMatch && keyMatch[1].startsWith('sk-clwz-')) {
+    const success = await runConnectionTest(keyMatch[1]);
+    if (success) {
+      blank();
+      bullet(ok, `${c.green}Everything looks good!${c.reset}`);
+    }
+  }
+
+  blank();
+  return cleanup();
+}
+
+function cmdHelp() {
+  banner();
+  console.log(`  ${c.bold}Usage:${c.reset}
+
+    ${c.cyan}npx clawzempic${c.reset}              Interactive setup (recommended)
+    ${c.cyan}npx clawzempic init${c.reset}         Set up Clawzempic in this project
+    ${c.cyan}npx clawzempic test${c.reset}         Verify your connection works
+    ${c.cyan}npx clawzempic status${c.reset}       Check usage and savings
+    ${c.cyan}npx clawzempic doctor${c.reset}       Diagnose common issues
+
+  ${c.bold}Options:${c.reset}
+
+    ${c.cyan}--key${c.reset} <key>              Clawzempic API key (skip prompt)
+    ${c.cyan}--help${c.reset}                  Show this help
+    ${c.cyan}--version${c.reset}               Show version
+
+  ${c.bold}What is Clawzempic?${c.reset}
+
+    Clawzempic is a drop-in proxy for Claude API calls. Point your SDK at
+    our base URL and get automatic prompt caching, intelligent model routing
+    (Haiku for simple tasks, Opus for complex ones), persistent memory, and
+    70-95% cost savings. Works with Anthropic and OpenRouter keys.
+
+  ${c.bold}Quick start:${c.reset}
+
+    ${c.dim}# In your project directory:${c.reset}
+    npx clawzempic
+
+    ${c.dim}# That's it. Restart your app and requests are proxied.${c.reset}
+
+  ${c.bold}Links:${c.reset}
+
+    Docs:      ${c.cyan}https://api.clawzempic.ai/docs${c.reset}
+    Dashboard: ${c.cyan}https://api.clawzempic.ai/v1/auth/portal${c.reset}
+    GitHub:    ${c.cyan}https://github.com/naveenspark/sam-router${c.reset}
+`);
+}
+
+// ── Arg Parsing ───────────────────────────────────────────────────────────────
+
+function parseArgs(argv) {
+  const args = { command: null, key: null, help: false, version: false };
+  const positional = [];
+
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') args.help = true;
+    else if (arg === '--version' || arg === '-v') args.version = true;
+    else if (arg === '--key' && argv[i + 1]) { args.key = argv[++i]; }
+    else if (!arg.startsWith('-')) positional.push(arg);
+  }
+
+  args.command = positional[0] || null;
+  return args;
+}
+
+// ── Cleanup ───────────────────────────────────────────────────────────────────
+
+function cleanup(exitCode = 0) {
+  if (rl) {
+    rl.close();
+    rl = null;
+  }
+  process.exit(exitCode);
+}
+
+// Handle Ctrl+C gracefully
+process.on('SIGINT', () => {
+  console.log(`\n\n  ${c.dim}Cancelled.${c.reset}\n`);
+  cleanup(1);
+});
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+const args = parseArgs(process.argv);
+
+if (args.version) {
+  console.log(`clawzempic ${VERSION}`);
+  process.exit(0);
+}
+
+if (args.help && !args.command) {
+  cmdHelp();
+  process.exit(0);
+}
+
+const command = args.command || 'init';
+
+switch (command) {
+  case 'init':
+    await cmdInit(args);
+    break;
+  case 'test':
+    await cmdTest(args);
+    break;
+  case 'status':
+    await cmdStatus(args);
+    break;
+  case 'doctor':
+    await cmdDoctor();
+    break;
+  case 'help':
+    cmdHelp();
+    process.exit(0);
+    break;
+  default:
+    console.error(`Unknown command: ${command}. Run 'npx clawzempic --help' for usage.`);
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "clawzempic",
+  "version": "1.0.0",
+  "description": "Intelligent LLM API proxy — prompt caching, smart routing, memory. Drop-in replacement that cuts your Claude API costs 70-95%.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "clawzempic": "./bin/clawzempic.mjs"
+  },
+  "files": [
+    "bin/"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "anthropic",
+    "claude",
+    "openrouter",
+    "llm",
+    "proxy",
+    "api",
+    "caching",
+    "routing",
+    "cost-optimization",
+    "ai",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/naveenspark/sam-router"
+  },
+  "homepage": "https://clawzempic.ai",
+  "author": "Clawzempic"
+}