@noelclaw/mcp 1.0.0

package/dist/tools/swarm.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SWARM_TOOLS = void 0;
+exports.handleSwarmTool = handleSwarmTool;
+const zod_1 = require("zod");
+const convex_js_1 = require("../convex.js");
+exports.SWARM_TOOLS = [
+    {
+        name: "start_swarm",
+        description: "Start the multi-agent swarm for autonomous market monitoring, sentiment tracking, and workflow execution.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                config: {
+                    type: "object",
+                    description: "Optional swarm config",
+                    properties: {
+                        enabledAgents: { type: "array", items: { type: "string" }, description: "Agent IDs to enable" },
+                        byok: { type: "boolean", description: "Use your own Bankr API key" },
+                    },
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "stop_swarm",
+        description: "Stop the active swarm session for a user.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "get_swarm_status",
+        description: "Get the current status of the swarm: active agents, shared memory snapshot, execution scores, and recent runs.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "write_swarm_memory",
+        description: "Write a key-value pair to the swarm's shared memory.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agentId: { type: "string", description: "ID of the agent writing this memory entry" },
+                key: { type: "string", description: "Memory key" },
+                value: { type: "string", description: "Value to store" },
+                ttlSeconds: { type: "number", description: "Optional TTL in seconds" },
+            },
+            required: ["agentId", "key", "value"],
+        },
+    },
+    {
+        name: "get_swarm_memory",
+        description: "Read a value from the swarm's shared memory by key.",
+        inputSchema: {
+            type: "object",
+            properties: { key: { type: "string", description: "Memory key to read" } },
+            required: ["key"],
+        },
+    },
+    {
+        name: "get_execution_scores",
+        description: "Get the self-improvement scores for all skills.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+];
+const StartSwarmSchema = zod_1.z.object({
+    config: zod_1.z.object({
+        enabledAgents: zod_1.z.array(zod_1.z.string()).optional(),
+        byok: zod_1.z.boolean().optional(),
+    }).optional(),
+});
+const WriteMemorySchema = zod_1.z.object({ agentId: zod_1.z.string().min(1), key: zod_1.z.string().min(1), value: zod_1.z.string(), ttlSeconds: zod_1.z.number().optional() });
+const GetMemorySchema = zod_1.z.object({ key: zod_1.z.string().min(1) });
+async function handleSwarmTool(name, args) {
+    switch (name) {
+        case "start_swarm": {
+            const parsed = StartSwarmSchema.safeParse(args ?? {});
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: config ${parsed.error.issues[0].message}` }], isError: true };
+            const data = await (0, convex_js_1.callConvex)("/swarm/start", "POST", { config: parsed.data.config }, "start_swarm");
+            if (!data.success)
+                return { content: [{ type: "text", text: `Failed: ${data.error}` }], isError: true };
+            const agents = data.activeAgents ?? [];
+            return {
+                content: [{
+                        type: "text",
+                        text: [`🤖 **Swarm Started**`, `Status: ${data.status}`, `Active agents (${agents.length}): ${agents.join(", ")}`, ``, `Use \`get_swarm_status\` to monitor, \`stop_swarm\` to stop.`].join("\n"),
+                    }],
+            };
+        }
+        case "stop_swarm": {
+            const data = await (0, convex_js_1.callConvex)("/swarm/stop", "POST", {}, "stop_swarm");
+            if (!data.success)
+                return { content: [{ type: "text", text: `Failed: ${data.error}` }], isError: true };
+            return { content: [{ type: "text", text: `⏹️ Swarm stopped.` }] };
+        }
+        case "get_swarm_status": {
+            const data = await (0, convex_js_1.callConvex)("/swarm/status", "GET", undefined, "get_swarm_status");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const job = data.job;
+            const memory = data.memory ?? [];
+            const scores = data.scores ?? [];
+            const lines = [
+                `🤖 **Swarm Status**`,
+                job ? `Status: ${job.status} | Agents: ${(job.activeAgents ?? []).join(", ")}` : `No active swarm.`,
+                ``,
+            ];
+            if (memory.length > 0) {
+                lines.push(`**Shared Memory** (${memory.length} entries)`);
+                for (const m of memory.slice(0, 5))
+                    lines.push(`• [${m.agentId}] ${m.key}: ${m.value.slice(0, 80)}`);
+                if (memory.length > 5)
+                    lines.push(`  …and ${memory.length - 5} more`);
+                lines.push("");
+            }
+            if (scores.length > 0) {
+                lines.push(`**Execution Scores** (top skills)`);
+                const sorted = scores.sort((a, b) => b.lastScore - a.lastScore).slice(0, 5);
+                for (const s of sorted)
+                    lines.push(`• ${s.skillName}: ${(s.lastScore * 100).toFixed(0)}% | ${s.successCount}W/${s.failCount}L | avg ${Math.round(s.avgDurationMs / 1000)}s`);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "write_swarm_memory": {
+            const parsed = WriteMemorySchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${String(parsed.error.issues[0].path[0])} ${parsed.error.issues[0].message}` }], isError: true };
+            const { agentId, key, value, ttlSeconds } = parsed.data;
+            await (0, convex_js_1.callConvex)("/swarm/memory/write", "POST", { agentId, key, value, ttlSeconds }, "write_swarm_memory");
+            return { content: [{ type: "text", text: `✅ Memory written: [${agentId}] ${key}${ttlSeconds ? ` (expires in ${ttlSeconds}s)` : ""}` }] };
+        }
+        case "get_swarm_memory": {
+            const parsed = GetMemorySchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: key ${parsed.error.issues[0].message}` }], isError: true };
+            const data = await (0, convex_js_1.callConvex)(`/swarm/memory?key=${encodeURIComponent(parsed.data.key)}`, "GET", undefined, "get_swarm_memory");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            if (data.value === null || data.value === undefined)
+                return { content: [{ type: "text", text: `No value found for key: ${parsed.data.key}` }] };
+            return { content: [{ type: "text", text: `**${parsed.data.key}**: ${data.value}` }] };
+        }
+        case "get_execution_scores": {
+            const data = await (0, convex_js_1.callConvex)("/swarm/scores", "GET", undefined, "get_execution_scores");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const scores = data.scores ?? [];
+            if (!scores.length)
+                return { content: [{ type: "text", text: "No execution scores yet. Run some swarm agents to build a history." }] };
+            const sorted = scores.sort((a, b) => b.lastScore - a.lastScore);
+            const lines = [
+                `**Execution Scores**`, ``,
+                `| Skill | Score | W | L | Avg Duration | Last Adapted |`,
+                `|-------|-------|---|---|--------------|--------------|`,
+                ...sorted.map((s) => `| ${s.skillName} | ${(s.lastScore * 100).toFixed(0)}% | ${s.successCount} | ${s.failCount} | ${Math.round(s.avgDurationMs / 1000)}s | ${new Date(s.lastAdaptedAt).toUTCString()} |`),
+            ];
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        default:
+            return null;
+    }
+}

