@opennous/cli 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @opennous/cli changelog
 
+## 0.10.1
+
+### Changed — new default vault folder structure
+
+`nous link` now scaffolds the vault with **inbox · projects · decisions · accounts ·
+people · resources · archive**. `accounts/` and `people/` are where Nous files the raw
+of each touch (email, meeting) by resolved account/person. Backward-compatible: the
+legacy folders (thoughts/briefs/content/company) are still walked, watched, and searched,
+so any files already in them keep syncing — only the folders created on a fresh link
+changed.
+
 ## 0.10.0
 
 ### Added — `nous vault`: on-device retrieval over your linked local vault

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opennous/cli",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Nous CLI — set up Nous, connect it to your coding agent, and read the Context API from your terminal",
   "type": "module",
   "bin": {

package/src/index.js

@@ -450,6 +450,50 @@ program
       })
   );
 
+// ---------------------------------------------------------------------------
+// nous connect <provider> — connect Gmail / Google Calendar via Composio
+// ---------------------------------------------------------------------------
+// You're already signed in (the saved key identifies you), so there's no device-code
+// dance — we start a Composio consent, open it in your browser, and poll until the
+// account goes ACTIVE. Composio holds the OAuth token; Nous never sees it.
+const CONNECT_ALIASES = {
+  gmail: "gmail_oauth",
+  gmail_oauth: "gmail_oauth",
+  calendar: "google_calendar",
+  gcal: "google_calendar",
+  "google-calendar": "google_calendar",
+  google_calendar: "google_calendar",
+};
+program
+  .command("connect <provider>")
+  .description("Connect a source: gmail | calendar (via Composio)")
+  .action(async (provider) => {
+    const name = CONNECT_ALIASES[String(provider).toLowerCase()];
+    if (!name) {
+      console.error(`Unknown source "${provider}". Try: nous connect gmail  |  nous connect calendar`);
+      process.exit(1);
+    }
+    const api = apiClient();
+    const start = await api.post("/api/connect/composio/start", { provider: name });
+    if (!start?.redirect_url) {
+      console.error("Couldn't start the connection. Ask an admin to set up the Integration Engine (Composio) in Settings first.");
+      process.exit(1);
+    }
+    console.log(`\nOpening your browser to authorize ${name === "gmail_oauth" ? "Gmail" : "Google Calendar"}…`);
+    console.log(dim(start.redirect_url) + "\n");
+    openBrowser(start.redirect_url);
+
+    process.stdout.write("Waiting for you to finish in the browser");
+    for (let i = 0; i < 150; i++) {   // ~5 min at 2s
+      await sleep(2000);
+      process.stdout.write(".");
+      const s = await api.get("/api/connect/composio/status", { provider: name, connection_request_id: start.connection_request_id });
+      if (s?.status === "connected") { console.log("\n✓ Connected. Your history is backfilling now and new events will flow in automatically."); return; }
+      if (s?.status === "failed") { console.log("\n✗ Google didn't approve the connection. Run the command again to retry."); process.exit(1); }
+    }
+    console.log("\nStill pending. If you finished in the browser, run the command again — it will pick up the active connection.");
+  });
+
 // ---------------------------------------------------------------------------
 // nous context <focus> — engineered, intent-shaped context for a task
 // ---------------------------------------------------------------------------
@@ -913,13 +957,15 @@ program
   });
 
 // ---------------------------------------------------------------------------
-// MCP registration — connect Nous to whatever agent is on this machine.
+// Connect OpenNous to whatever agent is on this machine — host-aware.
 //
