@dizzlkheinz/ynab-mcpb 0.17.0 → 0.18.0

package/src/__tests__/smoke.e2e.test.ts

@@ -0,0 +1,70 @@
+/**
+ * End-to-end smoke tests for YNAB MCP Server
+ *
+ * These tests require a real YNAB API key but only perform read operations
+ * to verify connectivity and basic functionality without hitting rate limits.
+ *
+ * NOTE: This file was intentionally reduced from comprehensive CRUD workflow tests
+ * to lightweight smoke tests. The full E2E test suite was removed because:
+ * 1. YNAB API rate limits (200 requests/hour) made full E2E runs unreliable in CI
+ * 2. Comprehensive integration tests with mocked APIs provide better coverage
+ * 3. Smoke tests validate real API connectivity without rate limit pressure
+ *
+ * For full workflow testing, see integration tests in src/tools/__tests__/
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { YNABMCPServer } from '../server/YNABMCPServer.js';
+import {
+  getTestConfig,
+  createTestServer,
+  executeToolCall,
+  parseToolResult,
+  validateOutputSchema,
+} from './testUtils.js';
+
+const runE2ETests = process.env['SKIP_E2E_TESTS'] !== 'true';
+const describeE2E = runE2ETests ? describe : describe.skip;
+
+describeE2E('YNAB MCP Server - Smoke Tests', () => {
+  let server: YNABMCPServer;
+  let testConfig: ReturnType<typeof getTestConfig>;
+
+  beforeAll(async () => {
+    testConfig = getTestConfig();
+
+    if (testConfig.skipE2ETests) {
+      console.warn('Skipping E2E smoke tests - no real API key or SKIP_E2E_TESTS=true');
+      return;
+    }
+
+    server = await createTestServer();
+  });
+
+  it('should authenticate and retrieve user information', async () => {
+    if (testConfig.skipE2ETests) return;
+
+    const result = await executeToolCall(server, 'ynab:get_user');
+
+    // Validate output schema
+    const validation = validateOutputSchema(server, 'get_user', result);
+    expect(validation.valid).toBe(true);
+
+    const data = parseToolResult(result);
+    expect(data.data.user).toBeDefined();
+    expect(data.data.user.id).toBeDefined();
+  });
+
+  it('should list budgets', async () => {
+    if (testConfig.skipE2ETests) return;
+
+    const result = await executeToolCall(server, 'ynab:list_budgets');
+
+    // Validate output schema
+    const validation = validateOutputSchema(server, 'list_budgets', result);
+    expect(validation.valid).toBe(true);
+
+    const data = parseToolResult(result);
+    expect(Array.isArray(data.data.budgets)).toBe(true);
+  });
+});

package/src/__tests__/testUtils.ts

@@ -3,7 +3,7 @@
  */
 
 import { expect } from 'vitest';
-import { YNABMCPServer } from '../server/YNABMCPServer.js';
+import type { YNABMCPServer } from '../server/YNABMCPServer.js';
 import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 
@@ -40,6 +40,7 @@ export async function createTestServer(): Promise<YNABMCPServer> {
     throw new Error('YNAB_ACCESS_TOKEN is required for testing');
   }
 
+  const { YNABMCPServer } = await import('../server/YNABMCPServer.js');
   return new YNABMCPServer();
 }
 
@@ -366,118 +367,6 @@ export const TestData = {
   },
 };
 
