symbiot 0.1.0 → 0.2.0

package/README.md

@@ -11,6 +11,8 @@ bring yourself.
 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 login      connect it to Claude (once)
+symbiot whoami     show how it's connected
 symbiot help
 ```
 
@@ -20,12 +22,19 @@ symbiot help
 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)
+
+Symbiot writes with **Claude**, so it needs an Anthropic API key. The easiest way:
 
 ```bash
-export ANTHROPIC_API_KEY=sk-ant-...     # or:  ant auth login
+symbiot login     # paste a key once — saved locally to ~/.config/symbiot
 ```
 
+Get a key at <https://console.anthropic.com/settings/keys>. Prefer an env var? Set
+`ANTHROPIC_API_KEY=sk-ant-...` instead and skip `login`. If you already use the
+Anthropic CLI, `ant auth login` works too — Symbiot picks up any of these
+automatically, and `symbiot whoami` shows which one it's using.
+
 ## Use
 
 ```bash
@@ -52,8 +61,11 @@ Point it somewhere specific with `--dir ~/work`.
 
 ## 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` — the model to use (default `claude-opus-5-5`; `claude-haiku-4-5`
+  is a cheaper option for this kind of summary).
+- `ANTHROPIC_API_KEY` — your key. Or run `symbiot login` once, or use an
+  `ant auth login` profile. `symbiot whoami` shows which credential is active;
+  `symbiot logout` forgets a saved key.
 
 ---
 

package/index.mjs

@@ -2,12 +2,14 @@
 // 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 Claude, so it needs an
+// Anthropic API key — set one 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 Claude (once)
+//   symbiot whoami    show how it's connected
 //   symbiot help
 //
 // Flags:  --dir <path>  where to look (default: your home folder)
@@ -17,10 +19,15 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { execSync } 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";
 
-const MODEL = process.env.SYMBIOT_MODEL || "claude-opus-5";
+const MODEL = process.env.SYMBIOT_MODEL || "claude-opus-5-5";
 const MAX_REPOS = 14;
 const MAX_COMMITS = 140;
+const CONFIG_DIR = join(homedir(), ".config", "symbiot");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 
 // ---- tiny arg parse --------------------------------------------------------
 const argv = process.argv.slice(2);
@@ -49,6 +56,60 @@ function spinner(label) {
   return () => { clearInterval(t); process.stderr.write("\r\x1b[K"); };
 }
 
