@noelclaw/mcp 2.3.1 → 3.0.0

package/dist/tools/vault.js

@@ -6,14 +6,14 @@ const zod_1 = require("zod");
 const convex_js_1 = require("../convex.js");
 const memory_js_1 = require("./memory.js");
 const VAULT_TYPES = ["research", "execution", "workflow", "prompt", "file", "memory", "credential"];
-const LINK_RELATIONS = ["references", "derived_from", "supersedes", "related", "continues"];
 exports.VAULT_TOOLS = [
     {
         name: "vault_save",
         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 +100,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 +109,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. " +
@@ -169,50 +137,42 @@ exports.VAULT_TOOLS = [
         },
     },
     {
-        name: "vault_publish",
-        description: "Publish a vault entry to the community vault so other Noelclaw users can discover and fork it. " +
-            "Credentials are never published — only research, prompts, workflows, memory, and execution entries. " +
-            "You can also unpublish by setting isPublic to false.",
+        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 publish or unpublish" },
-                isPublic: { type: "boolean", description: "true to publish, false to unpublish (default true)" },
-                authorName: { type: "string", description: "Display name shown to the community (default: Anonymous)" },
+                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_explore",
-        description: "Browse the community vault — public entries shared by all Noelclaw users. " +
-            "Discover research, prompts, and workflows published by the community. " +
-            "Use vault_save to fork any entry into your own vault.",
+        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: {
-                type: { type: "string", enum: ["research", "execution", "workflow", "prompt", "file", "memory"], description: "Filter by entry type" },
-                search: { type: "string", description: "Search query to filter community entries" },
-                limit: { type: "number", description: "Max entries to return (default 20)" },
+                key: { type: "string", description: "Entry key to delete permanently" },
             },
-            required: [],
+            required: ["key"],
         },
     },
     {
-        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_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 +203,11 @@ 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 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)
@@ -437,69 +395,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",
-            });
-            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": {
-            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 (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) => {
-                        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)
@@ -524,90 +419,34 @@ async function handleVaultTool(name, args) {
                 lines.push(`Stored: ${data.storedAt}`);
             return { content: [{ type: "text", text: lines.join("\n") }] };
         }
-        case "vault_publish": {
-            const parsed = PublishSchema.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 { key, isPublic = true, authorName } = parsed.data;
-            const endpoint = isPublic ? "/vault/publish" : "/vault/unpublish";
-            const data = await (0, convex_js_1.callConvex)(endpoint, "POST", { key, authorName }, "vault_publish");
+            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: isPublic
-                            ? `🌐 **Published to community vault**\nKey: \`${key}\`\nOther Noelclaw users can now discover this entry.\nUse \`vault_publish key: "${key}" isPublic: false\` to unpublish.`
-                            : `🔒 **Unpublished**\nKey: \`${key}\` is now private.`,
-                    }],
-            };
+            return { content: [{ type: "text", text: pinned ? `📌 Pinned: \`${key}\`` : `📌 Unpinned: \`${key}\`` }] };
         }
-        case "vault_explore": {
-            const parsed = ExploreSchema.safeParse(args ?? {});
+        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 params = new URLSearchParams();
-            if (parsed.data.type)
-                params.set("type", parsed.data.type);
-            if (parsed.data.search)
-                params.set("search", parsed.data.search);
-            if (parsed.data.limit)
-                params.set("limit", String(parsed.data.limit));
-            const data = await (0, convex_js_1.callConvex)(`/vault/community?${params}`, "GET", undefined, "vault_explore");
+            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 };
-            const entries = data.entries ?? [];
-            if (!entries.length)
-                return { content: [{ type: "text", text: `No community vault entries found${parsed.data.type ? ` of type '${parsed.data.type}'` : ""}.${parsed.data.search ? ` Try a different search term.` : "\nBe the first to publish with vault_publish!"}` }] };
-            const header = `🌐 **Community Vault** — ${entries.length} public entries`;
-            const rows = entries.map((e) => [
-                `**[${e.type}]** ${e.title}  ·  by ${e.authorName ?? "Anonymous"}`,
-                `  \`${e.key}\`  ·  v${e.version}  ·  ${formatDate(e.updatedAt)}`,
-                e.content ? `  ${e.content.slice(0, 100)}${e.content.length > 100 ? "…" : ""}` : "",
-            ].filter(Boolean).join("\n"));
-            return {
-                content: [{
-                        type: "text",
-                        text: [header, "", ...rows, "", "To fork an entry: `vault_save type: <type> title: <title> content: <content>`"].join("\n"),
-                    }],
-            };
+            return { content: [{ type: "text", text: `🗑️ Deleted: \`${parsed.data.key}\` (${data.versionsRemoved ?? 0} versions removed)` }] };
         }
-        case "vault_connect": {
-            const parsed = VaultConnectSchema.safeParse(args);
+        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 { 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
-            (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 {
-                content: [{
-                        type: "text",
-                        text: [
-                            `🔗 **Vault Connected**`,
-                            `URL: ${url}`,
-                            `Vault key: \`${vaultData.key}\``,
-                            `🧠 Indexing to semantic memory… searchable in ~30s`,
-                            ``,
-                            `Search it with: \`vault_search query: "${inferredTitle}"\``,
-                            `Or load as context: \`vault_context topic: "${inferredTitle}"\``,
-                        ].filter(Boolean).join("\n"),
-                    }],
-            };
+            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.1",
-  "description": "Noelclaw as an MCP skill — persistent memory, multi-agent coordination, scenario simulation, DeFi execution, and Sentinel-gated playbooks.",
+  "version": "3.0.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 };
-    }
-}