@memmo/cli 0.7.0

package/dist/index.js

@@ -0,0 +1,1957 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/version.ts
+import { createRequire } from "node:module";
+var require2, pkg, VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    require2 = createRequire(import.meta.url);
+    pkg = require2("../package.json");
+    VERSION = pkg.version;
+  }
+});
+
+// src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  apiFetch: () => apiFetch
+});
+async function apiFetch(opts, path, init = {}) {
+  const headers = {
+    ...init.headers
+  };
+  if (init.body != null && headers["content-type"] === void 0) {
+    headers["content-type"] = "application/json";
+  }
+  if (opts.token) headers.authorization = `Bearer ${opts.token}`;
+  headers["user-agent"] = `memmo-cli/${VERSION} (${process.platform}; node ${process.versions.node})`;
+  const res = await fetch(`${opts.baseUrl}${path}`, { ...init, headers });
+  const text = await res.text();
+  const body = text ? JSON.parse(text) : null;
+  if (!res.ok) {
+    const message = body?.error ?? res.statusText;
+    throw new Error(`API ${res.status}: ${message}`);
+  }
+  return body;
+}
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    init_version();
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/login.ts
+import { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+import { hostname } from "node:os";
+import { exec } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+
+// src/config.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { execSync } from "node:child_process";
+var CRED_DIR = join(homedir(), ".memmo");
+var CRED_FILE = join(CRED_DIR, "credentials.json");
+var PROJECT_DIR = ".memmo";
+var PROJECT_CONFIG = join(PROJECT_DIR, "config.json");
+function saveCredentials(creds) {
+  if (!existsSync(CRED_DIR)) mkdirSync(CRED_DIR, { recursive: true });
+  writeFileSync(CRED_FILE, JSON.stringify(creds, null, 2), { mode: 384 });
+}
+function loadCredentials() {
+  if (!existsSync(CRED_FILE)) return null;
+  return JSON.parse(readFileSync(CRED_FILE, "utf8"));
+}
+function loadProjectConfig(cwd = process.cwd()) {
+  const file = join(cwd, PROJECT_CONFIG);
+  if (!existsSync(file)) return null;
+  return JSON.parse(readFileSync(file, "utf8"));
+}
+var REPO_CACHE = join(CRED_DIR, "repos.json");
+var REPO_CACHE_TTL_MS = 12 * 60 * 60 * 1e3;
+function readRepoCache() {
+  try {
+    return existsSync(REPO_CACHE) ? JSON.parse(readFileSync(REPO_CACHE, "utf8")) : {};
+  } catch {
+    return {};
+  }
+}
+function cacheRepo(remote, entry) {
+  try {
+    if (!existsSync(CRED_DIR)) mkdirSync(CRED_DIR, { recursive: true });
+    const cache = readRepoCache();
+    cache[remote] = { ...entry, at: Date.now() };
+    writeFileSync(REPO_CACHE, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+function forgetRepo(remote) {
+  try {
+    const cache = readRepoCache();
+    delete cache[remote];
+    writeFileSync(REPO_CACHE, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+var DEFAULT_API_BASE_URL = process.env.MEMMO_API_URL ?? "https://api.memmo.dev";
+function detectGitRemote(cwd = process.cwd()) {
+  try {
+    return execSync("git remote get-url origin", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function resolveProjectConfig(cwd = process.cwd(), opts = {}) {
+  const creds = loadCredentials();
+  const apiBaseUrl = opts.apiBaseUrl ?? process.env.MEMMO_API_URL ?? creds?.apiBaseUrl ?? DEFAULT_API_BASE_URL;
+  const explicit = opts.repoId ?? process.env.MEMMO_REPO_ID;
+  if (explicit) return { apiBaseUrl, repoId: explicit };
+  const remote = detectGitRemote(cwd);
+  if (remote && creds) {
+    const hit = readRepoCache()[remote];
+    if (hit && hit.apiBaseUrl === apiBaseUrl && Date.now() - hit.at < REPO_CACHE_TTL_MS) {
+      return { apiBaseUrl, repoId: hit.repoId, repoFullName: hit.fullName };
+    }
+    try {
+      const { apiFetch: apiFetch2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+      const r = await apiFetch2(
+        { baseUrl: apiBaseUrl, token: creds.token },
+        "/repos/resolve",
+        { method: "POST", body: JSON.stringify({ repoRemote: remote }) }
+      );
+      if (r?.repoId) {
+        cacheRepo(remote, { repoId: r.repoId, fullName: r.fullName, apiBaseUrl });
+        return { apiBaseUrl, repoId: r.repoId, repoFullName: r.fullName };
+      }
+    } catch {
+    }
+  }
+  const legacy = loadProjectConfig(cwd);
+  return legacy ? { ...legacy, apiBaseUrl: legacy.apiBaseUrl ?? apiBaseUrl } : null;
+}
+var NOT_CONNECTED = "This repo isn't connected to Memmo yet. Run `memmo init` to add it to a project.";
+function repoFullNameFromRemote(remote) {
+  let s = remote.trim();
+  s = s.replace(/^git@[^:]+:/, "");
+  s = s.replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]+\//i, "");
+  s = s.replace(/\.git$/i, "").replace(/^\/+|\/+$/g, "");
+  const parts = s.split("/").filter(Boolean);
+  return parts.length >= 2 ? parts.slice(-2).join("/") : null;
+}
+
+// src/commands/login.ts
+async function whoami(baseUrl, token) {
+  const res = await fetch(`${baseUrl}/me`, { headers: { authorization: `Bearer ${token}` } });
+  if (!res.ok) throw new Error(`That token was rejected by ${baseUrl} (${res.status}).`);
+  return await res.json();
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, () => {
+  });
+}
+async function browserLogin(baseUrl, appUrl, noBrowser) {
+  const state = randomBytes(16).toString("hex");
+  return new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      if (url.pathname !== "/callback") {
+        res.writeHead(404).end();
+        return;
+      }
+      const token = url.searchParams.get("token");
+      const ok = token && url.searchParams.get("state") === state;
+      res.writeHead(ok ? 200 : 400, { "content-type": "text/html; charset=utf-8" });
+      res.end(
+        ok ? "<!doctype html><body style='font-family:system-ui;background:#0a0711;color:#ece9f3;display:grid;place-items:center;height:100vh'><div><h2>Memmo CLI authorized \u2713</h2><p>You can close this tab and return to your terminal.</p></div></body>" : "<!doctype html><body style='font-family:system-ui'><h2>Invalid callback</h2><p>Run <code>memmo login</code> again.</p></body>"
+      );
+      if (ok) {
+        clearTimeout(timer);
+        server.close();
+        resolve(token);
+      }
+    });
+    const timer = setTimeout(() => {
+      server.close();
+      reject(new Error("Timed out waiting for the browser. Run `memmo login` again, or use `memmo login --token <token>`."));
+    }, 5 * 60 * 1e3);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      const url = new URL("/cli/auth", appUrl);
+      url.searchParams.set("port", String(port));
+      url.searchParams.set("state", state);
+      url.searchParams.set("host", hostname());
+      console.log(`Opening your browser to sign in to Memmo\u2026
+  ${url.toString()}
+`);
+      if (!noBrowser) openBrowser(url.toString());
+    });
+  });
+}
+async function devLogin(baseUrl, email) {
+  if (!email) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    email = (await rl.question("Email: ")).trim();
+    rl.close();
+  }
+  const loginRes = await fetch(`${baseUrl}/auth/login`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ email })
+  });
+  if (!loginRes.ok) throw new Error(`Login failed: ${loginRes.status} ${await loginRes.text()}`);
+  const cookie = loginRes.headers.getSetCookie?.().join("; ") ?? "";
+  const tokenRes = await fetch(`${baseUrl}/auth/tokens`, {
+    method: "POST",
+    headers: { "content-type": "application/json", cookie },
+    body: JSON.stringify({ name: `cli \xB7 ${hostname()}` })
+  });
+  if (!tokenRes.ok) throw new Error(`Token mint failed: ${tokenRes.status} ${await tokenRes.text()}`);
+  return (await tokenRes.json()).token;
+}
+async function loginCommand(opts) {
+  const baseUrl = (opts.api ?? DEFAULT_API_BASE_URL).replace(/\/$/, "");
+  let config = {};
+  try {
+    const r = await fetch(`${baseUrl}/auth/config`);
+    if (r.ok) config = await r.json();
+  } catch {
+    throw new Error(`Can't reach the Memmo API at ${baseUrl}. Is it the right URL? (--api <url> or MEMMO_API_URL)`);
+  }
+  let token;
+  if (opts.token) {
+    token = opts.token.trim();
+  } else if (opts.email || opts.browser !== false && !config.github && config.devLogin) {
+    token = await devLogin(baseUrl, opts.email);
+  } else {
+    token = await browserLogin(baseUrl, config.appUrl ?? "https://app.memmo.dev", opts.browser === false);
+  }
+  const me = await whoami(baseUrl, token);
+  saveCredentials({ apiBaseUrl: baseUrl, token });
+  console.log(`Logged in as ${me.email}. Credentials saved to ~/.memmo/credentials.json`);
+  console.log("Next: run `memmo init` inside a repo.");
+}
+
+// src/commands/init.ts
+import { createInterface as createInterface2 } from "node:readline/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+init_api();
+
+// src/commands/claude-install.ts
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var MEMMO_CMD = "npx";
+var MEMMO_ARGS = ["-y", "@memmo/cli"];
+var hook = (event) => [MEMMO_CMD, ...MEMMO_ARGS, "hook", event].join(" ");
+var MCP_SERVER = { type: "stdio", command: MEMMO_CMD, args: [...MEMMO_ARGS, "mcp"] };
+var CLAUDE_MD_SECTION = `# Memmo Project Memory
+
+Before making changes, use the Memmo MCP tools to retrieve relevant repo memory.
+
+Recommended tools:
+- get_repo_context \u2014 call before starting work in this repo
+- search_memory \u2014 search approved memories relevant to your task
+- get_relevant_warnings \u2014 call BEFORE editing files, passing the paths you'll touch, to surface known risks/outages
+- propose_memories \u2014 record durable knowledge you discover (conventions, architecture, commands, risks); keep each memory ATOMIC (one fact) and CONCISE (1\u20133 sentences); NEVER include secrets (passwords, keys, tokens) and keep memories environment-agnostic (no ports, hostnames, or local paths); to bootstrap this repo, read its key files and propose memories
+- record_session_summary \u2014 call at the end of a meaningful task so Memmo can propose new memories
+
+Important:
+- Respect approved project memories.
+- Treat proposed memories as suggestions only.
+- Always check get_relevant_warnings before modifying sensitive files, and heed the warnings.
+- When asked to "scan" or "set up Memmo" for this repo, read the key files and call propose_memories.
+`;
+var HOOK_EVENTS = {
+  SessionStart: { hooks: [{ type: "command", command: hook("session-start") }] },
+  UserPromptSubmit: { hooks: [{ type: "command", command: hook("user-prompt") }] },
+  PreToolUse: {
+    matcher: "Edit|Write|MultiEdit|NotebookEdit",
+    hooks: [{ type: "command", command: hook("pre-edit") }]
+  },
+  SessionEnd: { hooks: [{ type: "command", command: hook("session-end") }] }
+};
+var isMemmoHook = (e) => e.hooks?.some((h) => typeof h.command === "string" && h.command.includes("memmo hook"));
+function mergeMcpJson(path) {
+  if (!existsSync2(path)) {
+    writeFileSync2(path, JSON.stringify({ mcpServers: { memmo: MCP_SERVER } }, null, 2) + "\n");
+    return "created .mcp.json";
+  }
+  try {
+    const json = JSON.parse(readFileSync2(path, "utf8"));
+    json.mcpServers = json.mcpServers ?? {};
+    if (json.mcpServers.memmo) return ".mcp.json already has the memmo server \u2014 left as is";
+    json.mcpServers.memmo = MCP_SERVER;
+    writeFileSync2(path, JSON.stringify(json, null, 2) + "\n");
+    return "added memmo server to existing .mcp.json";
+  } catch {
+    return "could not parse existing .mcp.json \u2014 add the memmo server manually";
+  }
+}
+function mergeClaudeMd(path) {
+  if (!existsSync2(path)) {
+    writeFileSync2(path, CLAUDE_MD_SECTION);
+    return "created CLAUDE.md";
+  }
+  const existing = readFileSync2(path, "utf8");
+  if (existing.includes("Memmo Project Memory") || existing.includes("Memmo MCP tools")) {
+    return "CLAUDE.md already mentions Memmo \u2014 left as is";
+  }
+  writeFileSync2(path, existing.trimEnd() + "\n\n" + CLAUDE_MD_SECTION);
+  return "appended Memmo section to existing CLAUDE.md";
+}
+function mergeSettingsHooks(claudeDir) {
+  if (!existsSync2(claudeDir)) mkdirSync2(claudeDir, { recursive: true });
+  const path = join2(claudeDir, "settings.json");
+  let json = {};
+  if (existsSync2(path)) {
+    try {
+      json = JSON.parse(readFileSync2(path, "utf8"));
+    } catch {
+      return "could not parse .claude/settings.json \u2014 add the memmo hooks manually";
+    }
+  }
+  json.hooks = json.hooks ?? {};
+  let added = 0;
+  for (const [event, entry] of Object.entries(HOOK_EVENTS)) {
+    const list = json.hooks[event] = json.hooks[event] ?? [];
+    if (list.some(isMemmoHook)) continue;
+    list.push(entry);
+    added++;
+  }
+  if (added === 0) return ".claude/settings.json already has the memmo hooks \u2014 left as is";
+  writeFileSync2(path, JSON.stringify(json, null, 2) + "\n");
+  return existsSync2(path) ? `registered ${added} Memmo hook(s) in .claude/settings.json` : "wrote .claude/settings.json";
+}
+function writeClaudeAssets(cwd = process.cwd()) {
+  return [
+    mergeMcpJson(join2(cwd, ".mcp.json")),
+    mergeClaudeMd(join2(cwd, "CLAUDE.md")),
+    mergeSettingsHooks(join2(cwd, ".claude"))
+  ];
+}
+function removeMcpServer(cwd = process.cwd()) {
+  const path = join2(cwd, ".mcp.json");
+  if (!existsSync2(path)) return null;
+  try {
+    const json = JSON.parse(readFileSync2(path, "utf8"));
+    if (!json.mcpServers?.memmo) return null;
+    delete json.mcpServers.memmo;
+    if (Object.keys(json.mcpServers).length === 0 && Object.keys(json).length === 1) {
+      writeFileSync2(path, JSON.stringify({ mcpServers: {} }, null, 2) + "\n");
+    } else {
+      writeFileSync2(path, JSON.stringify(json, null, 2) + "\n");
+    }
+    return "removed memmo server from .mcp.json";
+  } catch {
+    return null;
+  }
+}
+function removeSettingsHooks(cwd = process.cwd()) {
+  const path = join2(cwd, ".claude", "settings.json");
+  if (!existsSync2(path)) return null;
+  try {
+    const json = JSON.parse(readFileSync2(path, "utf8"));
+    if (!json.hooks) return null;
+    let removed = 0;
+    for (const event of Object.keys(json.hooks)) {
+      const before = json.hooks[event].length;
+      json.hooks[event] = json.hooks[event].filter((e) => !isMemmoHook(e));
+      removed += before - json.hooks[event].length;
+      if (json.hooks[event].length === 0) delete json.hooks[event];
+    }
+    if (removed === 0) return null;
+    if (Object.keys(json.hooks).length === 0) delete json.hooks;
+    writeFileSync2(path, JSON.stringify(json, null, 2) + "\n");
+    return `removed ${removed} Memmo hook(s) from .claude/settings.json`;
+  } catch {
+    return null;
+  }
+}
+function removeClaudeSection(cwd = process.cwd()) {
+  const path = join2(cwd, "CLAUDE.md");
+  if (!existsSync2(path)) return null;
+  const existing = readFileSync2(path, "utf8");
+  const idx = existing.indexOf("# Memmo Project Memory");
+  if (idx === -1) return null;
+  const trimmed = existing.slice(0, idx).trimEnd();
+  if (trimmed.length === 0) {
+    writeFileSync2(path, "");
+    return "cleared Memmo section from CLAUDE.md";
+  }
+  writeFileSync2(path, trimmed + "\n");
+  return "removed Memmo section from CLAUDE.md";
+}
+async function claudeInstallCommand() {
+  const actions = writeClaudeAssets();
+  console.log("Claude Code integration:");
+  for (const a of actions) console.log("  - " + a);
+}
+
+// src/commands/scan.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join3, delimiter } from "node:path";
+init_api();
+function findOnPath(cmd) {
+  const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      const full = join3(dir, cmd + ext);
+      if (existsSync3(full)) return full;
+    }
+  }
+  return null;
+}
+var AGENT_PROMPT = `You are onboarding onto THIS repository to build durable operational memory for future AI coding agents \u2014 like writing the onboarding doc for a senior engineer.
+
+FIRST call mcp__memmo__get_repo_context and run a few broad mcp__memmo__search_memory queries
+(architecture, commands, testing, deploy, risks) to learn what this project ALREADY knows. Never
+propose something already covered. If an existing memory is wrong or outdated, propose the corrected
+memory with "supersedes": "<that memory's id>".
+
+Then explore the codebase thoroughly. Read the README, package manifests, config files, the data model / schema, entry points, routes/services/handlers, CI workflows, and a representative sample of the most important source files. Use Read, Glob, and Grep freely.
+
+Also review the COMMIT HISTORY and its descriptions: run \`git log --pretty=format:'%h %s%n%b' -n 500\` (and \`git log --oneline -n 500\` for a quick overview). Commit subjects and bodies are evidence of decisions, recurring failures, and conventions enforced over time.
+
+Then call the propose_memories MCP tool (mcp__memmo__propose_memories) to record a THOROUGH set of memories a new engineer/agent must know:
+- Overall architecture and how the major modules/areas fit together (one memory per significant area).
+- The data model / key entities (from schema/models).
+- The API/interface surface and important flows.
+- Key commands: build, run, test, lint, migrate, deploy.
+- Conventions and project rules (naming, structure, patterns, error handling, auth).
+- Important dependencies and external services.
+- Testing and deployment practices.
+- Risks, gotchas, and "do not touch" areas.
+- Recurring themes, decisions, and past failures evident from the commit history (type "decision"/"failure"/"project_rule").
+
+Rules:
+- Base every memory ONLY on what you actually read. Do not invent or assume.
+- Be SPECIFIC and concrete \u2014 reference real modules, files, and names. No generic boilerplate.
+- ATOMIC: each memory is ONE fact, rule, command, entity, or decision. Split multi-topic content
+  into separate memories \u2014 never pack a whole subsystem into one giant memory.
+- CONCISE: 1\u20133 sentences, ideally under ~280 characters. State the fact, not an essay.
+- For area- or risk-specific memories, include path globs in "paths" (e.g. "apps/api/src/routes/**").
+- Set confidence 0..1 by certainty and reusability.
+- Propose as many small, high-signal memories as the codebase warrants (up to 30). Favor many
+  atomic memories over a few long ones.
+
+When you're done, briefly report how many memories you proposed.`;
+async function countProposed(client, repoId) {
+  try {
+    const detail = await apiFetch(client, `/repos/${repoId}`);
+    const row = detail.memoryCounts?.find((c) => c.status === "proposed");
+    return row?._count ?? 0;
+  } catch {
+    return 0;
+  }
+}
+async function agentScan(claudeBin, client, config, cwd) {
+  const mcpConfig = join3(cwd, ".mcp.json");
+  if (!existsSync3(mcpConfig)) {
+    throw new Error("No .mcp.json found \u2014 run `memmo init` (or `memmo claude install`) first.");
+  }
+  const before = await countProposed(client, config.repoId);
+  const t0 = Date.now();
+  console.log("Deep scan with local Claude Code (no API key, runs on your Claude subscription)\u2026");
+  console.log("Claude is reading the codebase and proposing memories. This can take a few minutes.\n");
+  const args = [
+    "-p",
+    AGENT_PROMPT,
+    "--mcp-config",
+    mcpConfig,
+    "--permission-mode",
+    "default",
+    "--allowedTools",
+    "Read",
+    "Glob",
+    "Grep",
+    "LS",
+    "Bash(git log:*)",
+    "mcp__memmo__get_repo_context",
+    "mcp__memmo__search_memory",
+    "mcp__memmo__propose_memories"
+  ];
+  const childEnv = { ...process.env };
+  delete childEnv.ANTHROPIC_API_KEY;
+  const code = await new Promise((resolve, reject) => {
+    const child = spawn(claudeBin, args, { cwd, stdio: "inherit", env: childEnv });
+    child.on("error", reject);
+    child.on("close", (c) => resolve(c ?? 0));
+  });
+  if (code !== 0) {
+    throw new Error(
+      `Claude Code exited with code ${code}.
+If you saw a 401/auth error, make sure Claude Code is logged in: run \`claude\` once and sign in (or \`claude login\`).
+Alternatively, use \`memmo scan --server\` to scan with the project API key.`
+    );
+  }
+  const after = await countProposed(client, config.repoId);
+  const added = Math.max(0, after - before);
+  const secs = Math.round((Date.now() - t0) / 1e3);
+  console.log(`
+Deep scan complete in ${secs}s \u2014 ${added} new memory proposal(s) waiting in your Inbox.`);
+}
+async function serverScan(client, config) {
+  console.log("Scanning the repo from GitHub\u2026");
+  const result = await apiFetch(client, `/repos/${config.repoId}/scan`, {
+    method: "POST"
+  });
+  const bits = [
+    result.filesRead != null ? `${result.filesRead} files` : null,
+    result.commitsRead != null ? `${result.commitsRead} commits` : null
+  ].filter(Boolean);
+  const from = bits.length ? ` (read ${bits.join(", ")})` : "";
+  console.log(
+    `Proposed ${result.proposedCount} memory(ies)${from}. Review them in the Memmo inbox.`
+  );
+}
+async function scanCommand(opts = {}) {
+  const creds = loadCredentials();
+  const config = await resolveProjectConfig();
+  if (!creds) throw new Error("Not logged in. Run `memmo login` first.");
+  if (!config) throw new Error(NOT_CONNECTED);
+  const client = {
+    baseUrl: config.apiBaseUrl ?? creds.apiBaseUrl,
+    token: creds.token
+  };
+  const cwd = process.cwd();
+  if (opts.server) {
+    return serverScan(client, config);
+  }
+  const claudeBin = findOnPath("claude");
+  if (opts.agent) {
+    if (!claudeBin) {
+      throw new Error(
+        "Claude Code (`claude`) was not found on your PATH. Install it from https://claude.com/claude-code, or run `memmo scan --server`."
+      );
+    }
+    return agentScan(claudeBin, client, config, cwd);
+  }
+  if (claudeBin) {
+    return agentScan(claudeBin, client, config, cwd);
+  }
+  console.log("Claude Code not found locally \u2014 falling back to the server scan.\n");
+  return serverScan(client, config);
+}
+
+// src/commands/init.ts
+async function ask(q) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  const a = (await rl.question(q)).trim();
+  rl.close();
+  return a;
+}
+async function chooseProject(client, wanted, yes = false) {
+  const projects = await apiFetch(client, "/projects");
+  if (projects.length === 0) throw new Error("You have no project yet. Sign in to the web app once to create one.");
+  if (wanted) {
+    const hit = projects.find((p) => p.id === wanted || p.name.toLowerCase() === wanted.toLowerCase());
+    if (!hit) throw new Error(`No project matches "${wanted}". Yours: ${projects.map((p) => p.name).join(", ")}`);
+    return hit;
+  }
+  if (projects.length === 1 || yes) return projects[0];
+  console.log("\nWhich project should this repo belong to? (a project = the repos that share one memory)");
+  projects.forEach((p, i) => console.log(`  ${i + 1}. ${p.name}${p.repoCount ? ` (${p.repoCount} repo${p.repoCount === 1 ? "" : "s"})` : ""}`));
+  const idx = Number(await ask("Number [1]: ")) || 1;
+  const pick = projects[idx - 1];
+  if (!pick) throw new Error("Invalid selection.");
+  return pick;
+}
+async function initCommand(opts) {
+  const creds = loadCredentials();
+  if (!creds) throw new Error("Not logged in. Run `memmo login` first.");
+  const client = { baseUrl: process.env.MEMMO_API_URL ?? creds.apiBaseUrl, token: creds.token };
+  const cwd = process.cwd();
+  if (!existsSync4(join4(cwd, ".git"))) {
+    console.log("note: no .git here \u2014 run `memmo init` at your repo root.");
+  }
+  const remote = detectGitRemote(cwd);
+  const fullName = remote ? repoFullNameFromRemote(remote) : null;
+  let repo = null;
+  if (opts.repo) {
+    const list = await apiFetch(client, "/repos");
+    repo = list.find((r) => r.id === opts.repo) ?? null;
+    if (!repo) throw new Error(`Repo ${opts.repo} not found in your account.`);
+  } else if (remote) {
+    try {
+      const r = await apiFetch(client, "/repos/resolve", {
+        method: "POST",
+        body: JSON.stringify({ repoRemote: remote })
+      });
+      repo = { id: r.repoId, fullName: r.fullName };
+      cacheRepo(remote, { repoId: repo.id, fullName: repo.fullName, apiBaseUrl: client.baseUrl });
+      console.log(`Already connected: ${repo.fullName}`);
+    } catch {
+    }
+  }
+  if (!repo) {
+    const name = fullName ?? await ask("Repo name (owner/repo): ");
+    if (!name.includes("/")) throw new Error("Expected owner/repo.");
+    const project = await chooseProject(client, opts.project, opts.yes);
+    if (!opts.yes) {
+      console.log(`
+Add ${name} to project "${project.name}"?`);
+      console.log(`  directory: ${cwd}`);
+      const ok = (await ask("Continue? (Y/n) ")).toLowerCase();
+      if (ok === "n" || ok === "no") {
+        console.log("Aborted \u2014 nothing written.");
+        return;
+      }
+    }
+    const created = await apiFetch(client, "/repos", {
+      method: "POST",
+      body: JSON.stringify({ projectId: project.id, provider: "github", name: name.split("/").pop(), fullName: name })
+    });
+    repo = { id: created.id, fullName: created.fullName };
+    if (remote) cacheRepo(remote, { repoId: repo.id, fullName: repo.fullName, apiBaseUrl: client.baseUrl });
+    console.log(`Connected ${repo.fullName} \u2192 project "${project.name}".`);
+  }
+  const actions = writeClaudeAssets(cwd);
+  for (const a of actions) console.log("  - " + a);
+  let doScan = opts.scan === true;
+  if (!doScan && !opts.yes) {
+    const ans = (await ask("\nScan this repo now to propose starter memories? (Y/n) ")).toLowerCase();
+    doScan = ans === "" || ans === "y" || ans === "yes";
+  }
+  if (doScan) {
+    try {
+      console.log("");
+      await scanCommand();
+    } catch (e) {
+      console.log(`Scan skipped: ${e instanceof Error ? e.message : String(e)}`);
+      console.log("Run it later with `memmo scan`.");
+    }
+  }
+  const appUrl = await appUrlFor(client);
+  console.log(`
+Done. Open Claude Code in this repo \u2014 it gets a briefing at session start.`);
+  console.log(`Review proposed memories: ${appUrl}/inbox`);
+  console.log(`Teammates: commit the generated files; they only need \`npm i -g @memmo/cli && memmo login\`.`);
+}
+async function appUrlFor(client) {
+  try {
+    const c = await apiFetch(client, "/auth/config");
+    if (c.appUrl) return c.appUrl.replace(/\/$/, "");
+  } catch {
+  }
+  return "https://app.memmo.dev";
+}
+
+// src/commands/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+init_api();
+init_version();
+async function mcpCommand(opts = {}) {
+  const creds = loadCredentials();
+  if (!creds) throw new Error("Not logged in. Run `memmo login` first.");
+  const resolved = await resolveProjectConfig(process.cwd(), { repoId: opts.repo, apiBaseUrl: opts.api });
+  if (!resolved) throw new Error(NOT_CONNECTED + " Or pass --repo <repoId>.");
+  const client = { baseUrl: resolved.apiBaseUrl, token: creds.token };
+  const config = { repoId: resolved.repoId };
+  const server = new McpServer({ name: "memmo", version: VERSION });
+  server.registerTool(
+    "search_memory",
+    {
+      title: "Search Memmo memory",
+      description: "Search approved operational memories for the connected repo (conventions, risks, commands, decisions).",
+      inputSchema: { query: z.string().describe("What to search for"), limit: z.number().optional() }
+    },
+    async ({ query, limit }) => {
+      const result = await apiFetch(client, "/mcp/search_memory", {
+        method: "POST",
+        body: JSON.stringify({ repoId: config.repoId, query: query ?? "", limit: limit ?? 10 })
+      });
+      const text = result.memories.length === 0 ? "No relevant approved memories found." : result.memories.map((m) => `- [${m.type}] ${m.title}${m.id ? ` (id: ${m.id})` : ""}
+  ${m.content}`).join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server.registerTool(
+    "get_repo_context",
+    {
+      title: "Get Memmo repo context",
+      description: "Retrieve the stack, package manager, known risks/warnings, and recommended commands for the connected repo.",
+      inputSchema: {}
+    },
+    async () => {
+      const result = await apiFetch(client, "/mcp/get_repo_context", {
+        method: "POST",
+        body: JSON.stringify({ repoId: config.repoId })
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "get_relevant_warnings",
+    {
+      title: "Get Memmo risk warnings for files",
+      description: "Before editing files, get risk/failure warnings that apply to them (past outages, gotchas). Call with the file paths you're about to modify.",
+      inputSchema: {
+        files: z.array(z.string()).describe("Repo-relative paths you're about to edit")
+      }
+    },
+    async ({ files }) => {
+      const result = await apiFetch(client, "/mcp/get_relevant_warnings", {
+        method: "POST",
+        body: JSON.stringify({ repoId: config.repoId, files })
+      });
+      const text = result.warnings.length === 0 ? "No known risks for these files." : result.warnings.map((w) => `\u26A0 [${w.type}] ${w.title}
+  ${w.content}`).join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server.registerTool(
+    "record_session_summary",
+    {
+      title: "Record a Memmo session summary",
+      description: "Submit a summary of the work you just did so Memmo can propose new memories for review. Call this at the end of a meaningful task.",
+      inputSchema: {
+        task: z.string().optional().describe("What the task was"),
+        summary: z.string().optional().describe("What happened: decisions, findings, outcomes"),
+        filesChanged: z.array(z.string()).optional(),
+        commandsRun: z.array(z.string()).optional(),
+        errors: z.array(z.string()).optional()
+      }
+    },
+    async (args) => {
+      const result = await apiFetch(client, `/repos/${config.repoId}/sessions`, {
+        method: "POST",
+        body: JSON.stringify(args)
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Session recorded. ${result.proposedCount} memory proposal(s) created for review in Memmo.`
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "propose_memories",
+    {
+      title: "Propose Memmo memories",
+      description: "Record durable, reusable knowledge you discovered (conventions, architecture, commands, risks, gotchas) as PROPOSED memories for human review. Use this to bootstrap a repo \u2014 read its key files (README, configs, manifests, schema, entry points) and propose memories \u2014 or any time you learn something a future agent should know. Keep each memory ATOMIC (one fact/rule/command/entity per memory \u2014 split multi-topic content) and CONCISE (1\u20133 sentences, ideally under ~280 characters); prefer many small memories over a few long ones. Add file globs in `paths` for risk/area-specific memories.",
+      inputSchema: {
+        memories: z.array(
+          z.object({
+            type: z.enum([
+              "project_rule",
+              "architecture",
+              "command",
+              "workflow",
+              "decision",
+              "failure",
+              "risk",
+              "dependency",
+              "testing",
+              "deployment",
+              "business_context"
+            ]),
+            title: z.string(),
+            content: z.string(),
+            confidence: z.number().min(0).max(1).optional(),
+            paths: z.array(z.string()).optional(),
+            evidence: z.string().optional(),
+            supersedes: z.string().optional().describe("Id of an existing memory this one corrects (from search_memory)")
+          })
+        )
+      }
+    },
+    async ({ memories }) => {
+      const result = await apiFetch(
+        client,
+        `/repos/${config.repoId}/proposals`,
+        { method: "POST", body: JSON.stringify({ memories }) }
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Proposed ${result.proposedCount} memory(ies) for review in Memmo.`
+          }
+        ]
+      };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/commands/hook.ts
+import { readFileSync as readFileSync3, existsSync as existsSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join5 } from "node:path";
+import { tmpdir } from "node:os";
+import { createHash } from "node:crypto";
+init_api();
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  try {
+    for await (const c of process.stdin) chunks.push(c);
+  } catch {
+    return "";
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function resolveHookEnv(cwd) {
+  const creds = loadCredentials();
+  if (!creds) return null;
+  const cfg = await resolveProjectConfig(cwd ?? process.cwd());
+  if (!cfg) return null;
+  return { client: { baseUrl: cfg.apiBaseUrl, token: creds.token }, repoId: cfg.repoId };
+}
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function uniq(arr) {
+  return [...new Set(arr.filter(Boolean))];
+}
+function capToBudget(lines, maxChars) {
+  const kept = [];
+  let used = 0;
+  for (const line2 of lines) {
+    if (used + line2.length > maxChars && kept.length > 0) break;
+    kept.push(line2);
+    used += line2.length;
+  }
+  return kept.join("\n\n");
+}
+async function sessionStart(input, env) {
+  const ctx = await apiFetch(env.client, "/mcp/get_repo_context", {
+    method: "POST",
+    body: JSON.stringify({ repoId: env.repoId, sessionId: input.session_id })
+  });
+  const lines = [];
+  const rc = ctx.repoContext;
+  if (rc?.stack?.length) lines.push(`Stack: ${rc.stack.join(", ")}${rc.packageManager ? ` (${rc.packageManager})` : ""}`);
+  if (rc?.notes) lines.push(`About: ${rc.notes}`);
+  const b = ctx.briefing;
+  const section = (title, items) => {
+    if (items?.length) lines.push(`${title}:
+- ${items.join("\n- ")}`);
+  };
+  if (b) {
+    section("Project rules & decisions", b.rules);
+    section("Architecture", b.architecture);
+    section("Key commands", b.commands);
+    section("Known risks \u2014 check before touching related code", b.risks);
+  } else {
+    section("Key commands", ctx.recommendedCommands);
+    section("Known risks", ctx.warnings);
+  }
+  if (lines.length === 0) return;
+  const text = `Memmo \u2014 what this team already knows about this repo (approved memory; use search_memory for more):
+${lines.join("\n\n")}`;
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: text }
+    })
+  );
+}
+async function userPrompt(input, env) {
+  const prompt = (input.prompt ?? "").trim();
+  if (prompt.length < 4) return;
+  const { memories } = await apiFetch(env.client, "/mcp/search_memory", {
+    method: "POST",
+    body: JSON.stringify({ repoId: env.repoId, query: prompt, limit: 4 })
+  });
+  if (!memories.length) return;
+  const body = memories.map((m) => `- [${m.type}] ${m.title}: ${m.content}`).join("\n");
+  const text = `Memmo memories relevant to this task:
+${body}`;
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: text }
+    })
+  );
+}
+async function preEdit(input, env) {
+  const ti = input.tool_input ?? {};
+  const file = ti.file_path ?? ti.notebook_path ?? ti.path;
+  if (!file) return;
+  const { warnings } = await apiFetch(env.client, "/mcp/get_relevant_warnings", {
+    method: "POST",
+    body: JSON.stringify({ repoId: env.repoId, files: [file], sessionId: input.session_id })
+  });
+  if (!warnings.length) return;
+  const key = createHash("sha1").update(`${input.session_id ?? "x"}:${file}`).digest("hex").slice(0, 16);
+  const marker = join5(tmpdir(), `memmo-warned-${key}`);
+  if (existsSync5(marker)) return;
+  try {
+    writeFileSync3(marker, "1");
+  } catch {
+  }
+  const body = warnings.map((w) => `\u26A0 [${w.type}] ${w.title}
+  ${w.content}`).join("\n");
+  process.stderr.write(`Memmo risk warnings for ${file}:
+${body}
+`);
+  process.exit(2);
+}
+async function sessionEnd(input, env) {
+  if (!input.transcript_path || !existsSync5(input.transcript_path)) return;
+  const raw = readFileSync3(input.transcript_path, "utf8");
+  const filesChanged = [];
+  const commandsRun = [];
+  const errors = [];
+  const userTexts = [];
+  const agentTexts = [];
+  let task;
+  for (const line2 of raw.split("\n")) {
+    if (!line2.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line2);
+    } catch {
+      continue;
+    }
+    const msg = entry.message;
+    const content = msg?.content;
+    if (!Array.isArray(content)) continue;
+    for (const item of content) {
+      if (item.type === "tool_use") {
+        const name = item.name;
+        const inp = item.input ?? {};
+        if (EDIT_TOOLS.has(name)) {
+          const f = inp.file_path ?? inp.notebook_path;
+          if (f) filesChanged.push(f);
+        } else if (name === "Bash" && typeof inp.command === "string") {
+          commandsRun.push(inp.command);
+        }
+      } else if (item.type === "tool_result" && item.is_error) {
+        const t = typeof item.content === "string" ? item.content : JSON.stringify(item.content);
+        if (t) errors.push(t.slice(0, 300));
+      } else if (item.type === "text" && typeof item.text === "string") {
+        const text = item.text.trim();
+        if (!text) continue;
+        if (msg?.role === "user") {
+          if (!task) task = text.slice(0, 280);
+          userTexts.push(text.slice(0, 400));
+        } else if (msg?.role === "assistant" && text.length > 40) {
+          agentTexts.push(text.slice(0, 600));
+        }
+      }
+    }
+  }
+  const files = uniq(filesChanged).slice(0, 50);
+  const cmds = uniq(commandsRun).slice(0, 50);
+  const errs = uniq(errors).slice(0, 20);
+  const userMessages = uniq(userTexts).slice(0, 15);
+  const reasoning = capToBudget(agentTexts.slice(-10), 3e3);
+  if (files.length === 0 && cmds.length === 0 && errs.length === 0) return;
+  const summary = `Claude Code session: ${files.length} file(s) edited, ${cmds.length} command(s) run${errs.length ? `, ${errs.length} error(s)` : ""}.`;
+  await apiFetch(env.client, `/repos/${env.repoId}/sessions`, {
+    method: "POST",
+    body: JSON.stringify({
+      agent: "claude-code",
+      sessionId: input.session_id,
+      task,
+      summary,
+      filesChanged: files,
+      commandsRun: cmds,
+      errors: errs,
+      userMessages,
+      reasoning
+    })
+  });
+}
+async function hookCommand(event) {
+  let input = {};
+  try {
+    const stdin = await readStdin();
+    if (stdin.trim()) input = JSON.parse(stdin);
+  } catch {
+    process.exit(0);
+  }
+  try {
+    const env = await resolveHookEnv(input.cwd);
+    if (!env) process.exit(0);
+    if (event === "session-start") await sessionStart(input, env);
+    else if (event === "user-prompt") await userPrompt(input, env);
+    else if (event === "pre-edit") await preEdit(input, env);
+    else if (event === "session-end") await sessionEnd(input, env);
+  } catch {
+  }
+  process.exit(0);
+}
+
+// src/commands/status.ts
+import { readFileSync as readFileSync4, existsSync as existsSync6 } from "node:fs";
+import { join as join6 } from "node:path";
+init_api();
+var OK = "\x1B[32m\u2713\x1B[0m";
+var NO = "\x1B[31m\u2717\x1B[0m";
+var WARN = "\x1B[33m!\x1B[0m";
+function line(mark, label, detail = "") {
+  console.log(`  ${mark} ${label}${detail ? `  \x1B[2m${detail}\x1B[0m` : ""}`);
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync4(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function hasMemmoHooks(cwd) {
+  const json = readJson(
+    join6(cwd, ".claude", "settings.json")
+  );
+  if (!json?.hooks) return { present: false, events: [] };
+  const events = Object.entries(json.hooks).filter(
+    ([, list]) => list?.some((e) => e.hooks?.some((h) => h.command?.includes("memmo hook")))
+  ).map(([event]) => event);
+  return { present: events.length > 0, events };
+}
+async function statusCommand() {
+  const cwd = process.cwd();
+  console.log("Memmo setup status\n");
+  const creds = loadCredentials();
+  line(creds ? OK : NO, "Logged in", creds ? creds.apiBaseUrl : "run `memmo login`");
+  const config = await resolveProjectConfig(cwd);
+  line(
+    config ? OK : NO,
+    "Repo connected",
+    config ? `${config.repoFullName ?? config.repoId}` : "run `memmo init`"
+  );
+  const mcp = readJson(join6(cwd, ".mcp.json"));
+  line(mcp?.mcpServers?.memmo ? OK : NO, ".mcp.json (memmo MCP server)");
+  const claudeMd = existsSync6(join6(cwd, "CLAUDE.md")) ? readFileSync4(join6(cwd, "CLAUDE.md"), "utf8") : "";
+  line(claudeMd.includes("Memmo") ? OK : WARN, "CLAUDE.md guidance");
+  const hooks = hasMemmoHooks(cwd);
+  line(
+    hooks.present ? OK : WARN,
+    "Claude Code hooks",
+    hooks.present ? hooks.events.join(", ") : "run `memmo claude install`"
+  );
+  if (creds && config) {
+    const client = { baseUrl: config.apiBaseUrl ?? creds.apiBaseUrl, token: creds.token };
+    try {
+      const repo = await apiFetch(
+        client,
+        `/repos/${config.repoId}`
+      );
+      const approved = repo.memoryCounts?.find((c) => c.status === "approved")?._count ?? 0;
+      const proposed = repo.memoryCounts?.find((c) => c.status === "proposed")?._count ?? 0;
+      line(OK, "API reachable", `${approved} approved \xB7 ${proposed} proposed memories`);
+    } catch (e) {
+      line(NO, "API reachable", e instanceof Error ? e.message : "request failed");
+    }
+  }
+  const ready = creds && config && mcp?.mcpServers?.memmo && hooks.present;
+  console.log(
+    ready ? "\n\x1B[32mMemmo is fully set up for this repo.\x1B[0m" : "\nSome steps are incomplete. Run `memmo init` to finish setup."
+  );
+}
+
+// src/commands/uninstall.ts
+import { existsSync as existsSync7, rmSync, readdirSync } from "node:fs";
+import { join as join7 } from "node:path";
+import { createInterface as createInterface3 } from "node:readline/promises";
+async function uninstallCommand(opts = {}) {
+  const cwd = process.cwd();
+  if (!opts.yes) {
+    console.log("Remove Memmo from this repo?");
+    console.log(`  directory: ${cwd}`);
+    console.log("  This removes the memmo MCP server, Claude Code hooks, the CLAUDE.md section,");
+    console.log("  and any legacy .memmo/config.json. Your login (~/.memmo/credentials.json) is kept.");
+    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    const ok = (await rl.question("Continue? (y/N) ")).trim().toLowerCase();
+    rl.close();
+    if (ok !== "y" && ok !== "yes") {
+      console.log("Aborted \u2014 nothing changed.");
+      return;
+    }
+  }
+  const actions = [];
+  const push = (a) => {
+    if (a) actions.push(a);
+  };
+  push(removeMcpServer(cwd));
+  push(removeSettingsHooks(cwd));
+  push(removeClaudeSection(cwd));
+  const remote = detectGitRemote(cwd);
+  if (remote) forgetRepo(remote);
+  const configFile = join7(cwd, ".memmo", "config.json");
+  if (existsSync7(configFile)) {
+    rmSync(configFile, { force: true });
+    actions.push("removed .memmo/config.json");
+    const dir = join7(cwd, ".memmo");
+    if (existsSync7(dir) && readdirSync(dir).length === 0) rmSync(dir, { recursive: true, force: true });
+  }
+  for (const f of ["memmo-session-end.sh", "memmo-before-edit.sh"]) {
+    const p = join7(cwd, ".claude", "hooks", f);
+    if (existsSync7(p)) {
+      rmSync(p, { force: true });
+      actions.push(`removed legacy .claude/hooks/${f}`);
+    }
+  }
+  if (actions.length === 0) {
+    console.log("Nothing to remove \u2014 Memmo isn't set up in this repo.");
+    return;
+  }
+  console.log("Removed Memmo from this repo:");
+  for (const a of actions) console.log("  - " + a);
+  console.log("\nRestart Claude Code so it stops loading the memmo MCP server and hooks.");
+}
+
+// src/commands/chat.ts
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join8, delimiter as delimiter2 } from "node:path";
+import { createInterface as createInterface4 } from "node:readline/promises";
+import Anthropic from "@anthropic-ai/sdk";
+init_api();
+var SYSTEM = `You are Memmo, answering questions about a software repository using ONLY the
+approved operational memories and repo context provided. Be concise and concrete, reference memory
+titles when relevant, and if the provided context doesn't answer the question, say so plainly
+instead of guessing.`;
+function findOnPath2(cmd) {
+  const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  for (const dir of (process.env.PATH ?? "").split(delimiter2)) {
+    if (!dir) continue;
+    for (const ext of exts) if (existsSync8(join8(dir, cmd + ext))) return join8(dir, cmd + ext);
+  }
+  return null;
+}
+async function buildContext(client, repoId, query) {
+  const [search, ctx] = await Promise.all([
+    apiFetch(client, "/mcp/search_memory", {
+      method: "POST",
+      body: JSON.stringify({ repoId, query, limit: 12 })
+    }),
+    apiFetch(client, "/mcp/get_repo_context", {
+      method: "POST",
+      body: JSON.stringify({ repoId })
+    })
+  ]);
+  const parts = [];
+  const rc = ctx.repoContext;
+  if (rc.stack?.length) parts.push(`Stack: ${rc.stack.join(", ")}`);
+  if (rc.packageManager) parts.push(`Package manager: ${rc.packageManager}`);
+  if (rc.notes) parts.push(`Notes: ${rc.notes}`);
+  if (ctx.recommendedCommands?.length) parts.push(`Key commands:
+- ${ctx.recommendedCommands.join("\n- ")}`);
+  if (ctx.warnings?.length) parts.push(`Known risks:
+- ${ctx.warnings.join("\n- ")}`);
+  const mems = search.memories.length === 0 ? "(no approved memories matched this question)" : search.memories.map((m) => `- [${m.type}] ${m.title}
+  ${m.content}`).join("\n");
+  return `Repo context:
+${parts.join("\n") || "(none)"}
+
+Relevant approved memories:
+${mems}`;
+}
+async function answerWithKey(apiKey, context, question) {
+  const client = new Anthropic({ apiKey });
+  const model = process.env.ANTHROPIC_MODEL ?? "claude-sonnet-4-6";
+  const stream = client.messages.stream({
+    model,
+    max_tokens: 1024,
+    system: SYSTEM,
+    messages: [{ role: "user", content: `${context}
+
+Question: ${question}` }]
+  });
+  stream.on("text", (t) => process.stdout.write(t));
+  await stream.finalMessage();
+  process.stdout.write("\n");
+}
+async function answerWithClaude(claudeBin, context, question) {
+  const prompt = `${SYSTEM}
+
+${context}
+
+Question: ${question}`;
+  const env = { ...process.env };
+  delete env.ANTHROPIC_API_KEY;
+  const code = await new Promise((resolve, reject) => {
+    const child = spawn2(claudeBin, ["-p", prompt], { stdio: ["ignore", "inherit", "inherit"], env });
+    child.on("error", reject);
+    child.on("close", (c) => resolve(c ?? 0));
+  });
+  if (code !== 0) {
+    process.stderr.write(
+      "\nClaude Code couldn't run headlessly here. Make sure it's logged in for terminal use:\n  \u2022 run `claude`, then `/login` and finish the browser flow, and verify with `claude -p \"hi\"`\n  \u2022 or set ANTHROPIC_API_KEY to use the API directly.\n"
+    );
+  }
+}
+async function chatCommand(questionArgs = []) {
+  const creds = loadCredentials();
+  const config = await resolveProjectConfig();
+  if (!creds) throw new Error("Not logged in. Run `memmo login` first.");
+  if (!config) throw new Error(NOT_CONNECTED);
+  const client = { baseUrl: config.apiBaseUrl ?? creds.apiBaseUrl, token: creds.token };
+  const envKey = process.env.ANTHROPIC_API_KEY;
+  const claudeBin = envKey ? null : findOnPath2("claude");
+  if (!envKey && !claudeBin) {
+    throw new Error(
+      "No Anthropic access found. Set ANTHROPIC_API_KEY (your own key), or install Claude Code (https://claude.com/claude-code) to use your subscription."
+    );
+  }
+  const answer = async (q) => {
+    const context = await buildContext(client, config.repoId, q);
+    if (envKey) await answerWithKey(envKey, context, q);
+    else await answerWithClaude(claudeBin, context, q);
+  };
+  const via = envKey ? "your ANTHROPIC_API_KEY" : "your Claude Code subscription";
+  const oneShot = questionArgs.join(" ").trim();
+  if (oneShot) {
+    await answer(oneShot);
+    return;
+  }
+  console.log(`Memmo chat \u2014 grounded in ${config.repoFullName ?? config.repoId} (via ${via}).`);
+  console.log("Ask a question, or type 'exit' to quit.\n");
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
+  try {
+    for (; ; ) {
+      const q = (await rl.question("you \u203A ")).trim();
+      if (!q) continue;
+      if (q === "exit" || q === "quit") break;
+      process.stdout.write("\nmemmo \u203A ");
+      await answer(q);
+      process.stdout.write("\n");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// src/commands/decision.ts
+init_api();
+async function decisionCommand(text, opts = {}) {
+  const creds = loadCredentials();
+  const config = await resolveProjectConfig();
+  if (!creds) throw new Error("Not logged in. Run `memmo login` first.");
+  if (!config) throw new Error(NOT_CONNECTED);
+  const title = text.join(" ").trim();
+  if (!title) {
+    throw new Error('Usage: memmo decision "what changed" [--why "the reason"]');
+  }
+  const client = {
+    baseUrl: config.apiBaseUrl ?? creds.apiBaseUrl,
+    token: creds.token
+  };
+  const content = opts.why ? `${title}
+
+Why: ${opts.why}` : title;
+  await apiFetch(client, `/repos/${config.repoId}/memories`, {
+    method: "POST",
+    body: JSON.stringify({
+      type: "decision",
+      title: title.slice(0, 140),
+      content,
+      status: "approved",
+      source: "cli_decision",
+      confidence: 0.9
+    })
+  });
+  console.log(`Recorded decision: ${title}`);
+}
+
+// src/commands/sync.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync9 } from "node:fs";
+import { join as join9 } from "node:path";
+init_api();
+var START = "<!-- memmo:memory:start -->";
+var END = "<!-- memmo:memory:end -->";
+function renderBlock(memories) {
+  const lines = [START, "", "## Memmo memory (auto-synced \u2014 do not edit by hand)", ""];
+  if (memories.length === 0) {
+    lines.push("_No approved memories yet. Approve some in the Memmo inbox._");
+  } else {
+    const byType = /* @__PURE__ */ new Map();
+    for (const m of memories) {
+      const arr = byType.get(m.type) ?? [];
+      arr.push(m);
+      byType.set(m.type, arr);
+    }
+    for (const [type, items] of byType) {
+      lines.push(`### ${type}`, "");
+      for (const m of items) {
+        lines.push(`- **${m.title}** \u2014 ${m.content}`);
+        if (m.paths?.length) lines.push(`  - paths: ${m.paths.join(", ")}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push(`_Last synced ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}._`, "", END);
+  return lines.join("\n");
+}
+function upsertBlock(existing, block) {
+  const s = existing.indexOf(START);
+  const e = existing.indexOf(END);
+  if (s !== -1 && e !== -1 && e > s) {
+    return existing.slice(0, s) + block + existing.slice(e + END.length);
+  }
+  return existing.trimEnd() + "\n\n" + block + "\n";
+}
+async function syncCommand() {
+  const creds = loadCredentials();
+  const config = await resolveProjectConfig();
+  if (!creds) throw new Error("Not logged in. Run `memmo login` first.");
+  if (!config) throw new Error(NOT_CONNECTED);
+  const client = {
+    baseUrl: config.apiBaseUrl ?? creds.apiBaseUrl,
+    token: creds.token
+  };
+  const memories = await apiFetch(
+    client,
+    `/repos/${config.repoId}/memories?status=approved`
+  );
+  const block = renderBlock(memories);
+  const path = join9(process.cwd(), "CLAUDE.md");
+  const existing = existsSync9(path) ? readFileSync5(path, "utf8") : "";
+  writeFileSync4(path, upsertBlock(existing, block));
+  console.log(`Synced ${memories.length} approved memory(ies) into CLAUDE.md.`);
+}
+
+// src/commands/review.ts
+import { execFileSync } from "node:child_process";
+import { writeFileSync as writeFileSync5 } from "node:fs";
+init_api();
+
+// ../../packages/shared/src/types.ts
+var MEMORY_TYPES = [
+  "project_rule",
+  "architecture",
+  "command",
+  "workflow",
+  "decision",
+  "failure",
+  "risk",
+  "dependency",
+  "testing",
+  "deployment",
+  "business_context"
+];
+var MEMORY_STATUSES = [
+  "proposed",
+  "approved",
+  "rejected",
+  "archived"
+];
+
+// ../../packages/shared/src/schemas.ts
+import { z as z2 } from "zod";
+var memoryTypeSchema = z2.enum(MEMORY_TYPES);
+var memoryStatusSchema = z2.enum(MEMORY_STATUSES);
+var loginSchema = z2.object({
+  email: z2.string().email(),
+  name: z2.string().min(1).optional()
+});
+var waitlistSchema = z2.object({
+  email: z2.string().email(),
+  source: z2.string().max(120).optional()
+});
+var TOKEN_SCOPES = ["cli", "mcp", "both"];
+var tokenScopeSchema = z2.enum(TOKEN_SCOPES);
+var moveProjectSchema = z2.object({ organizationId: z2.string().min(1) });
+var createTokenSchema = z2.object({
+  name: z2.string().min(1).max(80).default("cli"),
+  scope: tokenScopeSchema.default("both"),
+  // When set, the token is bound to this project (project); the CLI/MCP can
+  // only reach that project's repos. Omit for an account-wide token.
+  projectId: z2.string().optional()
+});
+var ORG_ROLES = ["owner", "admin", "member"];
+var orgRoleSchema = z2.enum(ORG_ROLES);
+var createOrgSchema = z2.object({ name: z2.string().min(1).max(80) });
+var updateOrgSchema = z2.object({ name: z2.string().min(1).max(80) });
+var joinOrgSchema = z2.object({ joinCode: z2.string().min(1) });
+var inviteOrgMemberSchema = z2.object({
+  email: z2.string().email(),
+  role: orgRoleSchema.default("member")
+});
+var setOrgRoleSchema = z2.object({ role: orgRoleSchema });
+var createProjectSchema = z2.object({
+  name: z2.string().min(1),
+  slug: z2.string().min(1).regex(/^[a-z0-9-]+$/, "slug must be lowercase alphanumeric with dashes")
+});
+var joinProjectSchema = z2.object({
+  joinCode: z2.string().min(1)
+});
+var inviteMemberSchema = z2.object({
+  email: z2.string().email(),
+  role: z2.enum(["admin", "member", "viewer"]).default("member")
+});
+var setMemberRoleSchema = z2.object({
+  role: z2.enum(["owner", "admin", "member", "viewer"])
+});
+var assignMemberSchema = z2.object({
+  userId: z2.string().min(1)
+});
+var updateProjectSchema = z2.object({
+  name: z2.string().min(1).max(80).optional(),
+  // null disables; a value in [0,1] auto-approves proposals at/above it.
+  autoApproveThreshold: z2.number().min(0).max(1).nullable().optional(),
+  // null disables; a value in [0,1] auto-rejects proposals below it.
+  autoRejectThreshold: z2.number().min(0).max(1).nullable().optional()
+});
+var chatSchema = z2.object({
+  message: z2.string().min(1).max(2e3)
+});
+var createRepoSchema = z2.object({
+  projectId: z2.string().min(1),
+  provider: z2.string().default("github"),
+  name: z2.string().min(1),
+  fullName: z2.string().min(1),
+  defaultBranch: z2.string().optional()
+});
+var updateRepoSchema = z2.object({
+  name: z2.string().min(1).optional(),
+  stack: z2.array(z2.string().min(1)).max(40).optional(),
+  packageManager: z2.string().max(40).optional(),
+  notes: z2.string().max(5e3).optional(),
+  defaultBranch: z2.string().max(120).optional(),
+  reviewerEnabled: z2.boolean().optional(),
+  reviewerInstructions: z2.string().max(4e3).optional()
+});
+var reviewPrSchema = z2.object({
+  prNumber: z2.number().int().positive(),
+  post: z2.boolean().optional()
+});
+var reviewDiffSchema = z2.object({
+  prTitle: z2.string().min(1).max(500),
+  prBody: z2.string().max(2e4).optional(),
+  diff: z2.string().min(1).max(4e5)
+});
+var PLANS = ["free", "scale", "enterprise"];
+var planSchema = z2.enum(PLANS);
+var PLAN_SOURCES = ["none", "stripe", "comp", "manual"];
+var planSourceSchema = z2.enum(PLAN_SOURCES);
+var billingCheckoutSchema = z2.object({
+  plan: planSchema
+});
+var requestUpgradeSchema = z2.object({
+  plan: planSchema,
+  note: z2.string().max(500).optional()
+});
+var setPlanSchema = z2.object({
+  plan: planSchema,
+  source: planSourceSchema.default("manual"),
+  status: z2.enum(["active", "past_due", "canceled"]).default("active"),
+  note: z2.string().max(500).optional()
+});
+var reviewFeedbackValueSchema = z2.enum(["pending", "accepted", "dismissed"]);
+var reviewFeedbackSchema = z2.object({
+  feedback: reviewFeedbackValueSchema
+});
+var reviewFeedbackBulkSchema = z2.object({
+  items: z2.array(z2.object({ key: z2.string().min(1), feedback: reviewFeedbackValueSchema })).min(1).max(200)
+});
+var reviewerSkillSchema = z2.object({
+  name: z2.string().min(1).max(120),
+  instructions: z2.string().min(1).max(8e3),
+  paths: z2.array(z2.string().min(1)).max(40).optional()
+});
+var updateReviewerSkillSchema = reviewerSkillSchema.partial();
+var setRepoSkillsSchema = z2.object({
+  skillIds: z2.array(z2.string().min(1)).max(50)
+});
+var memoryEvidenceSchema = z2.object({
+  kind: z2.string().min(1),
+  content: z2.string().min(1),
+  url: z2.string().url().optional()
+});
+var createMemorySchema = z2.object({
+  type: memoryTypeSchema,
+  title: z2.string().min(1),
+  content: z2.string().min(1),
+  paths: z2.array(z2.string().min(1)).max(50).optional(),
+  // Repos the memory applies to. Omitted on /repos/:id/memories = that repo;
+  // omitted on /projects/:id/memories = every repo in the project.
+  repoIds: z2.array(z2.string().min(1)).max(50).optional(),
+  confidence: z2.number().min(0).max(1).default(0.7),
+  status: memoryStatusSchema.default("proposed"),
+  source: z2.string().optional(),
+  evidence: z2.array(memoryEvidenceSchema).optional()
+});
+var updateMemorySchema = z2.object({
+  type: memoryTypeSchema.optional(),
+  title: z2.string().min(1).optional(),
+  content: z2.string().min(1).optional(),
+  paths: z2.array(z2.string().min(1)).max(50).optional(),
+  repoIds: z2.array(z2.string().min(1)).max(50).optional(),
+  confidence: z2.number().min(0).max(1).optional(),
+  status: memoryStatusSchema.optional()
+});
+var memoryListQuerySchema = z2.object({
+  status: memoryStatusSchema.optional(),
+  type: memoryTypeSchema.optional(),
+  search: z2.string().optional()
+});
+var sessionEventSchema = z2.object({
+  type: z2.string().min(1),
+  payload: z2.record(z2.unknown()).default({}),
+  // Optional span fields — render a session's events as a timeline.
+  name: z2.string().max(200).optional(),
+  durationMs: z2.number().int().min(0).optional(),
+  status: z2.enum(["ok", "error", "warning"]).optional()
+});
+var recordSessionSchema = z2.object({
+  agent: z2.string().default("claude-code"),
+  sessionId: z2.string().optional(),
+  task: z2.string().optional(),
+  summary: z2.string().optional(),
+  filesChanged: z2.array(z2.string()).optional(),
+  commandsRun: z2.array(z2.string()).optional(),
+  errors: z2.array(z2.string()).optional(),
+  // The reasoning arc — the human's steering (instructions + corrections) and a
+  // digest of the agent's reasoning — so the extractor captures the *why*, not
+  // just the mechanics.
+  userMessages: z2.array(z2.string()).optional(),
+  reasoning: z2.string().optional(),
+  events: z2.array(sessionEventSchema).optional()
+});
+var extractedMemorySchema = z2.object({
+  type: memoryTypeSchema,
+  title: z2.string().min(1).max(140),
+  content: z2.string().min(1),
+  confidence: z2.number().min(0).max(1),
+  paths: z2.array(z2.string().min(1)).max(50).optional(),
+  evidence: z2.string().optional(),
+  // Id of an existing memory this one corrects; approving it archives the old one.
+  supersedes: z2.string().optional()
+});
+var extractedMemoriesSchema = z2.array(extractedMemorySchema).max(20);
+var proposedMemoryInputSchema = z2.object({
+  type: memoryTypeSchema,
+  title: z2.string().min(1).max(140),
+  content: z2.string().min(1),
+  confidence: z2.number().min(0).max(1).default(0.6),
+  paths: z2.array(z2.string().min(1)).max(50).optional(),
+  evidence: z2.string().optional(),
+  supersedes: z2.string().optional()
+});
+var proposeMemoriesSchema = z2.object({
+  memories: z2.array(proposedMemoryInputSchema).min(1).max(20)
+});
+var mcpSearchMemorySchema = z2.object({
+  repoId: z2.string().min(1),
+  query: z2.string().default(""),
+  limit: z2.number().int().min(1).max(50).default(10)
+});
+var mcpRepoContextSchema = z2.object({
+  repoId: z2.string().min(1),
+  sessionId: z2.string().optional()
+});
+var mcpRelevantWarningsSchema = z2.object({
+  repoId: z2.string().min(1),
+  files: z2.array(z2.string().min(1)).min(1).max(100),
+  sessionId: z2.string().optional()
+});
+var setLlmSchema = z2.object({
+  provider: z2.enum(["anthropic", "openai", "google", "custom"]),
+  key: z2.string().min(1, "Missing key"),
+  model: z2.string().trim().min(1).optional(),
+  baseUrl: z2.string().url("Base URL must be a valid URL").optional()
+}).refine((v) => v.provider !== "custom" || !!v.baseUrl && !!v.model, {
+  message: "A custom provider needs both a base URL and a model.",
+  path: ["baseUrl"]
+});
+var testLlmSchema = z2.object({
+  provider: z2.enum(["anthropic", "openai", "google", "custom"]).optional(),
+  key: z2.string().min(1).optional(),
+  model: z2.string().trim().min(1).optional(),
+  baseUrl: z2.string().url("Base URL must be a valid URL").optional()
+});
+
+// ../../packages/shared/src/review.ts
+function slug(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+function findingKey(f) {
+  return `${f.path ?? ""}:${f.line ?? ""}:${slug(f.title)}`;
+}
+
+// src/github-review.ts
+var SEVERITY_LABEL = {
+  blocker: "\u{1F534} Blocker",
+  warning: "\u{1F7E1} Warning",
+  nit: "\u{1F535} Nit",
+  praise: "\u{1F7E2} Praise"
+};
+function parseDiffNewLines(diff) {
+  const out = /* @__PURE__ */ new Map();
+  let path = null;
+  let newLine = 0;
+  let inHunk = false;
+  for (const raw of diff.split("\n")) {
+    if (raw.startsWith("+++ ")) {
+      const p = raw.slice(4).replace(/^b\//, "");
+      path = p === "/dev/null" ? null : p;
+      if (path && !out.has(path)) out.set(path, /* @__PURE__ */ new Set());
+      inHunk = false;
+      continue;
+    }
+    const hunk = raw.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (hunk) {
+      newLine = parseInt(hunk[1], 10);
+      inHunk = true;
+      continue;
+    }
+    if (!inHunk || !path) continue;
+    if (raw.startsWith("-")) continue;
+    if (raw.startsWith("+") || raw.startsWith(" ")) {
+      out.get(path).add(newLine);
+      newLine++;
+    } else if (raw.startsWith("\\")) {
+    } else {
+      inHunk = false;
+    }
+  }
+  return out;
+}
+var MARKER_RE = /<!-- memmo-review:(.+?) -->/g;
+function extractMarkers(bodies) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const b of bodies) {
+    for (const m of b.matchAll(MARKER_RE)) keys.add(m[1]);
+  }
+  return keys;
+}
+function findingLine(f) {
+  const mem = f.memory ? ` _(memory: ${f.memory})_` : "";
+  return `**${SEVERITY_LABEL[f.severity]}** ${f.title}${mem}
+
+${f.detail}`;
+}
+function buildReviewPayload(summary, findings, commentable, existingKeys = /* @__PURE__ */ new Set()) {
+  const fresh = findings.filter((f) => !existingKeys.has(findingKey(f)));
+  const comments = [];
+  const leftover = [];
+  for (const f of fresh) {
+    if (f.path && f.line && commentable.get(f.path)?.has(f.line)) {
+      comments.push({
+        path: f.path,
+        line: f.line,
+        side: "RIGHT",
+        body: `${findingLine(f)}
+
+<!-- memmo-review:${findingKey(f)} -->`
+      });
+    } else {
+      leftover.push(f);
+    }
+  }
+  const bodyParts = ["### \u{1F9E0} Memmo Reviewer", "", summary || "_No summary._"];
+  if (leftover.length > 0) {
+    bodyParts.push("");
+    for (const f of leftover) {
+      const where = f.path ? ` \`${f.path}${f.line ? `:${f.line}` : ""}\`` : "";
+      const mem = f.memory ? ` _(memory: ${f.memory})_` : "";
+      bodyParts.push(`- **${SEVERITY_LABEL[f.severity]}**${where}: ${f.title}${mem}`);
+      if (f.detail) bodyParts.push(`  ${f.detail}`);
+      bodyParts.push(`  <!-- memmo-review:${findingKey(f)} -->`);
+    }
+  }
+  bodyParts.push("", "_Grounded in this repo's approved Memmo memories._");
+  return { body: bodyParts.join("\n"), event: "COMMENT", comments, newCount: fresh.length };
+}
+
+// src/github.ts
+import { readFileSync as readFileSync6, existsSync as existsSync10 } from "node:fs";
+function readEvent() {
+  const p = process.env.GITHUB_EVENT_PATH;
+  if (!p || !existsSync10(p)) return {};
+  try {
+    const ev = JSON.parse(readFileSync6(p, "utf8"));
+    return {
+      title: ev.pull_request?.title,
+      body: ev.pull_request?.body ?? void 0,
+      prNumber: ev.pull_request?.number ?? ev.number
+    };
+  } catch {
+    return {};
+  }
+}
+function ghContext(prFromEvent) {
+  const repo = process.env.GITHUB_REPOSITORY;
+  const token = process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN;
+  let pr = prFromEvent;
+  if (!pr) {
+    const m = (process.env.GITHUB_REF ?? "").match(/refs\/pull\/(\d+)\//);
+    if (m) pr = parseInt(m[1], 10);
+  }
+  if (!repo || !token || !pr) return null;
+  return { repo, pr, token };
+}
+async function gh(ctx, path, init = {}) {
+  const res = await fetch(`https://api.github.com${path}`, {
+    ...init,
+    headers: {
+      authorization: `Bearer ${ctx.token}`,
+      accept: "application/vnd.github+json",
+      "user-agent": "memmo",
+      ...init.body ? { "content-type": "application/json" } : {}
+    }
+  });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`GitHub ${res.status}: ${text.slice(0, 300)}`);
+  return text ? JSON.parse(text) : null;
+}
+
+// src/commands/review.ts
+function git(args) {
+  return execFileSync("git", args, { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+}
+function computeDiff(base) {
+  for (const ref of [`origin/${base}`, base]) {
+    try {
+      git(["rev-parse", "--verify", "--quiet", ref]);
+      return git(["diff", `${ref}...HEAD`]);
+    } catch {
+    }
+  }
+  try {
+    return git(["diff", "HEAD~1...HEAD"]);
+  } catch {
+    return "";
+  }
+}
+async function postInlineReview(ctx, diff, review) {
+  const commentable = parseDiffNewLines(diff);
+  const existing = await gh(
+    ctx,
+    `/repos/${ctx.repo}/pulls/${ctx.pr}/comments?per_page=100`
+  ).catch(() => []);
+  const existingKeys = extractMarkers(existing.map((c) => c.body ?? ""));
+  const payload = buildReviewPayload(review.summary, review.findings, commentable, existingKeys);
+  if (payload.newCount === 0 && existingKeys.size > 0) {
+    console.error("Memmo: no new findings since the last review \u2014 nothing to post.");
+    return;
+  }
+  await gh(ctx, `/repos/${ctx.repo}/pulls/${ctx.pr}/reviews`, {
+    method: "POST",
+    body: JSON.stringify({ body: payload.body, event: payload.event, comments: payload.comments })
+  });
+  console.error(
+    `Memmo: posted review (${payload.comments.length} inline, ${payload.newCount} new findings).`
+  );
+}
+async function reviewCommand(opts = {}) {
+  const config = await resolveProjectConfig();
+  if (!config) {
+    throw new Error(NOT_CONNECTED);
+  }
+  const creds = loadCredentials();
+  const token = process.env.MEMMO_TOKEN ?? creds?.token;
+  if (!token) throw new Error("No API token. Set MEMMO_TOKEN (CI) or run `memmo login`.");
+  const baseUrl = opts.api ?? process.env.MEMMO_API_URL ?? config.apiBaseUrl ?? creds?.apiBaseUrl;
+  if (!baseUrl) throw new Error("No API base URL. Set MEMMO_API_URL or pass --api.");
+  const client = { baseUrl, token };
+  const base = opts.base ?? process.env.GITHUB_BASE_REF ?? "main";
+  const diff = computeDiff(base).slice(0, 38e4);
+  if (!diff.trim()) {
+    console.error(`No diff detected against base "${base}" \u2014 nothing to review.`);
+    return;
+  }
+  const ev = readEvent();
+  const prTitle = (opts.title ?? ev.title ?? git(["log", "-1", "--pretty=%s"]).trim()).slice(0, 500);
+  const prBody = opts.body ?? ev.body;
+  const res = await apiFetch(client, `/repos/${config.repoId}/review-diff`, {
+    method: "POST",
+    body: JSON.stringify({ prTitle, prBody, diff })
+  });
+  if (res.skipped) {
+    console.error("Memmo reviewer is disabled for this repo \u2014 skipping (enable it in the dashboard).");
+    return;
+  }
+  const comment = res.comment ?? "";
+  if (opts.post) {
+    const ctx = ghContext(ev.prNumber);
+    if (!ctx) {
+      console.error(
+        "--post needs GitHub Actions context (GITHUB_REPOSITORY, a PR event, and GH_TOKEN/GITHUB_TOKEN). Falling back to markdown output."
+      );
+    } else if (res.review) {
+      try {
+        await postInlineReview(ctx, diff, res.review);
+        return;
+      } catch (e) {
+        console.error(
+          `Memmo: inline review failed (${e.message}); posting a summary comment instead.`
+        );
+        await gh(ctx, `/repos/${ctx.repo}/issues/${ctx.pr}/comments`, {
+          method: "POST",
+          body: JSON.stringify({ body: comment })
+        });
+        return;
+      }
+    }
+  }
+  if (opts.out) {
+    writeFileSync5(opts.out, comment);
+    console.error(`Wrote review to ${opts.out} (${res.review?.findings.length ?? 0} findings).`);
+  }
+  process.stdout.write(comment + "\n");
+}
+
+// src/commands/review-sync.ts
+init_api();
+function verdictFromReactions(reactions) {
+  let up = false;
+  let down = false;
+  for (const r of reactions) {
+    if (r.content === "+1") up = true;
+    else if (r.content === "-1") down = true;
+  }
+  if (up) return "accepted";
+  if (down) return "dismissed";
+  return null;
+}
+async function reviewSyncCommand(opts = {}) {
+  const config = await resolveProjectConfig();
+  if (!config) {
+    throw new Error(NOT_CONNECTED);
+  }
+  const creds = loadCredentials();
+  const token = process.env.MEMMO_TOKEN ?? creds?.token;
+  if (!token) throw new Error("No API token. Set MEMMO_TOKEN (CI) or run `memmo login`.");
+  const baseUrl = opts.api ?? process.env.MEMMO_API_URL ?? config.apiBaseUrl ?? creds?.apiBaseUrl;
+  if (!baseUrl) throw new Error("No API base URL. Set MEMMO_API_URL or pass --api.");
+  const client = { baseUrl, token };
+  const ev = readEvent();
+  const ctx = ghContext(ev.prNumber);
+  if (!ctx) {
+    throw new Error(
+      "review-sync needs GitHub Actions context (GITHUB_REPOSITORY, a PR event or refs/pull/<n>, and GH_TOKEN/GITHUB_TOKEN)."
+    );
+  }
+  const comments = await listReviewComments(ctx);
+  const items = [];
+  for (const c of comments) {
+    const keys = extractMarkers([c.body ?? ""]);
+    if (keys.size === 0) continue;
+    const reactions = await gh(
+      ctx,
+      `/repos/${ctx.repo}/pulls/comments/${c.id}/reactions?per_page=100`
+    ).catch(() => []);
+    const feedback = verdictFromReactions(reactions);
+    if (!feedback) continue;
+    for (const key of keys) items.push({ key, feedback });
+  }
+  if (items.length === 0) {
+    console.error("Memmo: no \u{1F44D}/\u{1F44E} reactions on Memmo review comments \u2014 nothing to sync.");
+    return;
+  }
+  const res = await apiFetch(
+    client,
+    `/repos/${config.repoId}/review-feedback`,
+    { method: "POST", body: JSON.stringify({ items }) }
+  );
+  const accepted = items.filter((i) => i.feedback === "accepted").length;
+  const dismissed = items.length - accepted;
+  console.error(
+    `Memmo: synced ${res.updated}/${items.length} finding(s) (${accepted} accepted, ${dismissed} dismissed).`
+  );
+}
+async function listReviewComments(ctx) {
+  return gh(ctx, `/repos/${ctx.repo}/pulls/${ctx.pr}/comments?per_page=100`).catch(
+    () => []
+  );
+}
+
+// src/commands/ci.ts
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync3, existsSync as existsSync11 } from "node:fs";
+import { join as join10 } from "node:path";
+var WORKFLOW = `name: Memmo Review
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+permissions:
+  contents: read
+  pull-requests: write
+jobs:
+  memmo-review:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm install -g @memmo/cli
+      - name: Memmo review
+        run: memmo review --base "\${{ github.event.pull_request.base.ref }}" --post
+        env:
+          MEMMO_TOKEN: \${{ secrets.MEMMO_TOKEN }}
+          MEMMO_API_URL: \${{ vars.MEMMO_API_URL }}
+          GH_TOKEN: \${{ github.token }}
+`;
+async function ciCommand(opts = {}) {
+  const dir = join10(process.cwd(), ".github", "workflows");
+  const file = join10(dir, "memmo-review.yml");
+  if (existsSync11(file) && !opts.force) {
+    console.error(`${file} already exists. Re-run with --force to overwrite.`);
+    return;
+  }
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync6(file, WORKFLOW);
+  console.log("Wrote .github/workflows/memmo-review.yml\n");
+  console.log("Next steps:");
+  console.log("  1. Commit .memmo/config.json and the workflow file.");
+  console.log("  2. Add your Memmo API token as a repo secret:");
+  console.log("       gh secret set MEMMO_TOKEN --body <your-memmo-token>");
+  console.log("  3. If you self-host the API, set its URL as a repo variable:");
+  console.log("       gh variable set MEMMO_API_URL --body https://your-memmo-api");
+  console.log("  4. Enable the reviewer for this repo in the Memmo dashboard (PR Reviewer card).");
+}
+
+// src/index.ts
+init_version();
+var program = new Command();
+program.name("memmo").description("Long-term memory for AI coding agents").version(VERSION);
+program.command("login").description("Sign in (opens your browser) and store an API token in ~/.memmo").option("-t, --token <token>", "Use a token from Account \u2192 API tokens instead of the browser (CI/headless)").option("-e, --email <email>", "Dev-only email login (local API)").option("--no-browser", "Print the sign-in URL instead of opening a browser").option("--api <url>", "API base URL").action((opts) => run(() => loginCommand(opts)));
+program.command("init").description("Connect this repo to Memmo (registers it from the git remote) and wire up Claude Code").option("-r, --repo <repoId>", "Repo ID to connect (default: detected from the git remote)").option("-p, --project <idOrName>", "Project to add the repo to (default: your only project, or a prompt)").option("-y, --yes", "Skip prompts").option("--scan", "Run an initial codebase scan after connecting").action((opts) => run(() => initCommand(opts)));
+program.command("claude").description("Claude Code integration").command("install").description("Generate CLAUDE.md, .mcp.json, and hooks").action(() => run(() => claudeInstallCommand()));
+program.command("mcp").description("Run the Memmo MCP stdio server (used by Claude Code / Claude Desktop)").option("-r, --repo <repoId>", "Repo to serve (for Claude Desktop; defaults to .memmo/config.json)").option("--api <url>", "API base URL").action((opts) => run(() => mcpCommand(opts)));
+program.command("scan").description("Scan the connected repo and propose starter memories").option("--agent", "Deep scan with local Claude Code (no API key, uses your subscription)").option("--server", "Scan on the server from GitHub (uses the project Anthropic key)").action((opts) => run(() => scanCommand(opts)));
+program.command("chat [question...]").description("Chat with this repo's memory using your own Anthropic (key or Claude subscription)").action((question) => run(() => chatCommand(question)));
+program.command("decision <text...>").description("Record a project decision (what changed) as memory").option("--why <reason>", "Why the decision was made").action((text, opts) => run(() => decisionCommand(text, opts)));
+program.command("status").description("Check whether Memmo is set up in this repo").action(() => run(() => statusCommand()));
+program.command("uninstall").description("Remove Memmo wiring (MCP server, hooks, CLAUDE.md section) from this repo").option("-y, --yes", "Skip the confirmation prompt").action((opts) => run(() => uninstallCommand(opts)));
+program.command("hook <event>", { hidden: true }).description("Run a Memmo Claude Code hook (internal)").action((event) => hookCommand(event));
+program.command("sync").description("Write approved memories into a managed CLAUDE.md block").action(() => run(() => syncCommand()));
+program.command("review").description("Review the current PR's diff with Memmo (inline comments in CI, or Markdown output)").option("--base <ref>", "Base branch to diff against (default: $GITHUB_BASE_REF or main)").option("--title <title>", "PR title (default: from the GitHub event or last commit)").option("--body <body>", "PR description").option("--post", "Post a PR review with inline comments using GH_TOKEN (for CI)").option("--out <file>", "Write the review Markdown to a file instead of posting").option("--api <url>", "API base URL").action((opts) => run(() => reviewCommand(opts)));
+program.command("review-sync").description("Sync GitHub \u{1F44D}/\u{1F44E} reactions on Memmo review comments back as finding feedback").option("--api <url>", "API base URL").action((opts) => run(() => reviewSyncCommand(opts)));
+program.command("ci").description("Generate a GitHub Actions workflow that runs the Memmo PR reviewer").option("-f, --force", "Overwrite an existing workflow file").action((opts) => run(() => ciCommand(opts)));
+var memory = program.command("memory").description("(coming soon) manage memories from the CLI");
+for (const stub of ["list", "propose"]) {
+  memory.command(stub).description(`(coming soon) memory ${stub}`).action(() => {
+    console.error(`\`memmo memory ${stub}\` is not implemented in this MVP pass.`);
+    process.exit(1);
+  });
+}
+function run(fn) {
+  fn().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+}
+program.parseAsync();