@dizzlkheinz/ynab-mcpb 0.16.1 → 0.17.1

package/dist/tools/utilityTools.js

@@ -1,12 +1,8 @@
-import { z } from 'zod/v4';
-import { withToolErrorHandling } from '../types/index.js';
 import { responseFormatter } from '../server/responseFormatter.js';
-export const ConvertAmountSchema = z
-    .object({
-    amount: z.number().finite(),
-    to_milliunits: z.boolean(),
-})
-    .strict();
+import { withToolErrorHandling } from '../types/index.js';
+import { createAdapters } from './adapters.js';
+import { emptyObjectSchema } from './schemas/common.js';
+import { ToolAnnotationPresets } from './toolCategories.js';
 export async function handleGetUser(ynabAPI) {
     return await withToolErrorHandling(async () => {
         const response = await ynabAPI.user.getUser();
@@ -24,33 +20,18 @@ export async function handleGetUser(ynabAPI) {
         };
     }, 'ynab:get_user', 'getting user information');
 }
-export async function handleConvertAmount(params) {
-    return await withToolErrorHandling(async () => {
-        const { amount, to_milliunits } = params;
-        let result;
-        let description;
-        if (to_milliunits) {
-            result = Math.round(amount * 1000);
-            description = `$${amount.toFixed(2)} = ${result} milliunits`;
-        }
-        else {
-            result = amount / 1000;
-            description = `${amount} milliunits = $${result.toFixed(2)}`;
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: responseFormatter.format({
-                        conversion: {
-                            original_amount: amount,
-                            converted_amount: result,
-                            to_milliunits,
-                            description,
-                        },
-                    }),
-                },
-            ],
-        };
-    }, 'ynab:convert_amount', 'converting amount');
-}
+export const registerUtilityTools = (registry, context) => {
+    const { adaptNoInput } = createAdapters(context);
+    registry.register({
+        name: 'get_user',
+        description: 'Get information about the authenticated user',
+        inputSchema: emptyObjectSchema,
+        handler: adaptNoInput(handleGetUser),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: Get User Information',
+            },
+        },
+    });
+};

package/dist/types/index.d.ts

@@ -18,3 +18,4 @@ export { RequestLogger, globalRequestLogger, type LogEntry, type LoggerConfig, }
 export { SecurityMiddleware, withSecurityWrapper, type SecurityContext, } from '../server/securityMiddleware.js';
 export type { MCPToolAnnotations } from './toolAnnotations.js';
 export type { ToolDefinition } from '../server/toolRegistry.js';
+export type { ToolContext, ToolFactory, BudgetIdResolverFactory } from './toolRegistration.js';

package/dist/types/toolRegistration.d.ts