-// There is deliberately no Claude Code plugin/marketplace. A plugin would be Claude-Code-only
-// and put a marketplace between a new user and the product — too much for a first run, and it
-// wouldn't work for Cursor, Codex, or any other host. The MCP server is the whole integration,
-// so registration is one cross-platform step: `claude mcp add` if the Claude CLI is here, else
-// a `.mcp.json` any MCP host reads.
+// The MCP server (7 primitives) is the universal capability: any MCP host runs `npx @opennous/mcp`.
+// But the SKILLS + routing are the product surface, and those are delivered per host:
+//   • Claude Code  → the OpenNous PLUGIN (skills + routing hooks + the trimmed MCP, one install).
+//   • Any other host (Cursor, Codex, Claude Desktop, …) → the trimmed MCP via a `.mcp.json`;
+//     each host's skills pack ships as we light it up.
+// So `init` installs the plugin on Claude Code, and writes the MCP config everywhere else — one
+// signup, the right shell per host, the same 7-primitive surface (NOUS_SURFACE=plugin) throughout.
 //
 // The MCP resolves its key from ~/.nous/config.json on every call, so we never bake the
 // key into any of these configs — sign-in already wrote it there.
@@ -943,11 +989,15 @@ function writeJsonMcp(path, apiUrl) {
     try { cfg = JSON.parse(readFileSync(path, "utf8")); } catch { cfg = {}; }
   }
   cfg.mcpServers = cfg.mcpServers || {};
