@noelclaw/mcp 3.0.0 → 3.2.0

package/dist/agent-loop.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgent = runAgent;
+const server_js_1 = require("./server.js");
+const llm_js_1 = require("./llm.js");
+const SYSTEM_PROMPT = "You are Noelclaw, a persistent AI with 74 tools covering memory, automations, DeFi execution, research, and code. " +
+    "Be concise and direct. Use tools when needed. Summarize tool results in plain English.";
+async function runAgent(userMessage, history, onToolCall) {
+    const anthropicKey = process.env.ANTHROPIC_API_KEY;
+    const bankrKey = process.env.BANKR_API_KEY;
+    if (anthropicKey)
+        return runAnthropicLoop(anthropicKey, userMessage, history, onToolCall);
+    if (bankrKey)
+        return runBankrLoop(bankrKey, userMessage, history, onToolCall);
+    // Fallback — no direct tool execution, just LLM chat via Convex
+    const text = await (0, llm_js_1.callLLM)(SYSTEM_PROMPT, userMessage, 1024, history);
+    return { text, toolCalls: [] };
+}
+// ── Anthropic agent loop ─────────────────────────────────────────────────────
+function toAnthropicTool(tool) {
+    return {
+        name: tool.name,
+        description: tool.description ?? "",
+        input_schema: tool.inputSchema ?? { type: "object", properties: {} },
+    };
+}
+async function runAnthropicLoop(apiKey, userMessage, history, onToolCall) {
+    const model = process.env.ANTHROPIC_MODEL ?? "claude-haiku-4-5-20251001";
+    const tools = server_js_1.ALL_TOOLS.map(toAnthropicTool);
+    const toolCalls = [];
+    const messages = [
+        ...history.map(h => ({ role: h.role, content: h.content })),
+        { role: "user", content: userMessage },
+    ];
+    for (let turn = 0; turn < 10; turn++) {
+        const res = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body: JSON.stringify({ model, max_tokens: 2048, system: SYSTEM_PROMPT, tools, messages }),
+            signal: AbortSignal.timeout(90000),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`Anthropic ${res.status}: ${body.slice(0, 300)}`);
+        }
+        const data = await res.json();
+        messages.push({ role: "assistant", content: data.content });
+        if (data.stop_reason !== "tool_use") {
+            const text = data.content
+                .filter(b => b.type === "text")
+                .map(b => b.text)
+                .join("");
+            return { text, toolCalls };
+        }
+        // Execute all tool_use blocks
+        const toolResults = [];
+        for (const block of data.content) {
+            if (block.type !== "tool_use")
+                continue;
+            onToolCall(block.name);
+            toolCalls.push({ name: block.name });
+            let resultText;
+            try {
+                const handler = server_js_1.HANDLER_MAP.get(block.name);
+                if (!handler)
+                    throw new Error(`Unknown tool: ${block.name}`);
+                const result = await handler(block.name, block.input ?? {});
+                resultText = result?.content?.[0]?.text ?? "Done.";
+            }
+            catch (err) {
+                resultText = `Error: ${err.message}`;
+            }
+            toolResults.push({ type: "tool_result", tool_use_id: block.id, content: resultText });
+        }
+        messages.push({ role: "user", content: toolResults });
+    }
+    return { text: "Reached max tool iterations.", toolCalls };
+}
+// ── Bankr (OpenAI-compatible) agent loop ─────────────────────────────────────
+function toBankrTool(tool) {
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description ?? "",
+            parameters: tool.inputSchema ?? { type: "object", properties: {} },
+        },
+    };
+}
+async function runBankrLoop(apiKey, userMessage, history, onToolCall) {
+    const model = process.env.BANKR_MODEL ?? "grok-3";
+    const tools = server_js_1.ALL_TOOLS.map(toBankrTool);
+    const toolCalls = [];
+    const messages = [
+        { role: "system", content: SYSTEM_PROMPT },
+        ...history.map(h => ({ role: h.role, content: h.content })),
+        { role: "user", content: userMessage },
+    ];
+    for (let turn = 0; turn < 10; turn++) {
+        const res = await fetch("https://llm.bankr.bot/v1/chat/completions", {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-API-Key": apiKey },
+            body: JSON.stringify({ model, messages, tools, max_tokens: 2048 }),
+            signal: AbortSignal.timeout(90000),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`Bankr ${res.status}: ${body.slice(0, 300)}`);
+        }
+        const data = await res.json();
+        const choice = data.choices?.[0]?.message;
+        if (!choice)
+            throw new Error("Empty response from Bankr");
+        messages.push(choice);
+        if (!choice.tool_calls?.length) {
+            return { text: choice.content ?? "", toolCalls };
+        }
+        for (const call of choice.tool_calls) {
+            onToolCall(call.function.name);
+            toolCalls.push({ name: call.function.name });
+            let resultText;
+            try {
+                const args = JSON.parse(call.function.arguments ?? "{}");
+                const handler = server_js_1.HANDLER_MAP.get(call.function.name);
+                if (!handler)
+                    throw new Error(`Unknown tool: ${call.function.name}`);
+                const result = await handler(call.function.name, args);
+                resultText = result?.content?.[0]?.text ?? "Done.";
+            }
+            catch (err) {
+                resultText = `Error: ${err.message}`;
+            }
+            messages.push({ role: "tool", tool_call_id: call.id, content: resultText });
+        }
+    }
+    return { text: "Reached max tool iterations.", toolCalls };
+}