package/dist/tools/twitter.js

@@ -0,0 +1,67 @@
+"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 };
+    }
+}

package/dist/tools/vault.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: { type: "string", enum: [...VAULT_TYPES], description: "Entry type" },
+                title: { type: "string", description: "Human-readable title" },
+                content: { type: "string", description: "Main content — markdown, JSON, code, or plain text" },
+                key: { type: "string", description: "Optional slug key e.g. 'research/btc-dominance-analysis'. Auto-generated if omitted." },
+                contentType: { type: "string", enum: ["markdown", "json", "text", "code"], description: "Content format hint" },
+                agentId: { type: "string", description: "Agent ID writing this entry" },
+                tags: { type: "array", items: { type: "string" }, description: "Tags for filtering and search" },
+                commitMsg: { type: "string", description: "Commit message for this version, e.g. 'initial research', 'refined with on-chain data'" },
+                metadata: { type: "string", description: "Optional JSON string for extra structured fields" },
+            },
+            required: ["type", "title", "content"],
+        },
+    },
+    {
+        name: "vault_read",
+        description: "Read a Noel-Vault entry by its key. Returns full content, version, tags, and any linked entries.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                key: { type: "string", description: "Entry key e.g. 'research/btc-dominance-analysis'" },
+            },
+            required: ["key"],
+        },
+    },
+    {
+        name: "vault_list",
+        description: "List Noel-Vault entries. Filter by type, agent, or pinned status. Returns previews, not full content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: { type: "string", enum: [...VAULT_TYPES], description: "Filter by type" },
+                agentId: { type: "string", description: "Filter by agent that wrote the entries" },
+                pinned: { type: "boolean", description: "Show only pinned entries" },
+                limit: { type: "number", description: "Max entries to return (default 50)" },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "vault_search",
+        description: "Full-text search across Noel-Vault. Searches content, titles, and tags. " +
+            "Optionally filter by type. Returns ranked results with previews.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search query" },
+                type: { type: "string", enum: [...VAULT_TYPES], description: "Narrow search to a specific type" },
+                limit: { type: "number", description: "Max results (default 20)" },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "vault_history",
+        description: "Get the full version history of a Noel-Vault entry — like git log. " +
+            "Shows each version with its commit message, author agent, size, and timestamp.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                key: { type: "string", description: "Entry key" },
+            },
+            required: ["key"],
+        },
+    },
+    {
+        name: "vault_diff",
+        description: "Compare two versions of a Noel-Vault entry — like git diff. " +
+            "Shows lines added (+) and removed (-) between fromVersion and toVersion.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                key: { type: "string", description: "Entry key" },
+                fromVersion: { type: "number", description: "Older version number" },
+                toVersion: { type: "number", description: "Newer version number" },
+            },
+            required: ["key", "fromVersion", "toVersion"],
+        },
+    },
+    {
+        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.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: { type: "string", enum: [...VAULT_TYPES], description: "Export only this type (omit for full export)" },
+            },
+            required: [],
+        },
+    },
+];
+// ─── Zod schemas ─────────────────────────────────────────────────────────────
+const SaveSchema = zod_1.z.object({
+    type: zod_1.z.enum(VAULT_TYPES),
+    title: zod_1.z.string().min(1),
+    content: zod_1.z.string().min(1),
+    key: zod_1.z.string().optional(),
+    contentType: zod_1.z.enum(["markdown", "json", "text", "code"]).optional(),
+    agentId: zod_1.z.string().optional(),
+    tags: zod_1.z.array(zod_1.z.string()).optional(),
+    commitMsg: zod_1.z.string().optional(),
+    metadata: zod_1.z.string().optional(),
+});
+const ReadSchema = zod_1.z.object({ key: zod_1.z.string().min(1) });
+const ListSchema = zod_1.z.object({
+    type: zod_1.z.enum(VAULT_TYPES).optional(),
+    agentId: zod_1.z.string().optional(),
+    pinned: zod_1.z.boolean().optional(),
+    limit: zod_1.z.number().optional(),
+});
+const SearchSchema = zod_1.z.object({
+    query: zod_1.z.string().min(1),
+    type: zod_1.z.enum(VAULT_TYPES).optional(),
+    limit: zod_1.z.number().optional(),
+});
+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() });
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function formatBytes(n) {
+    if (!n)
+        return "—";
+    if (n < 1024)
+        return `${n}B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)}KB`;
+    return `${(n / 1024 / 1024).toFixed(2)}MB`;
+}
+function formatDate(ts) {
+    return new Date(ts).toUTCString();
+}
+// ─── Handler ─────────────────────────────────────────────────────────────────
+async function handleVaultTool(name, args) {
+    switch (name) {
+        case "vault_save": {
+            const parsed = SaveSchema.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/save", "POST", parsed.data, "vault_save");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const { key, version, changed } = data;
+            const lines = [
+                `📦 **Vault ${changed ? (version === 1 ? "Created" : "Updated") : "Unchanged"}**`,
+                `Key: \`${key}\``,
+                `Version: v${version}`,
+                changed && version > 1 ? `Previous version auto-snapshotted.` : "",
+                ``,
+                `Use \`vault_read\` to retrieve, \`vault_history\` to see all versions.`,
+            ].filter(Boolean);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "vault_read": {
+            const parsed = ReadSchema.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/entry?key=${encodeURIComponent(parsed.data.key)}`, "GET", undefined, "vault_read");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const lines = [
+                `📂 **${data.title}**`,
+                `Key: \`${data.key}\`  ·  Type: ${data.type}  ·  v${data.version}  ·  ${formatBytes(data.size)}`,
+                data.tags?.length ? `Tags: ${data.tags.join(", ")}` : "",
+                data.isPinned ? "📌 Pinned" : "",
+                data.agentId ? `Agent: ${data.agentId}` : "",
+                `Updated: ${formatDate(data.updatedAt)}`,
+                data.linkedKeys?.length ? `\nLinks:\n${data.linkedKeys.map((l) => `  → ${l}`).join("\n")}` : "",
+                ``,
+                `---`,
+                ``,
+                data.content,
+            ].filter((l) => l !== "");
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "vault_list": {
+            const parsed = ListSchema.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.agentId)
+                params.set("agentId", parsed.data.agentId);
+            if (parsed.data.pinned !== undefined)
+                params.set("pinned", String(parsed.data.pinned));
+            if (parsed.data.limit)
+                params.set("limit", String(parsed.data.limit));
+            const data = await (0, convex_js_1.callConvex)(`/vault/list?${params}`, "GET", undefined, "vault_list");
+            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 vault entries found${parsed.data.type ? ` of type '${parsed.data.type}'` : ""}.` }] };
+            const header = `📚 **Noel-Vault** (${entries.length} entries)`;
+            const rows = entries.map((e) => `${e.isPinned ? "📌 " : ""}[\`${e.key}\`] ${e.title} — v${e.version} · ${e.type} · ${formatBytes(e.size)} · ${formatDate(e.updatedAt)}`);
+            return { content: [{ type: "text", text: [header, "", ...rows].join("\n") }] };
+        }
+        case "vault_search": {
+            const parsed = SearchSchema.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.query });
+            if (parsed.data.type)
+                params.set("type", parsed.data.type);
+            if (parsed.data.limit)
+                params.set("limit", String(parsed.data.limit));
+            const data = await (0, convex_js_1.callConvex)(`/vault/search?${params}`, "GET", undefined, "vault_search");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const results = data.results ?? [];
+            if (!results.length)
+                return { content: [{ type: "text", text: `No vault entries found for: "${parsed.data.query}"` }] };
+            const header = `🔍 **Vault Search**: "${parsed.data.query}" — ${results.length} result(s)`;
+            const rows = results.map((r, i) => [
+                `${i + 1}. [\`${r.key}\`] **${r.title}**  (${r.type} · v${r.version})`,
+                `   ${r.preview}`,
+            ].join("\n"));
+            return { content: [{ type: "text", text: [header, "", ...rows].join("\n") }] };
+        }
+        case "vault_history": {
+            const parsed = HistorySchema.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/history?key=${encodeURIComponent(parsed.data.key)}`, "GET", undefined, "vault_history");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const { key, title, currentVersion, history } = data;
+            const header = [
+                `📜 **History**: ${title}`,
+                `Key: \`${key}\`  ·  Current: v${currentVersion}`,
+                ``,
+                `| Version | Commit | Agent | Size | Date |`,
+                `|---------|--------|-------|------|------|`,
+            ];
+            const rows = history.map((v) => `| v${v.version} | ${v.commitMsg ?? "—"} | ${v.agentId ?? "—"} | ${formatBytes(v.size)} | ${formatDate(v.createdAt)} |`);
+            return { content: [{ type: "text", text: [...header, ...rows].join("\n") }] };
+        }
+        case "vault_diff": {
+            const parsed = DiffSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { key, fromVersion, toVersion } = parsed.data;
+            const data = await (0, convex_js_1.callConvex)(`/vault/diff?key=${encodeURIComponent(key)}&from=${fromVersion}&to=${toVersion}`, "GET", undefined, "vault_diff");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const lines = [
+                `📝 **Diff**: \`${data.key}\` — v${fromVersion} → v${toVersion}`,
+                ``,
+                "```diff",
+                data.diff,
+                "```",
+            ];
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "vault_export": {
+            const parsed = ExportSchema.safeParse(args ?? {});
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const params = parsed.data.type ? `?type=${parsed.data.type}` : "";
+            const data = await (0, convex_js_1.callConvex)(`/vault/export${params}`, "GET", undefined, "vault_export");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const { exportedAt, totalEntries, entries } = data;
+            const header = [
+                `📤 **Vault Export**`,
+                `Exported: ${formatDate(exportedAt)}  ·  ${totalEntries} entries${parsed.data.type ? ` (type: ${parsed.data.type})` : ""}`,
+                ``,
+            ];
+            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") }] };
+        }
+        default:
+            return null;
+    }
+}

