@opennous/cli 0.7.4 → 0.8.0

package/package.json

@@ -1,17 +1,28 @@
 {
   "name": "@opennous/cli",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Nous CLI — set up Nous, connect it to your coding agent, and read the Context API from your terminal",
   "type": "module",
   "bin": {
     "nous": "src/index.js"
   },
-  "files": ["src", "README.md"],
+  "files": [
+    "src",
+    "README.md"
+  ],
   "scripts": {
     "dev": "node src/index.js",
     "start": "node src/index.js"
   },
-  "keywords": ["nous", "crm", "cli", "agents", "memory", "observability", "stripe"],
+  "keywords": [
+    "nous",
+    "crm",
+    "cli",
+    "agents",
+    "memory",
+    "observability",
+    "stripe"
+  ],
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -20,6 +31,7 @@
   },
   "homepage": "https://opennous.cloud",
   "dependencies": {
+    "chokidar": "^3.6.0",
     "commander": "^12.1.0"
   }
 }

package/src/hooks/icp-sync-reminder.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// Nous ICP auto-sync reminder (installed by `npx @opennous/cli init`).
+//
+// A Claude Code PostToolUse hook. After the agent edits a Nous context file, it
+// reminds the agent that the file is INERT until synced: the app, the ICP tab, and
+// the ICP scoring model read the Nous GRAPH, not the repo file, so an edit does
+// nothing until mcp__nous__sync_icp runs. Standalone Node (no bash/jq) so it behaves
+// identically on Windows, macOS, and Linux.
+
+let raw = "";
+process.stdin.on("data", (c) => { raw += c; });
+process.stdin.on("end", () => {
+  try {
+    const j = JSON.parse(raw || "{}");
+    const f = (j && j.tool_input && j.tool_input.file_path) || (j && j.tool_response && j.tool_response.filePath) || "";
+    const norm = String(f).replace(/\\/g, "/");           // normalize Windows separators
+    if (!/\.md$/i.test(norm) || !/\/context\//i.test(norm)) return;
+
+    // Report the path relative to the project so the agent passes the right source_path.
+    const proj = (process.env.CLAUDE_PROJECT_DIR || "").replace(/\\/g, "/");
+    let rel = norm;
+    if (proj && norm.toLowerCase().startsWith(proj.toLowerCase())) {
+      rel = norm.slice(proj.length).replace(/^\/+/, "");
+    }
+    const base = norm.split("/").pop().toLowerCase();
+
+    const ctx = base === "icp.md"
+      ? `You just edited ${rel}, your Nous ICP file. It is INERT until synced: the app, the ICP tab, and the ICP scoring model read the Nous graph, not this file. Call the mcp__nous__sync_icp tool THIS TURN with section "ICP" and source_path "${rel}", passing the file body as the section content, so the graph and the scoring model rebuild from your edit. Do not end the turn with the ICP file edited but unsynced.`
+      : `You edited a Nous context file (${rel}). It stays inert until synced into the Nous graph. If it is an ICP, positioning, pricing, competitors, or market file, call mcp__nous__sync_icp this turn with the matching section and its source_path so the graph updates.`;
+
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: ctx } }));
+  } catch { /* never block a tool call */ }
+});

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";
 
@@ -961,6 +961,42 @@ function registerMcp(apiUrl) {
   return `Wrote ${path} — your agent will pick up Nous from it.`;
 }
 
+// Install the ICP auto-sync hook into the project's Claude Code config. Once in place,
+// editing a Nous context file (context/**/icp.md, etc.) reminds the agent to call
+// sync_icp that turn — because an edited ICP file is INERT until synced into the graph.
+// Copies our packaged hook script into .claude/hooks/ and merges the PostToolUse entry
+// into .claude/settings.json WITHOUT clobbering any existing hooks or settings.
+// Returns true if it was already installed. Uses the exec (args) form so there's no
+// shell/quoting difference between Windows PowerShell and macOS/Linux bash.
+function installIcpSyncHook() {
+  const claudeDir = join(process.cwd(), ".claude");
+  const hooksDir = join(claudeDir, "hooks");
+  const scriptPath = join(hooksDir, "icp-sync-reminder.mjs");
+  const settingsPath = join(claudeDir, "settings.json");
+
+  const src = readFileSync(new URL("./hooks/icp-sync-reminder.mjs", import.meta.url), "utf8");
+  mkdirSync(hooksDir, { recursive: true });
+  writeFileSync(scriptPath, src);
+
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try { settings = JSON.parse(readFileSync(settingsPath, "utf8")) || {}; } catch { settings = {}; }
+  }
+  settings.hooks = settings.hooks || {};
+  const post = settings.hooks.PostToolUse = settings.hooks.PostToolUse || [];
+  const already = post.some((e) => (e.hooks || []).some((h) =>
+    (Array.isArray(h.args) && h.args.some((a) => String(a).includes("icp-sync-reminder"))) ||
+    String(h.command || "").includes("icp-sync-reminder")));
+  if (!already) {
+    post.push({
+      matcher: "Write|Edit|MultiEdit",
+      hooks: [{ type: "command", command: "node", args: [scriptPath], timeout: 10 }],
+    });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  }
+  return already;
+}
+
 // nous init — the one-line "get started": sign in, register the MCP, hand off to the agent.
 // This is the command the install script and the marketing site point to.
 program
@@ -980,6 +1016,14 @@ program
         console.log("\nCouldn't register the MCP automatically. Add it with:");
         console.log(`  claude mcp add nous -- ${MCP_CMD} ${MCP_ARGS.join(" ")}`);
       }
+
+      // Auto-sync the ICP: a Claude Code hook so editing your ICP file reminds the
+      // agent to sync it into Nous (the file is inert until synced). Best-effort —
+      // a convenience, never a reason to fail setup.
+      try {
+        const already = installIcpSyncHook();
+        if (!already) console.log("Installed the ICP auto-sync hook — edits to your ICP file now sync to Nous automatically.");
+      } catch { /* non-fatal */ }
     }
 
     console.log("\nYou're set. Tell your agent:\n");
@@ -1007,8 +1051,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;
@@ -1031,14 +1075,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.
@@ -1054,4 +1098,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();