@noelclaw/mcp 2.3.0 → 2.4.0

package/dist/tools/vault.js

@@ -13,7 +13,8 @@ exports.VAULT_TOOLS = [
         description: "Save or update an artifact in Noel-Vault — the persistent memory layer for agents. " +
             "Use this to store research outputs, execution logs, workflows, versioned prompts, " +
             "generated files, or long-term memory. Each save creates a new version automatically. " +
-            "Same key = update existing (git-style). Types: research | execution | workflow | prompt | file | memory.",
+            "Same key = update existing (git-style). Types: research | execution | workflow | prompt | file | memory. " +
+            "For a quick note or preference, use type='memory' with just content — title is optional.",
         inputSchema: {
             type: "object",
             properties: {
@@ -100,7 +101,7 @@ exports.VAULT_TOOLS = [
     {
         name: "vault_export",
         description: "Export your entire Noel-Vault or a specific type as a structured bundle. " +
-            "Useful for archiving, syncing to Gitlawb, or passing context to another agent.",
+            "Useful for archiving, syncing to GitHub, or passing context to another agent.",
         inputSchema: {
             type: "object",
             properties: {
@@ -109,38 +110,6 @@ exports.VAULT_TOOLS = [
             required: [],
         },
     },
-    {
-        name: "vault_remember",
-        description: "One-liner: save anything to Noel-Vault without specifying type or title. " +
-            "Just pass content — Noel infers the title and saves as a memory entry. " +
-            "Use this for quick notes, preferences, decisions, and things to remember across sessions. " +
-            "Example: vault_remember content: 'User prefers low-risk DeFi, confirmed multiple times'",
-        inputSchema: {
-            type: "object",
-            properties: {
-                content: { type: "string", description: "What to remember — plain text, markdown, or a short note" },
-                title: { type: "string", description: "Optional title. Auto-inferred from content if omitted." },
-                tags: { type: "array", items: { type: "string" }, description: "Optional tags for later retrieval" },
-            },
-            required: ["content"],
-        },
-    },
-    {
-        name: "vault_context",
-        description: "Load semantically relevant vault entries for a topic — formatted context ready to inject into a prompt. " +
-            "Uses Supermemory vector search when available (understands meaning, not just keywords), " +
-            "with automatic fallback to full-text search. " +
-            "Call this at the start of any research or analysis task to prime your AI with all past knowledge on the topic. " +
-            "Returns full content of matching entries. Credentials are never included.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                topic: { type: "string", description: "Topic or query to load context for, e.g. 'ETH DeFi strategy' or 'BTC market thesis'" },
-                limit: { type: "number", description: "Max entries to return (default 8, max 20)" },
-            },
-            required: ["topic"],
-        },
-    },
     {
         name: "vault_store_credential",
         description: "Securely store an API key, token, or secret in your vault. " +
@@ -199,20 +168,56 @@ exports.VAULT_TOOLS = [
         },
     },
     {
-        name: "vault_connect",
-        description: "Connect an external URL or data source to your vault — fetches, indexes, and stores the content " +
-            "as a vault entry AND mirrors it to semantic memory for future retrieval. " +
-            "Perfect for indexing GitHub repos, research papers, Notion pages, or any web page. " +
-            "For full Google Drive / Gmail / Notion workspace sync, connect via the Noelclaw dashboard.",
+        name: "vault_pin",
+        description: "Pin or unpin a Noel-Vault entry. Pinned entries always appear first in vault_list and are " +
+            "prioritized in memory_context and search results. Use for your most important research, key prompts, or canonical references.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                key: { type: "string", description: "Entry key to pin or unpin" },
+                pinned: { type: "boolean", description: "true to pin, false to unpin (default: true)" },
+            },
+            required: ["key"],
+        },
+    },
+    {
+        name: "vault_delete",
+        description: "Permanently delete a Noel-Vault entry including all its version history. This cannot be undone. " +
+            "Use vault_list to browse entries before deleting.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                key: { type: "string", description: "Entry key to delete permanently" },
+            },
+            required: ["key"],
+        },
+    },
+    {
+        name: "vault_link",
+        description: "Create a semantic link between two Noel-Vault entries. Links appear in vault_read output and " +
+            "help agents navigate related knowledge. Relations: references | derived_from | supersedes | related | continues.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                fromKey: { type: "string", description: "Source entry key" },
+                toKey: { type: "string", description: "Target entry key" },
+                relation: { type: "string", enum: [...LINK_RELATIONS], description: "Relationship type (default: related)" },
+            },
+            required: ["fromKey", "toKey"],
+        },
+    },
+    {
+        name: "vault_tag",
+        description: "Add or replace tags on an existing Noel-Vault entry without modifying its content. " +
+            "Useful for organizing entries retroactively. Set replace=true to overwrite all existing tags.",
         inputSchema: {
             type: "object",
             properties: {
-                url: { type: "string", description: "URL to fetch and index (GitHub, Notion, web page, etc.)" },
-                title: { type: "string", description: "Title for this vault entry" },
-                type: { type: "string", enum: ["research", "file", "memory", "workflow"], description: "Vault entry type (default: research)" },
-                tags: { type: "array", items: { type: "string" }, description: "Tags for filtering" },
+                key: { type: "string", description: "Entry key to update tags on" },
+                tags: { type: "array", items: { type: "string" }, description: "Tags to add (or replace if replace=true)" },
+                replace: { type: "boolean", description: "If true, replaces all existing tags. If false (default), merges with existing." },
             },
-            required: ["url"],
+            required: ["key", "tags"],
         },
     },
 ];
