@noelclaw/mcp 1.5.7 → 2.2.0

package/dist/tools/vault.js

@@ -4,7 +4,7 @@ exports.VAULT_TOOLS = void 0;
 exports.handleVaultTool = handleVaultTool;
 const zod_1 = require("zod");
 const convex_js_1 = require("../convex.js");
-const VAULT_TYPES = ["research", "execution", "workflow", "prompt", "file", "memory"];
+const VAULT_TYPES = ["research", "execution", "workflow", "prompt", "file", "memory", "credential"];
 const LINK_RELATIONS = ["references", "derived_from", "supersedes", "related", "continues"];
 exports.VAULT_TOOLS = [
     {
@@ -106,6 +106,93 @@ 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 relevant vault entries for a topic and return them as formatted context ready to inject into a prompt. " +
+            "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, filtered by relevance. 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. " +
+            "Credentials are stored under type=credential and are excluded from normal search and export. " +
+            "Use this to keep API keys organized and accessible across agent sessions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Credential name, e.g. 'ALCHEMY_API_KEY', 'TELEGRAM_BOT_TOKEN'" },
+                value: { type: "string", description: "The secret value to store" },
+                description: { type: "string", description: "Optional note about this credential — what it's for, expiry, etc." },
+            },
+            required: ["name", "value"],
+        },
+    },
+    {
+        name: "vault_get_credential",
+        description: "Retrieve a stored credential from the vault by name. " +
+            "Only returns credentials owned by the authenticated user.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Credential name as used in vault_store_credential" },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        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.",
+        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)" },
+            },
+            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.",
+        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)" },
+            },
+            required: [],
+        },
+    },
 ];
 // ─── Zod schemas ─────────────────────────────────────────────────────────────
 const SaveSchema = zod_1.z.object({
@@ -134,6 +221,12 @@ 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() });
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 function formatBytes(n) {
     if (!n)
@@ -287,6 +380,110 @@ 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 };
+            return { content: [{ type: "text", text: `✅ Remembered — key: \`${data.key}\` (v${data.version})\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 params = new URLSearchParams({ q: parsed.data.topic });
+            if (parsed.data.limit)
+                params.set("limit", String(parsed.data.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)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const data = await (0, convex_js_1.callConvex)("/vault/credential/store", "POST", parsed.data, "vault_store_credential");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            return { content: [{ type: "text", text: `🔐 Credential stored: \`${data.name}\`\nKey: \`${data.key}\`\nRetrieve with: \`vault_get_credential name: "${data.name}"\`` }] };
+        }
+        case "vault_get_credential": {
+            const parsed = GetCredentialSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const params = new URLSearchParams({ name: parsed.data.name });
+            const data = await (0, convex_js_1.callConvex)(`/vault/credential?${params}`, "GET", undefined, "vault_get_credential");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const lines = [`🔐 **${data.name}**`, `Value: \`${data.value}\``];
+            if (data.description)
+                lines.push(`Note: ${data.description}`);
+            if (data.storedAt)
+                lines.push(`Stored: ${data.storedAt}`);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "vault_publish": {
+            const parsed = PublishSchema.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");
+            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.`,
+                    }],
+            };
+        }
+        case "vault_explore": {
+            const parsed = ExploreSchema.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");
+            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"),
+                    }],
+            };
+        }
         default:
             return null;
     }

package/package.json

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