actual-jev 0.1.0

package/dist/args.test.js

@@ -0,0 +1,84 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { parseArgs } from './args.js';
+void test('defaults to interactive and supports every option', () => {
+    assert.deepEqual(parseArgs([]), {
+        command: 'run',
+        mode: 'interactive',
+        threshold: 0.9,
+        account: undefined,
+        from: undefined,
+        to: undefined,
+        dataDir: undefined,
+        help: false,
+    });
+    assert.deepEqual(parseArgs([
+        '--auto',
+        '--threshold',
+        '0',
+        '--account',
+        'Checking',
+        '--from',
+        '2024-02-29',
+        '--to',
+        '2024-03-01',
+        '--data-dir',
+        '/tmp/budget',
+        '-h',
+    ]), {
+        command: 'run',
+        mode: 'auto',
+        threshold: 0,
+        account: 'Checking',
+        from: '2024-02-29',
+        to: '2024-03-01',
+        dataDir: '/tmp/budget',
+        help: true,
+    });
+    assert.equal(parseArgs(['--dry-run', '--threshold', '1']).mode, 'dry-run');
+    assert.equal(parseArgs(['--interactive', '--help']).help, true);
+});
+void test('repeated value flags use their last value, but repeated modes are errors', () => {
+    assert.equal(parseArgs(['--threshold', '0.2', '--threshold', '1']).threshold, 1);
+    assert.equal(parseArgs(['--account', 'first', '--account', 'second']).account, 'second');
+    for (const modes of [
+        ['--auto', '--auto'],
+        ['--interactive', '--dry-run'],
+    ]) {
+        assert.throws(() => parseArgs(modes), /Choose only one mode/);
+    }
+});
+void test('validates values and unknown options even when help is requested', () => {
+    for (const flag of ['--threshold', '--max-examples-per-category', '--account', '--from', '--to', '--data-dir']) {
+        for (const tail of [[], [''], ['--help']]) {
+            assert.throws(() => parseArgs([flag, ...tail]), /requires a value/);
+        }
+    }
+    for (const value of ['NaN', 'Infinity', '-0.1', '1.1']) {
+        assert.throws(() => parseArgs(['--threshold', value]), /between 0 and 1/);
+    }
+    for (const value of ['2025-02-29', '2026-04-31', '2026-13-01', '2026-1-01']) {
+        assert.throws(() => parseArgs(['--from', value]), /valid YYYY-MM-DD/);
+    }
+    assert.throws(() => parseArgs(['--from', '2026-09-02', '--to', '2026-09-01']), /on or before/);
+    assert.throws(() => parseArgs(['--help', '--unknown']), /Unknown option/);
+    // A short flag is accepted as a string value, matching the original parser.
+    assert.equal(parseArgs(['--account', '-h']).account, '-h');
+});
+void test('supports setup, config show, and explicit environment files', () => {
+    assert.equal(parseArgs(['setup']).command, 'setup');
+    assert.equal(parseArgs(['setup', '--help']).help, true);
+    assert.equal(parseArgs(['config', 'show', '--env-file', '/tmp/test.env']).envFile, '/tmp/test.env');
+    assert.equal(parseArgs(['--env-file', '/tmp/test.env', '--dry-run']).mode, 'dry-run');
+    assert.throws(() => parseArgs(['--env-file']), /requires a value/);
+    assert.throws(() => parseArgs(['setup', '--auto']), /setup accepts/);
+    assert.throws(() => parseArgs(['config', 'show', '--auto']), /config show accepts/);
+    assert.throws(() => parseArgs(['config']), /Unknown option/);
+});
+void test('example limit is a per-run flag, including zero to disable history', () => {
+    assert.equal(parseArgs(['--max-examples-per-category', '0']).maxExamplesPerCategory, 0);
+    assert.equal(parseArgs(['--max-examples-per-category', '100']).maxExamplesPerCategory, 100);
+    for (const value of ['-1', '1.5', '101', 'NaN', 'Infinity']) {
+        assert.throws(() => parseArgs(['--max-examples-per-category', value]), /integer between 0 and 100/);
+    }
+});

package/dist/choices.d.ts

@@ -0,0 +1,8 @@
+import { Separator } from '@inquirer/search';
+import type { CategoryCandidate } from './classifier.js';
+export declare const SKIP_LABEL = "Skip this transaction";
+export declare function categoryChoices(categories: readonly CategoryCandidate[], term?: string): (Separator | {
+    name: string;
+    value: string | null;
+    short: string;
+})[];