@@ -243,13 +248,14 @@ const SearchSchema = zod_1.z.object({
 const HistorySchema = zod_1.z.object({ key: zod_1.z.string().min(1) });
 const DiffSchema = zod_1.z.object({ key: zod_1.z.string().min(1), fromVersion: zod_1.z.number(), toVersion: zod_1.z.number() });
 const ExportSchema = zod_1.z.object({ type: zod_1.z.enum(VAULT_TYPES).optional() });
-const RememberSchema = zod_1.z.object({ content: zod_1.z.string().min(1), title: zod_1.z.string().optional(), tags: zod_1.z.array(zod_1.z.string()).optional() });
-const ContextSchema = zod_1.z.object({ topic: zod_1.z.string().min(1), limit: zod_1.z.number().optional() });
 const StoreCredentialSchema = zod_1.z.object({ name: zod_1.z.string().min(1), value: zod_1.z.string().min(1), description: zod_1.z.string().optional() });
 const GetCredentialSchema = zod_1.z.object({ name: zod_1.z.string().min(1) });
 const PublishSchema = zod_1.z.object({ key: zod_1.z.string().min(1), isPublic: zod_1.z.boolean().optional(), authorName: zod_1.z.string().optional() });
 const ExploreSchema = zod_1.z.object({ type: zod_1.z.enum(["research", "execution", "workflow", "prompt", "file", "memory"]).optional(), search: zod_1.z.string().optional(), limit: zod_1.z.number().optional() });
-const VaultConnectSchema = zod_1.z.object({ url: zod_1.z.string().url(), title: zod_1.z.string().optional(), type: zod_1.z.enum(["research", "file", "memory", "workflow"]).optional(), tags: zod_1.z.array(zod_1.z.string()).optional() });
+const PinSchema = zod_1.z.object({ key: zod_1.z.string().min(1), pinned: zod_1.z.boolean().optional() });
+const DeleteSchema = zod_1.z.object({ key: zod_1.z.string().min(1) });
+const LinkSchema = zod_1.z.object({ fromKey: zod_1.z.string().min(1), toKey: zod_1.z.string().min(1), relation: zod_1.z.enum(LINK_RELATIONS).optional() });
+const TagSchema = zod_1.z.object({ key: zod_1.z.string().min(1), tags: zod_1.z.array(zod_1.z.string()).min(1), replace: zod_1.z.boolean().optional() });
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 function formatBytes(n) {
     if (!n)
@@ -274,19 +280,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 +347,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
@@ -437,69 +443,6 @@ async function handleVaultTool(name, args) {
             const rows = entries.map((e) => `**[\`${e.key}\`]** ${e.title} (${e.type} · v${e.version})\n${e.content.slice(0, 500)}${e.content.length > 500 ? "\n…" : ""}`);
             return { content: [{ type: "text", text: [...header, ...rows.join("\n\n---\n\n").split("\n")].join("\n") }] };
         }
-        case "vault_remember": {
-            const parsed = RememberSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            const { content, title, tags } = parsed.data;
-            const inferredTitle = title ?? content.slice(0, 60).replace(/\n/g, " ").trim() + (content.length > 60 ? "…" : "");
-            const data = await (0, convex_js_1.callConvex)("/vault/save", "POST", {
-                type: "memory",
-                title: inferredTitle,
-                content,
-                tags,
-                commitMsg: "vault_remember",
-            }, "vault_remember");
-            if (data.error)
-                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            // Mirror to semantic memory
-            (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" : "";
-            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": {
-            const parsed = ContextSchema.safeParse(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) {
-                const smResults = await (0, memory_js_1.searchSupermemory)(parsed.data.topic, limit);
-                if (smResults.length > 0) {
-                    const contextParts = smResults.map((r, i) => {
-                        const title = r.metadata?.title ?? `Entry ${i + 1}`;
-                        return `### ${title}\n${r.content}`;
-                    });
-                    const summary = smResults.map(r => r.metadata?.title ?? r.content.slice(0, 50)).join(", ");
-                    return {
-                        content: [{
-                                type: "text",
-                                text: [
-                                    `📚 **Vault Context** [Semantic] for: "${parsed.data.topic}"`,
-                                    `Entries: ${summary}`,
-                                    ``,
-                                    `---`,
-                                    ``,
-                                    contextParts.join("\n\n---\n\n"),
-                                ].join("\n"),
-                            }],
-                    };
-                }
-            }
-            // Fallback: Convex full-text context
-            const params = new URLSearchParams({ q: parsed.data.topic });
-            params.set("limit", String(limit));
-            const data = await (0, convex_js_1.callConvex)(`/vault/context?${params}`, "GET", undefined, "vault_context");
-            if (data.error)
-                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            if (!data.context)
-                return { content: [{ type: "text", text: `No vault context found for: "${parsed.data.topic}"\nStart building your knowledge base with vault_remember or vault_save.` }] };
-            const summary = data.entries.map((e) => `[${e.type}] ${e.title}`).join(", ");
-            return { content: [{ type: "text", text: `📚 **Vault Context** loaded for: "${parsed.data.topic}"\nEntries: ${summary}\n\n---\n\n${data.context}` }] };
-        }
         case "vault_store_credential": {
             const parsed = StoreCredentialSchema.safeParse(args);
             if (!parsed.success)
@@ -572,46 +515,44 @@ async function handleVaultTool(name, args) {
                     }],
             };
         }
-        case "vault_connect": {
-            const parsed = VaultConnectSchema.safeParse(args);
+        case "vault_pin": {
+            const parsed = PinSchema.safeParse(args);
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            const { url, title, type = "research", tags } = parsed.data;
-            const inferredTitle = title ?? url.split("/").filter(Boolean).pop() ?? url;
-            // Save to Convex vault
-            const vaultData = await (0, convex_js_1.callConvex)("/vault/save", "POST", {
-                type,
-                title: inferredTitle,
-                content: `Connected from: ${url}\n\n(Content indexed into semantic memory via Supermemory)`,
-                key: `connected/${inferredTitle.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50)}`,
-                tags: [...(tags ?? []), "connected", new URL(url).hostname],
-                commitMsg: "vault_connect",
-                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(() => { });
-            }
-            if (vaultData.error)
-                return { content: [{ type: "text", text: `Error: ${vaultData.error}` }], isError: true };
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `🔗 **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`,
-                            ``,
-                            `Search it with: \`vault_search query: "${inferredTitle}"\``,
-                            `Or load as context: \`vault_context topic: "${inferredTitle}"\``,
-                        ].filter(Boolean).join("\n"),
-                    }],
-            };
+            const { key, pinned = true } = parsed.data;
+            const data = await (0, convex_js_1.callConvex)("/vault/pin", "POST", { key, pinned }, "vault_pin");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            return { content: [{ type: "text", text: pinned ? `📌 Pinned: \`${key}\`` : `📌 Unpinned: \`${key}\`` }] };
+        }
+        case "vault_delete": {
+            const parsed = DeleteSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const data = await (0, convex_js_1.callConvex)("/vault/delete", "POST", { key: parsed.data.key }, "vault_delete");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            return { content: [{ type: "text", text: `🗑️ Deleted: \`${parsed.data.key}\` (${data.versionsRemoved ?? 0} versions removed)` }] };
+        }
+        case "vault_link": {
+            const parsed = LinkSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { fromKey, toKey, relation = "related" } = parsed.data;
+            const data = await (0, convex_js_1.callConvex)("/vault/link", "POST", { fromKey, toKey, relation }, "vault_link");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            return { content: [{ type: "text", text: `🔗 Linked: \`${fromKey}\` → [${relation}] → \`${toKey}\`` }] };
+        }
+        case "vault_tag": {
+            const parsed = TagSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { key, tags, replace = false } = parsed.data;
+            const data = await (0, convex_js_1.callConvex)("/vault/tag", "POST", { key, tags, replace }, "vault_tag");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            return { content: [{ type: "text", text: `🏷️ Tags ${replace ? "set" : "updated"} on \`${key}\`: ${(data.tags ?? tags).join(", ")}` }] };
         }
         default:
             return null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@noelclaw/mcp",
