@productbrain/mcp 0.0.1-beta.11 → 0.0.1-beta.13

package/dist/{chunk-B56TXWX2.js → chunk-4ETXQ24K.js}

@@ -5,79 +5,149 @@ import {
 // src/tools/smart-capture.ts
 import { z } from "zod";
 
+// src/auth.ts
+import { AsyncLocalStorage } from "async_hooks";
+var requestStore = new AsyncLocalStorage();
+function runWithAuth(auth, fn) {
+  return requestStore.run(auth, fn);
+}
+function getRequestApiKey() {
+  return requestStore.getStore()?.apiKey;
+}
+var SESSION_TTL_MS = 30 * 60 * 1e3;
+var MAX_KEYS = 100;
+var keyStateMap = /* @__PURE__ */ new Map();
+function newKeyState() {
+  return {
+    workspaceId: null,
+    workspaceSlug: null,
+    workspaceName: null,
+    workspaceCreatedAt: null,
+    agentSessionId: null,
+    apiKeyId: null,
+    apiKeyScope: "readwrite",
+    sessionOriented: false,
+    sessionClosed: false,
+    lastAccess: Date.now()
+  };
+}
+function getKeyState(apiKey) {
+  let s = keyStateMap.get(apiKey);
+  if (!s) {
+    s = newKeyState();
+    keyStateMap.set(apiKey, s);
+    evictStale();
+  }
+  s.lastAccess = Date.now();
+  return s;
+}
+function evictStale() {
+  if (keyStateMap.size <= MAX_KEYS) return;
+  const now = Date.now();
+  for (const [key, s] of keyStateMap) {
+    if (now - s.lastAccess > SESSION_TTL_MS) keyStateMap.delete(key);
+  }
+  if (keyStateMap.size > MAX_KEYS) {
+    const sorted = [...keyStateMap.entries()].sort((a, b) => a[1].lastAccess - b[1].lastAccess);
+    for (let i = 0; i < sorted.length - MAX_KEYS; i++) {
+      keyStateMap.delete(sorted[i][0]);
+    }
+  }
+}
+
 // src/client.ts
 var DEFAULT_CLOUD_URL = "https://trustworthy-kangaroo-277.convex.site";
-var cachedWorkspaceId = null;
-var cachedWorkspaceSlug = null;
-var cachedWorkspaceName = null;
-var cachedWorkspaceCreatedAt = null;
-var cachedAgentSessionId = null;
-var cachedApiKeyId = null;
-var cachedApiKeyScope = "readwrite";
-var sessionOriented = false;
-var sessionClosed = false;
+var _stdioState = {
+  workspaceId: null,
+  workspaceSlug: null,
+  workspaceName: null,
+  workspaceCreatedAt: null,
+  agentSessionId: null,
+  apiKeyId: null,
+  apiKeyScope: "readwrite",
+  sessionOriented: false,
+  sessionClosed: false,
+  lastAccess: 0
+};
+function state() {
+  const reqKey = getRequestApiKey();
+  if (reqKey) return getKeyState(reqKey);
+  return _stdioState;
+}
+function getActiveApiKey() {
+  const fromRequest = getRequestApiKey();
+  if (fromRequest) return fromRequest;
+  const fromEnv = process.env.PRODUCTBRAIN_API_KEY;
+  if (!fromEnv) throw new Error("No API key available \u2014 set PRODUCTBRAIN_API_KEY or provide Bearer token");
+  return fromEnv;
+}
 function getAgentSessionId() {
-  return cachedAgentSessionId;
+  return state().agentSessionId;
 }
 function isSessionOriented() {
-  return sessionOriented;
+  return state().sessionOriented;
 }
 function setSessionOriented(value) {
-  sessionOriented = value;
+  state().sessionOriented = value;
 }
 async function startAgentSession() {
   const workspaceId = await getWorkspaceId();
-  if (!cachedApiKeyId) {
+  const s = state();
+  if (!s.apiKeyId) {
     throw new Error("Cannot start session: API key ID not resolved. Ensure workspace resolution completed.");
   }
   const result = await mcpCall("agent.startSession", {
     workspaceId,
-    apiKeyId: cachedApiKeyId
+    apiKeyId: s.apiKeyId
   });
-  cachedAgentSessionId = result.sessionId;
-  cachedApiKeyScope = result.toolsScope;
-  sessionOriented = false;
-  sessionClosed = false;
+  s.agentSessionId = result.sessionId;
+  s.apiKeyScope = result.toolsScope;
+  s.sessionOriented = false;
+  s.sessionClosed = false;
   return result;
 }
 async function closeAgentSession() {
-  if (!cachedAgentSessionId) return;
+  const s = state();
+  if (!s.agentSessionId) return;
   try {
     await mcpCall("agent.closeSession", {
-      sessionId: cachedAgentSessionId,
+      sessionId: s.agentSessionId,
       status: "closed"
     });
   } finally {
-    sessionClosed = true;
-    cachedAgentSessionId = null;
-    sessionOriented = false;
+    s.sessionClosed = true;
+    s.agentSessionId = null;
+    s.sessionOriented = false;
   }
 }
 async function orphanAgentSession() {
-  if (!cachedAgentSessionId) return;
+  const s = state();
+  if (!s.agentSessionId) return;
   try {
     await mcpCall("agent.closeSession", {
-      sessionId: cachedAgentSessionId,
+      sessionId: s.agentSessionId,
       status: "orphaned"
     });
   } catch {
   } finally {
-    cachedAgentSessionId = null;
-    sessionOriented = false;
+    s.agentSessionId = null;
+    s.sessionOriented = false;
   }
 }
 function touchSessionActivity() {
-  if (!cachedAgentSessionId) return;
+  const s = state();
+  if (!s.agentSessionId) return;
   mcpCall("agent.touchSession", {
-    sessionId: cachedAgentSessionId
+    sessionId: s.agentSessionId
   }).catch(() => {
   });
 }
 async function recordSessionActivity(activity) {
-  if (!cachedAgentSessionId) return;
+  const s = state();
+  if (!s.agentSessionId) return;
   try {
     await mcpCall("agent.recordActivity", {
-      sessionId: cachedAgentSessionId,
+      sessionId: s.agentSessionId,
       ...activity
     });
   } catch {
@@ -94,6 +164,9 @@ function bootstrap() {
   }
   process.env.CONVEX_SITE_URL ??= process.env.PRODUCTBRAIN_URL ?? DEFAULT_CLOUD_URL;
 }
+function bootstrapHttp() {
+  process.env.CONVEX_SITE_URL ??= process.env.PRODUCTBRAIN_URL ?? DEFAULT_CLOUD_URL;
+}
 function getEnv(key) {
   const value = process.env[key];
   if (!value) throw new Error(`${key} environment variable is required`);
@@ -104,7 +177,7 @@ function shouldLogAudit(status) {
 }
 function audit(fn, status, durationMs, errorMsg) {
   const ts = (/* @__PURE__ */ new Date()).toISOString();
-  const workspace = cachedWorkspaceId ?? "unresolved";
+  const workspace = state().workspaceId ?? "unresolved";
   const entry = { ts, fn, workspace, status, durationMs };
   if (errorMsg) entry.error = errorMsg;
   auditBuffer.push(entry);
@@ -125,7 +198,7 @@ function getAuditLog() {
 }
 async function mcpCall(fn, args = {}) {
   const siteUrl = getEnv("CONVEX_SITE_URL").replace(/\/$/, "");
-  const apiKey = getEnv("PRODUCTBRAIN_API_KEY");
+  const apiKey = getActiveApiKey();
   const start = Date.now();
   let res;
   try {
@@ -147,19 +220,22 @@ async function mcpCall(fn, args = {}) {
     throw new Error(`MCP call "${fn}" failed (${res.status}): ${json.error ?? "unknown error"}`);
   }
   audit(fn, "ok", Date.now() - start);
-  if (cachedAgentSessionId && fn !== "agent.touchSession" && fn !== "agent.startSession") {
+  const s = state();
+  if (s.agentSessionId && fn !== "agent.touchSession" && fn !== "agent.startSession") {
     touchSessionActivity();
   }
   return json.data;
 }
-var resolveInFlight = null;
+var resolveInFlightMap = /* @__PURE__ */ new Map();
 async function getWorkspaceId() {
-  if (cachedWorkspaceId) return cachedWorkspaceId;
-  if (resolveInFlight) return resolveInFlight;
-  resolveInFlight = resolveWorkspaceWithRetry().finally(() => {
-    resolveInFlight = null;
-  });
-  return resolveInFlight;
+  const s = state();
+  if (s.workspaceId) return s.workspaceId;
+  const apiKey = getActiveApiKey();
+  const existing = resolveInFlightMap.get(apiKey);
+  if (existing) return existing;
+  const promise = resolveWorkspaceWithRetry().finally(() => resolveInFlightMap.delete(apiKey));
+  resolveInFlightMap.set(apiKey, promise);
+  return promise;
 }
 async function resolveWorkspaceWithRetry(maxRetries = 2) {
   let lastError = null;
@@ -171,13 +247,14 @@ async function resolveWorkspaceWithRetry(maxRetries = 2) {
           "API key is valid but no workspace is associated. Run `npx productbrain setup` or regenerate your key."
         );
       }
-      cachedWorkspaceId = workspace._id;
-      cachedWorkspaceSlug = workspace.slug;
-      cachedWorkspaceName = workspace.name;
-      cachedWorkspaceCreatedAt = workspace.createdAt ?? null;
-      if (workspace.keyScope) cachedApiKeyScope = workspace.keyScope;
-      if (workspace.keyId) cachedApiKeyId = workspace.keyId;
-      return cachedWorkspaceId;
+      const s = state();
+      s.workspaceId = workspace._id;
+      s.workspaceSlug = workspace.slug;
+      s.workspaceName = workspace.name;
+      s.workspaceCreatedAt = workspace.createdAt ?? null;
+      if (workspace.keyScope) s.apiKeyScope = workspace.keyScope;
+      if (workspace.keyId) s.apiKeyId = workspace.keyId;
+      return s.workspaceId;
     } catch (err) {
       lastError = err;
       const isTransient = /network error|fetch failed|ECONNREFUSED|ETIMEDOUT/i.test(err.message);
@@ -194,11 +271,12 @@ async function resolveWorkspaceWithRetry(maxRetries = 2) {
 }
 async function getWorkspaceContext() {
   const workspaceId = await getWorkspaceId();
+  const s = state();
   return {
     workspaceId,
-    workspaceSlug: cachedWorkspaceSlug ?? "unknown",
-    workspaceName: cachedWorkspaceName ?? "unknown",
-    createdAt: cachedWorkspaceCreatedAt
+    workspaceSlug: s.workspaceSlug ?? "unknown",
+    workspaceName: s.workspaceName ?? "unknown",
+    createdAt: s.workspaceCreatedAt
   };
 }
 async function mcpQuery(fn, args = {}) {
@@ -210,36 +288,38 @@ async function mcpMutation(fn, args = {}) {
   return mcpCall(fn, { ...args, workspaceId });
 }
 function requireWriteAccess() {
-  if (!cachedAgentSessionId) {
+  const s = state();
+  if (!s.agentSessionId) {
     throw new Error(
       "Agent session required for write operations. Call `agent-start` first."
     );
   }
-  if (sessionClosed) {
+  if (s.sessionClosed) {
     throw new Error(
       "Agent session has been closed. Write tools are no longer available."
     );
   }
-  if (!sessionOriented) {
+  if (!s.sessionOriented) {
     throw new Error(
       "Orientation required before writing to the Chain. Call 'orient' first."
     );
   }
-  if (cachedApiKeyScope === "read") {
+  if (s.apiKeyScope === "read") {
     throw new Error(
       "This API key has read-only scope. Write tools are not available."
     );
   }
 }
 async function recoverSessionState() {
-  if (!cachedWorkspaceId) return;
+  const s = state();
+  if (!s.workspaceId) return;
   try {
-    const session = await mcpCall("agent.getActiveSession", { workspaceId: cachedWorkspaceId });
+    const session = await mcpCall("agent.getActiveSession", { workspaceId: s.workspaceId });
     if (session && session.status === "active") {
-      cachedAgentSessionId = session._id;
-      sessionOriented = session.oriented;
-      cachedApiKeyScope = session.toolsScope;
-      sessionClosed = false;
+      s.agentSessionId = session._id;
+      s.sessionOriented = session.oriented;
+      s.apiKeyScope = session.toolsScope;
+      s.sessionClosed = false;
     }
   } catch {
   }
@@ -961,6 +1041,162 @@ Use \`get-entry\` to inspect the existing entry, or \`update-entry\` to modify i
       return { content: [{ type: "text", text: lines.join("\n") }] };
     }
   );
+  server.registerTool(
+    "batch-capture",
+    {
+      title: "Batch Capture",
+      description: "Create multiple knowledge entries in one call. Ideal for workspace setup, document ingestion, or any scenario where you need to capture many entries at once.\n\nEach entry is created independently \u2014 if one fails, the others still succeed. Returns a compact summary instead of per-entry quality scorecards.\n\nAuto-linking runs per entry but contradiction checks and readiness hints are skipped for speed. Use `quality-check` on individual entries afterward if needed.",
+      inputSchema: {
+        entries: z.array(z.object({
+          collection: z.string().describe("Collection slug"),
+          name: z.string().describe("Display name"),
+          description: z.string().describe("Full context / definition"),
+          entryId: z.string().optional().describe("Optional custom entry ID")
+        })).min(1).max(50).describe("Array of entries to capture")
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ entries }) => {
+      requireWriteAccess();
+      const agentId = getAgentSessionId();
+      const createdBy = agentId ? `agent:${agentId}` : "capture";
+      const results = [];
+      const allCollections = await mcpQuery("chain.listCollections");
+      const collCache = /* @__PURE__ */ new Map();
+      for (const c of allCollections) collCache.set(c.slug, c);
+      const collIdToSlug = /* @__PURE__ */ new Map();
+      for (const c of allCollections) collIdToSlug.set(c._id, c.slug);
+      for (const entry of entries) {
+        const profile = PROFILES.get(entry.collection) ?? FALLBACK_PROFILE;
+        const col = collCache.get(entry.collection);
+        if (!col) {
+          results.push({ name: entry.name, collection: entry.collection, entryId: "", ok: false, autoLinks: 0, error: `Collection "${entry.collection}" not found` });
+          continue;
+        }
+        const finalEntryId = entry.entryId ?? generateEntryId(profile.idPrefix);
+        const data = {};
+        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        for (const field of col.fields ?? []) {
+          const key = field.key;
+          if (key === profile.descriptionField) {
+            data[key] = entry.description;
+          } else if (field.type === "array" || field.type === "multi-select") {
+            data[key] = [];
+          } else {
+            data[key] = "";
+          }
+        }
+        for (const def of profile.defaults) {
+          if (def.value === "today") data[def.key] = today;
+          else if (def.value !== "infer") data[def.key] = def.value;
+        }
+        if (profile.inferField) {
+          const inferred = profile.inferField({
+            collection: entry.collection,
+            name: entry.name,
+            description: entry.description,
+            data,
+            entryId: "",
+            linksCreated: [],
+            linksSuggested: [],
+            collectionFields: col.fields ?? []
+          });
+          for (const [key, val] of Object.entries(inferred)) {
+            if (val !== void 0 && val !== "") data[key] = val;
+          }
+        }
+        if (!data[profile.descriptionField] && !data.description && !data.canonical) {
+          data[profile.descriptionField || "description"] = entry.description;
+        }
+        try {
+          await mcpMutation("chain.createEntry", {
+            collectionSlug: entry.collection,
+            entryId: finalEntryId,
+            name: entry.name,
+            status: "draft",
+            data,
+            createdBy
+          });
+          let autoLinkCount = 0;
+          const searchQuery = extractSearchTerms(entry.name, entry.description);
+          if (searchQuery) {
+            try {
+              const searchResults = await mcpQuery("chain.searchEntries", { query: searchQuery });
+              const candidates = (searchResults ?? []).filter((r) => r.entryId !== finalEntryId).map((r) => ({
+                ...r,
+                collSlug: collIdToSlug.get(r.collectionId) ?? "unknown",
+                confidence: computeLinkConfidence(r, entry.name, entry.description, entry.collection, collIdToSlug.get(r.collectionId) ?? "unknown")
+              })).sort((a, b) => b.confidence - a.confidence);
+              for (const c of candidates) {
+                if (autoLinkCount >= MAX_AUTO_LINKS) break;
+                if (c.confidence < AUTO_LINK_CONFIDENCE_THRESHOLD) break;
+                if (!c.entryId) continue;
+                const relationType = inferRelationType(entry.collection, c.collSlug, profile);
+                try {
+                  await mcpMutation("chain.createEntryRelation", {
+                    fromEntryId: finalEntryId,
+                    toEntryId: c.entryId,
+                    type: relationType
+                  });
+                  autoLinkCount++;
+                } catch {
+                }
+              }
+            } catch {
+            }
+          }
+          results.push({ name: entry.name, collection: entry.collection, entryId: finalEntryId, ok: true, autoLinks: autoLinkCount });
+          await recordSessionActivity({ entryCreated: finalEntryId });
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          results.push({ name: entry.name, collection: entry.collection, entryId: finalEntryId, ok: false, autoLinks: 0, error: msg });
+        }
+      }
+      const created = results.filter((r) => r.ok);
+      const failed = results.filter((r) => !r.ok);
+      const totalAutoLinks = created.reduce((sum, r) => sum + r.autoLinks, 0);
+      const byCollection = /* @__PURE__ */ new Map();
+      for (const r of created) {
+        byCollection.set(r.collection, (byCollection.get(r.collection) ?? 0) + 1);
+      }
+      const lines = [
+        `# Batch Capture Complete`,
+        `**${created.length}** created, **${failed.length}** failed out of ${entries.length} total.`,
+        `**Auto-links created:** ${totalAutoLinks}`,
+        ""
+      ];
+      if (byCollection.size > 0) {
+        lines.push("## By Collection");
+        for (const [col, count] of byCollection) {
+          lines.push(`- \`${col}\`: ${count} entries`);
+        }
+        lines.push("");
+      }
+      if (created.length > 0) {
+        lines.push("## Created");
+        for (const r of created) {
+          const linkNote = r.autoLinks > 0 ? ` (${r.autoLinks} auto-links)` : "";
+          lines.push(`- **${r.entryId}**: ${r.name} [${r.collection}]${linkNote}`);
+        }
+      }
+      if (failed.length > 0) {
+        lines.push("");
+        lines.push("## Failed");
+        for (const r of failed) {
+          lines.push(`- ${r.name} [${r.collection}]: _${r.error}_`);
+        }
+      }
+      const entryIds = created.map((r) => r.entryId);
+      if (entryIds.length > 0) {
+        lines.push("");
+        lines.push("## Next Steps");
+        lines.push(`- **Connect:** Run \`suggest-links\` on key entries to build the knowledge graph`);
+        lines.push(`- **Commit:** Use \`commit-entry\` to promote drafts to SSOT`);
+        lines.push(`- **Quality:** Run \`quality-check\` on individual entries to assess completeness`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
   server.registerTool(
     "quality-check",
     {
@@ -1123,6 +1359,7 @@ async function runContradictionCheck(name, description) {
 }
 
 export {
+  runWithAuth,
   getAgentSessionId,
   isSessionOriented,
   setSessionOriented,
@@ -1131,6 +1368,7 @@ export {
   orphanAgentSession,
   recordSessionActivity,
   bootstrap,
+  bootstrapHttp,
   getAuditLog,
   mcpCall,
   getWorkspaceId,
@@ -1144,4 +1382,4 @@ export {
   registerSmartCaptureTools,
   runContradictionCheck
 };
-//# sourceMappingURL=chunk-B56TXWX2.js.map
+//# sourceMappingURL=chunk-4ETXQ24K.js.map