@algosuite/vo-mcp 0.2.0-beta.20 → 0.2.0-beta.22

package/dist/cli.js

@@ -1399,6 +1399,98 @@ var init_safe_memory_file = __esm({
   }
 });
 
+// src/tools/memory/memory-knowledge-bridge.ts
+var memory_knowledge_bridge_exports = {};
+__export(memory_knowledge_bridge_exports, {
+  extractMemoryTitle: () => extractMemoryTitle,
+  upsertMemoryFilesAsKnowledge: () => upsertMemoryFilesAsKnowledge
+});
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync7 } from "node:fs";
+function extractMemoryTitle(fileName, content) {
+  const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (frontmatter) {
+    const description23 = frontmatter[1].match(/^description:\s*(.+)$/m);
+    if (description23 && description23[1].trim()) return description23[1].trim().slice(0, 200);
+  }
+  const heading = content.match(/^#\s+(.+)$/m);
+  if (heading && heading[1].trim()) return heading[1].trim().slice(0, 200);
+  return fileName;
+}
+async function upsertMemoryFilesAsKnowledge(options) {
+  const { controlPlaneUrl, token, memoryDir, fetchFn } = options;
+  let files;
+  try {
+    if (!existsSync5(memoryDir)) {
+      return { attempted: 0, upserted: 0, failed: 0, failures: [] };
+    }
+    files = readdirSync4(memoryDir).filter(
+      (f) => f.endsWith(".md") && f.toUpperCase() !== "MEMORY.MD"
+    );
+  } catch (err) {
+    return {
+      attempted: 0,
+      upserted: 0,
+      failed: 1,
+      failures: [`memory dir scan: ${err instanceof Error ? err.message : String(err)}`]
+    };
+  }
+  let upserted = 0;
+  const failures = [];
+  for (const fileName of files) {
+    try {
+      const content = readFileSync7(resolveMemoryFilePath(memoryDir, fileName), "utf8");
+      if (content.length > CONTENT_HARD_LIMIT) {
+        failures.push(`${fileName}: ${content.length} chars exceeds the ${CONTENT_HARD_LIMIT} server limit \u2014 split the memory file`);
+        continue;
+      }
+      const title = extractMemoryTitle(fileName, content);
+      const base = {
+        knowledge_class: "memory",
+        source_path: `memory/${fileName}`,
+        title,
+        content
+      };
+      const post = (body) => fetchFn(`${controlPlaneUrl}/api/v1/knowledge/private`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${token}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      let response = await post({
+        ...base,
+        provenance: { written_by: "memory-bridge", source_kind: "operator_memory" }
+      });
+      if (response.status === 400) {
+        response = await post(base);
+      }
+      if (response.status >= 200 && response.status < 300) {
+        upserted += 1;
+      } else {
+        const text = await response.text();
+        failures.push(`${fileName}: HTTP ${response.status} ${text.slice(0, 80)}`);
+      }
+    } catch (err) {
+      failures.push(`${fileName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return {
+    attempted: files.length,
+    upserted,
+    failed: failures.length,
+    failures: failures.slice(0, 5)
+  };
+}
+var CONTENT_HARD_LIMIT;
+var init_memory_knowledge_bridge = __esm({
+  "src/tools/memory/memory-knowledge-bridge.ts"() {
+    "use strict";
+    init_safe_memory_file();
+    CONTENT_HARD_LIMIT = 5e5;
+  }
+});
+
 // src/tools/memory/sync-config.ts
 var sync_config_exports = {};
 __export(sync_config_exports, {
@@ -1413,7 +1505,7 @@ __export(sync_config_exports, {
 });
 import { homedir as homedir5 } from "node:os";
 import { join as join7 } from "node:path";
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync3, readdirSync as readdirSync4 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync3, readdirSync as readdirSync5 } from "node:fs";
 function isToolInput22(v) {
   if (typeof v !== "object" || v === null) return false;
   const o = v;
@@ -1422,7 +1514,7 @@ function isToolInput22(v) {
   return true;
 }
 function deriveProjectSlug(cwd) {
-  return cwd.replace(/\\/g, "/").replace(/\/+$/g, "").replace(/^([a-zA-Z]):/, (_m, drive) => `${drive.toUpperCase()}:`).replace(/[^a-zA-Z0-9]/g, "-");
+  return cwd.replace(/([^:\\/])[\\/]+$/, "$1").replace(/\\/g, "/").replace(/^([a-zA-Z]):/, (_m, drive) => `${drive.toUpperCase()}:`).replace(/[^a-zA-Z0-9]/g, "-");
 }
 function getMemoryDir(cwd) {
   const slug = deriveProjectSlug(cwd);
@@ -1457,12 +1549,12 @@ async function pullMemory(controlPlaneUrl, token, memoryDir, fetchFn) {
   return { pulled: data.entries.length, files };
 }
 async function pushMemory(controlPlaneUrl, token, memoryDir, sessionId, fetchFn) {
-  if (!existsSync5(memoryDir)) {
+  if (!existsSync6(memoryDir)) {
     return { pushed: 0, created: 0, updated: 0 };
   }
-  const localFiles = readdirSync4(memoryDir).filter((f) => f.endsWith(".md")).map((f) => ({
+  const localFiles = readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).map((f) => ({
     file_name: f,
-    content: readFileSync7(resolveMemoryFilePath(memoryDir, f), "utf8"),
+    content: readFileSync8(resolveMemoryFilePath(memoryDir, f), "utf8"),
     entry_type: f === "MEMORY.md" ? "index" : "topic"
   }));
   if (localFiles.length === 0) {
@@ -1571,13 +1663,32 @@ async function runMemorySync(action, cwd, sessionId, fetchFn = globalThis.fetch)
       return { synced: true, action: "pull", pulled: result2.pulled, files: result2.files, memory_dir: memoryDir };
     }
     const result = await pushMemory(baseUrl, token, memoryDir, sessionId, fetchFn);
+    let bridge = { upserted: 0, failed: 0, failures: [] };
+    try {
+      const { upsertMemoryFilesAsKnowledge: upsertMemoryFilesAsKnowledge2 } = await Promise.resolve().then(() => (init_memory_knowledge_bridge(), memory_knowledge_bridge_exports));
+      bridge = await upsertMemoryFilesAsKnowledge2({
+        controlPlaneUrl: baseUrl,
+        token,
+        memoryDir,
+        fetchFn
+      });
+    } catch (err) {
+      bridge = {
+        upserted: 0,
+        failed: 1,
+        failures: [`bridge unavailable: ${err instanceof Error ? err.message : String(err)}`]
+      };
+    }
     return {
       synced: true,
       action: "push",
       pushed: result.pushed,
       created: result.created,
       updated: result.updated,
-      memory_dir: memoryDir
+      memory_dir: memoryDir,
+      knowledge_upserted: bridge.upserted,
+      knowledge_failed: bridge.failed,
+      ...bridge.failed > 0 ? { knowledge_failures: bridge.failures } : {}
     };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -5507,6 +5618,7 @@ init_sync_config();
 init_common();
 var UPSERT_TOOL_NAME = "vo_private_knowledge_upsert";
 var CONTEXT_TOOL_NAME = "vo_private_knowledge_context";
+var INVALIDATE_TOOL_NAME = "vo_private_knowledge_invalidate";
 var KNOWLEDGE_CLASSES = ["memory", "skill", "doctrine", "hook", "command"];
 var PRECISION_CHAR_BUDGET = 12e3;
 var upsertInputSchema = {
@@ -5530,8 +5642,18 @@ var contextInputSchema = {
   required: ["query"],
   additionalProperties: false
 };
+var invalidateInputSchema = {
+  type: "object",
+  properties: {
+    knowledge_class: { type: "string", enum: KNOWLEDGE_CLASSES },
+    source_path: { type: "string", minLength: 1, maxLength: 400, description: "Stable private source identifier of the entry to invalidate \u2014 must match the source_path used at upsert." }
+  },
+  required: ["knowledge_class", "source_path"],
+  additionalProperties: false
+};
 var upsertDescription = "Uploads or refreshes the authenticated operator\u2019s private cloud knowledge. Works for Claude, Codex, Cursor, and cowork clients via the same vo-mcp login credential. Returns metadata only, not raw stored content. PRECISION DISCIPLINE: keep each entry tight and focused (~1-3 pages) with a descriptive retrieval-friendly title \u2014 retrieval surfaces whole entries, so small dense entries beat bulk dumps. Split large corpora into focused entries, then run a retrieval self-test via vo_private_knowledge_context before relying on the knowledge.";
 var contextDescription = "Retrieves prompt-ready private knowledge context for the authenticated operator. Returns snippets/context only; no raw corpus download. Also the retrieval self-test surface: after upserting critical knowledge, query for it here and confirm the entry surfaces before trusting it in downstream work.";
+var invalidateDescription = `Soft-deletes one private-knowledge entry for the authenticated operator: closes the live entry\u2019s validity window (bi-temporal) so it stops surfacing in retrieval. Never destroys data \u2014 invalidated versions remain queryable server-side via include_invalidated. Identify the entry by the same { knowledge_class, source_path } used at upsert; a not_found response means no live entry matches. After invalidating, self-test via ${CONTEXT_TOOL_NAME} to confirm the entry no longer surfaces.`;
 function isKnowledgeClass(value) {
   return typeof value === "string" && KNOWLEDGE_CLASSES.includes(value);
 }
@@ -5540,6 +5662,11 @@ function isUpsertInput(value) {
   const input = value;
   return isKnowledgeClass(input["knowledge_class"]) && typeof input["source_path"] === "string" && typeof input["title"] === "string" && typeof input["content"] === "string";
 }
+function isInvalidateInput(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const input = value;
+  return isKnowledgeClass(input["knowledge_class"]) && typeof input["source_path"] === "string";
+}
 function isContextInput(value) {
   if (typeof value !== "object" || value === null) return false;
   const input = value;
@@ -5573,7 +5700,12 @@ async function callPrivateKnowledge(path3, body, fetchFn) {
     body: JSON.stringify(body)
   });
   const text = await response.text();
-  const parsed = text ? JSON.parse(text) : null;
+  let parsed;
+  try {
+    parsed = text ? JSON.parse(text) : null;
+  } catch {
+    parsed = null;
+  }
   if (response.status < 200 || response.status >= 300) {
     return { ok: false, status: response.status, response: parsed ?? text };
   }
@@ -5594,6 +5726,13 @@ async function handlePrivateKnowledgeUpsert(_deps, rawInput, _signal, fetchFn =
   }
   return jsonContent(envelope);
 }
+async function handlePrivateKnowledgeInvalidate(_deps, rawInput, _signal, fetchFn = globalThis.fetch) {
+  if (!isInvalidateInput(rawInput)) {
+    throw invalidParams(INVALIDATE_TOOL_NAME, "expected { knowledge_class, source_path }.");
+  }
+  const payload = await callPrivateKnowledge("/api/v1/knowledge/private/invalidate", rawInput, fetchFn);
+  return jsonContent({ tool: INVALIDATE_TOOL_NAME, schema_version: 1, payload });
+}
 async function handlePrivateKnowledgeContext(_deps, rawInput, _signal, fetchFn = globalThis.fetch) {
   if (!isContextInput(rawInput)) {
     throw invalidParams(CONTEXT_TOOL_NAME, "expected { query, optional limit, optional knowledge_class }.");
@@ -5746,11 +5885,11 @@ async function handleHqWhiteboardRead(_deps, rawInput, signal) {
 }
 
 // src/tools/skills/skill-corpus.ts
-import { existsSync as existsSync6, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync7, statSync as statSync5 } from "node:fs";
 import { dirname as dirname5, isAbsolute, join as join9, resolve as resolve2 } from "node:path";
 
 // ../skill-registry/src/loader.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync4 } from "node:fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync9, statSync as statSync4 } from "node:fs";
 import { join as join8 } from "node:path";
 var InvalidSkillFrontmatterError = class extends Error {
   constructor(skillFile, reason) {
@@ -5801,7 +5940,7 @@ ${FRONTMATTER_DELIMITER}
   return { name, description: description23, body };
 }
 function loadSkillsFromDir(skillsDir) {
-  const entries = readdirSync5(skillsDir);
+  const entries = readdirSync6(skillsDir);
   const skills = [];
   for (const entry of entries) {
     const entryPath = join8(skillsDir, entry);
@@ -5815,7 +5954,7 @@ function loadSkillsFromDir(skillsDir) {
     const skillFile = join8(entryPath, "SKILL.md");
     let raw;
     try {
-      raw = readFileSync8(skillFile, "utf8");
+      raw = readFileSync9(skillFile, "utf8");
     } catch {
       continue;
     }
@@ -5857,12 +5996,12 @@ function resolveSkillsDir(env = process.env, startDir = process.cwd()) {
   const override = env.VO_SKILLS_DIR;
   if (typeof override === "string" && override.length > 0) {
     const abs = isAbsolute(override) ? override : resolve2(startDir, override);
-    return existsSync6(abs) && statSync5(abs).isDirectory() ? abs : null;
+    return existsSync7(abs) && statSync5(abs).isDirectory() ? abs : null;
   }
   let dir = resolve2(startDir);
   for (let i = 0; i < MAX_WALK_UP_LEVELS; i += 1) {
     const candidate = join9(dir, ".claude", "skills");
-    if (existsSync6(candidate) && statSync5(candidate).isDirectory()) return candidate;
+    if (existsSync7(candidate) && statSync5(candidate).isDirectory()) return candidate;
     const parent = dirname5(dir);
     if (parent === dir) break;
     dir = parent;
@@ -6130,6 +6269,14 @@ function buildToolRegistry() {
       },
       handler: handlePrivateKnowledgeContext
     },
+    [INVALIDATE_TOOL_NAME]: {
+      definition: {
+        name: INVALIDATE_TOOL_NAME,
+        description: invalidateDescription,
+        inputSchema: invalidateInputSchema
+      },
+      handler: handlePrivateKnowledgeInvalidate
+    },
     [POST_TOOL_NAME]: {
       definition: {
         name: POST_TOOL_NAME,
@@ -7401,18 +7548,36 @@ if (process.argv[2] === "login") {
   const cwdFlag = process.argv.indexOf("--cwd");
   const cwd = cwdFlag >= 0 && typeof process.argv[cwdFlag + 1] === "string" ? process.argv[cwdFlag + 1] : process.cwd();
   const sessionId = randomUUID5();
+  const appendSyncLog = async (line) => {
+    try {
+      const { appendFileSync: appendFileSync2, mkdirSync: mkdirSync6 } = await import("node:fs");
+      const { join: join11 } = await import("node:path");
+      const { homedir: homedir7 } = await import("node:os");
+      const dir = join11(homedir7(), ".claude");
+      mkdirSync6(dir, { recursive: true });
+      appendFileSync2(join11(dir, "vo-mcp-sync.log"), `${line}
+`, "utf8");
+    } catch {
+    }
+  };
   Promise.resolve().then(() => (init_sync_config(), sync_config_exports)).then(async ({ runMemorySync: runMemorySync2, isNoopSyncReason: isNoopSyncReason2 }) => {
     const r = await runMemorySync2(action, cwd, sessionId);
+    const stamp = `${sessionId} ${action}`;
     if (r.synced) {
       console.error(`[vo-mcp] sync ${action} ok: ${JSON.stringify(r)}`);
+      await appendSyncLog(`ok ${stamp} ${JSON.stringify(r)}`);
     } else if (isNoopSyncReason2(r.reason)) {
       console.error(`[vo-mcp] sync ${action} skipped: ${r.reason}`);
+      await appendSyncLog(`skip ${stamp} ${r.reason ?? ""}`);
     } else {
       console.error(`[vo-mcp] sync ${action} failed: ${r.reason}`);
+      await appendSyncLog(`FAIL ${stamp} ${r.reason ?? ""}`);
       process.exitCode = 1;
     }
-  }).catch((err) => {
-    console.error("[vo-mcp] sync fatal:", err instanceof Error ? err.message : String(err));
+  }).catch(async (err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error("[vo-mcp] sync fatal:", message);
+    await appendSyncLog(`FATAL ${sessionId} ${action} ${message}`);
     process.exitCode = 1;
   });
 } else {