-  "version": "2.3.0",
-  "description": "Noelclaw as an MCP skill — persistent memory, multi-agent coordination, scenario simulation, DeFi execution, and Sentinel-gated playbooks.",
+  "version": "2.4.0",
+  "description": "Noelclaw AI Operating System — persistent memory, multi-agent swarm, DeFi execution, market intelligence, and Sentinel-gated playbooks.",
   "main": "dist/index.js",
   "bin": {
     "noelclaw-mcp": "dist/index.js"
@@ -52,5 +52,8 @@
   },
   "engines": {
     "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/dist/tools/news.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NEWS_TOOLS = void 0;
-exports.handleNewsTool = handleNewsTool;
-exports.NEWS_TOOLS = [];
-async function handleNewsTool(_name, _args) { return null; }

package/dist/tools/research.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESEARCH_TOOLS = void 0;
-exports.handleResearchTool = handleResearchTool;
-exports.RESEARCH_TOOLS = [];
-async function handleResearchTool(_name, _args) {
-    return null;
-}

package/dist/tools/twitter.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TWITTER_TOOLS = void 0;
-exports.handleTwitterTool = handleTwitterTool;
-const zod_1 = require("zod");
-exports.TWITTER_TOOLS = [
-    {
-        name: "post_tweet",
-        description: "Post a tweet on X (Twitter) via Ayrshare. Requires AYRSHARE_API_KEY env var.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                text: { type: "string", description: "Tweet content (max 280 characters)" },
-                reply_to: { type: "string", description: "Optional: tweet ID to reply to" },
-            },
-            required: ["text"],
-        },
-    },
-];
-const PostTweetSchema = zod_1.z.object({
-    text: zod_1.z.string().min(1).max(280),
-    reply_to: zod_1.z.string().optional(),
-});
-async function handleTwitterTool(name, args) {
-    if (name !== "post_tweet")
-        return null;
-    const parsed = PostTweetSchema.safeParse(args);
-    if (!parsed.success)
-        return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-    const apiKey = process.env.AYRSHARE_API_KEY;
-    if (!apiKey) {
-        return {
-            content: [{ type: "text", text: "AYRSHARE_API_KEY not set.\n\nGet your key at ayrshare.com → Profile → API Key" }],
-            isError: true,
-        };
-    }
-    const body = {
-        post: parsed.data.text,
-        platforms: ["twitter"],
-    };
-    if (parsed.data.reply_to)
-        body.twitterOptions = { inReplyToStatusId: parsed.data.reply_to };
-    try {
-        const res = await fetch("https://app.ayrshare.com/api/post", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${apiKey}`,
-            },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(15000),
-        });
-        const data = await res.json();
-        if (!res.ok || data.status === "error") {
-            const msg = data?.message ?? data?.errors?.[0] ?? JSON.stringify(data);
-            return { content: [{ type: "text", text: `Ayrshare error: ${msg}` }], isError: true };
-        }
-        const tweetId = data?.postIds?.find((p) => p.platform === "twitter")?.id;
-        const tweetUrl = tweetId ? `https://x.com/i/web/status/${tweetId}` : "";
-        return {
-            content: [{ type: "text", text: `✅ Tweet posted!\n\n"${parsed.data.text}"${tweetUrl ? `\n\n${tweetUrl}` : ""}` }],
-        };
-    }
-    catch (err) {
-        return { content: [{ type: "text", text: `Failed to post tweet: ${err.message}` }], isError: true };
-    }
-}