@noelclaw/mcp 1.5.7 → 2.2.0

package/dist/tools/base.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_TOOLS = void 0;
+exports.handleBaseTool = handleBaseTool;
+const MORPHO_API = "https://blue-api.morpho.org/graphql";
+const MOONWELL_API = "https://api.moonwell.fi/v1/markets";
+exports.BASE_TOOLS = [
+    {
+        name: "base_query_vaults",
+        description: "List Morpho yield vaults on Base sorted by APY. Shows vault name, asset, current APY, and total deposits. Use this to find the best yield opportunities on Base.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                asset: {
+                    type: "string",
+                    description: "Filter by asset symbol (e.g. USDC, WETH, cbBTC). Leave empty for all.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max vaults to return (default 10)",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "base_list_markets",
+        description: "List Moonwell lending/borrowing markets on Base. Shows supply APY, borrow APY, total liquidity, and utilization rate for each asset.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                asset: {
+                    type: "string",
+                    description: "Filter by asset symbol (e.g. USDC, ETH, cbBTC). Leave empty for all.",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "base_prepare_deposit",
+        description: "Get deposit instructions for a Morpho vault — shows the vault address, expected APY, and step-by-step instructions. Does NOT execute the transaction.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                vaultName: {
+                    type: "string",
+                    description: "Name or partial name of the vault (e.g. 'Gauntlet USDC', 'steakUSDC')",
+                },
+                amount: {
+                    type: "string",
+                    description: "Amount to deposit (e.g. '100', '1000')",
+                },
+                asset: {
+                    type: "string",
+                    description: "Asset to deposit (e.g. USDC, WETH)",
+                },
+            },
+            required: ["asset", "amount"],
+        },
+    },
+    {
+        name: "base_chain_stats",
+        description: "Get real-time Base chain stats: ETH price, gas price in gwei, and latest block info.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+];
+// ── Helpers ────────────────────────────────────────────────────────────────────
+function fmt(n, decimals = 2) {
+    if (n >= 1000000000)
+        return `$${(n / 1000000000).toFixed(1)}B`;
+    if (n >= 1000000)
+        return `$${(n / 1000000).toFixed(1)}M`;
+    if (n >= 1000)
+        return `$${(n / 1000).toFixed(1)}K`;
+    return `$${n.toFixed(decimals)}`;
+}
+function pct(n) {
+    return `${(n * 100).toFixed(2)}%`;
+}
+// ── Morpho vaults ─────────────────────────────────────────────────────────────
+async function fetchMorphoVaults(asset, limit = 10) {
+    const gql = `{
+    vaults(
+      where: { chainId_in: [8453] }
+      orderBy: NetApy
+      orderDirection: Desc
+      first: 50
+    ) {
+      items {
+        name
+        address
+        asset { symbol name }
+        state { apy netApy totalAssetsUsd }
+      }
+    }
+  }`;
+    const res = await fetch(MORPHO_API, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query: gql }),
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok)
+        throw new Error(`Morpho API error: ${res.status}`);
+    const data = await res.json();
+    let vaults = data?.data?.vaults?.items ?? [];
+    // Filter out test/spam vaults: min $10k TVL, max 500% APY
+    vaults = vaults.filter((v) => {
+        const tvl = v.state?.totalAssetsUsd ?? 0;
+        const apy = v.state?.netApy ?? v.state?.apy ?? 0;
+        return tvl >= 10000 && apy <= 5;
+    });
+    if (asset) {
+        vaults = vaults.filter((v) => v.asset?.symbol?.toLowerCase().includes(asset.toLowerCase()));
+    }
+    vaults = vaults.slice(0, limit);
+    if (!vaults.length)
+        return "No vaults found for that asset.";
+    const lines = vaults.map((v, i) => {
+        const apy = pct(v.state?.netApy ?? v.state?.apy ?? 0);
+        const tvl = fmt(v.state?.totalAssetsUsd ?? 0);
+        const addr = `${v.address?.slice(0, 6)}...${v.address?.slice(-4)}`;
+        return `${i + 1}. ${v.name}\n   Asset: ${v.asset?.symbol}  APY: ${apy}  TVL: ${tvl}\n   Address: ${addr}`;
+    });
+    return `Morpho Vaults on Base (sorted by APY):\n\n${lines.join("\n\n")}`;
+}
+// ── Moonwell markets ───────────────────────────────────────────────────────────
+async function fetchMoonwellMarkets(asset) {
+    const res = await fetch(`${MOONWELL_API}?network=base`, {
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok)
+        throw new Error(`Moonwell API error: ${res.status}`);
+    const data = await res.json();
+    let markets = Array.isArray(data) ? data : (data?.data ?? data?.markets ?? []);
+    // Filter deprecated markets
+    markets = markets.filter((m) => !m.deprecated);
+    if (asset) {
+        markets = markets.filter((m) => (m.asset ?? m.underlyingSymbol ?? m.symbol ?? "").toLowerCase().includes(asset.toLowerCase()));
+    }
+    if (!markets.length)
+        return "No markets found.";
+    const lines = markets.slice(0, 15).map((m, i) => {
+        const symbol = m.asset ?? m.underlyingSymbol ?? m.symbol ?? "?";
+        const supplyApy = pct((m.baseSupplyApy ?? m.supplyApy ?? m.supplyRate ?? 0) / 100);
+        const borrowApy = pct((m.baseBorrowApy ?? m.borrowApy ?? m.borrowRate ?? 0) / 100);
+        const liquidity = fmt(m.totalSupplyUsd ?? m.liquidityUsd ?? m.totalSupply ?? 0);
+        const util = m.utilization != null ? `${(m.utilization * 100).toFixed(1)}%` : "—";
+        return `${i + 1}. ${symbol}\n   Supply APY: ${supplyApy}  Borrow APY: ${borrowApy}  Liquidity: ${liquidity}  Util: ${util}`;
+    });
+    return `Moonwell Markets on Base:\n\n${lines.join("\n\n")}`;
+}
+// ── Base chain stats ───────────────────────────────────────────────────────────
+async function fetchBaseStats() {
+    const rpc = "https://mainnet.base.org";
+    const [blockRes, priceRes, gasRes] = await Promise.all([
+        fetch(rpc, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_blockNumber", params: [] }),
+            signal: AbortSignal.timeout(8000),
+        }).then(r => r.json()).catch(() => null),
+        fetch("https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd", {
+            signal: AbortSignal.timeout(8000),
+        }).then(r => r.json()).catch(() => null),
+        fetch(rpc, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 2, method: "eth_gasPrice", params: [] }),
+            signal: AbortSignal.timeout(8000),
+        }).then(r => r.json()).catch(() => null),
+    ]);
+    const block = blockRes?.result ? parseInt(blockRes.result, 16) : "—";
+    const ethPrice = priceRes?.ethereum?.usd ?? "—";
+    const gasPriceGwei = gasRes?.result
+        ? (parseInt(gasRes.result, 16) / 1e9).toFixed(4)
+        : "—";
+    return `Base Chain Stats:\n\n• ETH Price: $${ethPrice}\n• Gas Price: ${gasPriceGwei} gwei\n• Latest Block: ${block.toLocaleString()}\n• Network: Base Mainnet (Chain ID 8453)`;
+}
+// ── Prepare deposit info ───────────────────────────────────────────────────────
+async function prepareDeposit(vaultName, asset, amount) {
+    const gql = `{
+    vaults(
+      where: { chainId_in: [8453] }
+      orderBy: NetApy
+      orderDirection: Desc
+      first: 100
+    ) {
+      items {
+        name
+        address
+        asset { symbol name }
+        state { netApy apy totalAssetsUsd }
+      }
+    }
+  }`;
+    const res = await fetch(MORPHO_API, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query: gql }),
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok)
+        throw new Error(`Morpho API error: ${res.status}`);
+    const data = await res.json();
+    let vaults = data?.data?.vaults?.items ?? [];
+    // Filter by asset first
+    vaults = vaults.filter((v) => v.asset?.symbol?.toLowerCase() === asset.toLowerCase());
+    // Filter by vault name if provided
+    if (vaultName) {
+        const match = vaults.find((v) => v.name?.toLowerCase().includes(vaultName.toLowerCase()));
+        if (match)
+            vaults = [match];
+    }
+    // Take best APY vault
+    const vault = vaults[0];
+    if (!vault) {
+        return `No Morpho vault found for ${asset} on Base. Try base_query_vaults to see available vaults.`;
+    }
+    const apy = pct(vault.state?.netApy ?? vault.state?.apy ?? 0);
+    const tvl = fmt(vault.state?.totalAssetsUsd ?? 0);
+    return [
+        `Morpho Vault Deposit Instructions`,
+        ``,
+        `Vault: ${vault.name}`,
+        `Asset: ${vault.asset?.symbol}`,
+        `APY: ${apy}  |  TVL: ${tvl}`,
+        `Contract: ${vault.address}`,
+        ``,
+        `Steps to deposit ${amount} ${asset}:`,
+        `1. Go to app.morpho.org or use the vault address above`,
+        `2. Connect your wallet (ensure you have ${amount} ${asset})`,
+        `3. Approve the vault contract to spend your ${asset}`,
+        `4. Call deposit(${amount}, yourAddress) on the vault contract`,
+        `5. You'll receive vault shares representing your deposit`,
+        ``,
+        `Expected yield: ~${apy} on ${amount} ${asset}`,
+        `Note: APY is variable and changes based on market conditions.`,
+    ].join("\n");
+}
+// ── Handler ────────────────────────────────────────────────────────────────────
+async function handleBaseTool(name, args) {
+    const a = (args ?? {});
+    switch (name) {
+        case "base_query_vaults": {
+            const text = await fetchMorphoVaults(a.asset, a.limit ?? 10);
+            return { content: [{ type: "text", text }] };
+        }
+        case "base_list_markets": {
+            const text = await fetchMoonwellMarkets(a.asset);
+            return { content: [{ type: "text", text }] };
+        }
+        case "base_prepare_deposit": {
+            const text = await prepareDeposit(a.vaultName, a.asset, a.amount);
+            return { content: [{ type: "text", text }] };
+        }
+        case "base_chain_stats": {
+            const text = await fetchBaseStats();
+            return { content: [{ type: "text", text }] };
+        }
+        default:
+            return null;
+    }
+}

