symbiot 0.1.1 → 0.4.0

package/README.md

@@ -4,28 +4,59 @@ Your week, written from your real work.
 
 Symbiot reads your **local git activity** and writes the update you'd actually send —
 your weekly summary, your standup, or what's still on your plate. No accounts, no
-OAuth, no integrations to wire up. The only thing it needs is an AI key, which you
-bring yourself.
+OAuth, no integrations to wire up. It writes with the **AI of your choice** —
+Claude, OpenAI, Gemini, or a **local model** via Ollama — set up once.
 
 ```
 symbiot            your last 7 days, written up   (same as: symbiot week)
 symbiot standup    yesterday + today, for standup
 symbiot todo       what's still on your plate
+symbiot app        open the visual app in your browser
+symbiot login      connect it to an AI (once)
+symbiot whoami     show how it's connected
 symbiot help
 ```
 
+## Prefer a window? `symbiot app`
+
+```bash
+symbiot app
+```
+
+Starts a tiny local server (127.0.0.1 only, protected by a one-time token) and
+opens the visual app in your browser — in a clean, chrome-less window if you have
+Chrome/Chromium/Edge/Brave (`--app` mode), otherwise a normal tab. Tabs for
+Week / Standup / Todo, a Copy button, and a Settings panel to pick your AI. No
+Electron, no install — it's the same CLI. Press Ctrl+C (or click Quit) to stop.
+
 ## Install
 
 ```bash
 npm install -g symbiot        # or run without installing:  npx symbiot week
 ```
 
-Then give it an AI key (this is the only credential it needs):
+## Connect it (once)
+
+Pick the AI you want it to write with:
 
 ```bash
-export ANTHROPIC_API_KEY=sk-ant-...     # or:  ant auth login
+symbiot login     # choose Claude, OpenAI, Gemini, or a local model (Ollama)
 ```
 