package/dist/cli.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline = __importStar(require("readline"));
+const agent_loop_js_1 = require("./agent-loop.js");
+const server_js_1 = require("./server.js");
+// ── ANSI ─────────────────────────────────────────────────────────────────────
+const C = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    cyan: "\x1b[36m",
+    violet: "\x1b[35m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+};
+const BANNER = `
+${C.cyan}${C.bold}  NOELCLAW${C.reset}  ${C.dim}v3.2.0 · 76 tools · persistent AI${C.reset}
+  ${C.dim}─────────────────────────────────────────${C.reset}
+  ${C.dim}Type anything. /help for commands. Ctrl+C to exit.${C.reset}
+`;
+// ── Spinner ───────────────────────────────────────────────────────────────────
+function spinner(label) {
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let i = 0;
+    const iv = setInterval(() => {
+        process.stdout.write(`\r  ${C.dim}${frames[i % frames.length]} ${label}${C.reset}  `);
+        i++;
+    }, 80);
+    return () => {
+        clearInterval(iv);
+        process.stdout.write("\r" + " ".repeat(label.length + 12) + "\r");
+    };
+}
+// ── Help ─────────────────────────────────────────────────────────────────────
+function printHelp() {
+    console.log(`
+  ${C.cyan}Commands:${C.reset}
+    /clear     Clear conversation history
+    /tools     List all 74 available tools
+    /quit      Exit
+
+  ${C.dim}Examples:
+    remember my coding style for next time
+    what's ETH doing right now?
+    swap 0.5 ETH to USDC on Base
+    send me a weekly digest every Monday
+    research "best DeFi yields on Base"${C.reset}
+`);
+}
+// ── Main ─────────────────────────────────────────────────────────────────────
+async function main() {
+    process.stdout.write(BANNER);
+    // Detect active LLM
+    const mode = process.env.ANTHROPIC_API_KEY
+        ? `${C.green}Anthropic${C.reset} ${C.dim}(full tool use)${C.reset}`
+        : process.env.BANKR_API_KEY
+            ? `${C.green}Bankr${C.reset} ${C.dim}(full tool use)${C.reset}`
+            : `${C.yellow}Convex chat${C.reset} ${C.dim}(no tool execution — set ANTHROPIC_API_KEY for full mode)${C.reset}`;
+    console.log(`  ${C.dim}Mode:${C.reset} ${mode}\n`);
+    const history = [];
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: `${C.green}>${C.reset} `,
+    });
+    rl.prompt();
+    rl.on("line", async (raw) => {
+        const line = raw.trim();
+        if (!line) {
+            rl.prompt();
+            return;
+        }
+        // Built-in commands
+        if (line === "/quit" || line === "/exit") {
+            console.log(`\n  ${C.dim}Goodbye.${C.reset}\n`);
+            process.exit(0);
+        }
+        if (line === "/clear") {
+            history.length = 0;
+            console.log(`  ${C.dim}History cleared.${C.reset}\n`);
+            rl.prompt();
+            return;
+        }
+        if (line === "/help") {
+            printHelp();
+            rl.prompt();
+            return;
+        }
+        if (line === "/tools") {
+            console.log(`\n  ${C.cyan}${server_js_1.ALL_TOOLS.length} tools:${C.reset}`);
+            for (const t of server_js_1.ALL_TOOLS) {
+                console.log(`  ${C.dim}·${C.reset} ${t.name}  ${C.dim}${(t.description ?? "").slice(0, 60)}${C.reset}`);
+            }
+            console.log();
+            rl.prompt();
+            return;
+        }
+        // Agent call
+        const stop = spinner("thinking");
+        let toolsUsed = 0;
+        try {
+            const result = await (0, agent_loop_js_1.runAgent)(line, history, (toolName) => {
+                stop();
+                toolsUsed++;
+                process.stdout.write(`  ${C.dim}✦ ${toolName}${C.reset}\n`);
+            });
+            stop();
+            // Update conversation history (keep last 20 turns)
+            history.push({ role: "user", content: line });
+            history.push({ role: "assistant", content: result.text });
+            while (history.length > 20)
+                history.splice(0, 2);
+            // Output
+            console.log();
+            const lines = result.text.split("\n");
+            for (const l of lines) {
+                console.log(`  ${l}`);
+            }
+            console.log();
+        }
+        catch (err) {
+            stop();
+            console.log(`\n  ${C.red}✗${C.reset} ${err.message}\n`);
+        }
+        rl.prompt();
+    });
+    rl.on("close", () => {
+        console.log(`\n  ${C.dim}Goodbye.${C.reset}\n`);
+        process.exit(0);
+    });
+}
+main().catch(err => {
+    console.error(`Fatal: ${err.message}`);
+    process.exit(1);
+});