package/dist/tools/wallet.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WALLET_TOOLS = void 0;
+exports.handleWalletTool = handleWalletTool;
+const zod_1 = require("zod");
+const convex_js_1 = require("../convex.js");
+const wallet_js_1 = require("../wallet.js");
+exports.WALLET_TOOLS = [
+    {
+        name: "get_wallet_address",
+        description: "Get your Noelclaw wallet address. This is the local MCP wallet used to sign " +
+            "requests and receive on-chain assets. Keys never leave your machine.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "set_telegram",
+        description: "Connect your Telegram account for push notifications — trading signals, " +
+            "whale alerts, and daily recaps sent directly to your Telegram.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                chat_id: {
+                    type: "string",
+                    description: "Your Telegram chat ID. Get it by messaging @userinfobot on Telegram.",
+                },
+                bot_token: {
+                    type: "string",
+                    description: "Optional: your own Telegram bot token. Leave empty to use the Noelclaw bot.",
+                },
+            },
+            required: ["chat_id"],
+        },
+    },
+];
+const SetTelegramSchema = zod_1.z.object({
+    chat_id: zod_1.z.string().min(1),
+    bot_token: zod_1.z.string().optional(),
+});
+async function handleWalletTool(name, args) {
+    switch (name) {
+        case "get_wallet_address": {
+            try {
+                const wallet = await (0, wallet_js_1.getOrCreateWallet)();
+                return {
+                    content: [{
+                            type: "text",
+                            text: [
+                                `**Your Noelclaw Wallet**`,
+                                ``,
+                                `Address: \`${wallet.address}\``,
+                                `Network: Base mainnet (chainId 8453)`,
+                                ``,
+                                `This wallet is stored locally at \`~/.noelclaw/wallet.json\`.`,
+                                `Private keys never leave your machine — all signing happens locally.`,
+                                ``,
+                                `Use this address to receive ETH, USDC, or any ERC-20 token on Base.`,
+                            ].join("\n"),
+                        }],
+                };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Failed to load wallet: ${err.message}` }], isError: true };
+            }
+        }
+        case "set_telegram": {
+            const parsed = SetTelegramSchema.safeParse(args);
+            if (!parsed.success) {
+                return { content: [{ type: "text", text: `Invalid input: chat_id ${parsed.error.issues[0].message}` }], isError: true };
+            }
+            const { chat_id, bot_token } = parsed.data;
+            const result = await (0, convex_js_1.callConvex)("/telegram/connect", "POST", {
+                chatId: chat_id,
+                botToken: bot_token,
+            }, "set_telegram");
+            if (result.error) {
+                return { content: [{ type: "text", text: `Failed: ${result.error}` }], isError: true };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `✅ **Telegram connected**`,
+                            ``,
+                            `Chat ID: \`${chat_id}\``,
+                            `You'll now receive:`,
+                            `• Trading signals (BTC/ETH, 08:00 UTC daily)`,
+                            `• Whale alerts (every 6 hours)`,
+                            `• Daily recap`,
+                            `• Research reports`,
+                            ``,
+                            `To stop: message the bot or use \`set_telegram\` with an empty chat_id.`,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        default:
+            return null;
+    }
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });