codeply-cli 0.1.1 → 0.2.0

package/lib/ai.js

@@ -1,22 +1,32 @@
 /**
  * Codeply CLI — AI client
  *
- * Two backends, selected by lib/config.js:
+ * Backends, selected by lib/config.js:
  *
- *   codeply  the 'ai-proxy' Supabase Edge Function the desktop app uses (see
- *            Codeply-App/supabase/functions/ai-proxy). No provider key lives in
- *            this CLI; it authenticates with the signed-in session from
- *            lib/auth.js, so usage counts against that account's daily cap.
+ *   codeply     the 'ai-proxy' Supabase Edge Function the desktop app uses
+ *               (see Codeply-App/supabase/functions/ai-proxy). No provider
+ *               key lives in this CLI; it authenticates with the signed-in
+ *               session from lib/auth.js, so usage counts against that
+ *               account's shared daily cap.
  *
- *   ollama   Ollama's OpenAI-compatible /v1/chat/completions, either the cloud
- *            (ollama.com, bearer key) or a local daemon (no key). No Codeply
- *            sign-in required, and no daily cap.
+ *   ollama      Ollama's OpenAI-compatible /v1/chat/completions, either the
+ *               cloud (ollama.com, bearer key) or a local daemon (no key).
+ *               No Codeply sign-in required, and no daily cap.
  *
- * Both return the identical shape — {success, data:{choices:[{message}]}, …} —
+ *   openrouter, groq, openai   BYOK: the user's own key against that
+ *               provider's OpenAI-compatible chat completions endpoint.
+ *               No Codeply account involved at all.
+ *
+ *   anthropic   BYOK against Anthropic's Messages API, which is NOT
+ *               OpenAI-compatible (different endpoint, a top-level `system`
+ *               field instead of a system message, and a `content` array in
+ *               the response) — handled by its own converter below.
+ *
+ * All of these return the identical shape — {success, data:{choices:[{message}]}, …} —
  * so nothing downstream (agent loop, edit engine) knows or cares which ran.
  */
 const { SUPABASE_URL, SUPABASE_ANON_KEY, getAccessToken } = require('./auth');
-const { getConfig } = require('./config');
+const { getConfig, byokHint } = require('./config');
 
 const AI_PROXY_URL = `${SUPABASE_URL}/functions/v1/ai-proxy`;
 
@@ -103,7 +113,11 @@ async function chatViaProxy(messages, opts) {
     // A structured error from the function itself is final: it means the
     // function ran and deliberately rejected us (auth, daily cap, provider
     // error). Retrying that just burns the user's quota.
-    if (body.error) return { done: true, value: { success: false, error: body.error } };
+    if (body.error) {
+      const hitCap = isRateLimitError(body.error) || /daily .* (limit|cap)/i.test(body.error);
+      const error = hitCap ? `${body.error} ${byokHint()}` : body.error;
+      return { done: true, value: { success: false, error } };
+    }
 
     return { retryable: isTransientStatus(res.status), error: describeStatus(res.status) };
   });
@@ -159,6 +173,189 @@ async function chatViaOllama(messages, opts, cfg) {
   });
 }
 
