@noelclaw/mcp 2.3.0 → 2.3.1

package/dist/tools/memory.js

@@ -1,82 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MEMORY_TOOLS = exports.SM_SPACE = void 0;
-exports.smFetch = smFetch;
+exports.MEMORY_TOOLS = void 0;
 exports.syncToSupermemory = syncToSupermemory;
 exports.searchSupermemory = searchSupermemory;
 exports.handleMemoryTool = handleMemoryTool;
 const zod_1 = require("zod");
-const SM_BASE = "https://api.supermemory.ai/v3";
-exports.SM_SPACE = "noelclaw-vault";
-// ─── Supermemory HTTP helpers ────────────────────────────────────────────────
-async function smFetch(path, method, body) {
-    const apiKey = process.env.SUPERMEMORY_API_KEY;
-    if (!apiKey)
-        return { ok: false, data: null, error: "SUPERMEMORY_API_KEY not set" };
-    try {
-        const res = await fetch(`${SM_BASE}${path}`, {
-            method,
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: body ? JSON.stringify(body) : undefined,
-            signal: AbortSignal.timeout(15000),
-        });
-        if (!res.ok) {
-            const err = await res.text().catch(() => "");
-            return { ok: false, data: null, error: `${res.status}: ${err.slice(0, 120)}` };
-        }
-        return { ok: true, data: await res.json() };
-    }
-    catch (err) {
-        return { ok: false, data: null, error: err.message };
-    }
-}
+const convex_js_1 = require("../convex.js");
+// ─── Helpers (proxied through Convex — server-side Supermemory key) ──────────
 async function syncToSupermemory(content, metadata, sourceUrl) {
-    await smFetch("/memories", "POST", {
+    await (0, convex_js_1.callConvex)("/memory/add", "POST", {
         content,
         metadata,
-        spaces: [exports.SM_SPACE],
         ...(sourceUrl ? { sourceUrl } : {}),
-    });
+    }).catch(() => { });
 }
 async function searchSupermemory(query, limit = 10) {
-    const { ok, data } = await smFetch("/search", "POST", {
-        q: query,
-        n: limit,
-        spaces: [exports.SM_SPACE],
-        returnContext: true,
-    });
-    if (!ok || !data?.results)
+    try {
+        const data = await (0, convex_js_1.callConvex)("/memory/search", "POST", { q: query, n: limit });
+        return data?.results ?? [];
+    }
+    catch {
         return [];
-    return data.results;
+    }
 }
 // ─── Tool definitions ────────────────────────────────────────────────────────
 exports.MEMORY_TOOLS = [
     {
         name: "memory_add",
-        description: "Add content to Noelclaw's semantic memory layer (powered by Supermemory). " +
-            "Unlike vault_save, memory_add is quick — no versioning, no type required. " +
-            "Use this for notes, decisions, preferences, URLs, or anything you want to " +
-            "find later with natural language search. Memory is indexed semantically — " +
-            "'what did I say about ETH yield?' will find it even without exact keywords.",
+        description: "Add content to your Noelclaw semantic memory — no setup needed, no extra API keys. " +
+            "Unlike vault_save, memory_add is instant: no versioning, no type required. " +
+            "Use for notes, decisions, preferences, URLs, or anything you want to find later " +
+            "with natural language. Memory is indexed semantically — 'what did I say about ETH yield?' " +
+            "will find it even without exact keywords.",
         inputSchema: {
             type: "object",
             properties: {
                 content: { type: "string", description: "Content to remember — text, markdown, or a note" },
                 title: { type: "string", description: "Optional title for this memory" },
                 tags: { type: "array", items: { type: "string" }, description: "Tags for grouping" },
-                sourceUrl: { type: "string", description: "Optional URL — if provided, Supermemory also fetches and indexes the page content" },
+                sourceUrl: { type: "string", description: "Optional URL — Noelclaw will fetch and index the page content automatically" },
             },
             required: ["content"],
         },
     },
     {
         name: "memory_search",
-        description: "Semantic search across all Noelclaw memories. Unlike keyword search, this " +
-            "understands meaning — 'low risk crypto yield' will match 'conservative DeFi strategies'. " +
-            "Also searches memories synced from vault_save and vault_remember automatically.",
+        description: "Semantic search across all your Noelclaw memories. Understands meaning, not just keywords — " +
+            "'low risk crypto yield' matches 'conservative DeFi strategies'. " +
+            "Also searches memories auto-synced from vault_save and vault_remember.",
         inputSchema: {
             type: "object",
             properties: {
@@ -88,10 +59,9 @@ exports.MEMORY_TOOLS = [
     },
     {
         name: "memory_context",
-        description: "Retrieve the most semantically relevant memories for a topic and format them " +
-            "as ready-to-inject context. Use at the start of research tasks to prime with " +
-            "everything stored about a topic. Smarter than vault_context — uses vector search, " +
-            "not just keyword matching.",
+        description: "Retrieve the most semantically relevant memories for a topic, formatted as AI-ready context. " +
+            "Use at the start of research tasks to prime with everything stored about a topic. " +
+            "Smarter than vault_context — uses vector search, not just keyword matching.",
         inputSchema: {
             type: "object",
             properties: {
@@ -103,8 +73,8 @@ exports.MEMORY_TOOLS = [
     },
     {
         name: "memory_profile",
-        description: "Show your semantic memory stats — how many memories, recent additions, and " +
-            "connected data sources. Useful for auditing what Noelclaw knows about you.",
+        description: "Show your semantic memory stats — total memories stored, your memory space, and connected sources. " +
+            "Useful for auditing what Noelclaw knows about you.",
         inputSchema: {
             type: "object",
             properties: {},
@@ -113,32 +83,18 @@ exports.MEMORY_TOOLS = [
     },
     {
         name: "memory_connect",
-        description: "Connect an external data source to Noelclaw's semantic memory, or add content " +
-            "from a specific URL. Supported sources:\n" +
-            "- url: fetch and index any web page or GitHub file\n" +
-            "- github: index a GitHub repository README/docs\n" +
-            "- notion: add content from a public Notion page URL\n" +
-            "- manual: paste content directly (same as memory_add with sourceUrl)\n" +
-            "For Google Drive, Gmail, and full Notion sync, connect via your Noelclaw dashboard.",
+        description: "Fetch and index content from an external URL into your semantic memory. " +
+            "Works with any web page, GitHub repo/file, or Notion page URL. " +
+            "Noelclaw crawls the URL and indexes the full content — searchable in ~30s. " +
+            "For full Google Drive / Gmail / Notion workspace sync, connect via the Noelclaw dashboard.",
         inputSchema: {
             type: "object",
             properties: {
-                source: {
-                    type: "string",
-                    enum: ["url", "github", "notion", "manual"],
-                    description: "Source type",
-                },
-                url: {
-                    type: "string",
-                    description: "URL to fetch and index (required for url/github/notion sources)",
-                },
-                content: {
-                    type: "string",
-                    description: "Direct content (for source: manual)",
-                },
-                title: { type: "string", description: "Title for this memory" },
+                url: { type: "string", description: "URL to fetch and index (GitHub, Notion, web page, etc.)" },
+                title: { type: "string", description: "Optional title for this memory" },
+                tags: { type: "array", items: { type: "string" }, description: "Optional tags" },
             },
-            required: ["source"],
+            required: ["url"],
         },
     },
 ];
@@ -158,41 +114,35 @@ const ContextSchema = zod_1.z.object({
     limit: zod_1.z.number().optional(),
 });
 const ConnectSchema = zod_1.z.object({
-    source: zod_1.z.enum(["url", "github", "notion", "manual"]),
-    url: zod_1.z.string().url().optional(),
-    content: zod_1.z.string().optional(),
+    url: zod_1.z.string().url(),
     title: zod_1.z.string().optional(),
+    tags: zod_1.z.array(zod_1.z.string()).optional(),
 });
 // ─── Handler ─────────────────────────────────────────────────────────────────
 async function handleMemoryTool(name, args) {
-    const apiKey = process.env.SUPERMEMORY_API_KEY;
     switch (name) {
         case "memory_add": {
             const parsed = AddSchema.safeParse(args);
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            if (!apiKey)
-                return { content: [{ type: "text", text: "⚠️ SUPERMEMORY_API_KEY not configured.\nSet it in your MCP env to enable semantic memory.\nGet a free key at supermemory.ai" }], isError: true };
             const { content, title, tags, sourceUrl } = parsed.data;
-            const { ok, data, error } = await smFetch("/memories", "POST", {
+            const data = await (0, convex_js_1.callConvex)("/memory/add", "POST", {
                 content,
-                metadata: { title, tags, source: "noelclaw-mcp", addedAt: Date.now() },
-                spaces: [exports.SM_SPACE],
+                metadata: { title, tags, source: "memory_add", addedAt: Date.now() },
                 ...(sourceUrl ? { sourceUrl } : {}),
-            });
-            if (!ok)
-                return { content: [{ type: "text", text: `Error adding to memory: ${error}` }], isError: true };
-            const memId = data?.id ?? data?.memoryId ?? "saved";
+            }).catch((err) => ({ error: err.message }));
+            if (data?.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
             return {
                 content: [{
                         type: "text",
                         text: [
-                            `🧠 **Memory added** — ID: \`${memId}\``,
+                            `🧠 **Memory added** — ID: \`${data?.id ?? "saved"}\``,
                             title ? `Title: ${title}` : "",
-                            sourceUrl ? `Source: ${sourceUrl}` : "",
+                            sourceUrl ? `Source: ${sourceUrl} (indexing in background…)` : "",
                             tags?.length ? `Tags: ${tags.join(", ")}` : "",
                             ``,
-                            `Find it later with: \`memory_search query: "${(title ?? content).slice(0, 40)}"\``,
+                            `Find it with: \`memory_search query: "${(title ?? content).slice(0, 40)}"\``,
                         ].filter(Boolean).join("\n"),
                     }],
             };
@@ -201,8 +151,6 @@ async function handleMemoryTool(name, args) {
             const parsed = SearchSchema.safeParse(args);
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            if (!apiKey)
-                return { content: [{ type: "text", text: "⚠️ SUPERMEMORY_API_KEY not configured. Set it in your MCP env to enable semantic memory." }], isError: true };
             const { query, limit = 10 } = parsed.data;
             const results = await searchSupermemory(query, limit);
             if (!results.length)
@@ -223,8 +171,6 @@ async function handleMemoryTool(name, args) {
             const parsed = ContextSchema.safeParse(args);
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            if (!apiKey)
-                return { content: [{ type: "text", text: "⚠️ SUPERMEMORY_API_KEY not configured. Set it in your MCP env to enable semantic memory." }], isError: true };
             const { topic, limit = 8 } = parsed.data;
             const results = await searchSupermemory(topic, limit);
             if (!results.length)
@@ -249,32 +195,26 @@ async function handleMemoryTool(name, args) {
             };
         }
         case "memory_profile": {
-            if (!apiKey)
-                return { content: [{ type: "text", text: "⚠️ SUPERMEMORY_API_KEY not configured.\n\nSet `SUPERMEMORY_API_KEY` in your MCP env vars.\nGet a free key at supermemory.ai" }], isError: true };
-            const { ok, data, error } = await smFetch(`/memories?spaces=${exports.SM_SPACE}&limit=1`, "GET");
-            if (!ok)
-                return { content: [{ type: "text", text: `Error fetching profile: ${error}` }], isError: true };
-            const count = data?.total ?? data?.count ?? "unknown";
+            const data = await (0, convex_js_1.callConvex)("/memory/profile", "GET").catch(() => null);
+            const total = data?.total ?? 0;
+            const status = data?.status ?? "unknown";
+            const space = data?.space ?? "—";
             return {
                 content: [{
                         type: "text",
                         text: [
-                            `🧠 **Noelclaw Semantic Memory Profile**`,
+                            `🧠 **Noelclaw Semantic Memory**`,
                             ``,
-                            `Space: \`${exports.SM_SPACE}\``,
-                            `Total memories: **${count}**`,
-                            `Status: ✅ Connected (Supermemory)`,
+                            `Space: \`${space}\``,
+                            `Total memories: **${total}**`,
+                            `Status: ${status === "ok" ? "✅ Active" : status === "not_configured" ? "⏳ Setting up" : "⚠️ " + status}`,
                             ``,
-                            `**Data sources:**`,
-                            `• vault_save / vault_remember — auto-synced ✅`,
-                            `• memory_add — direct input ✅`,
-                            `• memory_connect — URL ingestion ✅`,
-                            `• Google Drive / Gmail / Notion — connect via noelclaw.com dashboard`,
+                            `**Auto-synced sources:**`,
+                            `• vault_save + vault_remember — ✅`,
+                            `• memory_add + memory_connect — ✅`,
+                            `• Google Drive / Gmail / Notion — connect at noelclaw.com`,
                             ``,
-                            `**Capabilities:**`,
-                            `• Semantic search (vector similarity)`,
-                            `• 81.6% LongMemEval accuracy`,
-                            `• Context injection for AI tasks`,
+                            `**Capabilities:** Semantic search · Vector context · 81.6% LongMemEval`,
                         ].join("\n"),
                     }],
             };
@@ -283,53 +223,25 @@ async function handleMemoryTool(name, args) {
             const parsed = ConnectSchema.safeParse(args);
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            if (!apiKey)
-                return { content: [{ type: "text", text: "⚠️ SUPERMEMORY_API_KEY not configured. Set it in your MCP env to enable semantic memory." }], isError: true };
-            const { source, url, content, title } = parsed.data;
-            if (source === "manual") {
-                if (!content)
-                    return { content: [{ type: "text", text: "content is required for source: manual" }], isError: true };
-                const { ok, data, error } = await smFetch("/memories", "POST", {
-                    content,
-                    metadata: { title, source: "manual", addedAt: Date.now() },
-                    spaces: [exports.SM_SPACE],
-                });
-                if (!ok)
-                    return { content: [{ type: "text", text: `Error: ${error}` }], isError: true };
-                return { content: [{ type: "text", text: `✅ Memory connected — ID: \`${data?.id ?? "saved"}\`` }] };
-            }
-            if (!url)
-                return { content: [{ type: "text", text: `url is required for source: ${source}` }], isError: true };
-            const { ok, data, error } = await smFetch("/memories", "POST", {
-                content: title ?? "",
+            const { url, title, tags } = parsed.data;
+            const inferredTitle = title ?? url.split("/").filter(Boolean).pop() ?? url;
+            const data = await (0, convex_js_1.callConvex)("/memory/add", "POST", {
+                content: inferredTitle,
                 sourceUrl: url,
-                metadata: { title, source, connectedAt: Date.now() },
-                spaces: [exports.SM_SPACE],
-            });
-            if (!ok)
-                return { content: [{ type: "text", text: `Error connecting source: ${error}` }], isError: true };
-            const sourceLabels = {
-                url: "Web page",
-                github: "GitHub repo",
-                notion: "Notion page",
-            };
+                metadata: { title: inferredTitle, tags, source: "memory_connect", connectedAt: Date.now() },
+            }).catch((err) => ({ error: err.message }));
+            if (data?.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
             return {
                 content: [{
                         type: "text",
                         text: [
-                            `✅ **${sourceLabels[source] ?? source} connected**`,
-                            `URL: ${url}`,
+                            `✅ **Connected**: ${url}`,
                             `Memory ID: \`${data?.id ?? "queued"}\``,
                             ``,
-                            `Supermemory is fetching and indexing the content in the background.`,
-                            `Search it in ~30s with: \`memory_search query: "${title ?? url.split("/").pop()}"\``,
-                            ``,
-                            source === "github"
-                                ? `💡 Tip: For full repo sync (all files), connect via the Noelclaw dashboard at noelclaw.com`
-                                : source === "notion"
-                                    ? `💡 Tip: For full Notion workspace sync, connect via the Noelclaw dashboard at noelclaw.com`
-                                    : "",
-                        ].filter(Boolean).join("\n"),
+                            `Noelclaw is fetching and indexing the content in the background.`,
+                            `Search it in ~30s: \`memory_search query: "${inferredTitle.slice(0, 40)}"\``,
+                        ].join("\n"),
                     }],
             };
         }

package/dist/tools/vault.js

@@ -274,19 +274,19 @@ async function handleVaultTool(name, args) {
             if (data.error)
                 return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
             const { key, version, changed } = data;
-            // Mirror to semantic memory (fire-and-forget, don't fail the save if SM is unavailable)
+            // Mirror to semantic memory (fire-and-forget)
             if (parsed.data.type !== "credential") {
                 (0, memory_js_1.syncToSupermemory)(parsed.data.content, {
                     vaultKey: key, title: parsed.data.title, type: parsed.data.type,
                     tags: parsed.data.tags, version, source: "vault_save",
-                }).catch(() => { });
+                });
             }
             const lines = [
                 `📦 **Vault ${changed ? (version === 1 ? "Created" : "Updated") : "Unchanged"}**`,
                 `Key: \`${key}\``,
                 `Version: v${version}`,
                 changed && version > 1 ? `Previous version auto-snapshotted.` : "",
-                process.env.SUPERMEMORY_API_KEY ? `🧠 Synced to semantic memory` : "",
+                `🧠 Synced to semantic memory`,
                 ``,
                 `Use \`vault_read\` to retrieve, \`vault_history\` to see all versions.`,
             ].filter(Boolean);
@@ -341,8 +341,8 @@ async function handleVaultTool(name, args) {
             const parsed = SearchSchema.safeParse(args);
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            // Try Supermemory semantic search first
-            if (process.env.SUPERMEMORY_API_KEY) {
+            // Try semantic search first (proxied through Convex)
+            {
                 const smResults = await (0, memory_js_1.searchSupermemory)(parsed.data.query, parsed.data.limit ?? 20);
                 if (smResults.length > 0) {
                     // Filter by type if requested
@@ -456,8 +456,8 @@ async function handleVaultTool(name, args) {
             (0, memory_js_1.syncToSupermemory)(content, {
                 vaultKey: data.key, title: inferredTitle, type: "memory",
                 tags, version: data.version, source: "vault_remember",
-            }).catch(() => { });
-            const smNote = process.env.SUPERMEMORY_API_KEY ? "  🧠 Synced to semantic memory" : "";
+            });
+            const smNote = "  🧠 Synced to semantic memory";
             return { content: [{ type: "text", text: `✅ Remembered — key: \`${data.key}\` (v${data.version})${smNote}\nRetrieve later with: \`vault_context topic: "${inferredTitle.slice(0, 40)}"\`` }] };
         }
         case "vault_context": {
@@ -465,8 +465,8 @@ async function handleVaultTool(name, args) {
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
             const limit = parsed.data.limit ?? 8;
-            // Semantic context via Supermemory
-            if (process.env.SUPERMEMORY_API_KEY) {
+            // Semantic context (proxied through Convex)
+            {
                 const smResults = await (0, memory_js_1.searchSupermemory)(parsed.data.topic, limit);
                 if (smResults.length > 0) {
                     const contextParts = smResults.map((r, i) => {
@@ -589,11 +589,9 @@ async function handleVaultTool(name, args) {
                 metadata: JSON.stringify({ sourceUrl: url }),
             }, "vault_connect");
             // Mirror full content to Supermemory with source URL for ingestion
-            if (process.env.SUPERMEMORY_API_KEY) {
-                (0, memory_js_1.syncToSupermemory)("", {
-                    vaultKey: vaultData.key, title: inferredTitle, type, tags, source: "vault_connect",
-                }, url).catch(() => { });
-            }
+            (0, memory_js_1.syncToSupermemory)("", {
+                vaultKey: vaultData.key, title: inferredTitle, type, tags, source: "vault_connect",
+            }, url);
             if (vaultData.error)
                 return { content: [{ type: "text", text: `Error: ${vaultData.error}` }], isError: true };
             return {
@@ -603,9 +601,7 @@ async function handleVaultTool(name, args) {
                             `🔗 **Vault Connected**`,
                             `URL: ${url}`,
                             `Vault key: \`${vaultData.key}\``,
-                            process.env.SUPERMEMORY_API_KEY
-                                ? `🧠 Indexing to semantic memory… searchable in ~30s`
-                                : `⚠️ Set SUPERMEMORY_API_KEY for full semantic indexing`,
+                            `🧠 Indexing to semantic memory… searchable in ~30s`,
                             ``,
                             `Search it with: \`vault_search query: "${inferredTitle}"\``,
                             `Or load as context: \`vault_context topic: "${inferredTitle}"\``,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noelclaw/mcp",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Noelclaw as an MCP skill — persistent memory, multi-agent coordination, scenario simulation, DeFi execution, and Sentinel-gated playbooks.",
   "main": "dist/index.js",
   "bin": {