+// ---- auth ------------------------------------------------------------------
+// Symbiot writes with Claude. Credentials can come from (first wins):
+//   1. ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN in the environment
+//   2. a key saved by `symbiot login` (~/.config/symbiot/config.json)
+//   3. an Anthropic CLI profile on disk (`ant auth login`), which the SDK reads
+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; }
+}
+// Returns { opts, source } for building the client, or null if nothing is set up.
+function resolveAuth() {
+  if (process.env.ANTHROPIC_API_KEY) return { opts: {}, source: "ANTHROPIC_API_KEY (environment)" };
+  if (process.env.ANTHROPIC_AUTH_TOKEN) return { opts: {}, source: "ANTHROPIC_AUTH_TOKEN (environment)" };
+  const cfg = loadConfig();
+  if (cfg.apiKey) return { opts: { apiKey: cfg.apiKey }, source: "your saved login (~/.config/symbiot)" };
+  if (antProfileExists()) return { opts: {}, source: "your Anthropic CLI login (ant auth login)" };
+  return null;
+}
+function getClient() {
+  const auth = resolveAuth();
+  if (!auth) return null;
+  try { return { client: new Anthropic(auth.opts), source: auth.source }; }
+  catch { 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 }); }
@@ -120,29 +181,32 @@ function openWork(repos) {
 
 // ---- claude ---------------------------------------------------------------
 async function write(system, prompt) {
-  let client;
-  try { client = new Anthropic(); } catch { client = null; }
+  const conn = getClient();
+  if (!conn) { console.log(AUTH_HELP); return null; }
   const stop = spinner("thinking…");
   try {
-    const res = await client.messages.create({
+    const res = await conn.client.messages.create({
       model: MODEL, max_tokens: 1600,
+      output_config: { effort: "low" }, // a summary doesn't need deep reasoning — keeps it fast + cheap
       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();
   } catch (err) {
-    if (err instanceof Anthropic.AuthenticationError || /api key|ANTHROPIC_API_KEY|credential/i.test(err?.message || "")) {
-      return AUTH_HELP;
+    if (err instanceof Anthropic.AuthenticationError || /api key|ANTHROPIC_API_KEY|authentication|credential|401/i.test(err?.message || "")) {
+      console.log(c.y("Your Claude key was rejected. ") + "Re-connect 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.)");
+const AUTH_HELP =
+  c.y("Symbiot writes your updates with Claude, so it needs an Anthropic API key.\n") +
+  "  Fastest:   " + c.b("symbiot login") + c.d("        paste a key once; saved to ~/.config/symbiot") + "\n" +
+  "  Or set:    export ANTHROPIC_API_KEY=sk-ant-...\n" +
+  "  Get a key: https://console.anthropic.com/settings/keys\n" +
+  c.d("  (If you use the Anthropic CLI, `ant auth login` works too.)");
 
 // ---- render ---------------------------------------------------------------
 function renderCommits(list) {
@@ -158,6 +222,7 @@ const SINCE_WEEK = Number(flag("since", "7"));
 const BASE = flag("dir", homedir());
 
 async function cmdWeek(days, label) {
+  if (!resolveAuth()) { console.log(AUTH_HELP); return; }
   const who = me();
   const repos = findRepos(BASE, days);
   if (!repos.length) {
@@ -186,11 +251,12 @@ async function cmdWeek(days, label) {
     `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 out = await write(system, prompt);
+  if (out) console.log(out + "\n");
 }
 
 async function cmdTodo() {
+  if (!resolveAuth()) { console.log(AUTH_HELP); return; }
   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; }
@@ -199,8 +265,67 @@ async function cmdTodo() {
     `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("");
+  const out = await write(system, `Open work:\n${open.map((o) => `- ${o}`).join("\n")}\n\nWhat's still on my plate?`);
+  if (out) console.log(out + "\n");
+}
+
+async function cmdLogin() {
+  const existing = resolveAuth();
+  const provided = flag("key", null);
+  if (existing && !provided && !has("force")) {
+    console.log(c.g("✓ ") + `Already connected — Symbiot is using ${existing.source}.`);
+    console.log(c.d("  Replace it with `symbiot login --force`, or just run `symbiot week`."));
+    return;
+  }
+  console.log("\n" + c.b("Connect Symbiot to Claude") + "\n");
+  console.log("Symbiot writes your updates with Claude (Anthropic). It needs an API key,");
+  console.log("stored locally on this machine and used only to write your updates.\n");
+  console.log(c.d("  Get a key at:  https://console.anthropic.com/settings/keys") + "\n");
+
+  let key = provided;
+  if (!key) key = await ask("Paste your Anthropic API key (sk-ant-…): ", { secret: true });
+  key = (key || "").trim();
+  if (!key) { console.log(c.y("No key entered — nothing saved.")); return; }
+  if (!/^sk-ant-/.test(key)) console.log(c.d("(that doesn't look like an sk-ant- key, but I'll try it)"));
+
+  const stop = spinner("checking the key…");
+  let ok = false, why = "";
+  try { await new Anthropic({ apiKey: key }).models.list(); ok = true; }
+  catch (e) {
+    if (e instanceof Anthropic.AuthenticationError || /401|invalid|authentication/i.test(e?.message || ""))
+      why = "Anthropic rejected it — the key looks invalid.";
+    else why = `couldn't reach Anthropic — ${e?.message || e}`;
+  }
+  finally { stop(); }
+
+  if (!ok) {
+    console.log(c.y("That key didn't work: ") + why);
+    console.log(c.d("Double-check it and run `symbiot login` again."));
+    process.exitCode = 1;
+    return;
+  }
+  if (saveConfig({ ...loadConfig(), apiKey: key })) {
+    console.log(c.g("✓ ") + "Connected. You're set — try:  " + c.b("symbiot week"));
+    console.log(c.d(`  Key saved in ${CONFIG_PATH} (readable only by you).`));
+  } else {
+    console.log(c.y("Couldn't write the config file. Set it in your shell instead:"));
+    console.log("  export ANTHROPIC_API_KEY=" + key);
+  }
+}
+
+function cmdLogout() {
+  const cfg = loadConfig();
+  if (!cfg.apiKey) { console.log("No saved key to remove."); return; }
+  delete cfg.apiKey;
+  saveConfig(cfg);
+  console.log(c.g("✓ ") + `Removed the saved key from ${CONFIG_PATH}.`);
+  if (process.env.ANTHROPIC_API_KEY) console.log(c.d("Note: ANTHROPIC_API_KEY is still set in your environment."));
+}
+
+function cmdWhoami() {
+  const a = resolveAuth();
+  if (a) console.log(c.g("✓ ") + `Symbiot is connected — using ${a.source}.  Model: ${MODEL}`);
+  else { console.log(c.y("Not connected yet.\n")); console.log(AUTH_HELP); }
 }
 
 const HELP = `${c.b("symbiot")} — your week, written from your real work.
@@ -209,15 +334,21 @@ ${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 login                     connect it to Claude (once)
+  symbiot whoami                    show how it's connected
+  symbiot logout                    forget the saved key
   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")}  it writes with Claude, so it needs one Anthropic key:
+  symbiot login                         ${c.d("paste a key once (recommended)")}
+  export ANTHROPIC_API_KEY=sk-ant-...   ${c.d("or set it yourself")}
+  ${c.d("Change the model with SYMBIOT_MODEL (default " + MODEL + "; e.g. claude-haiku-4-5 is cheaper).")}
 
 ${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.")}`;
@@ -225,6 +356,9 @@ ${c.d("commit summaries sent to the model to write your update.")}`;
 // ---- main -----------------------------------------------------------------
 (async () => {
   if (cmd === "help" || cmd === "--help" || cmd === "-h") { console.log(HELP); return; }
+  if (cmd === "login" || cmd === "auth") return cmdLogin();
+  if (cmd === "logout") return cmdLogout();
+  if (cmd === "whoami" || cmd === "status") return cmdWhoami();
   if (cmd === "week") return cmdWeek(SINCE_WEEK, "week");
   if (cmd === "standup") return cmdWeek(2, "standup");
   if (cmd === "todo") return cmdTodo();

package/package.json

@@ -1,13 +1,40 @@
 {
   "name": "symbiot",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Your week, written from your real work. Reads your local git — no accounts, no OAuth, just an AI key you bring yourself.",
   "type": "module",
-  "bin": { "symbiot": "index.mjs" },
-  "files": ["index.mjs", "README.md", "LICENSE"],
-  "engines": { "node": ">=18" },
-  "keywords": ["git", "standup", "weekly-update", "changelog", "productivity", "ai", "developer-tools", "cli"],
+  "bin": {
+    "symbiot": "index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "git",
+    "standup",
+    "weekly-update",
+    "changelog",
+    "productivity",
+    "ai",
+    "developer-tools",
+    "cli"
+  ],
   "author": "Garth White <garth@ghost-ai.co.za>",
   "license": "MIT",
-  "dependencies": { "@anthropic-ai/sdk": "^0.128.0" }
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GarthGhostai/symbiot.git"
+  },
+  "homepage": "https://github.com/GarthGhostai/symbiot#readme",
+  "bugs": {
+    "url": "https://github.com/GarthGhostai/symbiot/issues"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.128.0"
+  }
 }