@lotargo/memory_plugin 1.4.620 → 1.5.0

package/mcp-server/memory.js

@@ -2,6 +2,7 @@ import { readFile, writeFile, mkdir, unlink, readdir } from "fs/promises";
 import { existsSync, mkdirSync } from "fs";
 import { join, basename, resolve } from "path";
 import { homedir } from "os";
+import { resolveProjectIdentity } from "./identity.js";
 
 function resolveMemoryDir() {
   if (process.env.MEMORY_DIR) return process.env.MEMORY_DIR;
@@ -46,7 +47,6 @@ export function ensureDirSync() {
   if (!existsSync(exportsDir)) mkdirSync(exportsDir, { recursive: true });
 }
 
-// Canonical absolute path key: forward slashes, lowercase drive letter on win32.
 export function canonicalPath(dir) {
   let p = resolve(dir || process.cwd());
   if (process.platform === "win32") {
@@ -55,24 +55,25 @@ export function canonicalPath(dir) {
   return p;
 }
 
-// Project store key = full directory path. This removes basename collisions and
-// binds each store to the real project location.
-export function projectKey(worktree, directory) {
-  return canonicalPath(worktree || directory);
+export async function projectKey(worktree, directory) {
+  const dir = worktree || directory || process.cwd();
+  const identity = await resolveProjectIdentity(dir);
+  return identity ? identity.key : null;
 }
 
-// Display label for a project (basename of the resolved directory).
-export function projectName(worktree, directory) {
+export async function projectName(worktree, directory) {
   const dir = worktree || directory || process.cwd();
-  return dir ? basename(resolve(dir)) : "default";
+  const identity = await resolveProjectIdentity(dir);
+  return identity ? identity.name : (dir ? basename(resolve(dir)) : "default");
 }
 
-export function scopeKey(scope, worktree, directory) {
-  return scope === "global" ? GLOBAL_KEY : projectKey(worktree, directory);
+export async function scopeKey(scope, worktree, directory) {
+  return scope === "global" ? GLOBAL_KEY : await projectKey(worktree, directory);
 }
 
-function slugify(key) {
-  return key.replace(/[^a-zA-Z0-9_-]/g, "_");
+export function slugify(key) {
+  if (!key) return "null";
+  return String(key).replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 
 function memoryPath(key) {
@@ -87,44 +88,17 @@ export function storeFilePath(key) {
   return memoryPath(key);
 }
 
-function parseMeta(content) {
-  const m = content.match(/<!-- path: (.+?) -->/);
-  return { path: m ? m[1].trim() : null };
+export function parseMeta(content) {
+  const m = content.match(/<!-- key: (.+?) -->/) || content.match(/<!-- path: (.+?) -->/);
+  return { key: m ? m[1].trim() : null };
 }
 
 function isSimpleKey(key) {
   return /^[a-zA-Z0-9_-]+$/.test(key);
 }
 
-// Lazy migration: when reading a project path store that doesn't exist yet but a
-// legacy <basename>.md store (without path binding) does, claim it under the path.
-async function maybeMigrateLegacy(key) {
-  if (key === GLOBAL_KEY || isSimpleKey(key)) return null;
-  const legacyBasename = basename(key);
-  if (!legacyBasename) return null;
-  const legacyFp = join(MEMORY_DIR, `${legacyBasename}.md`);
-  if (slugify(key) === legacyBasename || !existsSync(legacyFp)) return null;
-  const content = await readFile(legacyFp, "utf-8");
-  if (parseMeta(content).path) return null; // already bound to another project
-  // Collision guard: a different path with the same basename is already bound,
-  // so this legacy store is ambiguous and must not be silently claimed.
-  const files = await readdir(MEMORY_DIR).catch(() => []);
-  for (const f of files) {
-    if (!f.endsWith(".md") || f === `${legacyBasename}.md` || f === `${GLOBAL_KEY}.md`) continue;
-    try {
-      const other = parseMeta(await readFile(join(MEMORY_DIR, f), "utf-8")).path;
-      if (other && basename(other) === legacyBasename) return null;
-    } catch (e) {}
-  }
-  const facts = content.split("\n").filter((l) => l.startsWith("- ["));
-  await writeMemory(key, facts);
-  try {
-    await unlink(legacyFp);
-  } catch (e) {}
-  return facts;
-}
-
 export async function readMemory(key) {
+  if (!key) return [];
   const { getConfig } = await import("./config/config_manager.js");
   const config = getConfig();
   if (config.mode === "only-cloud") {
@@ -143,7 +117,6 @@ export async function readMemory(key) {
 
   const fp = memoryPath(key);
   if (config.mode === "hybrid-sync") {
-    // Pull cloud state down first so cloud-only records appear locally.
     try {
       const { ensureReverseSync } = await import("./db/sync_queue.js");
       await ensureReverseSync();
@@ -155,40 +128,35 @@ export async function readMemory(key) {
     const content = await readFile(fp, "utf-8");
     return content.split("\n").filter((l) => l.startsWith("- ["));
   }
-  const migrated = await maybeMigrateLegacy(key);
-  return migrated || [];
+  return [];
 }
 
 export async function readMemoryRaw(key) {
   return (await readMemory(key)).map((e) => e.slice(2));
 }
 
-// Build the markdown store content for a key from a list of fact lines.
 export function buildMemoryContent(key, entries) {
   const lines = [];
   if (key === GLOBAL_KEY) {
     lines.push("# Global Memory", "");
   } else {
     lines.push(`# Memory: ${basename(key) || key}`, "");
-    if (!isSimpleKey(key)) {
-      lines.push(`<!-- path: ${key} -->`, "");
-    }
+    lines.push(`<!-- key: ${key} -->`, "");
   }
   return lines.join("\n") + "\n" + (entries.length ? entries.join("\n") + "\n" : "");
 }
 
-// Extract fact lines (`- [date] ...`) from a store content string.
 export function extractFacts(content) {
   return (content || "").split("\n").filter((l) => l.startsWith("- ["));
 }
 
-// Write a store file directly to disk WITHOUT enqueueing a cloud sync task.
-// Used by the sync worker to apply pulled cloud state without re-queueing.
 export async function writeMemoryFile(key, content) {
+  if (!key) return;
   await writeFile(memoryPath(key), content);
 }
 
 export async function writeMemory(key, entries) {
+  if (!key) return;
   const content = buildMemoryContent(key, entries);
 
   const { getConfig } = await import("./config/config_manager.js");
@@ -236,11 +204,11 @@ export async function listProjectStores() {
         const meta = parseMeta(content);
         stores.push({
           key,
-          path: meta.path || (key.includes("/") || key.includes(":") ? key : null),
-          basename: basename(meta.path || key) || key,
+          path: meta.key || key,
+          basename: basename(meta.key || key) || key,
           file: `${slugify(key)}.md`,
           count: facts.length,
-          legacy: !meta.path,
+          legacy: !meta.key || (!meta.key.startsWith("git:") && !meta.key.startsWith("git_")),
         });
       }
       stores.sort((a, b) => a.basename.localeCompare(b.basename));
@@ -264,27 +232,29 @@ export async function listProjectStores() {
     }
     const facts = content.split("\n").filter((l) => l.startsWith("- ["));
     const meta = parseMeta(content);
-    const key = meta.path || f.slice(0, -3);
+    const key = meta.key || f.slice(0, -3);
     stores.push({
       key,
-      path: meta.path,
-      basename: basename(meta.path || key) || key,
+      path: meta.key,
+      basename: basename(meta.key || key) || key,
       file: f,
       count: facts.length,
-      legacy: !meta.path,
+      legacy: !meta.key || (!meta.key.startsWith("git:") && !meta.key.startsWith("git_")),
     });
   }
   stores.sort((a, b) => a.basename.localeCompare(b.basename));
   return stores;
 }
 
-// Bind an unbound legacy store (e.g. "comfy-meta-viewer") to a directory path.
 export async function migrateLegacyStore(legacyKey, targetDir) {
   const legacyFp = join(MEMORY_DIR, `${legacyKey.replace(/[^a-zA-Z0-9_-]/g, "_")}.md`);
   if (!existsSync(legacyFp)) return { ok: false, reason: "not_found", key: legacyKey };
   const content = await readFile(legacyFp, "utf-8");
-  if (parseMeta(content).path) return { ok: false, reason: "already_bound", key: legacyKey };
-  const targetKey = projectKey(targetDir, null);
+  if (parseMeta(content).key) return { ok: false, reason: "already_bound", key: legacyKey };
+
+  const targetKey = await projectKey(targetDir, null);
+  if (!targetKey) return { ok: false, reason: "not_a_git_repo", key: legacyKey };
+
   const facts = content.split("\n").filter((l) => l.startsWith("- ["));
   await writeMemory(targetKey, facts);
   try {
@@ -293,6 +263,23 @@ export async function migrateLegacyStore(legacyKey, targetDir) {
   return { ok: true, key: targetKey, file: memoryPath(targetKey), facts: facts.length };
 }
 
+// Mass-stamp titles onto legacy facts in a store. Returns how many lines were
+// changed. Skips stores that already have titles on every fact (fast no-op).
+export async function migrateStoreTitles(key) {
+  if (!key) return { ok: false, reason: "no_key", changed: 0 };
+  const { withTitle } = await import("./fact_format.js");
+  const facts = await readMemory(key);
+  let changed = 0;
+  const migrated = facts.map((line) => {
+    const next = withTitle(line);
+    if (next !== line) changed++;
+    return next;
+  });
+  if (!changed) return { ok: true, changed: 0 };
+  await writeMemory(key, migrated);
+  return { ok: true, changed };
+}
+
 export function today() {
   const d = new Date();
   const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;

package/mcp-server/prompt_manager.js

@@ -9,7 +9,7 @@ const END_MARKER = "<!-- END MEMORY AGENT PROMPT -->";
 
 export const PROMPT_BLOCK = `${START_MARKER}
 [SYSTEM INSTRUCTION: PERSONAL CONTEXT & MEMORY AGENT]
-1. MANDATORY FIRST STEP (SESSION INITIALIZATION): At the very start of every session or conversation, your VERY FIRST ACTION MUST BE to execute \`recall\` from \`memory-agent\` to load all saved facts, user preferences, personal context, and project guidelines BEFORE performing any other tasks or reading code.
+1. MANDATORY FIRST STEP (SESSION INITIALIZATION): At the very start of every session or conversation, your VERY FIRST ACTION MUST BE to execute \`recall\` from \`memory-agent\` with \`scope: "all"\` (or without restrictive query filters) to load ALL saved global facts, user preferences, personal context, and project guidelines BEFORE performing any other tasks or reading code. Do NOT filter or restrict the initial \`recall\` call with specific query keywords or scoped parameters, so that no global facts are missed.
 2. PROACTIVE SAVING DIRECTIVE: You MUST automatically and proactively call \`remember\` from \`memory-agent\` whenever the user shares durable facts, personal preferences, coding guidelines, technology choices, or project architecture decisions. Do NOT wait for explicit user commands like "remember this".
 3. SIGNAL FILTER: Save only high-signal facts (name, language, roles, constraints, tech stack preferences, architecture decisions, conventions). Translate facts into clear, concise English when saving. Do NOT save transient details or one-off conversation turns.
 ${END_MARKER}`;

package/mcp-server/setup.js

@@ -15,10 +15,42 @@ export async function runSetup() {
   const doAntigravity = !hasSpecificFlag || args.includes("--antigravity") || args.includes("--gemini");
   const doCodex = !hasSpecificFlag || args.includes("--codex");
 
+  // Headless cloud setup: --api-key <TURSO_API_TOKEN> and/or --mode <only-local|only-cloud|hybrid-sync>
+  const VALID_MODES = ["only-local", "only-cloud", "hybrid-sync"];
+  const apiKeyArg = flagValue(args, "--api-key");
+  const modeArg = flagValue(args, "--mode");
+  if (modeArg && !VALID_MODES.includes(modeArg)) {
+    console.log(`  [WARN] Unknown --mode "${modeArg}". Allowed: ${VALID_MODES.join(", ")}`);
+  }
+
   console.log("\nSetting up @lotargo/memory_plugin...\n");
   const home = homedir();
   let configuredCount = 0;
 
+  // 0. Headless cloud authentication (Google Jules / CI / VPS)
+  if (apiKeyArg) {
+    try {
+      const { loginWithApiToken } = await import("./admin/auth.js");
+      const secrets = await loginWithApiToken({ token: apiKeyArg });
+      if (modeArg && VALID_MODES.includes(modeArg)) {
+        const { updateConfig } = await import("./config/config_manager.js");
+        updateConfig({ mode: modeArg });
+      }
+      console.log(`  [OK] Cloud: authorized as "${secrets.username}" via API token. Endpoint: ${secrets.dbUrl}`);
+      configuredCount++;
+    } catch (err) {
+      console.log("  [FAIL] Cloud setup failed:", err.message);
+    }
+  } else if (modeArg && VALID_MODES.includes(modeArg)) {
+    try {
+      const { updateConfig } = await import("./config/config_manager.js");
+      updateConfig({ mode: modeArg });
+      console.log(`  [OK] Cloud: sync mode set to "${modeArg}"`);
+    } catch (err) {
+      console.log("  [SKIP] Cloud mode update skipped:", err.message);
+    }
+  }
+
   // 1. OpenCode (~/.config/opencode/opencode.json)
   if (doOpenCode) {
     try {
@@ -229,3 +261,12 @@ export async function runSetup() {
   console.log(`\nSetup complete. Configured ${configuredCount} environment(s).\n`);
 }
 
+// Read the value following --flag, or null when absent / followed by another flag.
+function flagValue(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return null;
+  const value = args[idx + 1];
+  if (value.startsWith("--")) return null;
+  return value;
+}
+

package/mcp-server/tools/helpers.js

@@ -0,0 +1,39 @@
+import * as z from "zod/v4";
+import { factMeta, factText } from "../fact_format.js";
+
+// Optional string/number that tolerates null (some tool-call layers fill omitted
+// optional args with null). Linking fields must NEVER be mandatory.
+export const optStr = () => z.string().optional().nullable();
+export const optNum = () => z.number().optional().nullable();
+export const defStr = (fallback) =>
+  z
+    .string()
+    .nullish()
+    .transform((v) => (v === null || v === undefined || v === "" ? fallback : v));
+export const defBool = (fallback) =>
+  z.boolean().nullish().transform((v) => (v === null || v === undefined ? fallback : v));
+export const defNum = (fallback) =>
+  z.number().nullish().transform((v) => (v === null || v === undefined ? fallback : v));
+
+// Project memory is git-based: outside a git repository there is no project key.
+export function requireProjectKey(key) {
+  if (!key) {
+    throw new Error(
+      "No project memory available: this directory is not inside a git repository. " +
+        "Project memory is tied to a git repo; use scope: 'global' or open a git repository."
+    );
+  }
+  return key;
+}
+
+// Resolve a fact reference (1-based number, metadata id, or text) to an index.
+export function resolveFactIndex(entries, ref) {
+  const trimmed = String(ref || "").trim();
+  if (!trimmed) return -1;
+  const num = parseInt(trimmed, 10);
+  if (/^\d+$/.test(trimmed) && num >= 1 && num <= entries.length) return num - 1;
+  const idIdx = entries.findIndex((e) => factMeta(e).id === trimmed);
+  if (idIdx !== -1) return idIdx;
+  const textIdx = entries.findIndex((e) => factText(e).toLowerCase().includes(trimmed.toLowerCase()));
+  return textIdx;
+}

package/mcp-server/tools/identity_tools.js

@@ -0,0 +1,277 @@
+import * as z from "zod/v4";
+import { basename } from "node:path";
+import { scopeKey, canonicalPath, readMemory, writeMemory, storeFilePath } from "../memory.js";
+import { factBody } from "../fact_format.js";
+import { optStr, optNum, defStr, defBool, requireProjectKey } from "./helpers.js";
+
+export function registerIdentityTools(server) {
+  server.registerTool(
+    "link_knowledge",
+    {
+      description:
+        "Explicitly link a Notebook memory fact to a Knowledge Base document, section, or line range. " +
+        "Creates Agent-driven Graph Edges connecting memory to RAG documents.",
+      inputSchema: z.object({
+        action: z.enum(["link", "list_links", "get_doc_links"]).nullish().transform((v) => v || "link").describe("Action type"),
+        factText: optStr().describe("Memory fact text or keyword"),
+        docId: optStr().describe("Document ID, title, or file path"),
+        scope: defStr("project").describe("'project' (default) or 'global'"),
+        startLine: optNum().describe("Starting line number in target document"),
+        endLine: optNum().describe("Ending line number in target document"),
+        relationType: defStr("LINKS_TO").describe("Relation type (e.g. 'RULES_FOR', 'IMPLEMENTS', 'EXPLAINS')"),
+      }),
+    },
+    async ({ action, factText, docId, scope, startLine, endLine, relationType }) => {
+      const { linkFactToDocument, getLinksForDoc, listAllLinks } = await import("../graph/knowledge_linker.js");
+      const key = await scopeKey(scope, null, null);
+
+      if (action === "link" || action === "list_links") {
+        requireProjectKey(key);
+      }
+
+      if (action === "link") {
+        if (!factText || !docId) {
+          throw new Error("factText and docId are required parameters for link action");
+        }
+        const res = linkFactToDocument({
+          factKey: key,
+          factText,
+          docId,
+          startLine,
+          endLine,
+          relationType,
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
+        };
+      }
+
+      if (action === "get_doc_links") {
+        if (!docId) throw new Error("docId parameter is required for get_doc_links action");
+        const links = getLinksForDoc(docId);
+        return {
+          content: [{ type: "text", text: JSON.stringify(links, null, 2) }],
+        };
+      }
+
+      if (action === "list_links") {
+        const links = listAllLinks(key);
+        return {
+          content: [{ type: "text", text: JSON.stringify(links, null, 2) }],
+        };
+      }
+
+      throw new Error(`Unknown action: ${action}`);
+    }
+  );
+
+  server.registerTool(
+    "link_project_memory",
+    {
+      description: "Link the current directory to a Git-based project identity, register aliases, and optionally migrate legacy/path stores.",
+      inputSchema: z.object({
+        directory: optStr().describe("Directory path to link (default: current directory)"),
+        remote: optStr().describe("Optional explicit remote URL to use as primary identity key"),
+      }),
+    },
+    async ({ directory, remote }) => {
+      const { getDatabase } = await import("../db/database.js");
+      const { resolveProjectIdentity, upsertIdentity, registerAlias, normalizeRemoteUrl } = await import("../identity.js");
+      const db = await getDatabase();
+
+      const dir = directory || process.cwd();
+      const identity = await resolveProjectIdentity(dir);
+      if (!identity && !remote) {
+        throw new Error("No Git repository detected and no remote URL specified.");
+      }
+
+      let key = identity ? identity.key : `git:${normalizeRemoteUrl(remote)}`;
+      let name = identity ? identity.name : basename(dir) || "unbound";
+      let primaryRemote = remote ? normalizeRemoteUrl(remote) : (identity ? identity.primaryRemote : null);
+
+      await upsertIdentity(db, { key, name, primaryRemote });
+
+      const aliases = [];
+      if (primaryRemote) {
+        aliases.push({ alias: `remote:${primaryRemote}`, kind: "remote" });
+      }
+      aliases.push({ alias: `path:${canonicalPath(dir)}`, kind: "path" });
+      aliases.push({ alias: `basename:${name}`, kind: "basename" });
+
+      for (const a of aliases) {
+        await registerAlias(db, { alias: a.alias, identityKey: key, kind: a.kind });
+      }
+
+      let migrated = false;
+      const legacyPathKey = canonicalPath(dir);
+      const legacyEntries = await readMemory(legacyPathKey);
+      if (legacyEntries && legacyEntries.length > 0) {
+        const gitEntries = await readMemory(key);
+        const seen = new Set(gitEntries.map((e) => factBody(e).toLowerCase().trim()));
+        let mergedCount = 0;
+        for (const entry of legacyEntries) {
+          const body = factBody(entry).toLowerCase().trim();
+          if (!seen.has(body)) {
+            seen.add(body);
+            gitEntries.push(entry);
+            mergedCount++;
+          }
+        }
+        if (mergedCount > 0) {
+          await writeMemory(key, gitEntries);
+          migrated = true;
+        }
+        try {
+          const legacyFp = storeFilePath(legacyPathKey);
+          const { existsSync } = await import("node:fs");
+          if (existsSync(legacyFp)) {
+            const { unlink } = await import("node:fs/promises");
+            await unlink(legacyFp);
+          }
+        } catch (e) {}
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                status: "success",
+                key,
+                name,
+                primaryRemote,
+                aliases: aliases.map((a) => a.alias),
+                migrated,
+              },
+              null,
+              2
+            ),
+          },
+        ],
+      };
+    }
+  );
+
+  server.registerTool(
+    "unlink_project_memory",
+    {
+      description: "Remove the path alias link for the specified project directory.",
+      inputSchema: z.object({
+        directory: optStr().describe("Directory path to unlink (default: current directory)"),
+        purge: defBool(false).describe("If true, completely purge the project identity from the SQLite store"),
+      }),
+    },
+    async ({ directory, purge }) => {
+      const { getDatabase } = await import("../db/database.js");
+      const { unregisterAlias, removeIdentity, resolveProjectIdentity } = await import("../identity.js");
+      const db = await getDatabase();
+
+      const dir = directory || process.cwd();
+      const alias = `path:${canonicalPath(dir)}`;
+      await unregisterAlias(db, alias);
+
+      let key = null;
+      if (purge) {
+        const identity = await resolveProjectIdentity(dir);
+        if (identity) {
+          key = identity.key;
+          await removeIdentity(db, key);
+        }
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                status: "success",
+                alias,
+                purgedIdentityKey: key,
+              },
+              null,
+              2
+            ),
+          },
+        ],
+      };
+    }
+  );
+
+  server.registerTool(
+    "relink_project_memory",
+    {
+      description: "Move or merge project memories from the current identity to a new target identity.",
+      inputSchema: z.object({
+        directory: optStr().describe("Directory path to relink (default: current directory)"),
+        remote: z.string().describe("New target remote URL / identity key to move memories to"),
+      }),
+    },
+    async ({ directory, remote }) => {
+      const { getDatabase } = await import("../db/database.js");
+      const { resolveProjectIdentity, upsertIdentity, removeIdentity, normalizeRemoteUrl } = await import("../identity.js");
+      const db = await getDatabase();
+
+      const dir = directory || process.cwd();
+      const sourceIdentity = await resolveProjectIdentity(dir);
+      if (!sourceIdentity) {
+        throw new Error("Source project identity not detected.");
+      }
+
+      const targetKey = `git:${normalizeRemoteUrl(remote)}`;
+      const sourceKey = sourceIdentity.key;
+
+      if (sourceKey === targetKey) {
+        return { content: [{ type: "text", text: "Source and target identities are already identical." }] };
+      }
+
+      const sourceFacts = await readMemory(sourceKey);
+      const targetFacts = await readMemory(targetKey);
+      const seen = new Set(targetFacts.map((e) => factBody(e).toLowerCase().trim()));
+
+      let mergedCount = 0;
+      for (const f of sourceFacts) {
+        const body = factBody(f).toLowerCase().trim();
+        if (!seen.has(body)) {
+          seen.add(body);
+          targetFacts.push(f);
+          mergedCount++;
+        }
+      }
+
+      await writeMemory(targetKey, targetFacts);
+
+      await db.prepare("UPDATE project_aliases SET identity_key = ? WHERE identity_key = ?;").run(targetKey, sourceKey);
+      await upsertIdentity(db, { key: targetKey, name: sourceIdentity.name, primaryRemote: normalizeRemoteUrl(remote) });
+      await removeIdentity(db, sourceKey);
+
+      try {
+        const sourceFp = storeFilePath(sourceKey);
+        const { existsSync } = await import("node:fs");
+        if (existsSync(sourceFp)) {
+          const { unlink } = await import("node:fs/promises");
+          await unlink(sourceFp);
+        }
+      } catch (e) {}
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                status: "success",
+                sourceKey,
+                targetKey,
+                mergedFacts: mergedCount,
+              },
+              null,
+              2
+            ),
+          },
+        ],
+      };
+    }
+  );
+}

package/mcp-server/tools/index.js

@@ -0,0 +1,9 @@
+import { registerMemoryTools } from "./memory_tools.js";
+import { registerIdentityTools } from "./identity_tools.js";
+import { registerRagTools } from "./rag_tools.js";
+
+export function registerAllTools(server) {
+  registerMemoryTools(server);
+  registerIdentityTools(server);
+  registerRagTools(server);
+}