package/dist/tools/coder.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODER_TOOLS = void 0;
+exports.handleCoderTool = handleCoderTool;
+const zod_1 = require("zod");
+const llm_js_1 = require("../llm.js");
+const CODER_SYSTEM = `You are Noel Coder — an expert software engineer embedded in the Noelclaw AI OS on Base chain.
+You specialize in:
+- Solidity smart contracts (ERC-20, ERC-721, DeFi hooks, Uniswap v3/v4 integrations)
+- TypeScript / React / Next.js frontend development
+- Convex backend (functions, schema, mutations, queries)
+- MCP (Model Context Protocol) server tools in TypeScript
+- Base chain ecosystem: 0x Protocol, Uniswap v3, ethers v6, wagmi v2
+
+Rules:
+- Output clean, production-ready code. No placeholders.
+- Add brief inline comments only where logic is non-obvious.
+- For smart contracts: always include NatSpec, SPDX license, pragma.
+- For React: use TypeScript, functional components, Tailwind CSS.
+- For MCP tools: follow the Noelclaw pattern (Zod schema, handler returns ToolResult | null).
+- Never include secrets or private keys in output.`;
+function ok(text) {
+    return { content: [{ type: "text", text }] };
+}
+function err(text) {
+    return { content: [{ type: "text", text }], isError: true };
+}
+// ── Tool definitions ──────────────────────────────────────────────────────────
+exports.CODER_TOOLS = [
+    {
+        name: "scaffold_project",
+        description: "Generate a complete project scaffold for a described idea — file tree + key file contents. " +
+            "Supports: Solidity contract projects, MCP skill packages, React/Next.js dApps, Convex backends, CLI tools.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: {
+                    type: "string",
+                    description: "What to build — be specific: tech stack, purpose, target chain, key features",
+                },
+                stack: {
+                    type: "string",
+                    enum: ["solidity", "mcp-skill", "react-dapp", "convex-backend", "node-cli", "auto"],
+                    description: "Tech stack. Use 'auto' to let Noel decide based on description.",
+                },
+                extras: {
+                    type: "string",
+                    description: "Optional: extra requirements, constraints, or preferred libraries",
+                },
+            },
+            required: ["description"],
+        },
+    },
+    {
+        name: "generate_component",
+        description: "Generate a production-ready React/TypeScript component. Returns the full .tsx file content. " +
+            "Includes props typing, Tailwind styling, and any hooks needed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: {
+                    type: "string",
+                    description: "What the component does, what it shows, and how it should behave",
+                },
+                name: {
+                    type: "string",
+                    description: "Component name in PascalCase, e.g. 'TokenPriceCard'",
+                },
+                context: {
+                    type: "string",
+                    description: "Optional: existing imports, store usage, or API calls the component should use",
+                },
+            },
+            required: ["description", "name"],
+        },
+    },
+    {
+        name: "generate_contract",
+        description: "Generate a Solidity smart contract from a description. Returns the full .sol file. " +
+            "Follows OpenZeppelin patterns, includes NatSpec, and is Base/EVM compatible.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: {
+                    type: "string",
+                    description: "What the contract does — token type, mechanics, access control, any special logic",
+                },
+                name: {
+                    type: "string",
+                    description: "Contract name in PascalCase, e.g. 'NoelRewards'",
+                },
+                features: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional: specific features to include, e.g. ['ERC-20', 'burnable', 'pausable', 'ownable']",
+                },
+            },
+            required: ["description", "name"],
+        },
+    },
+    {
+        name: "audit_contract",
+        description: "Audit a Solidity smart contract for security vulnerabilities, gas inefficiencies, and logic bugs. " +
+            "Returns a structured report with severity ratings and fix recommendations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "The full Solidity contract source code to audit",
+                },
+                focus: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional: specific areas to focus on, e.g. ['reentrancy', 'access control', 'overflow']",
+                },
+            },
+            required: ["code"],
+        },
+    },
+    {
+        name: "explain_code",
+        description: "Explain what a piece of code does in plain language. Works with Solidity, TypeScript, JavaScript, Python, and more. " +
+            "Breaks down logic, highlights key patterns, and explains the 'why' behind decisions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "The code to explain",
+                },
+                depth: {
+                    type: "string",
+                    enum: ["overview", "detailed", "line-by-line"],
+                    description: "How detailed the explanation should be. Default: 'detailed'",
+                },
+            },
+            required: ["code"],
+        },
+    },
+    {
+        name: "review_code",
+        description: "Review and improve a piece of code. Returns the improved version with a summary of changes. " +
+            "Fixes bugs, improves readability, adds types, optimizes gas (for Solidity), and removes anti-patterns.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "The code to review and improve",
+                },
+                language: {
+                    type: "string",
+                    description: "Language/framework, e.g. 'solidity', 'typescript', 'react', 'python'. Auto-detected if omitted.",
+                },
+                goals: {
+                    type: "string",
+                    description: "Optional: specific improvement goals, e.g. 'reduce gas costs', 'improve readability', 'add error handling'",
+                },
+            },
+            required: ["code"],
+        },
+    },
+];
+// ── Handlers ──────────────────────────────────────────────────────────────────
+const ScaffoldSchema = zod_1.z.object({
+    description: zod_1.z.string().min(10),
+    stack: zod_1.z.enum(["solidity", "mcp-skill", "react-dapp", "convex-backend", "node-cli", "auto"]).optional(),
+    extras: zod_1.z.string().optional(),
+});
+const ComponentSchema = zod_1.z.object({
+    description: zod_1.z.string().min(5),
+    name: zod_1.z.string().min(1),
+    context: zod_1.z.string().optional(),
+});
+const ContractSchema = zod_1.z.object({
+    description: zod_1.z.string().min(5),
+    name: zod_1.z.string().min(1),
+    features: zod_1.z.array(zod_1.z.string()).optional(),
+});
+const AuditSchema = zod_1.z.object({
+    code: zod_1.z.string().min(10),
+    focus: zod_1.z.array(zod_1.z.string()).optional(),
+});
+const ExplainSchema = zod_1.z.object({
+    code: zod_1.z.string().min(1),
+    depth: zod_1.z.enum(["overview", "detailed", "line-by-line"]).optional(),
+});
+const ReviewSchema = zod_1.z.object({
+    code: zod_1.z.string().min(1),
+    language: zod_1.z.string().optional(),
+    goals: zod_1.z.string().optional(),
+});
+async function handleCoderTool(name, args) {
+    switch (name) {
+        case "scaffold_project": {
+            const p = ScaffoldSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { description, stack = "auto", extras } = p.data;
+            const prompt = `Generate a complete project scaffold for the following:\n\n` +
+                `Description: ${description}\n` +
+                `Stack: ${stack}\n` +
+                (extras ? `Extra requirements: ${extras}\n` : "") +
+                `\nOutput format:\n` +
+                `1. Brief overview (2-3 sentences)\n` +
+                `2. Full file tree with all files listed\n` +
+                `3. Full content of each key file (package.json, main entry, config, one core module)\n` +
+                `4. Setup instructions (3-5 steps)\n\n` +
+                `Use real, runnable code. No TODO placeholders.`;
+            try {
+                const response = await (0, llm_js_1.callLLM)(CODER_SYSTEM, prompt, 4096);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`scaffold_project failed: ${e.message}`);
+            }
+        }
+        case "generate_component": {
+            const p = ComponentSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { description, name: componentName, context } = p.data;
+            const prompt = `Generate a production-ready React TypeScript component.\n\n` +
+                `Component name: ${componentName}\n` +
+                `Description: ${description}\n` +
+                (context ? `Context / existing code to integrate with:\n${context}\n` : "") +
+                `\nRequirements:\n` +
+                `- Full .tsx file, no omissions\n` +
+                `- TypeScript props interface\n` +
+                `- Tailwind CSS for styling\n` +
+                `- Use lucide-react for icons if needed\n` +
+                `- Framer Motion for animations if the component is interactive\n` +
+                `- Named export (not default)\n` +
+                `Output only the .tsx file content, no prose before or after.`;
+            try {
+                const response = await (0, llm_js_1.callLLM)(CODER_SYSTEM, prompt, 3000);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`generate_component failed: ${e.message}`);
+            }
+        }
+        case "generate_contract": {
+            const p = ContractSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { description, name: contractName, features = [] } = p.data;
+            const prompt = `Generate a production-ready Solidity smart contract.\n\n` +
+                `Contract name: ${contractName}\n` +
+                `Description: ${description}\n` +
+                (features.length ? `Required features: ${features.join(", ")}\n` : "") +
+                `\nRequirements:\n` +
+                `- Solidity ^0.8.20\n` +
+                `- SPDX-License-Identifier: MIT\n` +
+                `- Use OpenZeppelin contracts where appropriate (import paths: @openzeppelin/contracts/...)\n` +
+                `- Full NatSpec comments on all public functions\n` +
+                `- Optimized for Base chain (EVM compatible)\n` +
+                `- Include events for all state changes\n` +
+                `- Include a basic test outline as a comment at the bottom\n` +
+                `Output only the .sol file content.`;
+            try {
+                const response = await (0, llm_js_1.callLLM)(CODER_SYSTEM, prompt, 3500);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`generate_contract failed: ${e.message}`);
+            }
+        }
+        case "audit_contract": {
+            const p = AuditSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { code, focus = [] } = p.data;
+            const prompt = `Audit the following Solidity smart contract for security vulnerabilities, gas issues, and logic bugs.\n` +
+                (focus.length ? `Focus areas: ${focus.join(", ")}\n` : "") +
+                `\nContract:\n\`\`\`solidity\n${code}\n\`\`\`\n\n` +
+                `Output a structured audit report with these sections:\n` +
+                `## Summary\n` +
+                `(overall risk rating: Critical/High/Medium/Low/Informational, brief overview)\n\n` +
+                `## Findings\n` +
+                `For each issue:\n` +
+                `- **[SEVERITY]** Title\n` +
+                `  - Location: (function/line)\n` +
+                `  - Description: (what's wrong and why)\n` +
+                `  - Recommendation: (exact fix or mitigation)\n\n` +
+                `## Gas Optimizations\n` +
+                `(list 2-5 concrete gas savings with estimated impact)\n\n` +
+                `## Positive Patterns\n` +
+                `(what the contract does well)`;
+            try {
+                const response = await (0, llm_js_1.callLLM)(CODER_SYSTEM, prompt, 3000);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`audit_contract failed: ${e.message}`);
+            }
+        }
+        case "explain_code": {
+            const p = ExplainSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { code, depth = "detailed" } = p.data;
+            const depthInstructions = {
+                overview: "Give a high-level explanation in 3-5 sentences. What does it do, what problem does it solve, what are the main moving parts.",
+                detailed: "Explain the purpose, break down each major section, explain key patterns and design decisions, and note any non-obvious logic.",
+                "line-by-line": "Go through the code line by line (or block by block for repetitive parts), explaining exactly what each part does and why.",
+            };
+            const prompt = `Explain the following code.\n\nDepth: ${depth}\n${depthInstructions[depth]}\n\n` +
+                `Code:\n\`\`\`\n${code}\n\`\`\`\n\n` +
+                `Write in plain language. Assume the reader understands programming but may not know this specific codebase or language.`;
+            try {
+                const response = await (0, llm_js_1.callLLM)(CODER_SYSTEM, prompt, 2000);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`explain_code failed: ${e.message}`);
+            }
+        }
+        case "review_code": {
+            const p = ReviewSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { code, language, goals } = p.data;
+            const prompt = `Review and improve the following code.\n` +
+                (language ? `Language/framework: ${language}\n` : "") +
+                (goals ? `Improvement goals: ${goals}\n` : "") +
+                `\nOriginal code:\n\`\`\`\n${code}\n\`\`\`\n\n` +
+                `Output:\n` +
+                `## What I changed\n` +
+                `(bullet list: each change and why)\n\n` +
+                `## Improved code\n` +
+                `\`\`\`\n(full improved code — no omissions, no "rest of code unchanged")\n\`\`\`\n\n` +
+                `## Further recommendations\n` +
+                `(optional: things to consider beyond this snippet)`;
+            try {
+                const response = await (0, llm_js_1.callLLM)(CODER_SYSTEM, prompt, 3500);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`review_code failed: ${e.message}`);
+            }
+        }
+        default:
+            return null;
+    }
+}