-/**
- * Test data cleanup utilities
- */
-export class TestDataCleanup {
-  private createdAccountIds: string[] = [];
-  private createdTransactionIds: string[] = [];
-
-  /**
-   * Track created account for cleanup
-   */
-  trackAccount(accountId: string): void {
-    this.createdAccountIds.push(accountId);
-  }
-
-  /**
-   * Track created transaction for cleanup
-   */
-  trackTransaction(transactionId: string): void {
-    this.createdTransactionIds.push(transactionId);
-  }
-
-  /**
-   * Clean up all tracked test data
-   */
-  async cleanup(server: YNABMCPServer, budgetId: string): Promise<void> {
-    // Clean up transactions first (they depend on accounts)
-    for (const transactionId of this.createdTransactionIds) {
-      try {
-        await executeToolCall(server, 'ynab:delete_transaction', {
-          budget_id: budgetId,
-          transaction_id: transactionId,
-        });
-      } catch (error) {
-        console.warn(`Failed to cleanup transaction ${transactionId}:`, error);
-      }
-    }
-
-    // Note: YNAB API doesn't support deleting accounts via API
-    // Accounts created during testing will need manual cleanup
-    if (this.createdAccountIds.length > 0) {
-      console.warn(
-        `Created ${this.createdAccountIds.length} test accounts that need manual cleanup:`,
-        this.createdAccountIds,
-      );
-    }
-
-    this.createdAccountIds = [];
-    this.createdTransactionIds = [];
-  }
-}
-
-/**
- * Assertion helpers for YNAB data
- */
-export const YNABAssertions = {
-  /**
-   * Assert budget structure
-   */
-  assertBudget(budget: any): void {
-    expect(budget).toBeDefined();
-    expect(typeof budget.id).toBe('string');
-    expect(typeof budget.name).toBe('string');
-    expect(typeof budget.last_modified_on).toBe('string');
-  },
-
-  /**
-   * Assert account structure
-   */
-  assertAccount(account: any): void {
-    expect(account).toBeDefined();
-    expect(typeof account.id).toBe('string');
-    expect(typeof account.name).toBe('string');
-    expect(typeof account.type).toBe('string');
-    expect(typeof account.on_budget).toBe('boolean');
-    expect(typeof account.closed).toBe('boolean');
-    expect(typeof account.balance).toBe('number');
-  },
-
-  /**
-   * Assert transaction structure
-   */
-  assertTransaction(transaction: any): void {
-    expect(transaction).toBeDefined();
-    expect(typeof transaction.id).toBe('string');
-    expect(typeof transaction.date).toBe('string');
-    expect(typeof transaction.amount).toBe('number');
-    expect(typeof transaction.account_id).toBe('string');
-    expect(['cleared', 'uncleared', 'reconciled']).toContain(transaction.cleared);
-  },
-
-  /**
-   * Assert category structure
-   */
-  assertCategory(category: any): void {
-    expect(category).toBeDefined();
-    expect(typeof category.id).toBe('string');
-    expect(typeof category.name).toBe('string');
-    expect(typeof category.category_group_id).toBe('string');
-    expect(typeof category.budgeted).toBe('number');
-    expect(typeof category.activity).toBe('number');
-    expect(typeof category.balance).toBe('number');
-  },
-
-  /**
-   * Assert payee structure
-   */
-  assertPayee(payee: any): void {
-    expect(payee).toBeDefined();
-    expect(typeof payee.id).toBe('string');
-    expect(typeof payee.name).toBe('string');
-  },
-};
 /**
  * Determine whether a value represents a rate-limit (HTTP 429 / "too many requests") error.
  *

package/src/server/YNABMCPServer.ts

@@ -11,6 +11,9 @@ import {
   ListPromptsRequestSchema,
   ReadResourceRequestSchema,
   GetPromptRequestSchema,
+  CompleteRequestSchema,
+  ErrorCode,
+  McpError,
 } from '@modelcontextprotocol/sdk/types.js';
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import * as ynab from 'ynab';
@@ -36,7 +39,7 @@ import { registerUtilityTools } from '../tools/utilityTools.js';
 import { emptyObjectSchema } from '../tools/schemas/common.js';
 import { cacheManager, CacheManager } from './cacheManager.js';
 import { responseFormatter } from './responseFormatter.js';
-import { ToolRegistry, type ToolDefinition } from './toolRegistry.js';
+import { ToolRegistry, type ToolDefinition, type ProgressCallback } from './toolRegistry.js';
 import { ResourceManager } from './resources.js';
 import { PromptManager } from './prompts.js';
 import { DiagnosticManager } from './diagnostics.js';
@@ -44,6 +47,7 @@ import { ServerKnowledgeStore } from './serverKnowledgeStore.js';
 import { DeltaCache } from './deltaCache.js';
 import { DeltaFetcher } from '../tools/deltaFetcher.js';
 import { ToolAnnotationPresets } from '../tools/toolCategories.js';
+import { CompletionsManager } from './completions.js';
 
 /**
  * YNAB MCP Server class that provides integration with You Need A Budget API
@@ -63,6 +67,7 @@ export class YNABMCPServer {
   private deltaFetcher: DeltaFetcher;
   private diagnosticManager: DiagnosticManager;
   private errorHandler: ErrorHandler;
+  private completionsManager: CompletionsManager;
 
   constructor(exitOnError: boolean = true) {
     this.exitOnError = exitOnError;
@@ -84,9 +89,13 @@ export class YNABMCPServer {
       },
       {
         capabilities: {
-          tools: { listChanged: true },
-          resources: { listChanged: true },
-          prompts: { listChanged: true },
+          tools: { listChanged: false },
+          resources: {
+            subscribe: false, // YNAB API has no webhooks; subscriptions not applicable
+            listChanged: false,
+          },
+          prompts: { listChanged: false },
+          completions: {},
         },
       },
     );
@@ -173,6 +182,12 @@ export class YNABMCPServer {
       deltaCache: this.deltaCache,
     });
 
+    this.completionsManager = new CompletionsManager(
+      this.ynabAPI,
+      cacheManager,
+      () => this.defaultBudgetId,
+    );
+
     this.setupToolRegistry();
     this.setupHandlers();
   }
@@ -247,11 +262,7 @@ export class YNABMCPServer {
     // Handle read resource requests
     this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
       const { uri } = request.params;
-      try {
-        return await this.resourceManager.readResource(uri);
-      } catch (error) {
-        return this.errorHandler.handleError(error, `reading resource: ${uri}`);
-      }
+      return await this.resourceManager.readResource(uri);
     });
 
     // Handle list prompts requests
@@ -275,7 +286,10 @@ export class YNABMCPServer {
     });
 
     // Handle tool call requests
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+      if (!this.toolRegistry.hasTool(request.params.name)) {
+        throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${request.params.name}`);
+      }
       const rawArgs = (request.params.arguments ?? undefined) as
         | Record<string, unknown>
         | undefined;
@@ -296,6 +310,7 @@ export class YNABMCPServer {
         accessToken: string;
         arguments: Record<string, unknown>;
         minifyOverride?: boolean;
+        sendProgress?: ProgressCallback;
       } = {
         name: request.params.name,
         accessToken: this.configInstance.YNAB_ACCESS_TOKEN,
@@ -306,8 +321,47 @@ export class YNABMCPServer {
         executionOptions.minifyOverride = minifyOverride;
       }
 
+      // Create progress callback if client provided a progressToken
+      const progressToken = (request.params as { _meta?: { progressToken?: string | number } })
+        ._meta?.progressToken;
+      if (progressToken !== undefined && extra.sendNotification) {
+        executionOptions.sendProgress = async (params) => {
+          try {
+            await extra.sendNotification({
+              method: 'notifications/progress',
+              params: {
+                progressToken,
+                progress: params.progress,
+                ...(params.total !== undefined && { total: params.total }),
+                ...(params.message !== undefined && { message: params.message }),
+              },
+            });
+          } catch {
+            // Progress notifications are non-critical; allow tool execution to continue.
+          }
+        };
+      }
+
       return await this.toolRegistry.executeTool(executionOptions);
     });
+
+    // Handle completion requests for autocomplete
+    this.server.setRequestHandler(CompleteRequestSchema, async (request) => {
+      const { argument, context } = request.params;
+
+      // Get completions from the manager, handling optional context
+      const completionContext = context?.arguments ? { arguments: context.arguments } : undefined;
+      const result = await this.completionsManager.getCompletions(
+        argument.name,
+        argument.value,
+        completionContext,
+      );
+
+      // Return in MCP-compliant format
+      return {
+        completion: result.completion,
+      };
+    });
   }
 
   /**

package/src/server/__tests__/YNABMCPServer.test.ts

@@ -45,7 +45,6 @@ describe('YNABMCPServer', () => {
     'get_month',
     'list_months',
     'get_user',
-    'convert_amount',
     'diagnostic_info',
     'clear_cache',
     'set_output_format',

package/src/server/__tests__/completions.integration.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import type { YNABMCPServer } from '../YNABMCPServer.js';
+import { getTestConfig, createTestServer } from '../../__tests__/testUtils.js';
+
+/**
+ * Integration tests for CompletionsManager
+ * Tests completions functionality with real or mocked YNAB API
+ */
+describe('CompletionsManager Integration', () => {
+  let server: YNABMCPServer;
+  let testConfig: ReturnType<typeof getTestConfig>;
+
+  beforeAll(async () => {
+    testConfig = getTestConfig();
+
+    if (testConfig.skipE2ETests) {
+      console.warn('Skipping CompletionsManager integration tests - no real API key');
+      return;
+    }
+
+    server = await createTestServer();
+  });
+
+  beforeEach(() => {
+    if (testConfig.skipE2ETests) {
+      return;
+    }
+  });
+
+  describe('Budget Completions', () => {
+    it('should complete budget names from real API', async () => {
+      if (testConfig.skipE2ETests) return;
+
+      const completionsManager = (
+        server as unknown as {
+          completionsManager: {
+            getCompletions: (
+              arg: string,
+              val: string,
+            ) => Promise<{ completion: { values: string[]; total: number } }>;
+          };
+        }
+      ).completionsManager;
+
+      if (!completionsManager) {
+        console.warn('CompletionsManager not exposed on server - skipping test');
+        return;
+      }
+
+      const result = await completionsManager.getCompletions('budget_id', '');
+
+      expect(result.completion).toBeDefined();
+      expect(Array.isArray(result.completion.values)).toBe(true);
+      // Should have at least one budget
+      expect(result.completion.total).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('Account Completions', () => {
+    it('should require budget context for account completions', async () => {
+      if (testConfig.skipE2ETests) return;
+
+      const completionsManager = (
+        server as unknown as {
+          completionsManager: {
+            getCompletions: (
+              arg: string,
+              val: string,
+              ctx?: unknown,
+            ) => Promise<{ completion: { values: string[]; total: number } }>;
+          };
+        }
+      ).completionsManager;
+
+      if (!completionsManager) {
+        console.warn('CompletionsManager not exposed on server - skipping test');
+        return;
+      }
+
+      // Without budget context, should return empty
+      const result = await completionsManager.getCompletions('account_id', 'check');
+
+      expect(result.completion).toBeDefined();
+      expect(Array.isArray(result.completion.values)).toBe(true);
+    });
+  });
+
+  describe('MCP Completion Handler Integration', () => {
+    it('should handle completion requests through MCP server', async () => {
+      if (testConfig.skipE2ETests) return;
+
+      const mcpServer = server.getServer();
+
+      // The MCP server should have completion capability
+      expect(mcpServer).toBeDefined();
+
+      // Note: Full MCP completion request testing would require
+      // setting up the complete MCP request/response flow
+      // This is a basic smoke test for integration
+    });
+  });
+});
+
+/**
+ * Mock-based integration tests that don't require real API
+ */
+describe('CompletionsManager Mock Integration', () => {
+  it('should be importable and constructible', async () => {
+    const { CompletionsManager } = await import('../completions.js');
+    expect(CompletionsManager).toBeDefined();
+  });
+
+  it('should export correct types', async () => {
+    const module = await import('../completions.js');
+    expect(module.CompletionsManager).toBeDefined();
+  });
+});