@warmio/mcp 1.0.2 → 1.2.0

package/dist/install.js

@@ -1,8 +1,9 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { homedir, platform } from 'os';
 import { createInterface } from 'readline';
 const HOME = homedir();
+const CWD = process.cwd();
 function getClaudeDesktopPath() {
     if (platform() === 'win32') {
         return join(process.env.APPDATA || join(HOME, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
@@ -12,7 +13,7 @@ function getClaudeDesktopPath() {
     }
     return join(HOME, '.config', 'claude', 'claude_desktop_config.json');
 }
-const ALL_CLIENTS = [
+const GLOBAL_CLIENTS = [
     { name: 'Claude Code', configPath: join(HOME, '.claude.json'), format: 'json', alwaysInclude: true },
     { name: 'Claude Desktop', configPath: getClaudeDesktopPath(), format: 'json' },
     { name: 'Cursor', configPath: join(HOME, '.cursor', 'mcp.json'), format: 'json' },
@@ -22,11 +23,28 @@ const ALL_CLIENTS = [
     { name: 'Antigravity', configPath: join(HOME, '.gemini', 'antigravity', 'mcp_config.json'), format: 'json' },
     { name: 'Gemini CLI', configPath: join(HOME, '.gemini', 'settings.json'), format: 'json' },
 ];
+// Project-level MCP config files (checked in CWD)
+const PROJECT_CONFIGS = ['.mcp.json', '.cursor/mcp.json', '.vscode/mcp.json'];
 // On Windows, npx doesn't forward stdin/stdout properly for MCP's JSON-RPC protocol.
 // Using cmd /c npx ... fixes the pipe forwarding.
 const MCP_CONFIG = platform() === 'win32'
     ? { command: 'cmd', args: ['/c', 'npx', '-y', '@warmio/mcp', '--server'] }
     : { command: 'npx', args: ['-y', '@warmio/mcp', '--server'] };
+function detectProjectClients() {
+    const found = [];
+    for (const name of PROJECT_CONFIGS) {
+        const configPath = resolve(CWD, name);
+        if (existsSync(configPath)) {
+            found.push({
+                name: `Project (${name})`,
+                configPath,
+                format: 'json',
+                isProjectLevel: true,
+            });
+        }
+    }
+    return found;
+}
 function isDetected(client) {
     if (client.alwaysInclude)
         return true;
@@ -55,10 +73,16 @@ function configureJson(client, apiKey) {
     }
     if (!config.mcpServers)
         config.mcpServers = {};
-    config.mcpServers.warm = {
-        ...MCP_CONFIG,
-        env: { WARM_API_KEY: apiKey },
-    };
+    const servers = config.mcpServers;
+    const existing = servers.warm;
+    // For project-level configs, preserve existing command/args if present — only inject the key.
+    if (client.isProjectLevel && existing?.command) {
+        existing.env = { WARM_API_KEY: apiKey };
+        servers.warm = existing;
+    }
+    else {
+        servers.warm = { ...MCP_CONFIG, env: { WARM_API_KEY: apiKey } };
+    }
     mkdirSync(dirname(client.configPath), { recursive: true });
     writeFileSync(client.configPath, JSON.stringify(config, null, 2) + '\n');
 }
@@ -84,7 +108,7 @@ function configure(client, apiKey) {
         configureToml(client, apiKey);
 }
 function shortPath(p) {
-    return p.replace(HOME, '~');
+    return p.replace(HOME, '~').replace(CWD, '.');
 }
 function prompt(question) {
     return new Promise((resolve) => {
@@ -101,14 +125,17 @@ export async function install() {
     console.log('  Warm MCP Server Installer');
     console.log('  -------------------------');
     console.log('');
-    const detected = ALL_CLIENTS.filter(isDetected);
-    const needsSetup = detected.filter((c) => !isConfigured(c) || force);
-    // Show detected clients and their status
+    // Detect global + project-level clients
+    const globalClients = GLOBAL_CLIENTS.filter(isDetected);
+    const projectClients = detectProjectClients();
+    const allClients = [...globalClients, ...projectClients];
+    const needsSetup = allClients.filter((c) => !isConfigured(c) || force);
+    // Show all detected clients
     console.log('  MCP clients found:');
-    detected.forEach((client) => {
+    allClients.forEach((client) => {
         const configured = isConfigured(client);
         const status = configured && !force ? 'configured' : 'not configured';
-        console.log(`    ${client.name.padEnd(18)} ${shortPath(client.configPath).padEnd(60)} ${status}`);
+        console.log(`    ${client.name.padEnd(22)} ${shortPath(client.configPath).padEnd(55)} ${status}`);
     });
     console.log('');
     // Nothing to do
@@ -132,10 +159,10 @@ export async function install() {
     needsSetup.forEach((client) => {
         try {
             configure(client, apiKey);
-            console.log(`    ${client.name.padEnd(18)} done`);
+            console.log(`    ${client.name.padEnd(22)} done`);
         }
         catch (err) {
-            console.log(`    ${client.name.padEnd(18)} failed: ${err instanceof Error ? err.message : String(err)}`);
+            console.log(`    ${client.name.padEnd(22)} failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     });
     console.log('');

package/dist/server.js

@@ -11,6 +11,39 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 const API_URL = process.env.WARM_API_URL || 'https://warm.io';
+const MAX_RESPONSE_SIZE = 50_000;
+function compactTransaction(t) {
+    return {
+        d: t.date,
+        a: t.amount,
+        m: t.merchant_name || t.name || 'Unknown',
+        c: t.category || null,
+    };
+}
+function matchesSearch(t, search) {
+    const s = search.toLowerCase();
+    const merchant = (t.merchant_name || t.name || '').toLowerCase();
+    const category = (t.category || '').toLowerCase();
+    return merchant.includes(s) || category.includes(s);
+}
+function inDateRange(t, since, until) {
+    if (since && t.date < since)
+        return false;
+    if (until && t.date > until)
+        return false;
+    return true;
+}
+function calculateSummary(transactions) {
+    if (transactions.length === 0) {
+        return { total: 0, count: 0, avg: 0 };
+    }
+    const total = transactions.reduce((sum, t) => sum + t.a, 0);
+    return {
+        total: Math.round(total * 100) / 100,
+        count: transactions.length,
+        avg: Math.round((total / transactions.length) * 100) / 100,
+    };
+}
 function getApiKey() {
     if (process.env.WARM_API_KEY) {
         return process.env.WARM_API_KEY;
@@ -49,85 +82,84 @@ async function apiRequest(endpoint, params = {}) {
     }
     return response.json();
 }
-const server = new Server({ name: 'warm', version: '1.0.2' }, { capabilities: { tools: {} } });
+const server = new Server({ name: 'warm', version: '1.2.0' }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
             name: 'get_accounts',
-            description: 'Get all connected bank accounts with balances. Returns account names, types, balances, and institutions.',
+            description: 'Get all connected bank accounts with balances. Use for: "What accounts do I have?", "What is my checking balance?", "Show my credit cards". Returns: array of {name, type, balance, institution}.',
             inputSchema: {
                 type: 'object',
-                properties: {
-                    since: {
-                        type: 'string',
-                        description: 'Filter accounts updated since this date (ISO format)',
-                    },
-                },
+                properties: {},
             },
+            annotations: { readOnlyHint: true },
         },
         {
             name: 'get_transactions',
-            description: 'Get transactions from connected accounts. Supports pagination and date filtering.',
+            description: 'Search and analyze transactions. Use for: "How much did I spend on X?", "Show my Amazon purchases", "What did I buy last month?". Returns: {summary: {total, count, avg}, txns: [{d, a, m, c}]} where d=date, a=amount, m=merchant, c=category.',
             inputSchema: {
                 type: 'object',
                 properties: {
-                    limit: {
-                        type: 'number',
-                        description: 'Maximum number of transactions to return (default: 100)',
+                    search: {
+                        type: 'string',
+                        description: 'Filter by merchant or category (e.g., "coffee", "amazon", "groceries")',
                     },
                     since: {
                         type: 'string',
-                        description: 'Get transactions since this date (ISO format, e.g., 2024-01-01)',
+                        description: 'Start date inclusive (YYYY-MM-DD)',
                     },
-                    cursor: {
+                    until: {
                         type: 'string',
-                        description: 'Pagination cursor for fetching more results',
+                        description: 'End date inclusive (YYYY-MM-DD)',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Max transactions (default: 50, max: 200)',
                     },
                 },
             },
+            annotations: { readOnlyHint: true },
         },
         {
             name: 'get_recurring',
-            description: 'Get recurring payments and subscriptions detected from transaction history.',
+            description: 'Get detected subscriptions and recurring payments. Use for: "What subscriptions do I have?", "Show my monthly bills", "What are my recurring charges?". Returns: {recurring: [{merchant, amount, frequency, next_date}]}.',
             inputSchema: {
                 type: 'object',
-                properties: {
-                    since: {
-                        type: 'string',
-                        description: 'Filter recurring items detected since this date',
-                    },
-                },
+                properties: {},
             },
+            annotations: { readOnlyHint: true },
         },
         {
             name: 'get_snapshots',
-            description: 'Get net worth snapshots over time (daily or monthly aggregation).',
+            description: 'Get net worth history over time. Use for: "How has my net worth changed?", "Show my financial progress", "What was my balance last month?". Returns: {snapshots: [{d, nw, a, l}]} where nw=net_worth, a=assets, l=liabilities.',
             inputSchema: {
                 type: 'object',
                 properties: {
                     granularity: {
                         type: 'string',
                         enum: ['daily', 'monthly'],
-                        description: 'Aggregation level (default: daily)',
+                        description: 'daily or monthly (default: daily)',
                     },
                     limit: {
                         type: 'number',
-                        description: 'Number of snapshots to return',
+                        description: 'Number of snapshots (default: 30)',
                     },
                     since: {
                         type: 'string',
-                        description: 'Start date for snapshots (ISO format)',
+                        description: 'Start date (YYYY-MM-DD)',
                     },
                 },
             },
+            annotations: { readOnlyHint: true },
         },
         {
             name: 'verify_key',
-            description: 'Check if the Warm API key is valid and working.',
+            description: 'Check if API key is valid and working.',
             inputSchema: {
                 type: 'object',
                 properties: {},
             },
+            annotations: { readOnlyHint: true },
         },
     ],
 }));
@@ -136,37 +168,62 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         switch (name) {
             case 'get_accounts': {
-                const params = {};
-                if (args?.since)
-                    params.since = String(args.since);
-                const data = await apiRequest('/api/accounts', params);
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+                const data = await apiRequest('/api/accounts');
+                return { content: [{ type: 'text', text: JSON.stringify(data) }] };
             }
             case 'get_transactions': {
-                const params = {};
-                if (args?.limit)
-                    params.limit = String(args.limit);
-                if (args?.since)
-                    params.last_knowledge = String(args.since);
-                if (args?.cursor)
-                    params.cursor = String(args.cursor);
-                const data = await apiRequest('/api/transactions', params);
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+                const search = args?.search ? String(args.search) : undefined;
+                const since = args?.since ? String(args.since) : undefined;
+                const until = args?.until ? String(args.until) : undefined;
+                const requestedLimit = args?.limit ? Math.min(Number(args.limit), 200) : 50;
+                // Fetch more if filtering, since we'll reduce the set
+                const fetchLimit = search || until ? Math.min(requestedLimit * 10, 1000) : requestedLimit;
+                const params = { limit: String(fetchLimit) };
+                if (since)
+                    params.last_knowledge = since;
+                const response = (await apiRequest('/api/transactions', params));
+                let transactions = (response.transactions || []);
+                // Apply date range filter (until is client-side since API only supports since)
+                if (until) {
+                    transactions = transactions.filter((t) => inDateRange(t, since, until));
+                }
+                // Apply search filter
+                if (search) {
+                    transactions = transactions.filter((t) => matchesSearch(t, search));
+                }
+                // Convert to compact format
+                const compactTxns = transactions.map(compactTransaction);
+                // Calculate summary on ALL matching transactions
+                const summary = calculateSummary(compactTxns);
+                // Apply limit for display
+                const limited = compactTxns.slice(0, requestedLimit);
+                const truncated = compactTxns.length > requestedLimit;
+                // Build compact result
+                const result = { summary, txns: limited };
+                if (truncated) {
+                    result.more = compactTxns.length - requestedLimit;
+                }
+                // Size check and reduce if needed
+                let output = JSON.stringify(result);
+                if (output.length > MAX_RESPONSE_SIZE) {
+                    const reducedCount = Math.floor(limited.length * (MAX_RESPONSE_SIZE / output.length) * 0.8);
+                    result.txns = limited.slice(0, reducedCount);
+                    result.more = compactTxns.length - reducedCount;
+                    output = JSON.stringify(result);
+                }
+                return { content: [{ type: 'text', text: output }] };
             }
             case 'get_recurring': {
-                const params = {};
-                if (args?.since)
-                    params.since = String(args.since);
-                const data = await apiRequest('/api/recurring', params);
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+                const response = (await apiRequest('/api/transactions', { limit: '1' }));
+                const recurring = response.recurring || [];
+                return { content: [{ type: 'text', text: JSON.stringify({ recurring }) }] };
             }
             case 'get_snapshots': {
-                const response = (await apiRequest('/api/transactions', {
-                    limit: '1',
-                }));
+                const response = (await apiRequest('/api/transactions', { limit: '1' }));
                 const snapshots = response.snapshots || [];
                 const granularity = args?.granularity || 'daily';
-                const limit = args?.limit ? Number(args.limit) : granularity === 'daily' ? 100 : 0;
+                const defaultLimit = granularity === 'daily' ? 30 : 0;
+                const limit = args?.limit ? Number(args.limit) : defaultLimit;
                 const since = args?.since;
                 let filtered = snapshots;
                 if (since) {
@@ -176,8 +233,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const byMonth = new Map();
                     filtered.forEach((s) => {
                         const month = String(s.snapshot_date).substring(0, 7);
-                        if (!byMonth.has(month) ||
-                            String(s.snapshot_date) > String(byMonth.get(month).snapshot_date)) {
+                        if (!byMonth.has(month) || String(s.snapshot_date) > String(byMonth.get(month).snapshot_date)) {
                             byMonth.set(month, s);
                         }
                     });
@@ -187,23 +243,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (limit > 0) {
                     filtered = filtered.slice(0, limit);
                 }
-                const result = {
-                    granularity,
-                    snapshots: filtered.map((s) => ({
-                        date: s.snapshot_date,
-                        ...(granularity === 'monthly' && {
-                            month: String(s.snapshot_date).substring(0, 7),
-                        }),
-                        net_worth: s.net_worth,
-                        total_assets: s.total_assets,
-                        total_liabilities: s.total_liabilities,
-                    })),
-                };
-                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                // Compact output
+                const result = filtered.map((s) => ({
+                    d: s.snapshot_date,
+                    nw: s.net_worth,
+                    a: s.total_assets,
+                    l: s.total_liabilities,
+                }));
+                return { content: [{ type: 'text', text: JSON.stringify({ granularity, snapshots: result }) }] };
             }
             case 'verify_key': {
                 const data = await apiRequest('/api/verify');
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+                return { content: [{ type: 'text', text: JSON.stringify(data) }] };
             }
             default:
                 throw new Error(`Unknown tool: ${name}`);
@@ -212,7 +263,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return {
-            content: [{ type: 'text', text: JSON.stringify({ error: message }, null, 2) }],
+            content: [{ type: 'text', text: JSON.stringify({ error: message }) }],
             isError: true,
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warmio/mcp",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "MCP server for Warm Financial API",
   "type": "module",
   "main": "dist/index.js",