+You'll get a short menu; paste that provider's API key (or, for Ollama, just point
+it at your local server) and it's saved to `~/.config/symbiot/config.json`.
+
+| Provider | Get a key | Default model |
+|----------|-----------|---------------|
+| Claude (Anthropic) | <https://console.anthropic.com/settings/keys> | `claude-opus-5-5` |
+| OpenAI (GPT) | <https://platform.openai.com/api-keys> | `gpt-4o-mini` |
+| Gemini (Google) | <https://aistudio.google.com/apikey> | `gemini-1.5-flash` |
+| Local (Ollama) | runs on your machine, no key | `llama3.1` |
+
+Non-interactive: `symbiot login --provider openai --key sk-... [--model gpt-4o]`.
+Environment keys are auto-detected too (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`,
+`GEMINI_API_KEY`), and `symbiot whoami` shows which one is active.
+
 ## Use
 
 ```bash
@@ -46,17 +77,20 @@ Point it somewhere specific with `--dir ~/work`.
 
 - **Reads:** your local git — commit messages and changed-file names, plus
   `TODO`/`FIXME` markers and uncommitted changes for `todo`. All local.
-- **Sends to the model:** only those commit/TODO summaries, so it can write the
-  update. Not your code, not file contents.
+- **Sends to the AI:** only those commit/TODO summaries, so it can write the
+  update. Not your code, not file contents. With a **local Ollama model,
+  nothing leaves your machine at all.**
 - **Never:** no keylogging, no screen capture, no browsing history, no accounts.
 
 ## Config
 
-- `SYMBIOT_MODEL` — the model to use (default `claude-opus-5`).
-- `ANTHROPIC_API_KEY` — your key, or sign in once with `ant auth login`.
+- `SYMBIOT_MODEL` — override the model for any provider (e.g. `gpt-4o`,
+  `claude-haiku-4-5`, `gemini-1.5-pro`).
+- `symbiot whoami` shows the active provider, model, and where the credential
+  came from. `symbiot logout` forgets saved credentials.
 
 ---
 
 Part of Symbiot — an assistant that learns how you work and gives it back to you.
 This CLI is the personal, install-it-yourself front door: it needs nothing but your
-own machine and one key.
+own machine and an AI of your choice.

package/index.mjs

@@ -2,12 +2,15 @@
 // symbiot — your week, written from your real work.
 //
 // Reads your local git activity (no accounts, no OAuth, no integrations) and
-// writes the update you'd actually send. The only thing it needs is an AI key,
-// which you bring yourself:  export ANTHROPIC_API_KEY=sk-ant-...  (or `ant auth login`).
+// writes the update you'd actually send. It writes with an AI of your choice —
+// Claude, OpenAI, Gemini, or a local model (Ollama) — set up once with
+// `symbiot login`.
 //
 //   symbiot week      your week, written up          (default)
 //   symbiot standup   yesterday + today, for standup
 //   symbiot todo      what's still on your plate
+//   symbiot login     connect it to an AI (once)
+//   symbiot whoami    show how it's connected
 //   symbiot help
 //
 // Flags:  --dir <path>  where to look (default: your home folder)
@@ -15,12 +18,28 @@
 //         --plain       no colour, no spinner (for piping)
 
 import Anthropic from "@anthropic-ai/sdk";
-import { execSync } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
 
-const MODEL = process.env.SYMBIOT_MODEL || "claude-opus-5";
 const MAX_REPOS = 14;
 const MAX_COMMITS = 140;
+const MAX_TOKENS = 1600;
+const CONFIG_DIR = join(homedir(), ".config", "symbiot");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+// The providers Symbiot can write with. Models are sensible defaults; override
+// per provider at login, or globally with SYMBIOT_MODEL.
+const PROVIDERS = {
+  anthropic: { label: "Claude (Anthropic)", env: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"], keyUrl: "https://console.anthropic.com/settings/keys", keyName: "Anthropic API key (sk-ant-…)", model: "claude-opus-5-5" },
+  openai:    { label: "OpenAI (GPT)",       env: ["OPENAI_API_KEY"],                            keyUrl: "https://platform.openai.com/api-keys",       keyName: "OpenAI API key (sk-…)",     model: "gpt-4o-mini" },
+  gemini:    { label: "Gemini (Google)",    env: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],          keyUrl: "https://aistudio.google.com/apikey",         keyName: "Google AI API key",         model: "gemini-1.5-flash" },
+  ollama:    { label: "Local model (Ollama)", local: true,                                       keyUrl: "https://ollama.com",                         keyName: null,                        model: "llama3.1" },
+};
 
 // ---- tiny arg parse --------------------------------------------------------
 const argv = process.argv.slice(2);
@@ -31,6 +50,7 @@ const flag = (name, def) => {
 };
 const has = (name) => argv.includes(`--${name}`);
 const PLAIN = has("plain") || !process.stdout.isTTY;
+let SERVING = false; // set while `symbiot app` runs — silences the CLI spinner
 
 // ---- colour + spinner ------------------------------------------------------
 const c = PLAIN
@@ -42,6 +62,7 @@ const c = PLAIN
       y: (s) => `\x1b[38;5;179m${s}\x1b[0m`,   // amber
     };
 function spinner(label) {
+  if (SERVING) return () => {};
   if (PLAIN) { process.stderr.write(label + "\n"); return () => {}; }
   const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
   let i = 0;
@@ -49,6 +70,64 @@ function spinner(label) {
   return () => { clearInterval(t); process.stderr.write("\r\x1b[K"); };
 }
 
+// ---- config + provider resolution -----------------------------------------
+function loadConfig() {
+  try { return JSON.parse(readFileSync(CONFIG_PATH, "utf8")); } catch { return {}; }
+}
+function saveConfig(cfg) {
+  try {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+    try { chmodSync(CONFIG_PATH, 0o600); } catch {}
+    return true;
+  } catch { return false; }
+}
+function antProfileExists() {
+  try { return existsSync(join(homedir(), ".config", "anthropic")); } catch { return false; }
+}
+function envKey(provider) {
+  for (const e of (PROVIDERS[provider].env || [])) if (process.env[e]) return process.env[e];
+  return null;
+}
+// Returns { provider, key?, baseUrl?, model, source } or null if nothing set up.
+// Order: saved choice → legacy saved key → env keys → an `ant` profile.
+function resolveProvider() {
+  const cfg = loadConfig();
+  const m = process.env.SYMBIOT_MODEL;
+  if (cfg.provider && PROVIDERS[cfg.provider]) {
+    const p = cfg.provider, pc = cfg[p] || {};
+    if (p === "ollama") return { provider: p, baseUrl: pc.baseUrl || "http://localhost:11434", model: m || pc.model || PROVIDERS.ollama.model, source: "saved login" };
+    const key = pc.apiKey || envKey(p);
+    if (key || (p === "anthropic" && (process.env.ANTHROPIC_AUTH_TOKEN || antProfileExists())))
+      return { provider: p, key, model: m || pc.model || PROVIDERS[p].model, source: pc.apiKey ? "saved login" : "environment" };
+  }
+  if (cfg.apiKey) return { provider: "anthropic", key: cfg.apiKey, model: m || PROVIDERS.anthropic.model, source: "saved login (~/.config/symbiot)" };
+  if (process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN) return { provider: "anthropic", key: process.env.ANTHROPIC_API_KEY, model: m || PROVIDERS.anthropic.model, source: "ANTHROPIC_* (environment)" };
+  if (process.env.OPENAI_API_KEY) return { provider: "openai", key: process.env.OPENAI_API_KEY, model: m || PROVIDERS.openai.model, source: "OPENAI_API_KEY (environment)" };
+  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) return { provider: "gemini", key: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY, model: m || PROVIDERS.gemini.model, source: "GEMINI/GOOGLE_API_KEY (environment)" };
+  if (antProfileExists()) return { provider: "anthropic", model: m || PROVIDERS.anthropic.model, source: "Anthropic CLI profile (ant auth login)" };
+  return null;
+}
+
+// ---- prompt (with masked secret input) ------------------------------------
+function ask(question, { secret = false } = {}) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    if (secret && !PLAIN) {
+      rl._writeToOutput = (str) => {
+        if (str.includes(question)) rl.output.write(question);
+        else if (str.includes("\n")) rl.output.write("\n");
+        else rl.output.write("*");
+      };
+    }
+    rl.question(question, (ans) => {
+      rl.close();
+      if (secret) process.stdout.write("\n");
+      resolve((ans || "").trim());
+    });
+  });
+}
+
 // ---- git ------------------------------------------------------------------
 function sh(cmd) {
   try { return execSync(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 32 * 1024 * 1024 }); }