package/dist/choices.js

@@ -0,0 +1,26 @@
+import { Separator } from '@inquirer/search';
+export const SKIP_LABEL = 'Skip this transaction';
+export function categoryChoices(categories, term) {
+    const query = term?.trim().toLocaleLowerCase() ?? '';
+    const choices = [
+        { name: SKIP_LABEL, value: null, short: 'Skipped' },
+    ];
+    const groups = new Map();
+    for (const category of categories) {
+        if (query &&
+            !category.name.toLocaleLowerCase().includes(query) &&
+            !category.groupName.toLocaleLowerCase().includes(query)) {
+            continue;
+        }
+        const group = groups.get(category.groupName) ?? [];
+        group.push(category);
+        groups.set(category.groupName, group);
+    }
+    for (const [groupName, group] of groups) {
+        choices.push(new Separator(`── ${groupName} ──`));
+        for (const category of group) {
+            choices.push({ name: category.name, value: category.id, short: `${groupName} / ${category.name}` });
+        }
+    }
+    return choices;
+}

package/dist/choices.test.d.ts

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

package/dist/choices.test.js

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { Separator } from '@inquirer/search';
+import { categoryChoices } from './choices.js';
+const categories = [
+    { id: 'groceries', name: 'Groceries', groupName: 'Food' },
+    { id: 'bus', name: 'Bus', groupName: 'Transport' },
+    { id: 'restaurants', name: 'Restaurants', groupName: 'Food' },
+];
+function labels(term) {
+    return categoryChoices(categories, term).map((choice) => choice instanceof Separator ? choice.separator : choice.name);
+}
+void test('shows every category under its group with Skip first', () => {
+    assert.deepEqual(labels(), [
+        'Skip this transaction',
+        '── Food ──',
+        'Groceries',
+        'Restaurants',
+        '── Transport ──',
+        'Bus',
+    ]);
+    const choices = categoryChoices(categories);
+    assert.deepEqual(choices.flatMap((choice) => ('value' in choice ? [choice.value] : [])), [null, 'groceries', 'restaurants', 'bus']);
+});
+void test('searches names and group names without empty group headings', () => {
+    assert.deepEqual(labels('gRoC'), ['Skip this transaction', '── Food ──', 'Groceries']);
+    assert.deepEqual(labels('food'), ['Skip this transaction', '── Food ──', 'Groceries', 'Restaurants']);
+    assert.deepEqual(labels('absent'), ['Skip this transaction']);
+});

package/dist/classifier.d.ts

@@ -0,0 +1,56 @@
+import { choice, type EntryType } from '@typesafe-ai/sdk';
+export interface CategoryCandidate {
+    id: string;
+    name: string;
+    groupName: string;
+    isIncome?: boolean;
+    note?: string;
+}
+export interface TransactionDetails {
+    id?: string;
+    payeeName?: string;
+    importedPayee?: string;
+    notes?: string;
+    amount?: number;
+    date?: string;
+    accountName?: string;
+    payeeDefaultCategoryId?: string;
+}
+export interface CategorizedExample extends TransactionDetails {
+    categoryId: string;
+}
+export interface RankedCategory extends CategoryCandidate {
+    probability: number;
+}
+export interface Classification {
+    categoryId: string | null;
+    confidence: number;
+    candidates: RankedCategory[];
+    noMatchProbability: number;
+    requiresReview?: boolean;
+}
+export interface JevChoiceClient {
+    systemOne(request: {
+        state: EntryType;
+        model: string;
+        questions: {
+            category: ReturnType<typeof choice>;
+        };
+    }): Promise<{
+        answers: {
+            category: {
+                choice: string;
+                confidence: number;
+                probabilities: Record<string, number>;
+            };
+        };
+    }>;
+}
+export interface ClassifierOptions {
+    client?: JevChoiceClient;
+    model?: string;
+    examples?: readonly CategorizedExample[];
+    maxExamplesPerCategory?: number;
+}
+/** Ask Jev to choose among caller-supplied Actual category IDs. Never writes to Actual. */
+export declare function classifyTransaction(transaction: TransactionDetails, categories: readonly CategoryCandidate[], options?: ClassifierOptions): Promise<Classification>;

package/dist/classifier.js

