@opennous/cli 0.7.5 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opennous/cli",
-  "version": "0.7.5",
+  "version": "0.9.0",
   "description": "Nous CLI — set up Nous, connect it to your coding agent, and read the Context API from your terminal",
   "type": "module",
   "bin": {
@@ -31,6 +31,7 @@
   },
   "homepage": "https://opennous.cloud",
   "dependencies": {
+    "chokidar": "^3.6.0",
     "commander": "^12.1.0"
   }
 }

package/src/index.js

@@ -6,9 +6,9 @@
 // You never overwrite — Nous derives the facts.
 
 import { program, Command } from "commander";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } from "fs";
-import { homedir } from "os";
-import { join, resolve, dirname } from "path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync, readdirSync } from "fs";
+import { homedir, hostname } from "os";
+import { join, resolve, dirname, relative, sep } from "path";
 import { createInterface } from "readline";
 import { spawn, spawnSync } from "child_process";
 
@@ -837,18 +837,25 @@ program
 // freshly minted API key is saved to ~/.nous/config.json. No copy-paste. Shared
 // by `nous login` and `nous init`.
 // ---------------------------------------------------------------------------
-async function browserLogin(url) {
+async function browserLogin(url, opts = {}) {
   const apiUrl = url || process.env.NOUS_API_URL || readConfig().apiUrl || "https://api.opennous.cloud";
+  // Default = plain browser sign-in. With { startPath, startBody } it redeems a team
+  // join token instead (nous join): same device flow, different start endpoint.
+  const startPath = opts.startPath || "/api/cli/auth/start";
+  const startBody = opts.startBody ? JSON.stringify(opts.startBody) : "{}";
 
   let start;
   try {
-    const r = await fetch(`${apiUrl}/api/cli/auth/start`, {
-      method: "POST", headers: { "Content-Type": "application/json" }, body: "{}",
+    const r = await fetch(`${apiUrl}${startPath}`, {
+      method: "POST", headers: { "Content-Type": "application/json" }, body: startBody,
     });
-    if (!r.ok) throw new Error(`server returned ${r.status}`);
+    if (!r.ok) {
+      const j = await r.json().catch(() => ({}));
+      throw new Error(j.error ? j.error.replace(/_/g, " ") : `server returned ${r.status}`);
+    }
     start = await r.json();
   } catch (e) {
-    console.error(`Couldn't start sign-in: ${e.message}`);
+    console.error(`Couldn't start: ${e.message}`);
     process.exit(1);
   }
 
@@ -895,6 +902,16 @@ program
     console.log("Your Nous tools are ready — try `get_workspace_status` in your agent.");
   });
 
+program
+  .command("join <token>")
+  .description("Join a team with an invite/join token and set up your own scoped workspace")
+  .option("--url <url>", "API base URL (default: https://api.opennous.cloud)")
+  .action(async (token, { url }) => {
+    await browserLogin(url, { startPath: "/api/cli/auth/join/start", startBody: { token } });
+    console.log("You're in — your agent now has its own member-scoped Nous workspace.");
+    console.log("Try `get_workspace_status` in your agent.");
+  });
+
 // ---------------------------------------------------------------------------
 // MCP registration — connect Nous to whatever agent is on this machine.
 //
@@ -1051,8 +1068,8 @@ program
   .option("--force", "Overwrite files that already exist", false)
   .action(async ({ dir, force }) => {
     const api = apiClient();
-    const { playbooks } = await api.get("/v2/playbooks");
-    const docs = (playbooks || []).filter((p) => PULL_KINDS[p.kind] && (p.body_md || "").trim());
+    const { foundations } = await api.get("/v2/foundations");
+    const docs = (foundations || []).filter((p) => PULL_KINDS[p.kind] && (p.body_md || "").trim());
     if (!docs.length) {
       console.log("Nothing to pull — your Vault has no context docs yet. Set one up in the app first.");
       return;
@@ -1075,14 +1092,14 @@ program
       console.log(`  write ${rel}`);
       // Re-sync WITH the path so the graph now knows the repo is the author.
       try {
-        await api.post(`/v2/playbooks/${p.kind}`, { body_md: p.body_md, file_path: rel });
+        await api.post(`/v2/foundations/${p.kind}`, { body_md: p.body_md, file_path: rel });
         synced++;
       } catch { /* the file is written; a failed authorship flip is non-fatal, re-run pull */ }
     }
 
     console.log(`\n✓ ${written} written${skipped ? `, ${skipped} skipped` : ""}. Your repo now owns your context.`);
     if (synced < written) console.log(dim("  (some didn't sync back — re-run `nous pull` to finish)"));
-    console.log(dim("Edit these files and your agent syncs them with sync_playbook. Nous mirrors them."));
+    console.log(dim("Edit these files and your agent syncs them with sync_foundation. Nous mirrors them."));
   });
 
 // nous logout — top-level alias of `auth logout`. Removes the saved API key.
@@ -1098,4 +1115,167 @@ program
   });
 
 // ---------------------------------------------------------------------------
-program.name("nous").version("0.7.0").parse();
+// 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.");
+  });
+
+// ---------------------------------------------------------------------------
+program.name("nous").version("0.8.0").parse();