@agentprojectcontext/apx 1.69.0 → 1.71.0

package/src/core/memory/indexer.js

@@ -21,12 +21,14 @@ import fs from "node:fs";
 import path from "node:path";
 import { GLOBAL_MESSAGES_DIR, APX_HOME } from "../config/index.js";
 import { SELF_MEMORY_PATH, parseSelfMemoryEntries } from "../agent/self-memory.js";
+import { apcMemoryFile } from "../apc/paths.js";
 import { embedBatch, embedOne } from "./embeddings.js";
 
 export const CURSOR_PATH = path.join(APX_HOME, "memory-cursor.json");
 
 const BODY_CAP = 1200; // chars kept per user/agent chunk
 const TOOL_CAP = 400; // chars kept per tool-result chunk
+const SCOPED_CAP = 800; // chars kept per project/agent memory block
 
 function fnv1aHex(str) {
   let h = 0x811c9dc5;
@@ -37,6 +39,14 @@ function fnv1aHex(str) {
   return (h >>> 0).toString(16);
 }
 
+function readIfExists(p) {
+  try {
+    return fs.readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+}
+
 function readCursor(cursorPath) {
   try {
     return JSON.parse(fs.readFileSync(cursorPath, "utf8"));
@@ -177,6 +187,78 @@ function collectMemoryChunks(store, memoryPath) {
   return fresh;
 }
 
+// Split free-form markdown (project/agent memory — NOT the dated-notebook
+// format) into meaningful blocks: blank-line separated, whitespace-collapsed,
+// capped, and filtered so empty template sections ("## Identity\n- ") never
+// pollute the store. Each block becomes one scoped chunk.
+function chunkFreeMarkdown(text) {
+  return String(text || "")
+    .split(/\n\s*\n/)
+    .map((block) => {
+      // Drop pure-heading blocks (a "# Title" with no body under it) — they add
+      // noise to retrieval. Keep blocks that have at least one non-heading line.
+      const lines = block.split("\n").map((l) => l.trim()).filter(Boolean);
+      if (!lines.some((l) => !l.startsWith("#"))) return "";
+      return block.replace(/\s+/g, " ").trim();
+    })
+    .filter((b) => meaningfulBody(b))
+    .map((b) => b.slice(0, SCOPED_CAP));
+}
+
+// Per-agent memory lives at ~/.apx/projects/<projdir>/agents/<slug>/memory.md.
+// Walkable straight off the filesystem — no registry needed. Scoped by channel
+// "agent:<projdir>:<slug>" so retrieval never leaks between agents.
+function collectAgentMemoryChunks(store, apxHome) {
+  const fresh = [];
+  const projectsRoot = path.join(apxHome, "projects");
+  let projDirs;
+  try {
+    projDirs = fs.readdirSync(projectsRoot);
+  } catch {
+    return fresh;
+  }
+  for (const projDir of projDirs) {
+    const agentsDir = path.join(projectsRoot, projDir, "agents");
+    let slugs;
+    try {
+      slugs = fs.readdirSync(agentsDir);
+    } catch {
+      continue;
+    }
+    for (const slug of slugs) {
+      const body = readIfExists(path.join(agentsDir, slug, "memory.md"));
+      if (body == null) continue;
+      const channel = `agent:${projDir}:${slug}`;
+      for (const block of chunkFreeMarkdown(body)) {
+        const id = `agentmem:${projDir}:${slug}:${fnv1aHex(block)}`;
+        if (store.hasId(id)) continue;
+        fresh.push({ id, source: "agent-memory", channel, ts: "", tag: "agent-memory", text: block });
+      }
+    }
+  }
+  return fresh;
+}
+
+// Project memory (.apc/memory.md) for every registered project. Needs the
+// registry to map id → repo path. Scoped by channel "project:<id>".
+function collectProjectMemoryChunks(store, projects) {
+  const fresh = [];
+  const list = typeof projects?.list === "function" ? projects.list() : Array.isArray(projects) ? projects : [];
+  for (const entry of list) {
+    const root = entry?.path;
+    if (!root) continue; // the default project (id 0) has no repo root
+    const body = readIfExists(apcMemoryFile(root));
+    if (body == null) continue;
+    const channel = `project:${entry.id}`;
+    for (const block of chunkFreeMarkdown(body)) {
+      const id = `projmem:${entry.id}:${fnv1aHex(block)}`;
+      if (store.hasId(id)) continue;
+      fresh.push({ id, source: "project-memory", channel, ts: "", tag: "project-memory", text: block });
+    }
+  }
+  return fresh;
+}
+
 // Run one incremental indexing pass. Returns { indexed, backend }.
 // `opts.embed` overrides embedding options (baseUrl/model/timeoutMs) for tests.
 export async function indexNewMessages(store, opts = {}) {
@@ -220,7 +302,12 @@ export async function indexNewMessages(store, opts = {}) {
 
   const { fresh: msgChunks, maxTsByChannel } = collectMessageChunks(store, cursor, messagesDir);
   const memChunks = collectMemoryChunks(store, memoryPath);
-  let chunks = [...msgChunks, ...memChunks];
+  // Scoped memory (Pieza 5): per-agent + per-project notebooks, tagged with a
+  // scoped channel so retrieval can be isolated. Idempotent by content hash, so
+  // re-derived every pass like memory.md (cheap, few blocks).
+  const agentChunks = collectAgentMemoryChunks(store, opts.apxHome || APX_HOME);
+  const projChunks = collectProjectMemoryChunks(store, opts.projects);
+  let chunks = [...msgChunks, ...memChunks, ...agentChunks, ...projChunks];
   if (chunks.length === 0) return { indexed: 0, backend: store.backend };
 
   // Cap per-run work so a huge first index doesn't block; the rest is picked

package/src/core/memory/store.js

@@ -8,18 +8,30 @@
 //
 // Both expose the same interface:
 //   upsert(rows)              rows: {id, source, channel, ts, tag, text, embedder, dim, vector}
-//   search(vector, {embedder, k, channel}) -> [{...row, score}]
+//   search(vector, {embedder, k, channel, scope}) -> [{...row, score}]
 //   hasId(id) / count()
 //   close()
 //
 // Cosine is only meaningful within one embedder space, so search() filters to
 // rows whose `embedder` matches the query's embedder. Everything here is
 // best-effort: open() never throws — on any failure it returns a JsonStore.
+//
+// Scope isolation (memory belongs to whoever wrote it):
+//   - project/agent memory rows carry a scoped `channel` ("project:<id>" or
+//     "agent:<projdir>:<slug>"). Global conversational rows use the channel name
+//     (telegram/web/…) or "memory".
+//   - search({scope}) keeps retrieval from leaking across scopes:
+//       scope === "global"  → EXCLUDE project:/agent: rows (super-agent recall)
+//       scope === "<value>" → ONLY rows whose channel equals that value
+//       scope omitted        → no scope filter (back-compat)
 
 import fs from "node:fs";
 import path from "node:path";
 import { cosineSim } from "./embeddings.js";
 
+export const SCOPE_PREFIXES = ["project:", "agent:"];
+const isScopedChannel = (c) => SCOPE_PREFIXES.some((p) => String(c || "").startsWith(p));
+
 function vecToBlob(vec) {
   const f = new Float32Array(vec);
   return Buffer.from(f.buffer, f.byteOffset, f.byteLength);
@@ -87,11 +99,18 @@ export class JsonStore {
     this._flush();
   }
 
-  search(vector, { embedder, k = 5, channel } = {}) {
+  search(vector, { embedder, k = 5, channel, scope } = {}) {
+    const scopeArr = Array.isArray(scope) ? scope : null;
     const scored = [];
     for (const row of this.rows.values()) {
       if (embedder && row.embedder !== embedder) continue;
       if (channel && row.channel !== channel) continue;
+      if (scope === "global" && isScopedChannel(row.channel)) continue;
+      if (scopeArr) {
+        if (!scopeArr.includes(row.channel)) continue;
+      } else if (scope && scope !== "global" && row.channel !== scope) {
+        continue;
+      }
       if (!Array.isArray(row.vector) || row.vector.length !== vector.length) continue;
       scored.push({ ...row, score: cosineSim(vector, row.vector) });
     }
@@ -171,7 +190,7 @@ class SqliteVecStore {
     this.db.prepare("DELETE FROM chunks").run();
   }
 
-  search(vector, { embedder, k = 5, channel } = {}) {
+  search(vector, { embedder, k = 5, channel, scope } = {}) {
     const blob = vecToBlob(vector);
     const where = ["embedder = ?", "dim = ?"];
     const params = [embedder, vector.length];
@@ -179,6 +198,19 @@ class SqliteVecStore {
       where.push("channel = ?");
       params.push(channel);
     }
+    if (scope === "global") {
+      where.push("(channel NOT LIKE 'project:%' AND channel NOT LIKE 'agent:%')");
+    } else if (Array.isArray(scope)) {
+      if (scope.length === 0) {
+        where.push("0"); // no scopes → match nothing
+      } else {
+        where.push(`channel IN (${scope.map(() => "?").join(",")})`);
+        params.push(...scope);
+      }
+    } else if (scope) {
+      where.push("channel = ?");
+      params.push(scope);
+    }
     const rows = this.db
       .prepare(
         `SELECT id, source, channel, ts, tag, text, embedder, dim,

package/src/host/daemon/api/integrations.js

@@ -23,6 +23,7 @@ import {
   defaultIntegrationsStorage,
   listCatalog,
   getPluginService,
+  reconcilePluginMcp,
 } from "#core/integrations/index.js";
 
 function normalizeScope(raw) {
@@ -43,7 +44,23 @@ function storagePathForScope(scope, p, projects) {
   return p.storagePath || null;
 }
 
-export function register(app, { projects, project }) {
+export function register(app, { projects, project, registries }) {
+  // Keep a plugin's optional auto-registered MCP server (svc.mcpServer hook) in
+  // lockstep with its stored state. Best-effort: a failure here must not break
+  // the configure/validate/deactivate/delete response. `storagePath` is the one
+  // the handler wrote to (so global-scope records resolve from the default
+  // store), `scope` is the integration scope ("project" | "global").
+  function reconcileMcp(svc, storagePath, scope, p) {
+    if (typeof svc?.mcpServer !== "function") return;
+    try {
+      const record = storagePath ? new IntegrationStore(storagePath).get(svc.slug) : null;
+      const desired = svc.mcpServer(record);
+      reconcilePluginMcp({ desired, integrationScope: scope, project: p, projects, registries });
+    } catch {
+      /* best-effort MCP reconcile — ignore */
+    }
+  }
+
   // List stored integrations in the chosen scope (secrets redacted).
   app.get("/projects/:pid/integrations", (req, res) => {
     const p = project(req, res);
@@ -107,6 +124,7 @@ export function register(app, { projects, project }) {
     try {
       const { patch } = svc.configure(store.get(req.params.slug), req.body || {});
       const record = store.upsert(req.params.slug, patch);
+      reconcileMcp(svc, storagePath, scope, p);
       res.status(201).json(redactRecord(record));
     } catch (e) {
       res.status(400).json({ error: e.message });
@@ -129,6 +147,7 @@ export function register(app, { projects, project }) {
     try {
       const { patch, result } = await svc.validate(record);
       store.upsert(req.params.slug, patch);
+      reconcileMcp(svc, storagePath, scope, p);
       if (result && result.ok === false) return res.status(400).json(result);
       res.json(result);
     } catch (e) {
@@ -150,6 +169,7 @@ export function register(app, { projects, project }) {
     if (!store.get(req.params.slug)) return res.status(404).json({ error: "integration not configured" });
     const { patch } = svc.deactivate(store.get(req.params.slug));
     const record = store.upsert(req.params.slug, patch);
+    reconcileMcp(svc, storagePath, scope, p);
     res.json(svc.status(record));
   });
 
@@ -170,7 +190,10 @@ export function register(app, { projects, project }) {
     const record = new IntegrationStore(storagePath).get(req.params.slug);
     if (!record) return res.status(404).json({ error: "integration not configured" });
     try {
-      res.json(await fn.call(svc.actions, record));
+      // Actions get a 2nd ctx arg (existing plugins ignore it). Obsidian's
+      // sync_memory uses it to reach every project's memory.md.
+      const actionCtx = { storagePath, scope, project: p, projects, registries };
+      res.json(await fn.call(svc.actions, record, actionCtx));
     } catch (e) {
       res.status(400).json({ error: e.message });
     }
@@ -186,6 +209,8 @@ export function register(app, { projects, project }) {
     if (!storagePath) return res.status(400).json({ error: "project has no storage path" });
     const removed = new IntegrationStore(storagePath).remove(req.params.slug);
     if (!removed) return res.status(404).end();
+    // Record is gone → svc.mcpServer(null) yields def:null → drop any auto MCP.
+    reconcileMcp(getPluginService(req.params.slug), storagePath, scope, p);
     res.status(204).end();
   });
 }

package/src/host/daemon/api/mcps.js

@@ -96,7 +96,7 @@ export function register(app, { projects, registries, project }) {
     } catch (e) {
       return res.status(400).json({ error: e.message });
     }
-    registries.shutdown();
+    registries.evictName(name);
     projects.rebuild(p.id);
     const entry = registries.for(p).getByName(name);
     res.status(201).json(entry);
@@ -150,7 +150,7 @@ export function register(app, { projects, registries, project }) {
     } catch (e) {
       return res.status(400).json({ error: e.message });
     }
-    registries.shutdown();
+    registries.evictName(req.params.name);
     projects.rebuild(p.id);
     res.status(204).end();
   });

package/src/host/daemon/index.js

@@ -147,6 +147,12 @@ class RegistryCache {
   for(projectEntry) {
     return this.ensure(projectEntry);
   }
+  // Evict one MCP by name from every cached registry so its live process
+  // respawns with fresh config on next use. Used after add/remove instead of
+  // shutting down (and cold-restarting) every MCP across every project.
+  evictName(name) {
+    for (const r of this.byProjectId.values()) r.evict(name);
+  }
   shutdown() {
     for (const r of this.byProjectId.values()) r.shutdown();
     this.byProjectId.clear();
@@ -238,7 +244,7 @@ async function main() {
     // Cross-channel memory: ensure ~/.apx/memory.md exists, open the vector
     // store, and start the incremental RAG indexer. Best-effort — never blocks
     // boot and never throws into the daemon.
-    initMemory({ config: cfg, log }).catch((e) => log(`memory: init failed: ${e?.message || e}`));
+    initMemory({ config: cfg, log, projects }).catch((e) => log(`memory: init failed: ${e?.message || e}`));
     // Skill Inspector: if enabled, refresh its vector index in the background so
     // any SKILL.md added/edited while the daemon was down is picked up without a
     // manual `apx skills index`. Best-effort; never blocks boot.

package/src/interfaces/cli/commands/obsidian.js

@@ -0,0 +1,79 @@
+// `apx obsidian` — configure and drive the Obsidian integration from the CLI.
+// Thin client over the generic integrations daemon API (the same routes the web
+// panel uses), so scoping stays consistent: `--global` (or `--scope global`)
+// targets the default space; otherwise the current/`--project` project. A vault
+// is a local directory of Markdown notes; connecting it lets APX agents read,
+// search and write notes, optionally auto-registers an Obsidian MCP, and lets
+// you mirror APX memory into the vault.
+import { http } from "../http.js";
+import { resolveProjectId } from "./project.js";
+
+const SLUG = "obsidian";
+
+function resolveScope(flags = {}) {
+  if (flags.global) return "global";
+  const s = flags.scope ? String(flags.scope).toLowerCase() : "project";
+  if (s === "default") return "global";
+  if (s !== "project" && s !== "global") {
+    throw new Error(`unknown --scope "${flags.scope}" (use project|global)`);
+  }
+  return s;
+}
+
+function scopeQuery(scope) {
+  return `?scope=${encodeURIComponent(scope)}`;
+}
+
+export async function cmdObsidianSet(args) {
+  const vaultPath = args._[0];
+  if (!vaultPath) throw new Error("apx obsidian set: missing <vault-path>");
+  const scope = resolveScope(args.flags);
+  const pid = await resolveProjectId(args?.flags?.project);
+  const body = { vault_path: vaultPath };
+  if (args.flags.mcp) body.auto_mcp = true;
+  if (args.flags.memory || args.flags["memory-sync"]) body.memory_sync = true;
+
+  const q = scopeQuery(scope);
+  await http.post(`/projects/${pid}/integrations/${SLUG}/configure${q}`, body);
+  try {
+    const r = await http.post(`/projects/${pid}/integrations/${SLUG}/validate${q}`, {});
+    const badge = r.is_vault ? "Obsidian vault" : "folder (no .obsidian)";
+    console.log(`✓ Obsidian connected (${scope}) — ${r.vault_name} · ${r.note_count} notes · ${badge}`);
+    console.log(`  ${r.vault_path}`);
+    if (body.auto_mcp) console.log("  auto-MCP: on — an 'obsidian' MCP server was registered for this scope");
+    if (body.memory_sync) console.log("  memory-sync: on — run `apx obsidian sync` to mirror APX memory into the vault");
+  } catch (e) {
+    throw new Error(`Vault path saved but validation failed: ${e.message}`);
+  }
+}
+
+export async function cmdObsidianStatus(args) {
+  const scope = resolveScope(args.flags);
+  const pid = await resolveProjectId(args?.flags?.project);
+  const s = await http.get(`/projects/${pid}/integrations/${SLUG}${scopeQuery(scope)}`);
+  if (!s || s.status === "disconnected") {
+    console.log(`(Obsidian not configured in scope "${scope}")`);
+    return;
+  }
+  console.log(`Obsidian — ${s.status}${s.is_enabled ? " (enabled)" : ""}`);
+  if (s.vault_path) console.log(`  vault: ${s.vault_path}`);
+  if (s.vault_name) console.log(`  name:  ${s.vault_name}`);
+  if (s.note_count != null) console.log(`  notes: ${s.note_count}`);
+  console.log(`  auto-MCP:    ${s.auto_mcp ? "on" : "off"}`);
+  console.log(`  memory-sync: ${s.memory_sync ? "on" : "off"}`);
+}
+
+export async function cmdObsidianSync(args) {
+  const scope = resolveScope(args.flags);
+  const pid = await resolveProjectId(args?.flags?.project);
+  const r = await http.post(`/projects/${pid}/integrations/${SLUG}/action/sync_memory${scopeQuery(scope)}`, {});
+  console.log(`✓ Synced ${r.count} memory file(s) → vault folder "${r.folder}" (${r.changed} changed)`);
+  for (const n of r.notes || []) console.log(`  ${n.changed ? "↑" : "="} ${n.note}`);
+}
+
+export async function cmdObsidianRemove(args) {
+  const scope = resolveScope(args.flags);
+  const pid = await resolveProjectId(args?.flags?.project);
+  await http.delete(`/projects/${pid}/integrations/${SLUG}${scopeQuery(scope)}`);
+  console.log(`Removed Obsidian integration (scope: ${scope})`);
+}

package/src/interfaces/cli/index.js

@@ -101,6 +101,12 @@ import {
   cmdPermission,
 } from "./commands/config.js";
 import { cmdPluginsList, cmdPluginStatus } from "./commands/plugins.js";
+import {
+  cmdObsidianSet,
+  cmdObsidianStatus,
+  cmdObsidianSync,
+  cmdObsidianRemove,
+} from "./commands/obsidian.js";
 import { cmdDesktopStart, cmdDesktopStop, cmdDesktopRestart, cmdDesktopStatus, cmdDesktopInstall, cmdDesktopUninstall, desktopRunning } from "./commands/desktop.js";
 import { cmdVoiceSay, cmdVoiceListen, cmdVoiceProviders } from "./commands/voice.js";
 import { cmdSkillsAdd, cmdSkillsList, cmdSkillsStatus, cmdSkillsSync, cmdSkillsIndex, cmdSkillsInspect, cmdSkillsInspector } from "./commands/skills.js";
@@ -715,6 +721,30 @@ const HELP_TOPICS = new Map(Object.entries({
       "apx sessions list --engine codex --dir /Volumes/work/iacrmar",
     ],
   }),
+  obsidian: topic({
+    title: "apx obsidian",
+    summary: "Connect an Obsidian vault so agents can read, search and write notes; mirror APX memory into it.",
+    usage: ["apx obsidian <subcommand> [--global | --project <name|id|path>]"],
+    commands: [
+      ["set <vault-path>", "Connect a vault (validates the path). Add --mcp / --memory to enable extras."],
+      ["status", "Show the configured vault, note count and toggles for the scope."],
+      ["sync", "Mirror APX memory (global + projects) into the vault, without duplicates."],
+      ["remove | rm", "Disconnect the vault (also removes any auto-registered MCP)."],
+    ],
+    options: [
+      ["--global", "Target the default space (shared by all projects) instead of the current project."],
+      ["--scope <project|global>", "Explicit scope (alias of --global)."],
+      ["--mcp", "On `set`: auto-register an 'obsidian' MCP server pointing at the vault."],
+      ["--memory", "On `set`: enable memory sync (then run `apx obsidian sync`)."],
+      ["--project <name|id|path>", "Pin command to a specific project."],
+    ],
+    examples: [
+      "apx obsidian set ~/Obsidian/Work --project appsi",
+      "apx obsidian set ~/Obsidian/Personal --global --mcp --memory",
+      "apx obsidian sync --global",
+      "apx obsidian status",
+    ],
+  }),
   mcp: topic({
     title: "apx mcp",
     summary: "Manage and call MCP servers merged from APC and supported IDE configs.",
@@ -2135,6 +2165,12 @@ function buildHelp(version) {
     hCmd("apx mcp logs <name>",        36, "spawn/init log + stderr tail"),
     hCmd("apx mcp check",              36, "audit multi-source merge"),
 
+    hSec("Obsidian"),
+    hCmd("apx obsidian set <path>",    36, "connect a vault  --global  --project P  --mcp  --memory"),
+    hCmd("apx obsidian status",        36, "show configured vault + toggles"),
+    hCmd("apx obsidian sync",          36, "mirror APX memory into the vault (no duplicates)"),
+    hCmd("apx obsidian remove",        36, "disconnect the vault"),
+
     hSec("Daemon Service"),
     hCmd("apx daemon start",           36, ""),
     hCmd("apx daemon reload",          36, "reload ~/.apx/config.json without restart"),
@@ -2313,7 +2349,7 @@ function findHelpTopic(argv) {
 // Flags that never take a value. Without this the parser would greedily
 // swallow the following positional (e.g. `apx exec --code "hi"` would set
 // flags.code = "hi" and drop the prompt). Boolean flags always resolve to true.
-const BOOLEAN_FLAGS = new Set(["code", "verbose"]);
+const BOOLEAN_FLAGS = new Set(["code", "verbose", "global", "mcp", "memory"]);
 
 function parseArgs(argv) {
   const args = { _: [], flags: {} };
@@ -2501,6 +2537,17 @@ async function dispatch(cmd, rest) {
         break;
       }
 
+      case "obsidian": {
+        const sub = rest[0];
+        const a = parseArgs(rest.slice(1));
+        if (!sub || sub === "status" || sub === "show") await cmdObsidianStatus(a);
+        else if (sub === "set" || sub === "connect" || sub === "add") await cmdObsidianSet(a);
+        else if (sub === "sync") await cmdObsidianSync(a);
+        else if (sub === "remove" || sub === "rm" || sub === "disconnect") await cmdObsidianRemove(a);
+        else die(`unknown obsidian subcommand: ${sub}\nUsage: apx obsidian <set|status|sync|remove> [--global|--project <p>]`);
+        break;
+      }
+
       case "daemon": {
         const sub = rest[0];
         const a = parseArgs(rest.slice(1));