@@ -0,0 +1,147 @@
+import { choice } from '@typesafe-ai/sdk';
+const NO_MATCH = 'none_of_the_above';
+function exampleLimit(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 100) {
+        throw new RangeError(`${name} must be an integer between 0 and 100`);
+    }
+    return value;
+}
+function normalized(value) {
+    return (value ?? '')
+        .toLocaleLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .trim();
+}
+function words(value) {
+    return new Set(normalized(value)
+        .split(' ')
+        .filter((word) => word.length > 2));
+}
+function relevantExamples(transaction, examples, categoryIds, maxExamplesPerCategory) {
+    if (maxExamplesPerCategory === 0)
+        return [];
+    const payee = normalized(transaction.payeeName);
+    const imported = normalized(transaction.importedPayee);
+    const terms = words(`${transaction.payeeName ?? ''} ${transaction.importedPayee ?? ''} ${transaction.notes ?? ''}`);
+    const ranked = examples.flatMap((example, index) => {
+        if (!categoryIds.has(example.categoryId) || (transaction.id && example.id === transaction.id))
+            return [];
+        const exactPayee = Boolean(payee && payee === normalized(example.payeeName));
+        const exactImported = Boolean(imported && imported === normalized(example.importedPayee));
+        const overlap = [
+            ...words(`${example.payeeName ?? ''} ${example.importedPayee ?? ''} ${example.notes ?? ''}`),
+        ].filter((word) => terms.has(word)).length;
+        if (!exactPayee && !exactImported && overlap < 2)
+            return [];
+        const sameDirection = transaction.amount !== undefined &&
+            example.amount !== undefined &&
+            Math.sign(transaction.amount) === Math.sign(example.amount);
+        const score = Number(exactPayee) * 100 + Number(exactImported) * 60 + overlap * 5 + Number(sameDirection);
+        return [{ example, score, index }];
+    });
+    ranked.sort((a, b) => b.score - a.score || (b.example.date ?? '').localeCompare(a.example.date ?? '') || a.index - b.index);
+    const counts = new Map();
+    const selected = [];
+    for (const { example } of ranked) {
+        const count = counts.get(example.categoryId) ?? 0;
+        if (count >= maxExamplesPerCategory)
+            continue;
+        selected.push(example);
+        counts.set(example.categoryId, count + 1);
+    }
+    return selected;
+}
+function probability(value, label) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error(`Jev returned an invalid ${label}`);
+    }
+    return value;
+}
+/** Ask Jev to choose among caller-supplied Actual category IDs. Never writes to Actual. */
+export async function classifyTransaction(transaction, categories, options = {}) {
+    const maxExamplesPerCategory = exampleLimit(options.maxExamplesPerCategory ?? 3, 'maxExamplesPerCategory');
+    if (categories.length === 0) {
+        return { categoryId: null, confidence: 0, candidates: [], noMatchProbability: 1 };
+    }
+    if (categories.length > 254) {
+        throw new RangeError('Jev Choice supports at most 254 categories plus the no-match option');
+    }
+    const seen = new Set();
+    const criteria = {};
+    const byOption = new Map();
+    const optionById = new Map();
+    categories.forEach((category, index) => {
+        if (!category.id || !category.name || !category.groupName || seen.has(category.id)) {
+            throw new TypeError('Categories must have unique nonempty IDs, names, and group names');
+        }
+        seen.add(category.id);
+        const option = `category_${index}`;
+        const note = category.note?.trim().slice(0, 400);
+        criteria[option] =
+            `${category.groupName} / ${category.name}${category.isIncome ? ' (income)' : ''}${note ? `. Category note: ${note}` : ''}`;
+        byOption.set(option, category);
+        optionById.set(category.id, option);
+    });
+    criteria[NO_MATCH] = 'No listed category reasonably describes this transaction';
+    const examples = relevantExamples(transaction, options.examples ?? [], seen, maxExamplesPerCategory);
+    const state = {
+        transaction: {
+            payee: transaction.payeeName ?? null,
+            imported_payee: transaction.importedPayee ?? null,
+            notes: transaction.notes ?? null,
+            amount_minor_units: transaction.amount ?? null,
+            date: transaction.date ?? null,
+            account: transaction.accountName ?? null,
+        },
+        payee_default_category: optionById.get(transaction.payeeDefaultCategoryId ?? '') ?? null,
+        relevant_examples: examples.map((example) => ({
+            payee: example.payeeName ?? null,
+            imported_payee: example.importedPayee ?? null,
+            notes: example.notes ?? null,
+            amount_minor_units: example.amount ?? null,
+            category: optionById.get(example.categoryId),
+        })),
+    };
+    const client = options.client;
+    if (!client)
+        throw new TypeError('A configured Jev client is required');
+    const response = await client.systemOne({
+        model: options.model ?? 'jev-latest',
+        state,
+        questions: {
+            category: choice('Which available budget category best describes the transaction? Use its details, category notes, and relevant examples. Examples show past choices, not rules. Use none_of_the_above if none fits. Amounts are in minor currency units; negative amounts are expenses.', criteria),
+        },
+    });
+    const answer = response.answers.category;
+    const confidence = probability(answer.confidence, 'confidence');
+    if (answer.choice !== NO_MATCH && !byOption.has(answer.choice)) {
+        throw new Error(`Jev selected an unknown category option: ${answer.choice}`);
+    }
+    const candidates = [...byOption]
+        .map(([option, category]) => ({
+        ...category,
+        probability: probability(answer.probabilities[option], `probability for ${option}`),
+    }))
+        .sort((a, b) => b.probability - a.probability);
+    const noMatchProbability = probability(answer.probabilities[NO_MATCH], 'no-match probability');
+    const selectedId = answer.choice === NO_MATCH ? null : byOption.get(answer.choice).id;
+    const payee = normalized(transaction.payeeName);
+    const importedPayee = normalized(transaction.importedPayee);
+    const matchingPayee = (maxExamplesPerCategory ? (options.examples ?? []) : []).filter((example) => seen.has(example.categoryId) &&
+        !(transaction.id && example.id === transaction.id) &&
+        ((payee && payee === normalized(example.payeeName)) ||
+            (!payee && importedPayee && importedPayee === normalized(example.importedPayee))));
+    const historicalCategories = new Set(matchingPayee.map((example) => example.categoryId));
+    const requiresReview = Boolean(selectedId &&
+        (historicalCategories.size > 1 ||
+            (transaction.payeeDefaultCategoryId &&
+                transaction.payeeDefaultCategoryId !== selectedId &&
+                !historicalCategories.has(selectedId))));
+    return {
+        categoryId: selectedId,
+        confidence,
+        candidates,
+        noMatchProbability,
+        requiresReview,
+    };
+}