+// OpenAI-compatible /v1/chat/completions endpoints for the three providers
+// that speak that same dialect. Ollama has its own function above because it
+// also has to handle "no key at all for a local daemon", which these never do.
+const OPENAI_COMPATIBLE = {
+  openrouter: {
+    url: 'https://openrouter.ai/api/v1/chat/completions',
+    label: 'OpenRouter',
+    extraHeaders: { 'HTTP-Referer': 'https://codeply.online', 'X-Title': 'Codeply' },
+  },
+  groq: {
+    url: 'https://api.groq.com/openai/v1/chat/completions',
+    label: 'Groq',
+  },
+  openai: {
+    url: 'https://api.openai.com/v1/chat/completions',
+    label: 'OpenAI',
+  },
+};
+
+async function chatViaOpenAICompatible(messages, opts, providerName, cfg) {
+  const { url, label, extraHeaders } = OPENAI_COMPATIBLE[providerName];
+  const { apiKey, model } = cfg[providerName];
+  if (!apiKey) {
+    return { success: false, error: `No ${label} API key set. Run \`codeply provider ${providerName} --key <key>\`.` };
+  }
+
+  return withRetries(async () => {
+    let res;
+    try {
+      res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${apiKey}`,
+          ...extraHeaders,
+        },
+        body: JSON.stringify({
+          model,
+          messages,
+          temperature: opts.temperature ?? 0,
+          ...(opts.maxTokens ? { max_tokens: opts.maxTokens } : {}),
+          ...(opts.json ? { response_format: { type: 'json_object' } } : {}),
+        }),
+      });
+    } catch (e) {
+      return { retryable: true, error: e.message };
+    }
+
+    const body = await res.json().catch(() => ({}));
+
+    if (res.ok && body.choices?.[0]) {
+      return { done: true, value: { success: true, data: body, modelUsed: body.model || model } };
+    }
+
+    const apiError = body?.error?.message || body?.error;
+    if (apiError) {
+      const msg = typeof apiError === 'string' ? apiError : JSON.stringify(apiError);
+      const fatal = /not found|does not exist|unknown model|unauthor|invalid.*key|forbidden/i.test(msg);
+      if (fatal) return { done: true, value: { success: false, error: `${label}: ${msg}` } };
+      return { retryable: isTransientStatus(res.status), error: `${label}: ${msg}` };
+    }
+
+    return { retryable: isTransientStatus(res.status), error: describeStatus(res.status) };
+  });
+}
+
+// Below this many characters a block essentially never clears Anthropic's
+// minimum-token floor for caching (1024 tokens on Sonnet-class models, higher
+// on Haiku) — offering cache_control on it just adds a cache-write surcharge
+// for a block that will never actually be served from cache. ~4 chars/token is
+// a deliberately conservative floor, not a precise count.
+const ANTHROPIC_CACHEABLE_MIN_CHARS = 4000;
+
+/**
+ * Anthropic's Messages API isn't OpenAI-shaped: system prompt is a top-level
+ * field (not a message with role "system"), and the reply comes back as a
+ * `content` block array rather than `choices[0].message`. Converted both ways
+ * here so the rest of the codebase never has to know Anthropic is different.
+ *
+ * Prompt caching (`cache_control: {type:'ephemeral'}`) is applied at two
+ * breakpoints, because of how the agent loop in lib/agent.mjs actually calls
+ * this: one user turn can take up to 24 steps, and EVERY step resends the
+ * ENTIRE message array built up so far — there is no other way to talk to a
+ * stateless chat completions API. Without caching, a 20-step turn re-bills the
+ * system prompt and the whole growing transcript from scratch 20 times over.
+ * With it:
+ *   1. The system prompt (mode instructions + tool reference + skill index +
+ *      project context) is byte-identical across every step of a turn, and
+ *      usually across the whole session — cached at ~10% of its input-token
+ *      cost after the first call.
+ *   2. Everything except the newest message is marked as a second breakpoint,
+ *      so step N's request reuses step N-1's cache instead of re-billing the
+ *      whole transcript-so-far — turning per-step cost from O(conversation
+ *      length) into roughly O(what's new since the last step).
+ * Anthropic allows the read side of a cache hit to apply automatically for any
+ * request sharing a cached prefix, so these two breakpoints are enough; more
+ * would just spend the (4/hr) breakpoint limit for no further benefit here.
+ */
+async function chatViaAnthropic(messages, opts, cfg) {
+  const { apiKey, model } = cfg.anthropic;
+  if (!apiKey) {
+    return { success: false, error: 'No Anthropic API key set. Run `codeply provider anthropic --key <key>`.' };
+  }
+
+  const systemText = messages.filter((m) => m.role === 'system').map((m) => m.content).join('\n\n');
+  const turns = messages
+    .filter((m) => m.role !== 'system')
+    .map((m) => ({ role: m.role === 'assistant' ? 'assistant' : 'user', content: m.content }));
+
+  // Anthropic has no json_object response mode — ask for it in plain English instead.
+  const systemText2 = opts.json
+    ? `${systemText}\n\nRespond with ONLY a single valid JSON object. No prose, no markdown fences, nothing before or after it.`
+    : systemText;
+
+  const cacheControl = { type: 'ephemeral' };
+  const system = systemText2.length >= ANTHROPIC_CACHEABLE_MIN_CHARS
+    ? [{ type: 'text', text: systemText2, cache_control: cacheControl }]
+    : systemText2;
+
+  // Breakpoint 2: everything but the newest message. A single-message request
+  // (the very first call of a brand-new turn) has nothing "so far" to cache.
+  if (turns.length >= 2) {
+    const idx = turns.length - 2;
+    if (turns[idx].content.length >= ANTHROPIC_CACHEABLE_MIN_CHARS) {
+      turns[idx] = {
+        role: turns[idx].role,
+        content: [{ type: 'text', text: turns[idx].content, cache_control: cacheControl }],
+      };
+    }
+  }
+
+  return withRetries(async () => {
+    let res;
+    try {
+      res = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': apiKey,
+          'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+          model,
+          system,
+          messages: turns,
+          max_tokens: opts.maxTokens || 8192,
+          temperature: opts.temperature ?? 0,
+        }),
+      });
+    } catch (e) {
+      return { retryable: true, error: e.message };
+    }
+
+    const body = await res.json().catch(() => ({}));
+
+    if (res.ok && Array.isArray(body.content)) {
+      const text = body.content.filter((b) => b.type === 'text').map((b) => b.text).join('');
+      const data = {
+        choices: [{ message: { role: 'assistant', content: text }, finish_reason: body.stop_reason === 'max_tokens' ? 'length' : 'stop' }],
+        usage: {
+          prompt_tokens: body.usage?.input_tokens || 0,
+          completion_tokens: body.usage?.output_tokens || 0,
+          total_tokens: (body.usage?.input_tokens || 0) + (body.usage?.output_tokens || 0),
+          // Surfaced for anyone instrumenting cost later — not read anywhere yet.
+          cache_read_tokens: body.usage?.cache_read_input_tokens || 0,
+          cache_write_tokens: body.usage?.cache_creation_input_tokens || 0,
+        },
+      };
+      return { done: true, value: { success: true, data, modelUsed: model } };
+    }
+
+    const apiError = body?.error?.message || body?.error;
+    if (apiError) {
+      const msg = typeof apiError === 'string' ? apiError : JSON.stringify(apiError);
+      const fatal = /not_found_error|authentication_error|permission_error|invalid.*key/i.test(JSON.stringify(body.error || {})) || res.status === 401 || res.status === 403 || res.status === 404;
+      if (fatal) return { done: true, value: { success: false, error: `Anthropic: ${msg}` } };
+      return { retryable: isTransientStatus(res.status), error: `Anthropic: ${msg}` };
+    }
+
+    return { retryable: isTransientStatus(res.status), error: describeStatus(res.status) };
+  });
+}
+
 /**
  * @param {Array<{role:string, content:string}>} messages
  * @param {{ json?: boolean, maxTokens?: number, temperature?: number }} opts
@@ -166,9 +363,15 @@ async function chatViaOllama(messages, opts, cfg) {
  */
 async function chat(messages, opts = {}) {
   const cfg = getConfig();
-  return cfg.provider === 'ollama'
-    ? chatViaOllama(messages, opts, cfg)
-    : chatViaProxy(messages, opts);
+  switch (cfg.provider) {
+    case 'ollama': return chatViaOllama(messages, opts, cfg);
+    case 'anthropic': return chatViaAnthropic(messages, opts, cfg);
+    case 'openrouter':
+    case 'groq':
+    case 'openai':
+      return chatViaOpenAICompatible(messages, opts, cfg.provider, cfg);
+    default: return chatViaProxy(messages, opts);
+  }
 }
 
 /** Chat helper that expects a JSON object back and parses it. */

package/lib/apply-limit.js

@@ -26,13 +26,23 @@ async function checkApplyLimit() {
   }
 }
 
-/** Records one successful file write toward the daily cap. Fire-and-forget. */
-async function recordApplyEvent(filePath) {
+/**
+ * Records one successful file write toward the daily cap. Fire-and-forget.
+ * `linesAdded`/`linesRemoved` are what the admin dashboard's per-user view
+ * sums up to show how much someone actually changed, not just how often —
+ * deliberately just counts, never the file content itself.
+ */
+async function recordApplyEvent(filePath, linesAdded = 0, linesRemoved = 0) {
   const session = await getSession();
   if (!session) return;
   const supabase = getClient();
   try {
-    await supabase.from('apply_history').insert({ user_id: session.user.id, file_path: filePath || '' });
+    await supabase.from('apply_history').insert({
+      user_id: session.user.id,
+      file_path: filePath || '',
+      lines_added: linesAdded || 0,
+      lines_removed: linesRemoved || 0,
+    });
   } catch (e) {
     console.warn('[apply-limit] record failed:', e.message);
   }

package/lib/config.js

@@ -2,14 +2,22 @@
  * Codeply CLI — model provider configuration.
  *
  * Lives in ~/.codeply/config.json, next to auth.json, deliberately OUTSIDE the
- * repo: it holds an API key and must never be committable. Environment
+ * repo: it holds API keys and must never be committable. Environment
  * variables win over the file so a key can be supplied per-shell without ever
  * touching disk.
  *
  * Providers:
- *   codeply  the hosted ai-proxy (default; needs `codeply login`)
- *   ollama   Ollama's OpenAI-compatible API — cloud (ollama.com, needs a key)
- *            or a local daemon (http://localhost:11434, no key needed)
+ *   codeply     the hosted ai-proxy (default; needs `codeply login`), shares
+ *               a daily cap with the desktop app
+ *   ollama      Ollama's OpenAI-compatible API — cloud (ollama.com, needs a
+ *               key) or a local daemon (http://localhost:11434, no key)
+ *   openrouter  bring your own OpenRouter key, no cap
+ *   groq        bring your own Groq key, no cap
+ *   anthropic   bring your own Anthropic key, no cap
+ *   openai      bring your own OpenAI key, no cap
+ *
+ * The last four are "BYOK": once a key is set, the CLI talks to that
+ * provider directly and never touches the shared Codeply account limit.
  */
 const fs = require('fs');
 const path = require('path');
@@ -18,13 +26,16 @@ const os = require('os');
 const configDir = path.join(os.homedir(), '.codeply');
 const configPath = path.join(configDir, 'config.json');
 
+const PROVIDERS = ['codeply', 'ollama', 'openrouter', 'groq', 'anthropic', 'openai'];
+const BYOK_PROVIDERS = ['openrouter', 'groq', 'anthropic', 'openai'];
+
 const DEFAULTS = {
   provider: 'codeply',
-  ollama: {
-    host: 'https://ollama.com',
-    model: 'gemma4:31b',
-    apiKey: '',
-  },
+  ollama:     { host: 'https://ollama.com', model: 'gemma4:31b', apiKey: '' },
+  openrouter: { model: 'openrouter/auto', apiKey: '' },
+  groq:       { model: 'openai/gpt-oss-120b', apiKey: '' },
+  anthropic:  { model: 'claude-sonnet-5', apiKey: '' },
+  openai:     { model: 'gpt-4o-mini', apiKey: '' },
 };
 
 function readFile() {
@@ -41,6 +52,16 @@ function getConfig() {
   const provider = process.env.CODEPLY_PROVIDER || file.provider || DEFAULTS.provider;
   const fileOllama = file.ollama || {};
 
+  const byok = {};
+  for (const name of BYOK_PROVIDERS) {
+    const fileEntry = file[name] || {};
+    const envPrefix = name.toUpperCase();
+    byok[name] = {
+      model: process.env[`${envPrefix}_MODEL`] || fileEntry.model || DEFAULTS[name].model,
+      apiKey: process.env[`${envPrefix}_API_KEY`] || fileEntry.apiKey || '',
+    };
+  }
+
   return {
     provider,
     ollama: {
@@ -48,17 +69,19 @@ function getConfig() {
       model: process.env.OLLAMA_MODEL || fileOllama.model || DEFAULTS.ollama.model,
       apiKey: process.env.OLLAMA_API_KEY || fileOllama.apiKey || '',
     },
+    ...byok,
   };
 }
 
 /** Merge a patch into the stored config. Written user-only where supported. */
 function saveConfig(patch) {
   const current = readFile();
-  const next = {
-    ...current,
-    ...patch,
-    ollama: { ...(current.ollama || {}), ...(patch.ollama || {}) },
-  };
+  const next = { ...current, ...patch };
+  for (const name of ['ollama', ...BYOK_PROVIDERS]) {
+    if (current[name] || patch[name]) {
+      next[name] = { ...(current[name] || {}), ...(patch[name] || {}) };
+    }
+  }
   try {
     if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
     fs.writeFileSync(configPath, JSON.stringify(next, null, 2), { mode: 0o600 });
@@ -83,6 +106,9 @@ function describeProvider(cfg = getConfig()) {
     const where = /localhost|127\.0\.0\.1/.test(cfg.ollama.host) ? 'local' : 'cloud';
     return `ollama ${where} · ${cfg.ollama.model}`;
   }
+  if (BYOK_PROVIDERS.includes(cfg.provider)) {
+    return `${cfg.provider} (own key) · ${cfg[cfg.provider].model}`;
+  }
   return 'codeply proxy';
 }
 
@@ -92,7 +118,19 @@ function describeProviderShort(cfg = getConfig()) {
     const where = /localhost|127\.0\.0\.1/.test(cfg.ollama.host) ? 'local' : 'cloud';
     return `ollama ${where}`;
   }
+  if (BYOK_PROVIDERS.includes(cfg.provider)) {
+    return `${cfg.provider} (own key)`;
+  }
   return 'codeply proxy';
 }
 
-module.exports = { getConfig, saveConfig, maskKey, describeProvider, describeProviderShort, configPath };
+/** Suggested next step when the shared codeply account hits its daily cap. */
+function byokHint() {
+  return 'Have your own API key? Bring your own model instead, no shared daily cap: ' +
+    'codeply provider openrouter --key <key> (or groq, anthropic, openai).';
+}
+
+module.exports = {
+  getConfig, saveConfig, maskKey, describeProvider, describeProviderShort, byokHint,
+  configPath, PROVIDERS, BYOK_PROVIDERS,
+};