@slothmoney/agent-cli 0.1.0 → 0.3.0

package/dist/args.js

@@ -47,6 +47,47 @@ function requireNonEmpty(value, name) {
         throw new UsageError(`${name} requires a value`);
     return value;
 }
+function parseGoalAmount(value, name) {
+    if (!/^\d+(?:\.\d{1,2})?$/.test(value)) {
+        throw new UsageError(`${name} must be a positive amount with at most two decimal places`);
+    }
+    const amount = Number(value);
+    if (!Number.isFinite(amount) || amount <= 0) {
+        throw new UsageError(`${name} must be a positive amount with at most two decimal places`);
+    }
+    return amount;
+}
+function parseGoalMonthKey(value, name) {
+    if (!/^\d{4}-(0[1-9]|1[0-2])$/.test(value)) {
+        throw new UsageError(`${name} must be a valid YYYY-MM month`);
+    }
+    return value;
+}
+function parseExplicitBoolean(value, name) {
+    if (value !== 'true' && value !== 'false') {
+        throw new UsageError(`${name} must be true or false`);
+    }
+    return value === 'true';
+}
+function parseGoalName(value) {
+    const name = value.trim();
+    if (name.length > 200) {
+        throw new UsageError('--name must be at most 200 characters');
+    }
+    return name;
+}
+function parseGoalId(value) {
+    const goalId = value.trim();
+    if (goalId.length > 500
+        || goalId.includes('/')
+        || Array.from(goalId).some((character) => {
+            const codePoint = character.codePointAt(0);
+            return codePoint !== undefined && (codePoint < 32 || codePoint === 127);
+        })) {
+        throw new UsageError('--goal-id must be a valid goal document ID');
+    }
+    return goalId;
+}
 function parseTransactions(args) {
     const filters = {};
     for (let index = 0; index < args.length; index += 1) {
@@ -73,6 +114,7 @@ function parseTransactions(args) {
             '--q',
             '--account-id',
             '--category-id',
+            '--assignment-scope',
             '--cursor',
         ]);
         if (!name || !supported.has(name)) {
@@ -108,6 +150,12 @@ function parseTransactions(args) {
         else if (name === '--category-id') {
             filters.categoryId = setOnce(filters.categoryId, value, name);
         }
+        else if (name === '--assignment-scope') {
+            if (value !== 'personal' && value !== 'joint') {
+                throw new UsageError('--assignment-scope must be personal or joint');
+            }
+            filters.assignmentScope = setOnce(filters.assignmentScope, value, name);
+        }
         else if (name === '--cursor') {
             filters.cursor = setOnce(filters.cursor, value, name);
         }
@@ -122,15 +170,273 @@ function parseTransactions(args) {
 function withBaseUrl(value, baseUrl) {
     return baseUrl === undefined ? value : { ...value, baseUrl };
 }
+function parseAuth(args, baseUrl) {
+    const authCommand = args.shift();
+    if (!authCommand) {
+        throw new UsageError('auth requires login, status, or logout');
+    }
+    if (authCommand === 'login') {
+        let input;
+        for (const argument of args) {
+            if (argument === '--token-stdin') {
+                if (input === 'stdin') {
+                    throw new UsageError('--token-stdin may only be provided once');
+                }
+                if (input === 'environment') {
+                    throw new UsageError('--token-stdin and --from-env are mutually exclusive');
+                }
+                input = 'stdin';
+            }
+            else if (argument === '--from-env') {
+                if (input === 'environment') {
+                    throw new UsageError('--from-env may only be provided once');
+                }
+                if (input === 'stdin') {
+                    throw new UsageError('--token-stdin and --from-env are mutually exclusive');
+                }
+                input = 'environment';
+            }
+            else {
+                throw new UsageError(`Unknown auth login option: ${argument}`);
+            }
+        }
+        return withBaseUrl({ command: 'auth-login', input: input ?? 'prompt' }, baseUrl);
+    }
+    if (authCommand === 'status' || authCommand === 'logout') {
+        if (args.length > 0) {
+            throw new UsageError(`Unknown auth ${authCommand} option: ${args[0]}`);
+        }
+        return withBaseUrl({ command: `auth-${authCommand}` }, baseUrl);
+    }
+    throw new UsageError(`Unknown auth command: ${authCommand}`);
+}
+function parseGoals(args, baseUrl) {
+    const subcommand = args.shift();
+    if (subcommand === undefined || subcommand === 'list') {
+        if (args.length > 0) {
+            throw new UsageError(`Unknown goals list option: ${args[0]}`);
+        }
+        return withBaseUrl({ command: 'goals-list' }, baseUrl);
+    }
+    if (subcommand === 'create') {
+        let name;
+        let targetAmount;
+        let targetMonthKey;
+        let apply = false;
+        for (let index = 0; index < args.length; index += 1) {
+            const argument = args[index];
+            if (argument === '--apply') {
+                if (apply)
+                    throw new UsageError('--apply may only be provided once');
+                apply = true;
+                continue;
+            }
+            const [option, inlineValue] = argument.includes('=')
+                ? argument.split(/=(.*)/s, 2)
+                : [argument, undefined];
+            if (option !== '--name'
+                && option !== '--target-amount'
+                && option !== '--target-month') {
+                throw new UsageError(`Unknown goals create option: ${argument}`);
+            }
+            const value = requireNonEmpty(inlineValue ?? readOptionValue(args, index, option), option);
+            if (inlineValue === undefined)
+                index += 1;
+            if (option === '--name') {
+                name = setOnce(name, parseGoalName(value), option);
+            }
+            else if (option === '--target-amount') {
+                targetAmount = setOnce(targetAmount, parseGoalAmount(value, option), option);
+            }
+            else {
+                targetMonthKey = setOnce(targetMonthKey, parseGoalMonthKey(value, option), option);
+            }
+        }
+        if (!name)
+            throw new UsageError('goals create requires --name <name>');
+        return withBaseUrl({
+            command: 'goals-create',
+            name,
+            ...(targetAmount === undefined ? {} : { targetAmount }),
+            ...(targetMonthKey === undefined ? {} : { targetMonthKey }),
+            apply,
+        }, baseUrl);
+    }
+    if (subcommand === 'update') {
+        let goalId;
+        let name;
+        let targetAmount;
+        let targetMonthKey;
+        let isAchieved;
+        let apply = false;
+        for (let index = 0; index < args.length; index += 1) {
+            const argument = args[index];
+            if (argument === '--apply') {
+                if (apply)
+                    throw new UsageError('--apply may only be provided once');
+                apply = true;
+                continue;
+            }
+            if (argument === '--clear-target-amount') {
+                if (targetAmount !== undefined) {
+                    throw new UsageError('--target-amount and --clear-target-amount are mutually exclusive');
+                }
+                targetAmount = null;
+                continue;
+            }
+            if (argument === '--clear-target-month') {
+                if (targetMonthKey !== undefined) {
+                    throw new UsageError('--target-month and --clear-target-month are mutually exclusive');
+                }
+                targetMonthKey = null;
+                continue;
+            }
+            const [option, inlineValue] = argument.includes('=')
+                ? argument.split(/=(.*)/s, 2)
+                : [argument, undefined];
+            if (option !== '--goal-id'
+                && option !== '--name'
+                && option !== '--target-amount'
+                && option !== '--target-month'
+                && option !== '--achieved') {
+                throw new UsageError(`Unknown goals update option: ${argument}`);
+            }
+            const value = requireNonEmpty(inlineValue ?? readOptionValue(args, index, option), option);
+            if (inlineValue === undefined)
+                index += 1;
+            if (option === '--goal-id') {
+                goalId = setOnce(goalId, parseGoalId(value), option);
+            }
+            else if (option === '--name') {
+                name = setOnce(name, parseGoalName(value), option);
+            }
+            else if (option === '--target-amount') {
+                if (targetAmount !== undefined) {
+                    throw new UsageError('--target-amount and --clear-target-amount are mutually exclusive');
+                }
+                targetAmount = parseGoalAmount(value, option);
+            }
+            else if (option === '--target-month') {
+                if (targetMonthKey !== undefined) {
+                    throw new UsageError('--target-month and --clear-target-month are mutually exclusive');
+                }
+                targetMonthKey = parseGoalMonthKey(value, option);
+            }
+            else {
+                isAchieved = setOnce(isAchieved, parseExplicitBoolean(value, option), option);
+            }
+        }
+        if (!goalId)
+            throw new UsageError('goals update requires --goal-id <id>');
+        if (name === undefined
+            && targetAmount === undefined
+            && targetMonthKey === undefined
+            && isAchieved === undefined) {
+            throw new UsageError('goals update requires at least one field to update');
+        }
+        return withBaseUrl({
+            command: 'goals-update',
+            goalId,
+            ...(name === undefined ? {} : { name }),
+            ...(targetAmount === undefined ? {} : { targetAmount }),
+            ...(targetMonthKey === undefined ? {} : { targetMonthKey }),
+            ...(isAchieved === undefined ? {} : { isAchieved }),
+            apply,
+        }, baseUrl);
+    }
+    if (subcommand === 'delete') {
+        let goalId;
+        let apply = false;
+        for (let index = 0; index < args.length; index += 1) {
+            const argument = args[index];
+            if (argument === '--apply') {
+                if (apply)
+                    throw new UsageError('--apply may only be provided once');
+                apply = true;
+                continue;
+            }
+            const [option, inlineValue] = argument.includes('=')
+                ? argument.split(/=(.*)/s, 2)
+                : [argument, undefined];
+            if (option !== '--goal-id') {
+                throw new UsageError(`Unknown goals delete option: ${argument}`);
+            }
+            const value = requireNonEmpty(inlineValue ?? readOptionValue(args, index, option), option);
+            if (inlineValue === undefined)
+                index += 1;
+            goalId = setOnce(goalId, parseGoalId(value), option);
+        }
+        if (!goalId)
+            throw new UsageError('goals delete requires --goal-id <id>');
+        return withBaseUrl({
+            command: 'goals-delete',
+            goalId,
+            apply,
+        }, baseUrl);
+    }
+    throw new UsageError(`Unknown goals command: ${subcommand}`);
+}
+function helpTopic(argv) {
+    const positionals = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (argument === undefined)
+            continue;
+        if (argument === '--base-url') {
+            index += 1;
+            continue;
+        }
+        if (argument.startsWith('--base-url=') || argument.startsWith('-')) {
+            continue;
+        }
+        positionals.push(argument);
+    }
+    const [command, subcommand] = positionals;
+    if (command === 'auth') {
+        if (subcommand === 'login'
+            || subcommand === 'status'
+            || subcommand === 'logout') {
+            return `auth-${subcommand}`;
+        }
+        return 'auth';
+    }
+    if (command === 'goals') {
+        if (subcommand === 'list')
+            return 'goals-list';
+        if (subcommand === 'create')
+            return 'goals-create';
+        if (subcommand === 'update')
+            return 'goals-update';
+        if (subcommand === 'delete')
+            return 'goals-delete';
+        return 'goals';
+    }
+    if (command === 'categories'
+        || command === 'transactions'
+        || command === 'assign'
+        || command === 'joint-budget-settings'
+        || command === 'ask-partner') {
+        return command;
+    }
+    return undefined;
+}
 export function parseArgs(argv) {
-    if (argv.includes('--help') || argv.includes('-h'))
-        return { command: 'help' };
+    if (argv.includes('--help') || argv.includes('-h')) {
+        const topic = helpTopic(argv);
+        return topic ? { command: 'help', topic } : { command: 'help' };
+    }
     if (argv.includes('--version') || argv.includes('-V'))
         return { command: 'version' };
     const { args, baseUrl } = parseGlobalOptions(argv);
     const command = args.shift();
     if (!command)
         return { command: 'help' };
+    if (command === 'auth') {
+        return parseAuth(args, baseUrl);
+    }
+    if (command === 'goals') {
+        return parseGoals(args, baseUrl);
+    }
     if (command === 'categories') {
         if (args.length > 0) {
             throw new UsageError(`Unknown categories option: ${args[0]}`);
@@ -165,6 +471,43 @@ export function parseArgs(argv) {
             throw new UsageError('assign requires --input <file>');
         return withBaseUrl({ command, input, apply }, baseUrl);
     }
+    if (command === 'joint-budget-settings') {
+        let includeSharedPersonalTransactions;
+        let apply = false;
+        for (let index = 0; index < args.length; index += 1) {
+            const argument = args[index];
+            if (argument === '--apply') {
+                if (apply)
+                    throw new UsageError('--apply may only be provided once');
+                apply = true;
+                continue;
+            }
+            const optionName = '--include-shared-personal-transactions';
+            if (argument === optionName || argument.startsWith(`${optionName}=`)) {
+                const value = argument === optionName
+                    ? readOptionValue(args, index, optionName)
+                    : argument.slice(`${optionName}=`.length);
+                if (argument === optionName)
+                    index += 1;
+                if (value !== 'true' && value !== 'false') {
+                    throw new UsageError(`${optionName} must be true or false`);
+                }
+                includeSharedPersonalTransactions = setOnce(includeSharedPersonalTransactions, value === 'true', optionName);
+                continue;
+            }
+            throw new UsageError(`Unknown joint-budget-settings option: ${argument}`);
+        }
+        if (apply && includeSharedPersonalTransactions === undefined) {
+            throw new UsageError('--apply requires --include-shared-personal-transactions=true|false');
+        }
+        return withBaseUrl({
+            command,
+            ...(includeSharedPersonalTransactions === undefined
+                ? {}
+                : { includeSharedPersonalTransactions }),
+            apply,
+        }, baseUrl);
+    }
     if (command === 'ask-partner') {
         let transactionRef;
         for (let index = 0; index < args.length; index += 1) {