@dizzlkheinz/ynab-mcpb 0.18.3 → 0.19.0

package/src/tools/__tests__/adapters.test.ts

@@ -1,113 +1,147 @@
-import { describe, expect, it, vi } from 'vitest';
-import { DefaultArgumentResolutionError } from '../../server/toolRegistry.js';
-import type { ToolContext } from '../../types/toolRegistration.js';
-import { createAdapters, createBudgetResolver } from '../adapters.js';
-
-const createMockContext = (overrides: Partial<ToolContext> = {}): ToolContext => {
-  return {
-    ynabAPI: (overrides.ynabAPI ?? ({ budgets: {} } as unknown as any)) as ToolContext['ynabAPI'],
-    deltaFetcher: overrides.deltaFetcher ?? ({} as any),
-    deltaCache: overrides.deltaCache ?? ({} as any),
-    serverKnowledgeStore: overrides.serverKnowledgeStore ?? ({} as any),
-    getDefaultBudgetId:
-      overrides.getDefaultBudgetId ?? vi.fn(() => '123e4567-e89b-12d3-a456-426614174000'),
-    setDefaultBudget: overrides.setDefaultBudget ?? vi.fn(),
-    cacheManager: overrides.cacheManager ?? ({} as any),
-    diagnosticManager: overrides.diagnosticManager,
-  } satisfies ToolContext;
+import { describe, expect, it, vi } from "vitest";
+import { createErrorHandler } from "../../server/errorHandler.js";
+import { DefaultArgumentResolutionError } from "../../server/toolRegistry.js";
+import type { ToolContext } from "../../types/toolRegistration.js";
+import { createAdapters, createBudgetResolver } from "../adapters.js";
+
+const createMockErrorHandler = () =>
+	createErrorHandler({
+		format: (value: unknown) => JSON.stringify(value, null, 2),
+	});
+
+const createMockContext = (
+	overrides: Partial<ToolContext> = {},
+): ToolContext => {
+	return {
+		ynabAPI: (overrides.ynabAPI ??
+			({ budgets: {} } as unknown as any)) as ToolContext["ynabAPI"],
+		deltaFetcher: overrides.deltaFetcher ?? ({} as any),
+		deltaCache: overrides.deltaCache ?? ({} as any),
+		serverKnowledgeStore: overrides.serverKnowledgeStore ?? ({} as any),
+		getDefaultBudgetId:
+			overrides.getDefaultBudgetId ??
+			vi.fn(() => "123e4567-e89b-12d3-a456-426614174000"),
+		setDefaultBudget: overrides.setDefaultBudget ?? vi.fn(),
+		cacheManager: overrides.cacheManager ?? ({} as any),
+		errorHandler: overrides.errorHandler ?? createMockErrorHandler(),
+		diagnosticManager: overrides.diagnosticManager,
+	} satisfies ToolContext;
 };
 
-describe('createAdapters', () => {
-  it('adapt passes api and params to handler', async () => {
-    const context = createMockContext();
-    const { adapt } = createAdapters(context);
-    const handler = vi.fn().mockResolvedValue({ content: [] });
-
-    const adapted = adapt(handler);
-    await adapted({ input: { foo: 'bar' }, context: {} as any });
-
-    expect(handler).toHaveBeenCalledWith(context.ynabAPI, { foo: 'bar' });
-  });
-
-  it('adaptNoInput passes api without params', async () => {
-    const context = createMockContext();
-    const { adaptNoInput } = createAdapters(context);
-    const handler = vi.fn().mockResolvedValue({ content: [] });
-
-    const adapted = adaptNoInput(handler);
-    await adapted({ input: {}, context: {} as any });
-
-    expect(handler).toHaveBeenCalledWith(context.ynabAPI);
-  });
-
-  it('adaptWithDelta passes deltaFetcher to handler', async () => {
-    const deltaFetcher = { fetch: vi.fn() } as any;
-    const context = createMockContext({ deltaFetcher });
-    const { adaptWithDelta } = createAdapters(context);
-    const handler = vi.fn().mockResolvedValue({ content: [] });
-
-    const adapted = adaptWithDelta(handler);
-    await adapted({ input: { a: 1 }, context: {} as any });
-
-    expect(handler).toHaveBeenCalledWith(context.ynabAPI, deltaFetcher, { a: 1 });
-  });
-
-  it('adaptWrite passes cache and knowledge store to handler', async () => {
-    const deltaCache = { invalidate: vi.fn() } as any;
-    const serverKnowledgeStore = { update: vi.fn() } as any;
-    const context = createMockContext({ deltaCache, serverKnowledgeStore });
-    const { adaptWrite } = createAdapters(context);
-    const handler = vi.fn().mockResolvedValue({ content: [] });
-
-    const adapted = adaptWrite(handler);
-    await adapted({ input: { a: 2 }, context: {} as any });
-
-    expect(handler).toHaveBeenCalledWith(context.ynabAPI, deltaCache, serverKnowledgeStore, {
-      a: 2,
-    });
-  });
+describe("createAdapters", () => {
+	it("adapt passes api and params to handler", async () => {
+		const context = createMockContext();
+		const { adapt } = createAdapters(context);
+		const handler = vi.fn().mockResolvedValue({ content: [] });
+
+		const adapted = adapt(handler);
+		await adapted({ input: { foo: "bar" }, context: {} as any });
+
+		expect(handler).toHaveBeenCalledWith(
+			context.ynabAPI,
+			{ foo: "bar" },
+			context.errorHandler,
+		);
+	});
+
+	it("adaptNoInput passes api without params", async () => {
+		const context = createMockContext();
+		const { adaptNoInput } = createAdapters(context);
+		const handler = vi.fn().mockResolvedValue({ content: [] });
+
+		const adapted = adaptNoInput(handler);
+		await adapted({ input: {}, context: {} as any });
+
+		expect(handler).toHaveBeenCalledWith(context.ynabAPI, context.errorHandler);
+	});
+
+	it("adaptWithDelta passes deltaFetcher to handler", async () => {
+		const deltaFetcher = { fetch: vi.fn() } as any;
+		const context = createMockContext({ deltaFetcher });
+		const { adaptWithDelta } = createAdapters(context);
+		const handler = vi.fn().mockResolvedValue({ content: [] });
+
+		const adapted = adaptWithDelta(handler);
+		await adapted({ input: { a: 1 }, context: {} as any });
+
+		expect(handler).toHaveBeenCalledWith(
+			context.ynabAPI,
+			deltaFetcher,
+			{
+				a: 1,
+			},
+			context.errorHandler,
+		);
+	});
+
+	it("adaptWrite passes cache and knowledge store to handler", async () => {
+		const deltaCache = { invalidate: vi.fn() } as any;
+		const serverKnowledgeStore = { update: vi.fn() } as any;
+		const context = createMockContext({ deltaCache, serverKnowledgeStore });
+		const { adaptWrite } = createAdapters(context);
+		const handler = vi.fn().mockResolvedValue({ content: [] });
+
+		const adapted = adaptWrite(handler);
+		await adapted({ input: { a: 2 }, context: {} as any });
+
+		expect(handler).toHaveBeenCalledWith(
+			context.ynabAPI,
+			deltaCache,
+			serverKnowledgeStore,
+			{
+				a: 2,
+			},
+			context.errorHandler,
+		);
+	});
 });
 
-describe('createBudgetResolver', () => {
-  it('returns provided budget_id when supplied', () => {
-    const context = createMockContext({ getDefaultBudgetId: () => 'default-budget' });
-    const resolverFactory = createBudgetResolver(context);
-    const resolver = resolverFactory<{ budget_id?: string }>();
-
-    const result = resolver({
-      name: 'tool',
-      accessToken: 'token',
-      rawArguments: { budget_id: '123e4567-e89b-12d3-a456-426614174000' },
-    });
-
-    expect(result).toEqual({ budget_id: '123e4567-e89b-12d3-a456-426614174000' });
-  });
-
-  it('falls back to default budget id when not provided', () => {
-    const context = createMockContext({
-      getDefaultBudgetId: () => '89abcdef-0123-4567-89ab-cdef01234567',
-    });
-    const resolver = createBudgetResolver(context)<{ budget_id?: string }>();
-
-    const result = resolver({
-      name: 'tool',
-      accessToken: 'token',
-      rawArguments: {},
-    });
-
-    expect(result).toEqual({ budget_id: '89abcdef-0123-4567-89ab-cdef01234567' });
-  });
-
-  it('throws DefaultArgumentResolutionError when no budget id available', () => {
-    const context = createMockContext({ getDefaultBudgetId: () => undefined });
-    const resolver = createBudgetResolver(context)<{ budget_id?: string }>();
-
-    expect(() =>
-      resolver({
-        name: 'tool',
-        accessToken: 'token',
-        rawArguments: {},
-      }),
-    ).toThrow(DefaultArgumentResolutionError);
-  });
+describe("createBudgetResolver", () => {
+	it("returns provided budget_id when supplied", () => {
+		const context = createMockContext({
+			getDefaultBudgetId: () => "default-budget",
+		});
+		const resolverFactory = createBudgetResolver(context);
+		const resolver = resolverFactory<{ budget_id?: string }>();
+
+		const result = resolver({
+			name: "tool",
+			accessToken: "token",
+			rawArguments: { budget_id: "123e4567-e89b-12d3-a456-426614174000" },
+		});
+
+		expect(result).toEqual({
+			budget_id: "123e4567-e89b-12d3-a456-426614174000",
+		});
+	});
+
+	it("falls back to default budget id when not provided", () => {
+		const context = createMockContext({
+			getDefaultBudgetId: () => "89abcdef-0123-4567-89ab-cdef01234567",
+		});
+		const resolver = createBudgetResolver(context)<{ budget_id?: string }>();
+
+		const result = resolver({
+			name: "tool",
+			accessToken: "token",
+			rawArguments: {},
+		});
+
+		expect(result).toEqual({
+			budget_id: "89abcdef-0123-4567-89ab-cdef01234567",
+		});
+	});
+
+	it("throws DefaultArgumentResolutionError when no budget id available", () => {
+		const context = createMockContext({ getDefaultBudgetId: () => undefined });
+		const resolver = createBudgetResolver(context)<{ budget_id?: string }>();
+
+		expect(() =>
+			resolver({
+				name: "tool",
+				accessToken: "token",
+				rawArguments: {},
+			}),
+		).toThrow(DefaultArgumentResolutionError);
+	});
 });

package/src/tools/__tests__/budgetTools.delta.integration.test.ts

@@ -1,90 +1,90 @@
-import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
-import * as ynab from 'ynab';
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { handleListBudgets } from '../budgetTools.js';
-import { CacheManager } from '../../server/cacheManager.js';
-import { ServerKnowledgeStore } from '../../server/serverKnowledgeStore.js';
-import { DeltaCache } from '../../server/deltaCache.js';
-import { DeltaFetcher } from '../deltaFetcher.js';
-import { skipOnRateLimit } from '../../__tests__/testUtils.js';
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import * as ynab from "ynab";
+import { skipOnRateLimit } from "../../__tests__/testUtils.js";
+import { CacheManager } from "../../server/cacheManager.js";
+import { DeltaCache } from "../../server/deltaCache.js";
+import { ServerKnowledgeStore } from "../../server/serverKnowledgeStore.js";
+import { handleListBudgets } from "../budgetTools.js";
+import { DeltaFetcher } from "../deltaFetcher.js";
 
-const shouldSkip = ['true', '1', 'yes', 'y', 'on'].includes(
-  (process.env['SKIP_E2E_TESTS'] || '').toLowerCase().trim(),
+const shouldSkip = ["true", "1", "yes", "y", "on"].includes(
+	(process.env.SKIP_E2E_TESTS || "").toLowerCase().trim(),
 );
-const hasToken = !!process.env['YNAB_ACCESS_TOKEN'];
+const hasToken = !!process.env.YNAB_ACCESS_TOKEN;
 const skipTests = shouldSkip || !hasToken;
 const describeIntegration = skipTests ? describe.skip : describe;
 
-describeIntegration('Delta-backed budget tool handler', () => {
-  let ynabAPI: ynab.API;
-  let deltaFetcher: DeltaFetcher;
-  let previousNodeEnv: string | undefined;
+describeIntegration("Delta-backed budget tool handler", () => {
+	let ynabAPI: ynab.API;
+	let deltaFetcher: DeltaFetcher;
+	let previousNodeEnv: string | undefined;
 
-  beforeAll(async () => {
-    const accessToken = process.env['YNAB_ACCESS_TOKEN']!;
-    ynabAPI = new ynab.API(accessToken);
-  });
+	beforeAll(async () => {
+		const accessToken = process.env.YNAB_ACCESS_TOKEN!;
+		ynabAPI = new ynab.API(accessToken);
+	});
 
-  beforeEach(() => {
-    previousNodeEnv = process.env['NODE_ENV'];
-    process.env['NODE_ENV'] = 'integration';
-    const cacheManager = new CacheManager();
-    const knowledgeStore = new ServerKnowledgeStore();
-    const deltaCache = new DeltaCache(cacheManager, knowledgeStore);
-    deltaFetcher = new DeltaFetcher(ynabAPI, deltaCache);
-    process.env['YNAB_MCP_ENABLE_DELTA'] = 'true';
-  });
+	beforeEach(() => {
+		previousNodeEnv = process.env.NODE_ENV;
+		process.env.NODE_ENV = "integration";
+		const cacheManager = new CacheManager();
+		const knowledgeStore = new ServerKnowledgeStore();
+		const deltaCache = new DeltaCache(cacheManager, knowledgeStore);
+		deltaFetcher = new DeltaFetcher(ynabAPI, deltaCache);
+		process.env.YNAB_MCP_ENABLE_DELTA = "true";
+	});
 
-  afterEach(() => {
-    delete process.env['YNAB_MCP_ENABLE_DELTA'];
-    if (previousNodeEnv === undefined) {
-      delete process.env['NODE_ENV'];
-    } else {
-      process.env['NODE_ENV'] = previousNodeEnv;
-    }
-    previousNodeEnv = undefined;
-  });
+	afterEach(() => {
+		process.env.YNAB_MCP_ENABLE_DELTA = undefined;
+		if (previousNodeEnv === undefined) {
+			process.env.NODE_ENV = undefined;
+		} else {
+			process.env.NODE_ENV = previousNodeEnv;
+		}
+		previousNodeEnv = undefined;
+	});
 
-  const parseResponse = (result: CallToolResult) => {
-    const content = result.content?.[0];
-    if (!content || content.type !== 'text') {
-      throw new Error('Unexpected tool response format');
-    }
-    return JSON.parse(content.text);
-  };
-  const expectCacheHit = (payload: { cached: boolean; cache_info: string }) => {
-    expect(payload.cached).toBe(true);
-    expect(payload.cache_info).toMatch(/cache/i);
-  };
+	const parseResponse = (result: CallToolResult) => {
+		const content = result.content?.[0];
+		if (!content || content.type !== "text") {
+			throw new Error("Unexpected tool response format");
+		}
+		return JSON.parse(content.text);
+	};
+	const expectCacheHit = (payload: { cached: boolean; cache_info: string }) => {
+		expect(payload.cached).toBe(true);
+		expect(payload.cache_info).toMatch(/cache/i);
+	};
 
-  it(
-    'serves cached budget summaries on the second invocation',
-    { meta: { tier: 'domain', domain: 'delta' } },
-    async (ctx) => {
-      await skipOnRateLimit(async () => {
-        const firstCall = await handleListBudgets(ynabAPI, deltaFetcher, {});
-        const firstPayload = parseResponse(firstCall);
+	it(
+		"serves cached budget summaries on the second invocation",
+		{ meta: { tier: "domain", domain: "delta" } },
+		async (ctx) => {
+			await skipOnRateLimit(async () => {
+				const firstCall = await handleListBudgets(ynabAPI, deltaFetcher, {});
+				const firstPayload = parseResponse(firstCall);
 
-        // If response contains an error, throw it so skipOnRateLimit can catch it
-        if (firstPayload.error) {
-          throw new Error(JSON.stringify(firstPayload.error));
-        }
+				// If response contains an error, throw it so skipOnRateLimit can catch it
+				if (firstPayload.error) {
+					throw new Error(JSON.stringify(firstPayload.error));
+				}
 
-        expect(firstPayload.cached).toBe(false);
+				expect(firstPayload.cached).toBe(false);
 
-        const secondCall = await handleListBudgets(ynabAPI, deltaFetcher, {});
-        const secondPayload = parseResponse(secondCall);
+				const secondCall = await handleListBudgets(ynabAPI, deltaFetcher, {});
+				const secondPayload = parseResponse(secondCall);
 
-        // If response contains an error, throw it so skipOnRateLimit can catch it
-        if (secondPayload.error) {
-          throw new Error(JSON.stringify(secondPayload.error));
-        }
+				// If response contains an error, throw it so skipOnRateLimit can catch it
+				if (secondPayload.error) {
+					throw new Error(JSON.stringify(secondPayload.error));
+				}
 
-        expectCacheHit(secondPayload);
+				expectCacheHit(secondPayload);
 
-        // Verify cached response contains the same budget data as initial fetch
-        expect(secondPayload.budgets).toEqual(firstPayload.budgets);
-      }, ctx);
-    },
-  );
+				// Verify cached response contains the same budget data as initial fetch
+				expect(secondPayload.budgets).toEqual(firstPayload.budgets);
+			}, ctx);
+		},
+	);
 });