memro-cli 0.1.0 → 0.1.1

package/README.md

@@ -1,15 +1,18 @@
-# memro
+# memro-cli
 
 Connect your AI tools to [Memro](https://memro.co) memory with one command.
 
 ```bash
-npx memro connect
+npx memro-cli connect
 ```
 
-1. Shows a code and opens the Memro dashboard. Sign in and press **Connect**.
-2. Receives a new API key (revocable in the dashboard → API keys) and stores
+1. Lists the supported tools with the ones on this machine already ticked.
+   Use ↑/↓ to move, space to tick, `a` for all, Enter to confirm (Esc cancels
+   without signing in).
+2. Shows a code and opens the Memro dashboard. Sign in and press **Connect**.
+3. Receives a new API key (revocable in the dashboard → API keys) and stores
    it in `~/.memro/credentials.json` (readable only by you).
-3. Finds the tools on this machine and adds the Memro MCP server to each:
+4. Adds the Memro MCP server to each tool you picked:
 
 | Tool | Config written |
 |---|---|
@@ -29,11 +32,13 @@ once as `<file>.memro-backup`. Restart the tool afterwards.
 ## Commands
 
 ```
-npx memro connect [--client cursor,codex] [--yes]
-npx memro status
-npx memro disconnect [--client ...]
+npx memro-cli connect [--client cursor,codex] [--yes]
+npx memro-cli status
+npx memro-cli disconnect [--client ...]
 ```
 
+`--client` picks tools without the list; `--yes` takes every detected tool
+(both work in scripts, where there is no list to show).
 `--staging`, `--local` or `--api <url>` target another Memro server
 (self-hosted: `--api https://memro.example.com`).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memro-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Connect Claude Code, Codex, Cursor, Antigravity, OpenCode and other AI tools to Memro memory with one command.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://memro.co",

package/src/cli.js

@@ -2,9 +2,9 @@ import { execFile } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import readline from "node:readline/promises";
 
 import { CLIENTS, findClient } from "./clients.js";
+import { pick } from "./picker.js";
 
 const ENVIRONMENTS = {
   prod: "https://api.memro.co",
@@ -14,20 +14,20 @@ const ENVIRONMENTS = {
 
 const CREDENTIALS = () => path.join(os.homedir(), ".memro", "credentials.json");
 
-const HELP = `memro — connect your AI tools to Memro memory
+const HELP = `memro-cli — connect your AI tools to Memro memory
 
 Usage
   npx memro-cli connect      Sign in and add Memro to Claude Code, Codex, Cursor,
-                         Antigravity, OpenCode, Gemini CLI, VS Code, Windsurf
-                         and Claude Desktop
+                             Antigravity, OpenCode, Gemini CLI, VS Code, Windsurf
+                             and Claude Desktop
   npx memro-cli status       Show the connected account and configured tools
   npx memro-cli disconnect   Remove Memro from your tools and forget the key
 
 Options
-  --client <ids>         Only these tools, comma-separated (${CLIENTS.map((c) => c.id).join(", ")})
-  --yes, -y              Don't ask before writing configs
-  --staging | --local    Use staging or a local server instead of Memro Cloud
-  --api <url>            Use a specific Memro API (self-hosted)
+  --client <ids>             Only these tools, comma-separated, skipping the list (${CLIENTS.map((c) => c.id).join(", ")})
+  --yes, -y                  Don't ask: use every detected tool
+  --staging | --local        Use staging or a local server instead of Memro Cloud
+  --api <url>                Use a specific Memro API (self-hosted)
 `;
 
 function parseArgs(argv) {
@@ -148,20 +148,39 @@ function selectClients(ids) {
   });
 }
 
-async function confirm(question) {
-  if (!process.stdin.isTTY) {
-    console.log("  Not a terminal: pass --yes to write configs without asking.");
-    return false;
+/**
+ * Which tools to configure: --client wins; --yes takes every detected tool;
+ * otherwise the user picks in a list with detected tools pre-selected.
+ * Returns null when the user cancels or nothing can be asked.
+ */
+async function chooseTargets(opts) {
+  if (opts.clients) return selectClients(opts.clients);
+  const detected = new Set(CLIENTS.filter((c) => c.detect()));
+  if (opts.yes) return [...detected];
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.log("  Not a terminal: pass --yes (every detected tool) or --client <ids>.");
+    return null;
   }
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = (await rl.question(question)).trim().toLowerCase();
-  rl.close();
-  return answer === "" || answer === "y" || answer === "yes";
+  console.log("");
+  const picked = await pick(
+    CLIENTS.map((c) => ({ label: c.name, hint: detected.has(c) ? "" : "not detected", checked: detected.has(c), client: c })),
+    { title: "Which tools should use Memro?" },
+  );
+  return picked && picked.map((p) => p.client);
 }
 
 async function connect(opts) {
-  const targets = selectClients(opts.clients);
   console.log(`\n◆ Memro connect  (${opts.api})`);
+  // Choose first, so cancelling never creates an API key.
+  const targets = await chooseTargets(opts);
+  if (!targets) {
+    console.log("  Nothing changed.");
+    return;
+  }
+  if (targets.length === 0 && !opts.yes) {
+    console.log("  No tools selected. Nothing changed.");
+    return;
+  }
 
   let creds = loadCredentials();
   if (creds?.api_url === opts.api) {
@@ -185,11 +204,7 @@ async function connect(opts) {
     printManual(creds);
     return;
   }
-  console.log(`\n  Found: ${targets.map((c) => c.name).join(", ")}`);
-  if (!opts.yes && !(await confirm("  Add Memro to these tools? [Y/n] "))) {
-    console.log("  Nothing changed.");
-    return;
-  }
+  console.log(`\n  Adding Memro to: ${targets.map((c) => c.name).join(", ")}`);
 
   const conn = { mcpUrl: creds.mcp_url, apiKey: creds.api_key };
   let ok = 0;

package/src/picker.js

@@ -0,0 +1,91 @@
+// A small multi-select for the terminal: arrow keys (or j/k) move, space
+// toggles, "a" toggles all, Enter confirms, Esc/q/Ctrl-C cancels. No
+// dependencies; the state logic is pure so it can be tested without a TTY.
+
+import readline from "node:readline";
+
+const ESC = "\x1b[";
+const c = {
+  dim: (s) => `${ESC}2m${s}${ESC}22m`,
+  bold: (s) => `${ESC}1m${s}${ESC}22m`,
+  accent: (s) => `${ESC}38;5;141m${s}${ESC}39m`,
+  green: (s) => `${ESC}32m${s}${ESC}39m`,
+};
+
+/** Initial state: items are { label, hint?, checked }. */
+export function initialState(items) {
+  return { items: items.map((i) => ({ ...i })), cursor: 0, done: false, cancelled: false };
+}
+
+/** Apply one key ({ name, ctrl, sequence }) to the state. */
+export function reduce(state, key) {
+  const s = { ...state, items: state.items.map((i) => ({ ...i })) };
+  const n = s.items.length;
+  const name = key.name || key.sequence;
+  if ((key.ctrl && name === "c") || name === "escape" || name === "q") {
+    s.cancelled = true;
+  } else if (name === "return" || name === "enter") {
+    s.done = true;
+  } else if (name === "up" || name === "k") {
+    s.cursor = (s.cursor - 1 + n) % n;
+  } else if (name === "down" || name === "j" || name === "tab") {
+    s.cursor = (s.cursor + 1) % n;
+  } else if (name === "space" || name === " ") {
+    s.items[s.cursor].checked = !s.items[s.cursor].checked;
+  } else if (name === "a") {
+    const all = s.items.every((i) => i.checked);
+    s.items.forEach((i) => { i.checked = !all; });
+  }
+  return s;
+}
+
+/** The lines to draw for a state. */
+export function render(state, title) {
+  const lines = [`  ${c.bold(title)}`, c.dim("  ↑/↓ move · space select · a all · enter confirm · esc cancel"), ""];
+  state.items.forEach((item, i) => {
+    const here = i === state.cursor;
+    const box = item.checked ? c.green("◉") : c.dim("○");
+    const label = here ? c.accent(item.label) : item.label;
+    const hint = item.hint ? "  " + c.dim(item.hint) : "";
+    lines.push(`  ${here ? c.accent("›") : " "} ${box} ${label}${hint}`);
+  });
+  const count = state.items.filter((i) => i.checked).length;
+  lines.push("", c.dim(`  ${count} selected`));
+  return lines;
+}
+
+/**
+ * Show the picker and resolve with the selected items, or null if the user
+ * cancelled. Requires an interactive terminal on `input`.
+ */
+export function pick(items, { title, input = process.stdin, output = process.stdout } = {}) {
+  return new Promise((resolve) => {
+    let state = initialState(items);
+    let drawn = 0;
+    const draw = () => {
+      const lines = render(state, title);
+      if (drawn) output.write(`${ESC}${drawn}A`); // back to the top of the last frame
+      output.write(lines.map((l) => `${ESC}2K${l}`).join("\n") + "\n");
+      drawn = lines.length;
+    };
+    const finish = (value) => {
+      input.off("keypress", onKey);
+      if (input.isTTY) input.setRawMode(false);
+      input.pause();
+      output.write(`${ESC}?25h`); // show the cursor again
+      resolve(value);
+    };
+    const onKey = (_str, key = {}) => {
+      state = reduce(state, key);
+      if (state.cancelled) return finish(null);
+      if (state.done) return finish(state.items.filter((i) => i.checked));
+      draw();
+    };
+    readline.emitKeypressEvents(input);
+    if (input.isTTY) input.setRawMode(true);
+    input.resume();
+    output.write(`${ESC}?25l`); // hide the cursor while choosing
+    input.on("keypress", onKey);
+    draw();
+  });
+}