package/dist/classifier.test.d.ts

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

package/dist/classifier.test.js

@@ -0,0 +1,257 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { classifyTransaction } from './classifier.js';
+const categories = [
+    { id: 'food-id', name: 'Groceries', groupName: 'Food' },
+    { id: 'travel-id', name: 'Train', groupName: 'Travel' },
+];
+function mock(choice, confidence = 0.8) {
+    return {
+        systemOne(request) {
+            assert.equal(request.model, 'jev-latest');
+            assert.equal(request.questions.category.criteria.category_0, 'Food / Groceries');
+            assert.equal(request.state.transaction.imported_payee, 'Fresh Market');
+            return Promise.resolve({
+                answers: {
+                    category: {
+                        choice,
+                        confidence,
+                        probabilities: { category_0: 0.7, category_1: 0.2, none_of_the_above: 0.1 },
+                    },
+                },
+            });
+        },
+    };
+}
+void test('maps Jev options back to category IDs and ranks alternatives', async () => {
+    const result = await classifyTransaction({ importedPayee: 'Fresh Market', amount: -2300 }, categories, {
+        client: mock('category_0'),
+    });
+    assert.equal(result.categoryId, 'food-id');
+    assert.equal(result.confidence, 0.8);
+    assert.deepEqual(result.candidates.map((candidate) => candidate.id), ['food-id', 'travel-id']);
+});
+void test('returns no-match without inventing a category', async () => {
+    const result = await classifyTransaction({ importedPayee: 'Fresh Market' }, categories, {
+        client: mock('none_of_the_above'),
+    });
+    assert.equal(result.categoryId, null);
+    assert.equal(result.noMatchProbability, 0.1);
+});
+void test('rejects selections that were not offered', async () => {
+    await assert.rejects(classifyTransaction({ importedPayee: 'Fresh Market' }, categories, { client: mock('category_999') }), /unknown category option/);
+});
+void test('does not call Jev when no categories are available', async () => {
+    const result = await classifyTransaction({}, [], { client: mock('category_0') });
+    assert.equal(result.categoryId, null);
+});
+void test('rejects malformed confidences and probabilities', async () => {
+    for (const value of [NaN, Infinity, -0.1, 1.1, undefined, '0.5', null]) {
+        for (const field of ['confidence', 'category_0', 'none_of_the_above']) {
+            const client = {
+                async systemOne(request) {
+                    const response = await mock('category_0').systemOne(request);
+                    if (field === 'confidence')
+                        Object.assign(response.answers.category, { confidence: value });
+                    else
+                        Object.assign(response.answers.category.probabilities, { [field]: value });
+                    return response;
+                },
+            };
+            const message = field === 'confidence'
+                ? 'confidence'
+                : field === 'category_0'
+                    ? 'probability for category_0'
+                    : 'no-match probability';
+            await assert.rejects(classifyTransaction({ importedPayee: 'Fresh Market' }, categories, { client }), {
+                message: `Jev returned an invalid ${message}`,
+            });
+        }
+    }
+});
+void test('validates category IDs, labels, and limits before contacting Jev', async () => {
+    const client = {
+        systemOne: () => {
+            throw new Error('Unexpected request');
+        },
+    };
+    for (const invalid of [
+        [categories[0], categories[0]],
+        [{ id: '', name: 'Food', groupName: 'Living' }],
+        [{ id: 'food', name: '', groupName: 'Living' }],
+        [{ id: 'food', name: 'Food', groupName: '' }],
+    ]) {
+        await assert.rejects(classifyTransaction({}, invalid, { client }), TypeError);
+    }
+    const tooMany = Array.from({ length: 255 }, (_, i) => ({ id: `${i}`, name: 'Category', groupName: 'Group' }));
+    await assert.rejects(classifyTransaction({}, tooMany, { client }), RangeError);
+});
+void test('accepts the category limit, forwards state and model, and ranks by probability', async () => {
+    const catalog = Array.from({ length: 254 }, (_, i) => ({
+        id: `${i}`,
+        name: `Category ${i}`,
+        groupName: 'Group',
+        isIncome: i === 253,
+    }));
+    const client = {
+        systemOne(request) {
+            assert.equal(request.model, 'custom-model');
+            assert.deepEqual(request.state, {
+                transaction: {
+                    payee: 'Employer',
+                    imported_payee: null,
+                    notes: 'Salary',
+                    amount_minor_units: 10000,
+                    date: '2026-09-01',
+                    account: 'Checking',
+                },
+                payee_default_category: null,
+                relevant_examples: [],
+            });
+            assert.equal(Object.keys(request.questions.category.criteria).length, 255);
+            assert.equal(request.questions.category.criteria.category_253, 'Group / Category 253 (income)');
+            return Promise.resolve({
+                answers: {
+                    category: {
+                        choice: 'category_253',
+                        confidence: 1,
+                        probabilities: {
+                            ...Object.fromEntries(catalog.map((_, i) => [`category_${i}`, i === 253 ? 1 : 0])),
+                            none_of_the_above: 0,
+                        },
+                    },
+                },
+            });
+        },
+    };
+    const result = await classifyTransaction({ payeeName: 'Employer', notes: 'Salary', amount: 10000, date: '2026-09-01', accountName: 'Checking' }, catalog, { client, model: 'custom-model' });
+    assert.equal(result.categoryId, '253');
+    assert.equal(result.candidates[0]?.id, '253');
+    assert.equal(result.confidence, 1);
+});
+void test('uses contrasting history and notes, but requires review for a mixed-payee history', async () => {
+    const catalog = [
+        { id: 'groceries', name: 'Groceries', groupName: 'Food', note: 'Food to prepare at home' },
+        { id: 'restaurants', name: 'Restaurants', groupName: 'Food', note: 'Prepared meals and deli lunches' },
+    ];
+    const examples = [
+        {
+            id: 'old-grocery',
+            categoryId: 'groceries',
+            payeeName: 'Fresh Market',
+            notes: 'Weekly groceries',
+            amount: -6200,
+        },
+        { id: 'old-lunch', categoryId: 'restaurants', payeeName: 'Fresh Market', notes: 'Deli lunch', amount: -1300 },
+        { id: 'self', categoryId: 'groceries', payeeName: 'Fresh Market', notes: 'Self' },
+        { id: 'hidden', categoryId: 'hidden', payeeName: 'Fresh Market', notes: 'Hidden' },
+    ];
+    const client = {
+        systemOne(request) {
+            const description = request.questions.category.criteria.category_1;
+            assert.equal(typeof description, 'string');
+            assert.match(description, /Prepared meals and deli lunches/);
+            const state = request.state;
+            assert.equal(state.payee_default_category, 'category_0');
+            assert.deepEqual(state.relevant_examples.map((example) => [example.notes, example.category]), [
+                ['Deli lunch', 'category_1'],
+                ['Weekly groceries', 'category_0'],
+            ]);
+            return Promise.resolve({
+                answers: {
+                    category: {
+                        choice: 'category_1',
+                        confidence: 0.99,
+                        probabilities: { category_0: 0.01, category_1: 0.99, none_of_the_above: 0 },
+                    },
+                },
+            });
+        },
+    };
+    const result = await classifyTransaction({
+        id: 'self',
+        payeeName: 'Fresh Market',
+        notes: 'Lunch sandwich',
+        amount: -1450,
+        payeeDefaultCategoryId: 'groceries',
+    }, catalog, { client, examples });
+    assert.equal(result.categoryId, 'restaurants');
+    assert.equal(result.requiresReview, true);
+});
+void test('keeps history bounded and ignores irrelevant examples', async () => {
+    const examples = Array.from({ length: 30 }, (_, i) => ({
+        categoryId: i % 2 ? 'travel-id' : 'food-id',
+        payeeName: 'Fresh Market',
+        notes: `Visit ${i}`,
+    }));
+    examples.push({ categoryId: 'travel-id', payeeName: 'Other Store', notes: 'Unrelated' });
+    const client = {
+        systemOne(request) {
+            const state = request.state;
+            assert.equal(state.relevant_examples.length, 6);
+            assert.ok(state.relevant_examples.every((example) => example.payee === 'Fresh Market'));
+            return mock('category_0').systemOne(request);
+        },
+    };
+    await classifyTransaction({ payeeName: 'Fresh Market', importedPayee: 'Fresh Market' }, categories, {
+        client,
+        examples,
+    });
+});
+void test('honors the per-category limit, including zero', async () => {
+    const examples = Array.from({ length: 8 }, (_, i) => ({
+        id: `example-${i}`,
+        categoryId: i % 2 ? 'travel-id' : 'food-id',
+        payeeName: 'Fresh Market',
+    }));
+    const lengths = [];
+    const client = {
+        systemOne(request) {
+            const state = request.state;
+            lengths.push(state.relevant_examples.length);
+            return Promise.resolve({
+                answers: {
+                    category: {
+                        choice: 'category_0',
+                        confidence: 0.8,
+                        probabilities: { category_0: 0.8, category_1: 0.1, none_of_the_above: 0.1 },
+                    },
+                },
+            });
+        },
+    };
+    const transaction = { importedPayee: 'Fresh Market' };
+    await classifyTransaction(transaction, categories, { client, examples, maxExamplesPerCategory: 2 });
+    await classifyTransaction(transaction, categories, { client, examples, maxExamplesPerCategory: 0 });
+    assert.deepEqual(lengths, [4, 0]);
+    await assert.rejects(classifyTransaction(transaction, categories, { client, maxExamplesPerCategory: -1 }), RangeError);
+});
+void test('includes relevant examples from all 20 categories without a total cap', async () => {
+    const catalog = Array.from({ length: 20 }, (_, index) => ({
+        id: `category-id-${index}`,
+        name: `Category ${index}`,
+        groupName: 'Group',
+    }));
+    const examples = catalog.map((category) => ({ categoryId: category.id, payeeName: 'Shared Shop' }));
+    const client = {
+        systemOne(request) {
+            const state = request.state;
+            assert.equal(state.relevant_examples.length, 20);
+            assert.equal(new Set(state.relevant_examples.map((example) => example.category)).size, 20);
+            assert.equal(Object.keys(request.questions.category.criteria).length, 21);
+            return Promise.resolve({
+                answers: {
+                    category: {
+                        choice: 'category_0',
+                        confidence: 1,
+                        probabilities: {
+                            ...Object.fromEntries(catalog.map((_, index) => [`category_${index}`, index === 0 ? 1 : 0])),
+                            none_of_the_above: 0,
+                        },
+                    },
+                },
+            });
+        },
+    };
+    await classifyTransaction({ payeeName: 'Shared Shop' }, catalog, { client, examples });
+});

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export { parseArgs } from './args.js';