@@ -118,38 +197,101 @@ function openWork(repos) {
   return items;
 }
 
-// ---- claude ---------------------------------------------------------------
+// ---- model calls (one per provider, same in/out) --------------------------
+async function callAnthropic(r, system, prompt) {
+  const client = new Anthropic(r.key ? { apiKey: r.key } : {});
+  const base = { model: r.model, max_tokens: MAX_TOKENS, system, messages: [{ role: "user", content: prompt }] };
+  let res;
+  try { res = await client.messages.create({ ...base, output_config: { effort: "low" } }); }
+  catch (e) {
+    // effort/output_config isn't accepted on every model (e.g. Haiku) — retry plain
+    if (/effort|output_config|thinking|budget|400/i.test(e?.message || "")) res = await client.messages.create(base);
+    else throw e;
+  }
+  if (res.stop_reason === "refusal") return "(the model declined this one — odd for a work summary; try again)";
+  return res.content.filter((b) => b.type === "text").map((b) => b.text).join("\n").trim();
+}
+async function callOpenAI(r, system, prompt) {
+  const messages = [{ role: "system", content: system }, { role: "user", content: prompt }];
+  // Newer models want max_completion_tokens instead of max_tokens; try both.
+  for (const tokKey of ["max_tokens", "max_completion_tokens"]) {
+    const res = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${r.key}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ model: r.model, [tokKey]: MAX_TOKENS, messages }),
+    });
+    const text = await res.text();
+    if (res.ok) return (JSON.parse(text).choices?.[0]?.message?.content || "").trim();
+    if (res.status === 400 && tokKey === "max_tokens" && /max_tokens|max_completion_tokens/i.test(text)) continue;
+    throw new Error(`OpenAI ${res.status}: ${text.slice(0, 200)}`);
+  }
+  return "";
+}
+async function callGemini(r, system, prompt) {
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(r.model)}:generateContent?key=${encodeURIComponent(r.key)}`;
+  const res = await fetch(url, {
+    method: "POST", headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      systemInstruction: { parts: [{ text: system }] },
+      contents: [{ role: "user", parts: [{ text: prompt }] }],
+      generationConfig: { maxOutputTokens: MAX_TOKENS },
+    }),
+  });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`Gemini ${res.status}: ${text.slice(0, 200)}`);
+  const parts = JSON.parse(text).candidates?.[0]?.content?.parts || [];
+  return parts.map((p) => p.text || "").join("").trim();
+}
+async function callOllama(r, system, prompt) {
+  const res = await fetch(`${r.baseUrl}/api/chat`, {
+    method: "POST", headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model: r.model, stream: false, messages: [{ role: "system", content: system }, { role: "user", content: prompt }] }),
+  });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`Ollama ${res.status}: ${text.slice(0, 200)}`);
+  return (JSON.parse(text).message?.content || "").trim();
+}
+
 async function write(system, prompt) {
-  let client;
-  try { client = new Anthropic(); } catch { client = null; }
+  const r = resolveProvider();
+  if (!r) { console.log(AUTH_HELP); return null; }
   const stop = spinner("thinking…");
   try {
-    const res = await client.messages.create({
-      model: MODEL, max_tokens: 1600,
-      system, messages: [{ role: "user", content: prompt }],
-    });
-    if (res.stop_reason === "refusal") return "(the model declined this one — odd for a work summary; try again)";
-    return res.content.filter((b) => b.type === "text").map((b) => b.text).join("\n").trim();
+    if (r.provider === "anthropic") return await callAnthropic(r, system, prompt);
+    if (r.provider === "openai") return await callOpenAI(r, system, prompt);
+    if (r.provider === "gemini") return await callGemini(r, system, prompt);
+    if (r.provider === "ollama") return await callOllama(r, system, prompt);
+    return null;
   } catch (err) {
-    if (err instanceof Anthropic.AuthenticationError || /api key|ANTHROPIC_API_KEY|credential/i.test(err?.message || "")) {
-      return AUTH_HELP;
+    if (/\b401\b|\b403\b|invalid|authentication|api key|unauthor/i.test(err?.message || "")) {
+      console.log(c.y(`Your ${PROVIDERS[r.provider].label} credentials were rejected. `) + "Reconnect with:  " + c.b("symbiot login --force"));
+      return null;
     }
     return `Couldn't reach the model: ${err?.message || err}`;
   } finally { stop(); }
 }
 