package/dist/server.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.server = exports.ALL_TOOLS = void 0;
+exports.server = exports.HANDLER_MAP = exports.ALL_TOOLS = void 0;
 exports.startServer = startServer;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
@@ -50,11 +50,11 @@ exports.ALL_TOOLS = [
     ...scanner_js_1.SCANNER_TOOLS, // 4 — score_token, check_token, scan_dips, scan_momentum
     ...coder_js_1.CODER_TOOLS, // 5 — generate_contract, audit_contract, explain_code, review_code, generate_mcp_skill
     ...base_js_1.BASE_TOOLS, // 4 — query_vaults, list_markets, prepare_deposit, chain_stats
-    ...memory_js_1.MEMORY_TOOLS, // 7 — memory_add, memory_search, memory_context, memory_profile, memory_list, memory_delete, memory_insight
+    ...memory_js_1.MEMORY_TOOLS, // 9 — memory_add, memory_search, memory_context, memory_profile, memory_list, memory_delete, memory_insight, memory_extract, memory_consolidate
     ...os_js_1.OS_TOOLS, // 3 — noel_status, noel_boot, noel_shutdown
-    // total: 74
+    // total: 76
 ];
-const HANDLER_MAP = new Map([
+exports.HANDLER_MAP = new Map([
     ...market_js_1.MARKET_TOOLS.map(t => [t.name, market_js_1.handleMarketTool]),
     ...defi_js_1.DEFI_TOOLS.map(t => [t.name, defi_js_1.handleDefiTool]),
     ...automation_js_1.AUTOMATION_TOOLS.map(t => [t.name, automation_js_1.handleAutomationTool]),
@@ -72,13 +72,13 @@ const HANDLER_MAP = new Map([
     ...memory_js_1.MEMORY_TOOLS.map(t => [t.name, memory_js_1.handleMemoryTool]),
     ...os_js_1.OS_TOOLS.map(t => [t.name, os_js_1.handleOsTool]),
 ]);
-exports.server = new index_js_1.Server({ name: "noelclaw", version: "2.4.0" }, { capabilities: { tools: {} } });
+exports.server = new index_js_1.Server({ name: "noelclaw", version: "3.2.0" }, { capabilities: { tools: {} } });
 exports.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({ tools: exports.ALL_TOOLS }));
 exports.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     if (containsSensitiveRequest(args))
         return PRIVATE_KEY_RESPONSE;
-    const handler = HANDLER_MAP.get(name);
+    const handler = exports.HANDLER_MAP.get(name);
     if (!handler) {
         return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
     }

package/dist/tools/memory.js

@@ -123,6 +123,36 @@ exports.MEMORY_TOOLS = [
             required: ["topic"],
         },
     },
+    {
+        name: "memory_extract",
+        description: "Auto-extract discrete facts, preferences, and decisions from any text and save them individually to semantic memory. " +
+            "Instead of storing a wall of text, Noelclaw breaks it into 3-10 searchable atomic facts using AI. " +
+            "Best for processing chat logs, research notes, meeting summaries, or any unstructured content. " +
+            "Each extracted fact becomes independently searchable — 'what do I prefer about staking?' will find it.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: { type: "string", description: "Text to extract facts from — notes, research, chat logs, any unstructured content" },
+                source: { type: "string", description: "Optional label for where this came from (e.g. 'telegram', 'research', 'meeting')" },
+            },
+            required: ["text"],
+        },
+    },
+    {
+        name: "memory_consolidate",
+        description: "Fetch all memories on a topic and consolidate them into a single comprehensive summary using AI. " +
+            "Removes redundancy, merges overlapping facts, and saves the result as a new 'consolidated' memory. " +
+            "Use this to clean up fragmented knowledge after heavy research sessions. " +
+            "Returns the summary and saves it automatically — the original memories remain intact.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: { type: "string", description: "Topic to consolidate memories for (e.g. 'ETH liquid staking', 'Base DeFi')" },
+                limit: { type: "number", description: "Max source memories to consolidate (default 12)" },
+            },
+            required: ["topic"],
+        },
+    },
 ];
 // ─── Zod schemas ─────────────────────────────────────────────────────────────
 const AddSchema = zod_1.z.object({
@@ -148,6 +178,14 @@ const InsightSchema = zod_1.z.object({
     topic: zod_1.z.string().min(1),
     depth: zod_1.z.enum(["quick", "standard", "deep"]).optional(),
 });
+const ExtractSchema = zod_1.z.object({
+    text: zod_1.z.string().min(1),
+    source: zod_1.z.string().optional(),
+});
+const ConsolidateSchema = zod_1.z.object({
+    topic: zod_1.z.string().min(1),
+    limit: zod_1.z.number().optional(),
+});
 // ─── Handler ─────────────────────────────────────────────────────────────────
 async function handleMemoryTool(name, args) {
     switch (name) {
@@ -361,6 +399,51 @@ async function handleMemoryTool(name, args) {
             lines.push(`• \`swarm_watch topic: "${topic}"\` — monitor this topic continuously`);
             return { content: [{ type: "text", text: lines.filter(l => l !== undefined).join("\n") }] };
         }
+        case "memory_extract": {
+            const parsed = ExtractSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { text, source = "extract" } = parsed.data;
+            const data = await (0, convex_js_1.callConvex)("/memory/extract", "POST", { text, source }).catch((err) => ({ error: err.message }));
+            if (data?.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const facts = data?.facts ?? [];
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `🧠 **Auto-extracted ${data?.extracted ?? facts.length} facts** (${data?.saved ?? 0} saved)`,
+                            ``,
+                            ...facts.map((f, i) => `${i + 1}. ${f}`),
+                            ``,
+                            `All facts are now searchable via \`memory_search\`.`,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        case "memory_consolidate": {
+            const parsed = ConsolidateSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { topic, limit = 12 } = parsed.data;
+            const data = await (0, convex_js_1.callConvex)("/memory/consolidate", "POST", { topic, n: limit }).catch((err) => ({ error: err.message }));
+            if (data?.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `🧠 **Consolidated "${topic}"** — merged ${data?.consolidatedFrom ?? "?"} memories`,
+                            `Saved as: \`${data?.id ?? "consolidated"}\``,
+                            ``,
+                            `**Summary:**`,
+                            data?.summary ?? "",
+                            ``,
+                            `Use \`memory_search query: "${topic}"\` to find it.`,
+                        ].join("\n"),
+                    }],
+            };
+        }
         default:
             return null;
     }

package/dist/tools/os.js

@@ -108,18 +108,21 @@ async function handleOsTool(name, args) {
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
             const { focus } = parsed.data;
-            const [swarmRes, marketRes, autoRes, memRes, focusRes] = await Promise.allSettled([
+            const [swarmRes, marketRes, autoRes, memRes, focusRes, prefRes] = await Promise.allSettled([
                 (0, convex_js_1.callConvex)("/swarm/start", "POST", {}, "start_swarm"),
                 (0, market_js_1.fetchMarketSnapshot)(),
                 (0, convex_js_1.callConvex)("/automations/list", "GET", undefined, "list_automations"),
                 (0, convex_js_1.callConvex)("/memory/profile", "GET"),
-                focus ? (0, memory_js_1.searchSupermemory)(focus, 4) : Promise.resolve([]),
+                focus ? (0, memory_js_1.searchSupermemory)(focus, 5) : Promise.resolve([]),
+                // Always load user preference/context memories for smart boot
+                (0, memory_js_1.searchSupermemory)("user preferences style goals priorities", 4),
             ]);
             const swarm = swarmRes.status === "fulfilled" ? swarmRes.value : null;
             const market = marketRes.status === "fulfilled" ? marketRes.value : null;
             const autos = autoRes.status === "fulfilled" ? autoRes.value : null;
             const mem = memRes.status === "fulfilled" ? memRes.value : null;
             const focusMem = focusRes.status === "fulfilled" ? focusRes.value : [];
+            const prefMem = prefRes.status === "fulfilled" ? prefRes.value : [];
             const automations = autos?.automations ?? [];
             const activeAutos = automations.filter((a) => a.status === "active");
             const memTotal = mem?.total ?? 0;
@@ -148,6 +151,15 @@ async function handleOsTool(name, args) {
                 }
                 lines.push("");
             }
+            // Always show user context memories if available
+            if (prefMem.length > 0) {
+                lines.push(`**User context loaded (${prefMem.length} preferences):**`);
+                for (const r of prefMem) {
+                    const title = r.metadata?.title ?? r.content.slice(0, 80).replace(/\n/g, " ");
+                    lines.push(`  • ${title}`);
+                }
+                lines.push("");
+            }
             if (focus && focusMem.length > 0) {
                 lines.push(`**Memory context for "${focus}" (${focusMem.length} items):**`);
                 for (const r of focusMem) {
@@ -166,6 +178,7 @@ async function handleOsTool(name, args) {
                 lines.push(`  • \`swarm_research topic: "BTC"\` — start morning research`);
                 lines.push(`  • \`noel_status\` — full system dashboard`);
             }
+            lines.push(`  • \`memory_extract text: "...\"\` — auto-save facts from any note`);
             return { content: [{ type: "text", text: lines.join("\n") }] };
         }
         case "noel_shutdown": {

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@noelclaw/mcp",
-  "version": "3.0.0",
+  "version": "3.2.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"
+    "noelclaw-mcp": "dist/index.js",
+    "noelclaw": "dist/cli.js"
   },
   "scripts": {
     "build": "tsc",