-  cfg.mcpServers.nous = {
+  cfg.mcpServers.opennous = {
     command: MCP_CMD,
     args: MCP_ARGS,
-    // Only pin a non-default API URL (self-host). Cloud reads the key from the config file.
-    ...(apiUrl && apiUrl !== "https://api.opennous.cloud" ? { env: { NOUS_API_URL: apiUrl } } : {}),
+    // NOUS_SURFACE=plugin trims to the 7 revenue primitives (never the full internal toolset).
+    // Only pin a non-default API URL (self-host); cloud reads the key from ~/.nous/config.json.
+    env: {
+      NOUS_SURFACE: "plugin",
+      ...(apiUrl && apiUrl !== "https://api.opennous.cloud" ? { NOUS_API_URL: apiUrl } : {}),
+    },
   };
   const dir = dirname(path);
   if (dir && !existsSync(dir)) mkdirSync(dir, { recursive: true });
@@ -963,19 +1013,26 @@ function writeJsonMcp(path, apiUrl) {
  *   2. Write ./.mcp.json in the current project (Claude Code and most clients read it).
  * We never fail the flow on this — a printed fallback is better than an abort.
  */
-function registerMcp(apiUrl) {
-  if (hasClaudeCli()) {
-    const args = ["mcp", "add", "nous", "--scope", "user"];
-    if (apiUrl && apiUrl !== "https://api.opennous.cloud") args.push("-e", `NOUS_API_URL=${apiUrl}`);
-    args.push("--", MCP_CMD, ...MCP_ARGS);
-    const r = spawnSync("claude", args, { stdio: "ignore" });
-    if (r.status === 0) return "Registered Nous with Claude Code (claude mcp add).";
-    // add fails if a server named nous already exists — that's a success for our purposes.
-    return "Nous is already registered with Claude Code.";
-  }
+const PLUGIN_MARKETPLACE = "NousC/nous-plugin";
+const PLUGIN_ID = "opennous@opennous";
+
+// Claude Code → install the OpenNous PLUGIN (skills + routing hooks + the trimmed MCP, in one).
+// We try the plugin CLI; if this Claude build has no `plugin` subcommand it returns null and the
+// caller prints the two slash-commands instead. We deliberately do NOT fall back to a bare
+// `claude mcp add` — a standalone MCP server would duplicate the plugin's and drop the skills.
+function installClaudePlugin() {
+  const add = spawnSync("claude", ["plugin", "marketplace", "add", PLUGIN_MARKETPLACE], { stdio: "ignore" });
+  if (add.status !== 0 && add.status !== null) { /* non-zero: try install anyway, marketplace may already be added */ }
+  const inst = spawnSync("claude", ["plugin", "install", PLUGIN_ID], { stdio: "ignore" });
+  return inst.status === 0;
+}
+
+// Any other MCP host (Cursor, Codex, Claude Desktop, …) → the trimmed MCP server via a .mcp.json
+// any MCP host reads. Skills for those hosts arrive as their own packs (roadmap).
+function registerMcpServer(apiUrl) {
   const path = join(process.cwd(), ".mcp.json");
   writeJsonMcp(path, apiUrl);
-  return `Wrote ${path} — your agent will pick up Nous from it.`;
+  return `Wrote ${path} — your agent will pick up OpenNous (7 primitives) from it.`;
 }
 
 // Install the ICP auto-sync hook into the project's Claude Code config. Once in place,
@@ -1026,12 +1083,25 @@ program
 
     const apiUrl = url || readConfig().apiUrl || "https://api.opennous.cloud";
     if (register !== false) {
-      try {
-        console.log(`\n${registerMcp(apiUrl)}`);
-      } catch (e) {
-        // Never let registration take down sign-in — print the manual line instead.
-        console.log("\nCouldn't register the MCP automatically. Add it with:");
-        console.log(`  claude mcp add nous -- ${MCP_CMD} ${MCP_ARGS.join(" ")}`);
+      // Claude Code → the plugin (skills + hooks + trimmed MCP). Any other host → the MCP config.
+      if (hasClaudeCli()) {
+        let installed = false;
+        try { installed = installClaudePlugin(); } catch { /* fall through to instructions */ }
+        if (installed) {
+          console.log("\n✓ Installed the OpenNous plugin into Claude Code — skills, routing, and the 7 primitives.");
+          console.log("  If Claude Code is already running, apply it with /reload-plugins.");
+        } else {
+          console.log("\nDetected Claude Code. Install the OpenNous plugin (skills + hooks + tools):");
+          console.log("  /plugin marketplace add NousC/nous-plugin");
+          console.log("  /plugin install opennous@opennous");
+        }
+      } else {
+        try {
+          console.log(`\n${registerMcpServer(apiUrl)}`);
+        } catch {
+          console.log("\nCouldn't write .mcp.json automatically. Add OpenNous to your host's MCP config:");
+          console.log(`  command: ${MCP_CMD}  args: ${MCP_ARGS.join(" ")}  env: NOUS_SURFACE=plugin`);
+        }
       }
 
       // Auto-sync the ICP: a Claude Code hook so editing your ICP file reminds the
@@ -1059,7 +1129,7 @@ program
 //
 // It only touches slots that exist, and by default won't clobber a file that's already there
 // (the repo, once it's the author, wins) unless you pass --force.
-const PULL_KINDS = { icp: "icp.md", positioning: "positioning.md", voice: "voice.md", outreach: "messaging.md" };
+const PULL_KINDS = { icp: "icp.md" };
 
 program
   .command("pull")
@@ -1114,271 +1184,5 @@ program
     console.log("✓ Signed out — removed the saved API key from ~/.nous/config.json");
   });
 
-// ---------------------------------------------------------------------------
-// nous link <dir> — pair a local folder with your personal vault and keep them in
-// sync, both ways. Your laptop and Nous become two views of the same files: edit in
-// Obsidian/Finder and it flows up; the agent files a brief (once you approve it) and
-// it flows down. This is the "local desk" — the same vault the GitHub sync fills,
-// only the transport is your filesystem instead of a repo. `nous link` is idempotent;
-// run it once and leave it watching, or pass --once for a single reconcile.
-// ---------------------------------------------------------------------------
-
-const VAULT_FOLDERS = ["inbox", "thoughts", "decisions", "projects", "briefs", "content", "company"];
-
-// A resilient API caller for the daemon — unlike apiClient(), a failed poll or push
-// must NOT exit the process; the loop should keep running and retry on the next tick.
-function softClient() {
-  const cfg = readConfig();
-  const apiKey = process.env.NOUS_API_KEY || cfg.apiKey;
-  const apiUrl = process.env.NOUS_API_URL || cfg.apiUrl || "https://api.opennous.cloud";
-  if (!apiKey) { console.error("No API key. Run: nous login"); process.exit(1); }
-  return async (method, path, { body, query } = {}) => {
-    const url = new URL(path, apiUrl);
-    if (query) for (const [k, v] of Object.entries(query)) if (v != null) url.searchParams.set(k, String(v));
-    try {
-      const res = await fetch(url.toString(), {
-        method,
-        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-        body: body ? JSON.stringify(body) : undefined,
-      });
-      if (!res.ok) return { ok: false, status: res.status };
-      return { ok: true, data: res.status === 204 ? {} : await res.json() };
-    } catch (e) {
-      return { ok: false, error: e.message };
-    }
-  };
-}
-
-// Every .md under the foundation folders of `root`, as repo-style relative paths.
-function walkVaultMd(root) {
-  const out = [];
-  const rec = (dir, prefix) => {
-    let entries = [];
-    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
-    for (const e of entries) {
-      if (e.name.startsWith(".")) continue;
-      const abs = join(dir, e.name);
-      const rel = prefix ? `${prefix}/${e.name}` : e.name;
-      if (e.isDirectory()) rec(abs, rel);
-      else if (e.name.endsWith(".md")) out.push({ rel, abs });
-    }
-  };
-  for (const f of VAULT_FOLDERS) rec(join(root, f), f);
-  return out;
-}
-
-const safeRead = (abs) => { try { return readFileSync(abs, "utf8"); } catch { return null; } };
-const saveCursor = (cursor) => { const c = readConfig(); c.link = { ...(c.link || {}), cursor }; writeConfig(c); };
-
-// Write incoming files to disk where they differ. Records what we wrote so the watcher
-// can ignore the change event it will fire, and so we never push a file straight back.
-async function pullOnce(call, root, recentlyWritten, quiet) {
-  const since = readConfig().link?.cursor || new Date(0).toISOString();
-  const r = await call("GET", "/v2/personal/local/pull", { query: { since } });
-  if (!r.ok) return;
-  let wrote = 0;
-  for (const f of r.data.files || []) {
-    const abs = join(root, f.path.split("/").join(sep));
-    if (safeRead(abs) === f.content) continue;   // already identical — no write, no echo
-    mkdirSync(dirname(abs), { recursive: true });
-    writeFileSync(abs, f.content);
-    recentlyWritten.set(f.path, Date.now());
-    if (!quiet) process.stdout.write(`  ↓ ${f.path}\n`);
-    wrote++;
-  }
-  if (r.data.cursor) saveCursor(r.data.cursor);
-  return wrote;
-}
-
-program
-  .command("link <dir>")
-  .description("Pair a local folder with your personal vault and keep them in sync")
-  .option("--once", "Reconcile once and exit instead of watching", false)
-  .option("--interval <sec>", "How often to pull incoming changes while watching", "15")
-  .action(async (dir, { once, interval }) => {
-    const call = softClient();
-    const root = resolve(dir);
-    // Scaffold the folder so the desk has the same shape as the vault.
-    if (!existsSync(root)) mkdirSync(root, { recursive: true });
-    for (const f of VAULT_FOLDERS) { const d = join(root, f); if (!existsSync(d)) mkdirSync(d, { recursive: true }); }
-
-    const label = hostname() || "my machine";
-    const linked = await call("POST", "/v2/personal/local/link", { body: { label } });
-    if (!linked.ok) { console.error("Couldn't link this folder — check your API key with `nous auth status`."); process.exit(1); }
-
-    const cfg = readConfig();
-    cfg.link = { dir: root, cursor: new Date(0).toISOString() };
-    writeConfig(cfg);
-    console.log(`Linked ${root} ↔ your Nous vault (${label}).\n`);
-
-    const recentlyWritten = new Map();
-    const wasJustWritten = (rel) => { const t = recentlyWritten.get(rel); return t && Date.now() - t < 4000; };
-
-    // ── Initial reconcile: pull server state, then push anything local that differs. ──
-    const serverState = await call("GET", "/v2/personal/local/pull", { query: { since: new Date(0).toISOString() } });
-    const serverMap = new Map((serverState.ok ? serverState.data.files : []).map((f) => [f.path, f.content]));
-    // Write server files that are missing/different on disk.
-    for (const [path, content] of serverMap) {
-      const abs = join(root, path.split("/").join(sep));
-      if (safeRead(abs) === content) continue;
-      mkdirSync(dirname(abs), { recursive: true });
-      writeFileSync(abs, content);
-      recentlyWritten.set(path, Date.now());
-      console.log(`  ↓ ${path}`);
-    }
-    // Push local files the server doesn't have or that differ.
-    const toPush = walkVaultMd(root).filter((f) => serverMap.get(f.rel) !== safeRead(f.abs));
-    if (toPush.length) {
-      const files = toPush.map((f) => ({ path: f.rel, content: safeRead(f.abs) ?? "" }));
-      await call("POST", "/v2/personal/local/push", { body: { files } });
-      for (const f of toPush) console.log(`  ↑ ${f.rel}`);
-    }
-    saveCursor(new Date().toISOString());
-    console.log(`\n✓ In sync — ${serverMap.size} in Nous, ${walkVaultMd(root).length} on disk.`);
-
-    if (once) return;
-
-    // ── Watch: push local edits up; poll: pull remote edits down. ──
-    let chokidar;
-    try { chokidar = (await import("chokidar")).default; }
-    catch { console.error("\nWatching needs chokidar. Re-run with --once, or `npm i -g @opennous/cli` to get it."); process.exit(1); }
-
-    const pushPath = async (abs, deleted) => {
-      const rel = relative(root, abs).split(sep).join("/");
-      if (!rel.endsWith(".md")) return;
-      if (wasJustWritten(rel)) return;   // this change is one we just pulled — don't echo it back
-      const content = deleted ? "" : (safeRead(abs) ?? "");
-      const r = await call("POST", "/v2/personal/local/push", { body: { files: [{ path: rel, content, deleted: !!deleted }] } });
-      if (r.ok) { saveCursor(new Date().toISOString()); process.stdout.write(deleted ? `  ↑ removed ${rel}\n` : `  ↑ ${rel}\n`); }
-    };
-
-    const watcher = chokidar.watch(VAULT_FOLDERS.map((f) => join(root, f)), {
-      ignoreInitial: true, awaitWriteFinish: { stabilityThreshold: 400, pollInterval: 100 },
-    });
-    watcher.on("add", (p) => pushPath(p, false)).on("change", (p) => pushPath(p, false)).on("unlink", (p) => pushPath(p, true));
-
-    const secs = Math.max(5, Number(interval) || 15);
-    setInterval(() => { pullOnce(call, root, recentlyWritten).catch(() => {}); }, secs * 1000);
-
-    console.log(`\nWatching for changes. Pulling every ${secs}s. Press Ctrl-C to stop.`);
-    process.stdin.resume();   // keep the process alive
-  });
-
-// nous unlink — detach the local folder. Files stay in the vault; only the pairing ends.
-program
-  .command("unlink")
-  .description("Stop syncing your linked local folder (files stay in Nous)")
-  .action(async () => {
-    const call = softClient();
-    await call("POST", "/v2/personal/local/unlink", {});
-    const cfg = readConfig();
-    delete cfg.link;
-    writeConfig(cfg);
-    console.log("✓ Unlinked. Your files are still in Nous; this folder just stopped syncing.");
-  });
-
-// ---------------------------------------------------------------------------
-// nous vault — read + search the LINKED local vault ON-DEVICE. When an agent runs
-// where the vault is linked (`nous link`), it should read these files directly
-// instead of calling the search_my_vault MCP tool: fresher (no sync lag), fuller
-// (whole files, not snippets), faster (no network), and private (the reads never
-// leave the machine). This is the native personal-vault retrieval path.
-// ---------------------------------------------------------------------------
-function linkedVaultRoot() {
-  const dir = readConfig().link?.dir;
-  if (!dir || !existsSync(dir)) return null;
-  return dir;
-}
-function requireVaultRoot() {
-  const root = linkedVaultRoot();
-  if (!root) { console.error("No local vault linked. Run `nous link <dir>` first."); process.exit(1); }
-  return root;
-}
-// Resolve a 'folder/[subfolder/]name' argument to an absolute .md path under the vault.
-function resolveVaultRel(root, p) {
-  const rel = String(p).replace(/^\/+/, "").endsWith(".md") ? String(p).replace(/^\/+/, "") : `${String(p).replace(/^\/+/, "")}.md`;
-  return { rel, abs: join(root, rel.split("/").join(sep)) };
-}
-
-const vaultCmd = program
-  .command("vault")
-  .description("Read and search your linked local vault — on-device, no server round-trip");
-
-vaultCmd
-  .command("path")
-  .description("Print the linked vault folder (point your own Read/Grep at it)")
-  .action(() => { console.log(requireVaultRoot()); });
-
-vaultCmd
-  .command("list [folder]")
-  .description("List vault files, optionally within one folder")
-  .option("--json", "Output JSON", false)
-  .action((folder, { json }) => {
-    const root = requireVaultRoot();
-    let files = walkVaultMd(root).map((f) => f.rel);
-    if (folder) files = files.filter((r) => r.split("/")[0] === folder);
-    files.sort();
-    if (json) { console.log(JSON.stringify(files)); return; }
-    if (!files.length) { console.log(folder ? `No files in ${folder}.` : "Vault is empty."); return; }
-    for (const r of files) console.log(`  ${r}`);
-  });
-
-vaultCmd
-  .command("read <path>")
-  .description("Print a vault file's full content (e.g. decisions/pricing)")
-  .action((p) => {
-    const root = requireVaultRoot();
-    const { rel, abs } = resolveVaultRel(root, p);
-    const content = safeRead(abs);
-    if (content == null) { console.error(`Not found: ${rel}`); process.exit(1); }
-    process.stdout.write(content.endsWith("\n") ? content : content + "\n");
-  });
-
-vaultCmd
-  .command("search <query...>")
-  .description("Search the linked vault locally (on-device — never leaves your machine)")
-  .option("--folder <folder>", "Restrict to one vault folder")
-  .option("--limit <n>", "Max results", "6")
-  .option("--json", "Output JSON", false)
-  .action((queryParts, { folder, limit, json }) => {
-    const root = requireVaultRoot();
-    const query = queryParts.join(" ");
-    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
-    if (!terms.length) { console.error("Pass a query, e.g. `nous vault search pricing objections`."); process.exit(1); }
-
-    let files = walkVaultMd(root);
-    if (folder) files = files.filter((f) => f.rel.split("/")[0] === folder);
-
-    const hits = [];
-    for (const f of files) {
-      const content = safeRead(f.abs) ?? "";
-      const hay = content.toLowerCase();
-      const name = f.rel.toLowerCase();
-      let score = 0;
-      for (const t of terms) {
-        if (name.includes(t)) score += 5;                         // a filename hit is a strong signal
-        score += Math.min(hay.split(t).length - 1, 5);            // content occurrences, capped
-      }
-      if (score <= 0) continue;
-      // Snippet around the first matching term.
-      let snippet = "";
-      for (const t of terms) {
-        const i = hay.indexOf(t);
-        if (i >= 0) { snippet = content.slice(Math.max(0, i - 60), i + 140).replace(/\s+/g, " ").trim(); break; }
-      }
-      hits.push({ path: f.rel, score, snippet });
-    }
-    hits.sort((a, b) => b.score - a.score);
-    const top = hits.slice(0, Math.min(Math.max(1, Number(limit) || 6), 30));
-
-    if (json) { console.log(JSON.stringify(top)); return; }
-    if (!top.length) { console.log(`No local vault notes matched "${query}".`); return; }
-    console.log(`Local vault notes matching "${query}":\n`);
-    for (const h of top) {
-      console.log(`  ${h.path}`);
-      if (h.snippet) console.log(`    ${h.snippet}`);
-    }
-  });
-
 // ---------------------------------------------------------------------------
 program.name("nous").version("0.8.0").parse();