-const AUTH_HELP = c.y("Symbiot needs an AI key to write your update.\n") +
-  "  Set one of these, then run again:\n" +
-  "    export ANTHROPIC_API_KEY=sk-ant-...\n" +
-  "    or:  ant auth login\n" +
-  c.d("  (This is the only key it needs — no Google, no integrations.)");
+async function validate(provider, { key, baseUrl } = {}) {
+  try {
+    if (provider === "anthropic") { await new Anthropic({ apiKey: key }).models.list(); return true; }
+    if (provider === "openai") return (await fetch("https://api.openai.com/v1/models", { headers: { Authorization: `Bearer ${key}` } })).ok;
+    if (provider === "gemini") return (await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${encodeURIComponent(key)}`)).ok;
+    if (provider === "ollama") return (await fetch(`${baseUrl}/api/tags`)).ok;
+  } catch { return false; }
+  return false;
+}
+
+const AUTH_HELP =
+  c.y("Symbiot needs an AI to write your updates. Connect one:\n") +
+  "  " + c.b("symbiot login") + c.d("   pick Claude, OpenAI, Gemini, or a local model (Ollama)") + "\n" +
+  c.d("  Or set a key in your environment: ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY.");
 
 // ---- render ---------------------------------------------------------------
 function renderCommits(list) {
   return list.map((x) => `- [${x.repo}] ${x.subject}${x.files.length ? ` (${x.files.length} files)` : ""}`).join("\n");
 }
-function header(title, sub) {
-  if (PLAIN) { console.log(`${title}\n${sub}\n`); return; }
+function header(sub) {
+  if (PLAIN) { console.log(`Symbiot\n${sub}\n`); return; }
   console.log(`\n${c.g("●")} ${c.b("Symbiot")} ${c.d("· " + sub)}\n`);
 }
 
@@ -157,20 +299,30 @@ function header(title, sub) {
 const SINCE_WEEK = Number(flag("since", "7"));
 const BASE = flag("dir", homedir());
 
-async function cmdWeek(days, label) {
+// Build a write-up for a command; returns { text, sub, error? } without printing.
+// Shared by the CLI (cmdRun) and the web UI (symbiot app).
+async function produce(cmd) {
+  if (!resolveProvider()) return { error: "not-connected" };
+  if (cmd === "todo") {
+    const repos = findRepos(BASE, 60);
+    const open = openWork(repos);
+    if (!open.length) return { text: "Nothing outstanding found (no TODOs or uncommitted work).", sub: "0 open items · todo" };
+    const system =
+      `You summarise what's still on a developer's plate from their TODO markers and uncommitted work. ` +
+      `Group by project, lead with what looks most in-flight (uncommitted work) then the to-dos. ` +
+      `Be concise and concrete. No preamble.`;
+    const text = await write(system, `Open work:\n${open.map((o) => `- ${o}`).join("\n")}\n\nWhat's still on my plate?`);
+    return { text: text || "(couldn't reach the model)", sub: `${open.length} open items · todo` };
+  }
+  const label = cmd === "standup" ? "standup" : "week";
+  const days = cmd === "standup" ? 2 : SINCE_WEEK;
   const who = me();
   const repos = findRepos(BASE, days);
-  if (!repos.length) {
-    console.log(c.y(`No git activity in the last ${days} days under ${BASE}.`));
-    console.log(c.d("Try:  symbiot week --dir ~/projects   (point it at where your repos live)"));
-    return;
-  }
-  // Your own commits (per-repo identity); --all includes everyone's.
+  if (!repos.length) return { text: `No git activity in the last ${days} days under ${BASE}.\nPoint it at your repos with --dir.`, sub: "no activity" };
   let cs = commits(repos, `${days} days ago`, !has("all"));
   if (!cs.length) cs = commits(repos, `${days} days ago`, false); // fall back to all if none matched you
   const open = label === "week" ? openWork(repos) : [];
-
-  if (!cs.length) { console.log(c.y("Found repos, but no commits in the window.")); return; }
+  if (!cs.length) return { text: "Found repos, but no commits in the window.", sub: "no commits" };
 
   const system =
     `You write a short, first-person work update from a person's git commits. ` +
@@ -178,29 +330,255 @@ async function cmdWeek(days, label) {
     `Turn commit messages into outcomes a manager or teammate would understand — not a raw commit list. ` +
     `${label === "standup" ? "Keep it to 3-5 bullets: done, and what's next." : "A short paragraph or a few grouped bullets; end with a one-line 'In progress / next' if there are open items."} ` +
     `No preamble, no sign-off, no invented work — only what the commits and open items show.`;
-
   const prompt =
     `Person: ${who.name || "me"}. Window: ${label === "standup" ? "since yesterday" : `last ${days} days`}.\n\n` +
     `Commits:\n${renderCommits(cs)}\n\n` +
     (open.length ? `Open / in progress:\n${open.map((o) => `- ${o}`).join("\n")}\n\n` : "") +
     `Write the ${label === "standup" ? "standup" : "update"}.`;
 
-  header("Symbiot", `${cs.length} commits across ${new Set(cs.map((x) => x.repo)).size} repos · ${label}`);
-  console.log(await write(system, prompt));
-  console.log("");
+  const text = await write(system, prompt);
+  return { text: text || "(couldn't reach the model)", sub: `${cs.length} commits across ${new Set(cs.map((x) => x.repo)).size} repos · ${label}` };
 }
 
-async function cmdTodo() {
-  const repos = findRepos(BASE, 60);
-  const open = openWork(repos);
-  if (!open.length) { console.log(c.y("Nothing outstanding found (no TODOs or uncommitted work).")); return; }
-  const system =
-    `You summarise what's still on a developer's plate from their TODO markers and uncommitted work. ` +
-    `Group by project, lead with what looks most in-flight (uncommitted work) then the to-dos. ` +
-    `Be concise and concrete. No preamble.`;
-  header("Symbiot", `${open.length} open items · todo`);
-  console.log(await write(system, `Open work:\n${open.map((o) => `- ${o}`).join("\n")}\n\nWhat's still on my plate?`));
-  console.log("");
+async function cmdRun(cmd) {
+  if (!resolveProvider()) { console.log(AUTH_HELP); return; }
+  const r = await produce(cmd);
+  header(r.sub || cmd);
+  if (r.text) console.log(r.text + "\n");
+}
+
+// Save a provider connection (used by the web Settings panel); mirrors cmdLogin.
+async function connectProvider(b) {
+  const provider = b && b.provider;
+  if (!PROVIDERS[provider]) return { ok: false, message: "Unknown provider." };
+  const cfg = loadConfig();
+  if (provider === "ollama") {
+    const baseUrl = (b.baseUrl || "http://localhost:11434").trim();
+    const model = (b.model || "").trim() || PROVIDERS.ollama.model;
+    if (!(await validate("ollama", { baseUrl }))) return { ok: false, message: `Couldn't reach Ollama at ${baseUrl}. Is it running?` };
+    cfg.provider = "ollama"; cfg.ollama = { baseUrl, model }; delete cfg.apiKey;
+    return saveConfig(cfg) ? { ok: true, message: `Connected: ${PROVIDERS.ollama.label} · ${model}` } : { ok: false, message: "Couldn't write the config file." };
+  }
+  const key = (b.key || "").trim();
+  if (!key) return { ok: false, message: "No key entered." };
+  const model = (b.model || "").trim() || PROVIDERS[provider].model;
+  if (!(await validate(provider, { key }))) return { ok: false, message: `That key didn't work for ${PROVIDERS[provider].label}.` };
+  cfg.provider = provider; cfg[provider] = { apiKey: key, model }; delete cfg.apiKey;
+  return saveConfig(cfg) ? { ok: true, message: `Connected: ${PROVIDERS[provider].label} · ${model}` } : { ok: false, message: "Couldn't write the config file." };
+}
+
+function saveAndReport(cfg, what) {
+  if (saveConfig(cfg)) {
+    console.log(c.g("✓ ") + `Connected: ${what}. Try:  ` + c.b("symbiot week"));
+    console.log(c.d(`  Saved in ${CONFIG_PATH} (readable only by you).`));
+  } else console.log(c.y("Couldn't write the config file at " + CONFIG_PATH));
+}
+
+async function cmdLogin() {
+  const flagProvider = flag("provider", null);
+  const existing = resolveProvider();
+  if (existing && !flagProvider && !flag("key", null) && !has("force")) {
+    console.log(c.g("✓ ") + `Already connected — ${PROVIDERS[existing.provider].label} via ${existing.source}.`);
+    console.log(c.d("  Switch or replace it with `symbiot login --force`."));
+    return;
+  }
+
+  let provider = flagProvider;
+  if (!provider) {
+    console.log("\n" + c.b("Connect Symbiot") + "\n");
+    console.log("Which AI should Symbiot write your updates with?\n");
+    console.log("  1) " + PROVIDERS.anthropic.label + c.d("    — needs an Anthropic API key"));
+    console.log("  2) " + PROVIDERS.openai.label + c.d("          — needs an OpenAI API key"));
+    console.log("  3) " + PROVIDERS.gemini.label + c.d("       — needs a Google AI API key"));
+    console.log("  4) " + PROVIDERS.ollama.label + c.d("  — runs on your machine, no key"));
+    const pick = (await ask("\nChoose 1-4 [1]: ")) || "1";
+    provider = { 1: "anthropic", 2: "openai", 3: "gemini", 4: "ollama" }[pick] || (PROVIDERS[pick] ? pick : "anthropic");
+  }
+  if (!PROVIDERS[provider]) { console.log(c.y("Unknown provider: " + provider)); return; }
+  const meta = PROVIDERS[provider];
+  const cfg = loadConfig();
+
+  if (provider === "ollama") {
+    const baseUrl = (flag("base-url", null) || (await ask("Ollama URL [http://localhost:11434]: ")) || "").trim() || "http://localhost:11434";
+    const model = (flag("model", null) || (await ask(`Model name [${meta.model}]: `)) || "").trim() || meta.model;
+    const stop = spinner("checking Ollama…");
+    const ok = await validate("ollama", { baseUrl });
+    stop();
+    if (!ok) { console.log(c.y(`Couldn't reach Ollama at ${baseUrl}. `) + c.d("Is it running?  (try: ollama serve)")); process.exitCode = 1; return; }
+    cfg.provider = "ollama"; cfg.ollama = { baseUrl, model }; delete cfg.apiKey;
+    saveAndReport(cfg, `${meta.label} · ${model}`);
+    return;
+  }
+
+  console.log("\n" + c.b(`Connect ${meta.label}`) + "\n" + c.d(`  Get a key at:  ${meta.keyUrl}`) + "\n");
+  let key = flag("key", null);
+  if (!key) key = await ask(`Paste your ${meta.keyName}: `, { secret: true });
+  key = (key || "").trim();
+  if (!key) { console.log(c.y("No key entered — nothing saved.")); return; }
+  const model = (flag("model", null) || "").trim() || meta.model;
+
+  const stop = spinner("checking the key…");
+  const ok = await validate(provider, { key });
+  stop();
+  if (!ok) {
+    console.log(c.y(`That key didn't work for ${meta.label}. `) + c.d("Double-check it and run `symbiot login` again."));
+    process.exitCode = 1;
+    return;
+  }
+  cfg.provider = provider; cfg[provider] = { apiKey: key, model }; delete cfg.apiKey;
+  saveAndReport(cfg, `${meta.label} · ${model}`);
+}
+
+function cmdLogout() {
+  const cfg = loadConfig();
+  const had = cfg.provider || cfg.apiKey || Object.keys(PROVIDERS).some((p) => cfg[p]);
+  delete cfg.provider; delete cfg.apiKey;
+  for (const p of Object.keys(PROVIDERS)) delete cfg[p];
+  saveConfig(cfg);
+  console.log(had ? c.g("✓ ") + `Cleared saved credentials from ${CONFIG_PATH}.` : "No saved credentials to remove.");
+  const envs = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY"].filter((e) => process.env[e]);
+  if (envs.length) console.log(c.d(`Note: still set in your environment: ${envs.join(", ")}.`));
+}
+
+function cmdWhoami() {
+  const r = resolveProvider();
+  if (r) console.log(c.g("✓ ") + `Connected: ${PROVIDERS[r.provider].label} · model ${r.model} · via ${r.source}.`);
+  else { console.log(c.y("Not connected yet.\n")); console.log(AUTH_HELP); }
+}
+
+// ---- `symbiot app` : the same UI in a chrome-less browser window ----------
+// Self-contained HTML served at / — no backticks or ${} inside (it lives in a
+// template literal). Talks to the local API with the per-launch token.
+const EMBEDDED_UI = `<!doctype html><html><head><meta charset="utf8">
+<meta name="viewport" content="width=device-width,initial-scale=1"><title>Symbiot</title>
+<style>
+:root{--ink:#0E1A1F;--ink2:#15262C;--ink3:#1D333A;--line:#24404A;--bone:#F4F1EA;--text:#B7C9C4;--faint:#7E9690;--green:#3DDC97;--amber:#F2A541;--green-dim:#16322D;--sans:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif}
+*{box-sizing:border-box}html,body{margin:0;height:100%}
+body{background:var(--ink);color:var(--text);font-family:var(--sans);font-size:14px;display:flex;flex-direction:column}
+header{padding:16px 18px 10px;display:flex;align-items:center;gap:10px}
+.dot{width:10px;height:10px;border-radius:50%;background:var(--green);box-shadow:0 0 12px var(--green)}
+.brand{font-weight:700;color:var(--bone);font-size:16px}
+.status{margin-left:auto;font-size:12px;color:var(--faint);text-align:right;max-width:52%}
+.tabs{display:flex;gap:6px;padding:0 14px;border-bottom:1px solid var(--line)}
+.tab{padding:9px 14px;border:0;background:none;color:var(--faint);font:inherit;font-weight:600;cursor:pointer;border-bottom:2px solid transparent}
+.tab.active{color:var(--bone);border-bottom-color:var(--green)}
+main{flex:1;overflow:auto;padding:16px 18px}
+.row{display:flex;gap:10px;align-items:center;margin-bottom:12px;flex-wrap:wrap}
+button.act{background:var(--green);color:var(--ink);border:0;border-radius:10px;padding:10px 16px;font:inherit;font-weight:700;cursor:pointer}
+button.act:hover{filter:brightness(1.08)}
+button.ghost{background:var(--ink3);color:var(--bone);border:1px solid var(--line);border-radius:10px;padding:9px 14px;font:inherit;font-weight:600;cursor:pointer}
+button.ghost:hover{border-color:var(--faint)}
+.out{white-space:pre-wrap;background:var(--ink2);border:1px solid var(--line);border-radius:12px;padding:16px;min-height:180px;color:var(--bone);line-height:1.6}
+.muted{color:var(--faint)}
+label{display:block;font-size:12px;color:var(--faint);margin:14px 0 5px}
+select,input{width:100%;background:var(--ink);border:1px solid var(--line);border-radius:9px;padding:10px 12px;color:var(--bone);font:inherit}
+select:focus,input:focus{outline:none;border-color:var(--green)}
+a{color:var(--green);cursor:pointer}.hidden{display:none}
+.note{font-size:12px;margin-top:10px}.ok{color:var(--green)}.err{color:var(--amber)}
+footer{padding:10px 18px;border-top:1px solid var(--line);display:flex}
+</style></head><body>
+<header><span class="dot"></span><span class="brand">Symbiot</span><span class="status" id="status">...</span></header>
+<div class="tabs">
+<button class="tab active" data-tab="week">Week</button>
+<button class="tab" data-tab="standup">Standup</button>
+<button class="tab" data-tab="todo">Todo</button>
+<button class="tab" data-tab="settings">Settings</button>
+</div>
+<main>
+<section id="panel-run">
+<div class="row"><button class="act" id="write">Write my <span id="what">week</span></button>
+<button class="ghost hidden" id="copy">Copy</button>
+<span class="muted">Reads your local git and writes it up.</span></div>
+<div class="out muted" id="out">Nothing yet - hit the button.</div>
+</section>
+<section id="panel-settings" class="hidden">
+<label>Which AI should Symbiot write with?</label>
+<select id="provider">
+<option value="anthropic">Claude (Anthropic)</option>
+<option value="openai">OpenAI (GPT)</option>
+<option value="gemini">Gemini (Google)</option>
+<option value="ollama">Local model (Ollama)</option>
+</select>
+<div id="keyWrap"><label>API key</label><input id="key" type="password" placeholder="paste your key">
+<div class="note"><a id="getkey">Where do I get a key?</a></div></div>
+<div id="baseWrap" class="hidden"><label>Ollama URL</label><input id="baseUrl" type="text" value="http://localhost:11434"></div>
+<label>Model <span class="muted" id="modelHint"></span></label>
+<input id="model" type="text" placeholder="(blank = default)">
+<div class="row" style="margin-top:16px"><button class="act" id="save">Save &amp; connect</button>
+<span class="note" id="saveMsg"></span></div>
+</section>
+</main>
+<footer><button class="ghost" id="quit" style="margin-left:auto">Quit</button></footer>
+<script>
+var T=new URLSearchParams(window.location.search).get('t')||'';
+function api(path,body){return fetch(path,{method:body?'POST':'GET',headers:{'x-symbiot-token':T,'content-type':'application/json'},body:body?JSON.stringify(body):undefined}).then(function(r){return r.json();});}
+var KEYURL={anthropic:'https://console.anthropic.com/settings/keys',openai:'https://platform.openai.com/api-keys',gemini:'https://aistudio.google.com/apikey',ollama:'https://ollama.com'};
+var DEFMODEL={anthropic:'claude-opus-5-5',openai:'gpt-4o-mini',gemini:'gemini-1.5-flash',ollama:'llama3.1'};
+function $(id){return document.getElementById(id);}
+var current='week';
+function tabs(){return document.querySelectorAll('.tab');}
+function setTab(tab){current=tab;tabs().forEach(function(t){t.classList.toggle('active',t.dataset.tab===tab);});
+var s=tab==='settings';$('panel-run').classList.toggle('hidden',s);$('panel-settings').classList.toggle('hidden',!s);
+if(!s){$('what').textContent=tab;$('out').textContent='Nothing yet - hit the button.';$('out').classList.add('muted');$('copy').classList.add('hidden');}}
+tabs().forEach(function(t){t.addEventListener('click',function(){setTab(t.dataset.tab);});});
+function refresh(){api('/api/status').then(function(s){$('status').textContent=s.connected?s.line:'Not connected - open Settings';});}
+$('write').addEventListener('click',function(){$('out').textContent='Writing...';$('out').classList.add('muted');$('copy').classList.add('hidden');
+api('/api/run',{cmd:current}).then(function(r){if(r.error==='not-connected'){$('out').textContent='Not connected yet - open Settings and pick an AI.';return;}
+$('out').textContent=r.text||'(no output)';$('out').classList.remove('muted');$('copy').classList.remove('hidden');});});
+$('copy').addEventListener('click',function(){navigator.clipboard.writeText($('out').textContent);$('copy').textContent='Copied';setTimeout(function(){$('copy').textContent='Copy';},1400);});
+function syncP(){var p=$('provider').value;var local=p==='ollama';$('keyWrap').classList.toggle('hidden',local);$('baseWrap').classList.toggle('hidden',!local);
+$('getkey').textContent=local?'About Ollama':'Where do I get a key?';$('modelHint').textContent='(default '+DEFMODEL[p]+')';$('model').placeholder='(blank = '+DEFMODEL[p]+')';}
+$('provider').addEventListener('change',syncP);
+$('getkey').addEventListener('click',function(){window.open(KEYURL[$('provider').value],'_blank');});
+$('save').addEventListener('click',function(){var p=$('provider').value;$('saveMsg').textContent='checking...';$('saveMsg').className='note muted';
+var cfg={provider:p,model:$('model').value.trim()};if(p==='ollama')cfg.baseUrl=$('baseUrl').value.trim();else cfg.key=$('key').value.trim();
+api('/api/connect',cfg).then(function(r){$('saveMsg').textContent=r.message||(r.ok?'Connected.':'Could not connect.');$('saveMsg').className='note '+(r.ok?'ok':'err');if(r.ok){$('key').value='';refresh();}});});
+$('quit').addEventListener('click',function(){api('/api/quit');document.body.innerHTML='<div style=\\'padding:40px;color:#7E9690;font-family:sans-serif\\'>Symbiot stopped. You can close this window.</div>';});
+syncP();refresh();
+</script></body></html>`;
+
+function readBody(req) {
+  return new Promise((resolve) => {
+    let d = ""; req.on("data", (ch) => (d += ch));
+    req.on("end", () => { try { resolve(d ? JSON.parse(d) : {}); } catch { resolve({}); } });
+  });
+}
+function onPath(cands) { for (const cc of cands) { if (sh(`command -v ${cc} 2>/dev/null`).trim()) return cc; } return null; }
+function openApp(url) {
+  try {
+    const chrome = onPath(["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "brave-browser", "microsoft-edge"]);
+    if (chrome) { spawn(chrome, [`--app=${url}`, "--new-window"], { detached: true, stdio: "ignore" }).unref(); return "app window"; }
+    const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    spawn(opener, [url], { detached: true, stdio: "ignore", shell: process.platform === "win32" }).unref();
+    return "browser tab";
+  } catch { return null; }
+}
+async function cmdApp() {
+  SERVING = true;
+  const TOKEN = randomBytes(16).toString("hex");
+  const json = (res, obj) => { res.writeHead(200, { "content-type": "application/json" }); res.end(JSON.stringify(obj)); };
+  const server = createServer(async (req, res) => {
+    const u = new URL(req.url, "http://127.0.0.1");
+    if (req.method === "GET" && u.pathname === "/") { res.writeHead(200, { "content-type": "text/html; charset=utf-8" }); res.end(EMBEDDED_UI); return; }
+    if (u.pathname.startsWith("/api/")) {
+      const tok = req.headers["x-symbiot-token"] || u.searchParams.get("t");
+      if (tok !== TOKEN) { res.writeHead(403); res.end("forbidden"); return; }
+    }
+    try {
+      if (u.pathname === "/api/status") { const r = resolveProvider(); return json(res, r ? { connected: true, line: `${PROVIDERS[r.provider].label} · ${r.model}` } : { connected: false }); }
+      if (u.pathname === "/api/run" && req.method === "POST") { const b = await readBody(req); const cmd = ["week", "standup", "todo"].includes(b.cmd) ? b.cmd : "week"; return json(res, await produce(cmd)); }
+      if (u.pathname === "/api/connect" && req.method === "POST") { return json(res, await connectProvider(await readBody(req))); }
+      if (u.pathname === "/api/quit") { res.writeHead(200); res.end("bye"); setTimeout(() => process.exit(0), 150); return; }
+    } catch (e) { res.writeHead(500, { "content-type": "application/json" }); res.end(JSON.stringify({ error: String((e && e.message) || e) })); return; }
+    res.writeHead(404); res.end("not found");
+  });
+  server.listen(0, "127.0.0.1", () => {
+    const url = `http://127.0.0.1:${server.address().port}/?t=${TOKEN}`;
+    const how = openApp(url);
+    console.log(`\n${c.g("●")} ${c.b("Symbiot")} is running at ${c.b(url)}`);
+    console.log(how ? c.d(`  Opened in a ${how}.`) : c.d("  Open that URL in your browser."));
+    console.log(c.d("  Leave this running; press Ctrl+C to stop (or click Quit in the window)."));
+  });
 }
 
 const HELP = `${c.b("symbiot")} — your week, written from your real work.
@@ -209,24 +587,37 @@ ${c.b("Usage")}
   symbiot ${c.d("(or)")} symbiot week      write up your last ${SINCE_WEEK} days
   symbiot standup                   yesterday + today, for standup
   symbiot todo                      what's still on your plate
+  symbiot app                       open the visual app in your browser
+  symbiot login                     connect it to an AI (once)
+  symbiot whoami                    show how it's connected
+  symbiot logout                    forget saved credentials
   symbiot help
 
 ${c.b("Options")}
   --dir <path>    where your repos are (default: ${homedir()})
   --since <days>  window for 'week' (default 7)
+  --all           everyone's commits, not just yours
   --plain         no colour/spinner (good for piping)
 
-${c.b("Setup")}  one key, nothing else:
-  export ANTHROPIC_API_KEY=sk-ant-...   ${c.d("(or: ant auth login)")}
+${c.b("Setup")}  pick any AI to write with:
+  symbiot login                       ${c.d("choose Claude / OpenAI / Gemini / Ollama")}
+  symbiot login --provider openai --key sk-...   ${c.d("(non-interactive)")}
+  ${c.d("Env keys also work: ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY.")}
+  ${c.d("Override the model per run with SYMBIOT_MODEL.")}
 
 ${c.d("Reads only your local git. No accounts, no OAuth, no data leaves except the")}
-${c.d("commit summaries sent to the model to write your update.")}`;
+${c.d("commit summaries sent to the AI to write your update (nothing leaves at all")}
+${c.d("with a local Ollama model).")}`;
 
 // ---- main -----------------------------------------------------------------
 (async () => {
   if (cmd === "help" || cmd === "--help" || cmd === "-h") { console.log(HELP); return; }
-  if (cmd === "week") return cmdWeek(SINCE_WEEK, "week");
-  if (cmd === "standup") return cmdWeek(2, "standup");
-  if (cmd === "todo") return cmdTodo();
+  if (cmd === "login" || cmd === "auth") return cmdLogin();
+  if (cmd === "logout") return cmdLogout();
+  if (cmd === "whoami" || cmd === "status") return cmdWhoami();
+  if (cmd === "app" || cmd === "ui") return cmdApp();
+  if (cmd === "week") return cmdRun("week");
+  if (cmd === "standup") return cmdRun("standup");
+  if (cmd === "todo") return cmdRun("todo");
   console.log(c.y(`Unknown command: ${cmd}`) + "\n"); console.log(HELP);
 })();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "symbiot",
-  "version": "0.1.1",
-  "description": "Your week, written from your real work. Reads your local git — no accounts, no OAuth, just an AI key you bring yourself.",
+  "version": "0.4.0",
+  "description": "Your week, written from your real work. Reads your local git and writes it up with the AI of your choice — Claude, OpenAI, Gemini, or a local model.",
   "type": "module",
   "bin": {
     "symbiot": "index.mjs"
@@ -21,6 +21,10 @@
     "changelog",
     "productivity",
     "ai",
+    "claude",
+    "openai",
+    "gemini",
+    "ollama",
     "developer-tools",
     "cli"
   ],