@@ -0,0 +1,27 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import * as ynab from 'ynab';
+import type { ToolRegistry, ToolExecutionPayload, DefaultArgumentResolver } from '../server/toolRegistry.js';
+import type { DeltaFetcher } from '../tools/deltaFetcher.js';
+import type { DeltaCache } from '../server/deltaCache.js';
+import type { ServerKnowledgeStore } from '../server/serverKnowledgeStore.js';
+import type { DiagnosticManager } from '../server/diagnostics.js';
+import type { CacheManager } from '../server/cacheManager.js';
+export interface ToolContext {
+    ynabAPI: ynab.API;
+    deltaFetcher: DeltaFetcher;
+    deltaCache: DeltaCache;
+    serverKnowledgeStore: ServerKnowledgeStore;
+    getDefaultBudgetId: () => string | undefined;
+    setDefaultBudget: (budgetId: string) => void;
+    cacheManager: CacheManager;
+    diagnosticManager?: DiagnosticManager;
+}
+export type ToolFactory = (registry: ToolRegistry, context: ToolContext) => void;
+export type Adapter<TInput extends Record<string, unknown>> = (payload: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
+export type Handler<TInput extends Record<string, unknown>> = (api: ynab.API, params: TInput) => Promise<CallToolResult>;
+export type DeltaHandler<TInput extends Record<string, unknown>> = (api: ynab.API, deltaFetcher: DeltaFetcher, params: TInput) => Promise<CallToolResult>;
+export type WriteHandler<TInput extends Record<string, unknown>> = (api: ynab.API, deltaCache: DeltaCache, serverKnowledgeStore: ServerKnowledgeStore, params: TInput) => Promise<CallToolResult>;
+export type NoInputHandler = (api: ynab.API) => Promise<CallToolResult>;
+export type BudgetIdResolverFactory = <TInput extends {
+    budget_id?: string | undefined;
+}>() => DefaultArgumentResolver<TInput>;

package/dist/types/toolRegistration.js

@@ -0,0 +1 @@
+export {};

package/docs/maintainers/npm-publishing.md

@@ -0,0 +1,27 @@
+# npm publishing (maintainers)
+
+This repo publishes the package `@dizzlkheinz/ynab-mcpb` to the public npm registry via GitHub Actions (`.github/workflows/publish.yml`).
+
+## Trusted publishing (OIDC)
+
+This package is configured as a **Trusted Publisher** on npm (OIDC). With that enabled, the publish workflow does **not** need an npm token and can still work even if the package is set to “disallow tokens”.
+
+Note: `npm whoami` will still fail in CI under OIDC; authentication happens only during `npm publish`.
+
+## Common failure: `npm ERR! need auth`
+
+This error means the runner has no valid auth for `https://registry.npmjs.org/`.
+
+Checklist:
+
+- The Trusted Publisher entry matches exactly (repo, workflow filename `publish.yml`, and environment `npm-publish`).
+- The workflow has `permissions: id-token: write`.
+- You’re using a recent npm CLI (the workflow uses Node `24`).
+- For first-time scoped publishes, the workflow uses `npm publish --access public`.
+
+## Local manual publish (optional)
+
+```bash
+npm adduser
+npm publish --access public
+```

package/docs/reference/API.md

@@ -49,10 +49,10 @@ The server automatically converts YNAB's internal milliunits to dollars in all r
 - Budget amounts: `150.00` (instead of `150000` milliunits)
 
 **Input formats**:
-- When creating transactions, amounts should be provided in milliunits (as per YNAB API requirements)
-- Use the `convert_amount` tool to convert between dollars and milliunits if needed
+- When creating transactions, amounts should be provided in dollars (e.g., `50.25`)
+- The server automatically converts to YNAB's internal milliunit format
 
-**Legacy behavior**: YNAB's internal representation uses milliunits (1/1000th of currency unit), but this is now transparent to users
+**Note**: YNAB's internal representation uses milliunits (1/1000th of currency unit), but this is now transparent to users - all inputs and outputs use standard dollar amounts
 
 ### Dates
 
@@ -1227,60 +1227,6 @@ Gets information about the authenticated user.
 }
 ```
 
-### convert_amount
-
-Converts between dollars and milliunits with integer arithmetic for precision.
-
-**Parameters:**
-- `amount` (number, required): The amount to convert
-- `to_milliunits` (boolean, required): If true, convert from dollars to milliunits. If false, convert from milliunits to dollars
-
-**Example Request (dollars to milliunits):**
-```json
-{
-  "name": "convert_amount",
-  "arguments": {
-    "amount": 50.25,
-    "to_milliunits": true
-  }
-}
-```
-
-**Example Response:**
-```json
-{
-  "content": [
-    {
-      "type": "text",
-      "text": "{\n  \"original_amount\": 50.25,\n  \"converted_amount\": 50250,\n  \"conversion_type\": \"dollars_to_milliunits\"\n}"
-    }
-  ]
-}
-```
-
-**Example Request (milliunits to dollars):**
-```json
-{
-  "name": "convert_amount",
-  "arguments": {
-    "amount": 50250,
-    "to_milliunits": false
-  }
-}
-```
-
-**Example Response:**
-```json
-{
-  "content": [
-    {
-      "type": "text",
-      "text": "{\n  \"original_amount\": 50250,\n  \"converted_amount\": 50.25,\n  \"conversion_type\": \"milliunits_to_dollars\"\n}"
-    }
-  ]
-}
-```
-
 ## Diagnostic Tools
 
 These tools help inspect the server, environment, and performance. They do not modify YNAB data.
@@ -1549,24 +1495,23 @@ const recentTransactions = await mcpClient.callTool('list_transactions', {
 });
 ```
 
-### 4. Amount Conversions
+### 4. Amount Handling
 
-Use the conversion utility for user-friendly displays:
+All amounts are automatically handled in dollars:
 
 ```javascript
-// Convert milliunits to dollars for display
-const dollarsResult = await mcpClient.callTool('convert_amount', {
-  amount: 50250,
-  to_milliunits: false
-});
-console.log(`Amount: $${dollarsResult.converted_amount}`); // Amount: $50.25
+// All returned amounts are in dollars - no conversion needed
+const accounts = await mcpClient.callTool('list_accounts', { budget_id: budgetId });
+console.log(`Balance: $${accounts.accounts[0].balance}`); // Balance: $1234.56
 
-// Convert user input to milliunits for API calls
-const milliUnitsResult = await mcpClient.callTool('convert_amount', {
-  amount: 50.25,
-  to_milliunits: true
+// When creating transactions, provide amounts in dollars
+await mcpClient.callTool('create_transaction', {
+  budget_id: budgetId,
+  account_id: accountId,
+  amount: -50.25,  // Negative for outflows
+  date: '2024-01-15',
+  payee_name: 'Coffee Shop'
 });
-// Use milliUnitsResult.converted_amount in transaction creation
 ```
 
 ### 5. Caching Strategies