@yigemo/choosefire 0.1.0

package/dist/commands.js

@@ -0,0 +1,637 @@
+import { getBooleanFlag, getRepeatedStringFlag, getStringFlag, } from './args.js';
+import { authStatus, login, logout } from './auth.js';
+import { getAccountFinancialWorkspaceActivity, getAccountFinancialWorkspaceSnapshot, getAccountFinancialWorkspaceSummary, initializeAccountFinancialWorkspace, recordAccountFinancialWorkspaceFact, requestChooseFire, } from './http.js';
+import { randomUUID } from 'node:crypto';
+import { getFamilyWealthV2Activity, getFamilyWealthV2Overview, getFamilyWealthV2Summary, archiveFamilyWealthV2AssetAccount, createFamilyWealthV2AssetAccount, updateFamilyWealthV2AssetAccount, appendFamilyWealthV2Valuation, replaceFamilyWealthV2Classification, issueFamilyWealthV2McpDelegation, initializeFamilyWealthV2, revokeFamilyWealthV2McpDelegation, } from './family-wealth-v2-http.js';
+export async function runCommand(config, parsed, dependencies = {}) {
+    const [resource, action, maybeId] = parsed.positionals;
+    if (!resource || resource === 'help' || getBooleanFlag(parsed.flags, 'help')) {
+        return help();
+    }
+    if (resource === 'auth') {
+        return runAuthCommand(config, action, parsed);
+    }
+    if (resource === 'workspace') {
+        return runWorkspaceCommand(config, action, parsed, dependencies);
+    }
+    if (resource === 'household') {
+        return runHouseholdCommand(config, action, parsed, dependencies);
+    }
+    if (resource === 'activity') {
+        return runFamilyActivityCommand(config, action, parsed, dependencies);
+    }
+    if (resource === 'wealth') {
+        return runWealthCommand(config, action, parsed, dependencies);
+    }
+    if (resource === 'mcp') {
+        return runMcpCommand(config, action, maybeId, parsed, dependencies);
+    }
+    if (resource === 'plan') {
+        return runPlanCommand(config, action, maybeId, parsed);
+    }
+    if (resource === 'asset') {
+        return runAssetCommand(config, action, parsed);
+    }
+    if (resource === 'visual') {
+        return runVisualCommand(config, action, parsed);
+    }
+    throw new Error(`Unknown command: ${parsed.positionals.join(' ')}`);
+}
+async function runMcpCommand(config, action, maybeAction, parsed, dependencies) {
+    if (action !== 'token' || !maybeAction || parsed.positionals.length !== 3) {
+        throw new Error(`Unknown mcp command: ${action || ''}`);
+    }
+    if (maybeAction === 'issue') {
+        assertAllowedFlags(parsed, ['clientId', 'ttlSeconds']);
+        const ttlRaw = getStringFlag(parsed.flags, 'ttlSeconds');
+        const result = await issueFamilyWealthV2McpDelegation(config, {
+            clientId: requireFlag(parsed, 'clientId', '--client-id'),
+            ...(ttlRaw === undefined ? {} : { ttlSeconds: requiredIntegerFlag(parsed, 'ttlSeconds') }),
+        }, dependencies);
+        return getBooleanFlag(parsed.flags, 'json')
+            ? result
+            : [
+                'ChooseFIRE MCP 只读令牌已创建',
+                `客户端：${result.clientId}`,
+                `工作区：${result.workspaceId}`,
+                `有效期：${result.expiresIn} 秒`,
+                `令牌：${result.accessToken}`,
+            ].join('\n');
+    }
+    if (maybeAction === 'revoke') {
+        assertAllowedFlags(parsed, ['accessToken']);
+        const result = await revokeFamilyWealthV2McpDelegation(config, requireFlag(parsed, 'accessToken', '--access-token'), dependencies);
+        return getBooleanFlag(parsed.flags, 'json') ? result : 'ChooseFIRE MCP 只读令牌已撤销';
+    }
+    throw new Error(`Unknown mcp token command: ${maybeAction}`);
+}
+async function runHouseholdCommand(config, action, parsed, dependencies) {
+    if (parsed.positionals.length !== 2) {
+        throw new Error('Household commands do not accept additional positional arguments');
+    }
+    if (action === 'init') {
+        assertAllowedFlags(parsed, [
+            'commandId',
+            'idempotencyKey',
+            'baseCurrency',
+            'timezone',
+        ]);
+        const result = await initializeFamilyWealthV2(config, {
+            kind: 'workspace.initialize.v2',
+            commandId: getStringFlag(parsed.flags, 'commandId') ?? randomUUID(),
+            idempotencyKey: requireFlag(parsed, 'idempotencyKey', '--idempotency-key'),
+            expectedWorkspaceVersion: 0,
+            source: { clientId: 'choosefire-cli', channel: 'cli' },
+            payload: {
+                baseCurrency: requireFlag(parsed, 'baseCurrency', '--base-currency'),
+                timezone: requireFlag(parsed, 'timezone', '--timezone'),
+            },
+        }, dependencies);
+        return getBooleanFlag(parsed.flags, 'json')
+            ? result
+            : formatInitializeReceipt(result);
+    }
+    if (action === 'summary') {
+        assertAllowedFlags(parsed, []);
+        const result = await getFamilyWealthV2Summary(config, dependencies);
+        return getBooleanFlag(parsed.flags, 'json')
+            ? result
+            : formatWorkspaceSummary(result);
+    }
+    throw new Error(`Unknown household command: ${action || ''}`);
+}
+async function runFamilyActivityCommand(config, action, parsed, dependencies) {
+    if (action !== 'list' || parsed.positionals.length !== 2) {
+        throw new Error(`Unknown activity command: ${action || ''}`);
+    }
+    assertAllowedFlags(parsed, ['limit', 'cursor']);
+    const cursor = getStringFlag(parsed.flags, 'cursor');
+    const result = await getFamilyWealthV2Activity(config, {
+        limit: requiredIntegerFlag(parsed, 'limit'),
+        ...(cursor === undefined ? {} : { cursor }),
+    }, dependencies);
+    return getBooleanFlag(parsed.flags, 'json')
+        ? result
+        : formatActivityPage(result);
+}
+async function runWealthCommand(config, action, parsed, dependencies) {
+    if (parsed.positionals.length !== 2)
+        throw new Error('Wealth commands do not accept additional positional arguments');
+    if (action === 'overview') {
+        assertAllowedFlags(parsed, []);
+        const result = await getFamilyWealthV2Overview(config, dependencies);
+        return getBooleanFlag(parsed.flags, 'json') ? result : formatWealthOverview(result);
+    }
+    if (action === 'account-create') {
+        assertWealthFlags(parsed, [
+            'commandId', 'idempotencyKey', 'expectedWorkspaceVersion', 'accountId',
+            'name', 'accountType', 'ownerSubjectId', 'currency', 'visibility', 'maintenanceMode',
+        ]);
+        const command = {
+            kind: 'asset_account.create.v2',
+            commandId: getStringFlag(parsed.flags, 'commandId') ?? randomUUID(),
+            idempotencyKey: requireFlag(parsed, 'idempotencyKey', '--idempotency-key'),
+            expectedWorkspaceVersion: requiredIntegerFlag(parsed, 'expectedWorkspaceVersion'),
+            expectedObjectRevision: null,
+            source: { clientId: 'choosefire-cli', channel: 'cli' },
+            payload: {
+                accountId: requireFlag(parsed, 'accountId', '--account-id'),
+                account: {
+                    name: requireFlag(parsed, 'name', '--name'),
+                    accountType: requireFlag(parsed, 'accountType', '--account-type'),
+                    ownerSubjectId: requireFlag(parsed, 'ownerSubjectId', '--owner-subject-id'),
+                    visibility: (getStringFlag(parsed.flags, 'visibility') ?? 'household'),
+                    aggregationConsent: !getBooleanFlag(parsed.flags, 'noAggregationConsent'),
+                    currency: requireFlag(parsed, 'currency', '--currency'),
+                    maintenanceMode: (getStringFlag(parsed.flags, 'maintenanceMode') ?? 'simplified'),
+                },
+            },
+        };
+        const result = await createFamilyWealthV2AssetAccount(config, command, dependencies);
+        return getBooleanFlag(parsed.flags, 'json') ? result : formatMutationReceipt(result);
+    }
+    if (action === 'account-update') {
+        assertWealthFlags(parsed, [
+            'commandId', 'idempotencyKey', 'expectedWorkspaceVersion', 'expectedObjectRevision',
+            'accountId', 'name', 'accountType', 'ownerSubjectId', 'currency', 'visibility',
+            'maintenanceMode',
+        ]);
+        const command = {
+            kind: 'asset_account.update.v2',
+            commandId: getStringFlag(parsed.flags, 'commandId') ?? randomUUID(),
+            idempotencyKey: requireFlag(parsed, 'idempotencyKey', '--idempotency-key'),
+            expectedWorkspaceVersion: requiredIntegerFlag(parsed, 'expectedWorkspaceVersion'),
+            expectedObjectRevision: requiredIntegerFlag(parsed, 'expectedObjectRevision'),
+            source: { clientId: 'choosefire-cli', channel: 'cli' },
+            payload: {
+                accountId: requireFlag(parsed, 'accountId', '--account-id'),
+                account: {
+                    name: requireFlag(parsed, 'name', '--name'),
+                    accountType: requireFlag(parsed, 'accountType', '--account-type'),
+                    ownerSubjectId: requireFlag(parsed, 'ownerSubjectId', '--owner-subject-id'),
+                    visibility: (getStringFlag(parsed.flags, 'visibility') ?? 'household'),
+                    aggregationConsent: !getBooleanFlag(parsed.flags, 'noAggregationConsent'),
+                    currency: requireFlag(parsed, 'currency', '--currency'),
+                    maintenanceMode: (getStringFlag(parsed.flags, 'maintenanceMode') ?? 'simplified'),
+                },
+            },
+        };
+        const result = await updateFamilyWealthV2AssetAccount(config, command, dependencies);
+        return getBooleanFlag(parsed.flags, 'json') ? result : formatMutationReceipt(result);
+    }
+    if (action === 'account-archive') {
+        assertWealthFlags(parsed, [
+            'commandId', 'idempotencyKey', 'expectedWorkspaceVersion', 'expectedObjectRevision',
+            'accountId', 'reason',
+        ]);
+        const command = {
+            kind: 'asset_account.archive.v2',
+            commandId: getStringFlag(parsed.flags, 'commandId') ?? randomUUID(),
+            idempotencyKey: requireFlag(parsed, 'idempotencyKey', '--idempotency-key'),
+            expectedWorkspaceVersion: requiredIntegerFlag(parsed, 'expectedWorkspaceVersion'),
+            expectedObjectRevision: requiredIntegerFlag(parsed, 'expectedObjectRevision'),
+            source: { clientId: 'choosefire-cli', channel: 'cli' },
+            payload: {
+                accountId: requireFlag(parsed, 'accountId', '--account-id'),
+                reason: requireFlag(parsed, 'reason', '--reason'),
+            },
+        };
+        const result = await archiveFamilyWealthV2AssetAccount(config, command, dependencies);
+        return getBooleanFlag(parsed.flags, 'json') ? result : formatMutationReceipt(result);
+    }
+    if (action === 'valuation-append') {
+        assertWealthFlags(parsed, [
+            'commandId', 'idempotencyKey', 'expectedWorkspaceVersion', 'snapshotId',
+            'scopeId', 'amount', 'currency', 'asOf', 'quality',
+        ]);
+        const command = {
+            kind: 'valuation_snapshot.append.v2',
+            commandId: getStringFlag(parsed.flags, 'commandId') ?? randomUUID(),
+            idempotencyKey: requireFlag(parsed, 'idempotencyKey', '--idempotency-key'),
+            expectedWorkspaceVersion: requiredIntegerFlag(parsed, 'expectedWorkspaceVersion'),
+            expectedObjectRevision: null,
+            source: { clientId: 'choosefire-cli', channel: 'cli' },
+            payload: {
+                snapshotId: requireFlag(parsed, 'snapshotId', '--snapshot-id'),
+                snapshot: {
+                    scopeType: 'account',
+                    scopeId: requireFlag(parsed, 'scopeId', '--scope-id'),
+                    value: {
+                        amount: requireFlag(parsed, 'amount', '--amount'),
+                        currency: requireFlag(parsed, 'currency', '--currency'),
+                    },
+                    asOf: requireFlag(parsed, 'asOf', '--as-of'),
+                    quality: (getStringFlag(parsed.flags, 'quality') ?? 'confirmed'),
+                    source: { clientId: 'choosefire-cli', channel: 'cli' },
+                },
+            },
+        };
+        const result = await appendFamilyWealthV2Valuation(config, command, dependencies);
+        return getBooleanFlag(parsed.flags, 'json') ? result : formatMutationReceipt(result);
+    }
+    if (action === 'classify') {
+        assertWealthFlags(parsed, [
+            'commandId', 'idempotencyKey', 'expectedWorkspaceVersion', 'expectedObjectRevision',
+            'classificationRevisionId', 'scopeId', 'effectiveFrom',
+        ], ['assetClass', 'purpose']);
+        const command = {
+            kind: 'classification.replace.v2',
+            commandId: getStringFlag(parsed.flags, 'commandId') ?? randomUUID(),
+            idempotencyKey: requireFlag(parsed, 'idempotencyKey', '--idempotency-key'),
+            expectedWorkspaceVersion: requiredIntegerFlag(parsed, 'expectedWorkspaceVersion'),
+            expectedObjectRevision: requiredIntegerFlag(parsed, 'expectedObjectRevision', true),
+            source: { clientId: 'choosefire-cli', channel: 'cli' },
+            payload: {
+                classificationRevisionId: requireFlag(parsed, 'classificationRevisionId', '--classification-revision-id'),
+                classification: {
+                    scopeType: 'account',
+                    scopeId: requireFlag(parsed, 'scopeId', '--scope-id'),
+                    assetClasses: readAllocationLines(parsed, 'assetClass', '--asset-class'),
+                    purposeBuckets: readAllocationLines(parsed, 'purpose', '--purpose'),
+                    effectiveFrom: requireFlag(parsed, 'effectiveFrom', '--effective-from'),
+                },
+            },
+        };
+        const result = await replaceFamilyWealthV2Classification(config, command, dependencies);
+        return getBooleanFlag(parsed.flags, 'json') ? result : formatMutationReceipt(result);
+    }
+    throw new Error(`Unknown wealth command: ${action || ''}`);
+}
+function formatMutationReceipt(receipt) {
+    return [
+        receipt.replayed ? '家庭财富变更已重放' : '家庭财富变更已提交',
+        `版本：${receipt.baseWorkspaceVersion} -> ${receipt.resultWorkspaceVersion}`,
+        `回执：${receipt.receiptId}`,
+    ].join('\n');
+}
+function formatWealthOverview(overview) {
+    return [
+        `家庭净资产：${overview.totals.netWorth.amount} ${overview.baseCurrency}`,
+        `总资产：${overview.totals.grossAssets.amount} ${overview.baseCurrency}`,
+        `负债：${overview.totals.liabilities.amount} ${overview.baseCurrency}`,
+        `可见账户：${overview.coverage.visibleAccountCount}`,
+        overview.warnings.length > 0 ? `提示：${overview.warnings.join(', ')}` : '数据状态：完整',
+    ].join('\n');
+}
+function readAllocationLines(parsed, name, label) {
+    const values = getRepeatedStringFlag(parsed.flags, name);
+    if (values.length === 0)
+        throw new Error(`At least one ${label} value is required`);
+    const lines = values.map((value) => {
+        const [code, rawBasisPoints] = splitAssignment(value);
+        const basisPoints = Number(rawBasisPoints);
+        if (!/^[a-z][a-z0-9._-]{0,63}$/.test(code) || !Number.isInteger(basisPoints) || basisPoints < 0 || basisPoints > 10_000) {
+            throw new Error(`Invalid ${label} assignment: ${value}`);
+        }
+        return { code, basisPoints };
+    });
+    if (new Set(lines.map((line) => line.code)).size !== lines.length || lines.reduce((sum, line) => sum + line.basisPoints, 0) !== 10_000) {
+        throw new Error(`${label} values must total 10000 basis points without duplicate codes`);
+    }
+    return lines;
+}
+function assertWealthFlags(parsed, allowed, repeated = []) {
+    const allowedFlags = new Set([...allowed, ...repeated, 'json', 'noAggregationConsent']);
+    const unexpected = Object.keys(parsed.flags).find((flag) => !allowedFlags.has(flag));
+    if (unexpected)
+        throw new Error(`Unknown wealth flag: --${flagName(unexpected)}`);
+    for (const flag of allowed) {
+        const value = parsed.flags[flag];
+        if (value !== undefined && typeof value !== 'string')
+            throw new Error(`--${flagName(flag)} must be provided exactly once with a value`);
+    }
+    for (const flag of repeated) {
+        if (parsed.flags[flag] !== undefined && getRepeatedStringFlag(parsed.flags, flag).length === 0)
+            throw new Error(`--${flagName(flag)} must include a value`);
+    }
+    if (parsed.flags.json !== undefined && parsed.flags.json !== true)
+        throw new Error('--json must be provided without a value');
+    if (parsed.flags.noAggregationConsent !== undefined && parsed.flags.noAggregationConsent !== true)
+        throw new Error('--no-aggregation-consent must be provided without a value');
+}
+function formatInitializeReceipt(receipt) {
+    const workspace = receipt.affectedObjects.find((item) => item.objectType === 'workspace');
+    return [
+        receipt.replayed ? '家庭财富工作区已确认（幂等重放）' : '家庭财富工作区已建立',
+        `工作区：${workspace?.objectId ?? '-'}`,
+        `版本：${receipt.resultWorkspaceVersion}`,
+        `回执：${receipt.receiptId}`,
+    ].join('\n');
+}
+function formatWorkspaceSummary(summary) {
+    return [
+        '家庭财富工作区',
+        `家庭：${summary.authority.householdId}`,
+        `工作区：${summary.authority.workspaceId}`,
+        `角色：${summary.authority.role}`,
+        `基准币种：${summary.baseCurrency}`,
+        `时区：${summary.timezone}`,
+        `版本：${summary.workspaceVersion}`,
+        '当前为空，可以开始建立第一项资产。',
+    ].join('\n');
+}
+function formatActivityPage(page) {
+    if (page.items.length === 0)
+        return '暂无新的工作区活动。';
+    return page.items
+        .map((item) => `${item.committedAt}  ${item.operation}  ${item.source.channel}  v${item.resultWorkspaceVersion}`)
+        .join('\n');
+}
+async function runWorkspaceCommand(config, action, parsed, dependencies) {
+    if (parsed.positionals.length !== 2) {
+        throw new Error('Workspace commands do not accept additional positional arguments');
+    }
+    if (action === 'initialize') {
+        assertAllowedFlags(parsed, ['idempotencyKey']);
+        return initializeAccountFinancialWorkspace(config, {
+            kind: 'financial_workspace_initialize_command.v1',
+            idempotencyKey: requireFlag(parsed, 'idempotencyKey', '--idempotency-key'),
+        }, dependencies);
+    }
+    if (action === 'snapshot') {
+        assertAllowedFlags(parsed, []);
+        return getAccountFinancialWorkspaceSnapshot(config, dependencies);
+    }
+    if (action === 'summary') {
+        assertAllowedFlags(parsed, []);
+        return getAccountFinancialWorkspaceSummary(config, dependencies);
+    }
+    if (action === 'activity') {
+        assertAllowedFlags(parsed, ['limit', 'cursor']);
+        const cursor = getStringFlag(parsed.flags, 'cursor');
+        return getAccountFinancialWorkspaceActivity(config, {
+            limit: requiredIntegerFlag(parsed, 'limit'),
+            ...(cursor === undefined ? {} : { cursor }),
+        }, dependencies);
+    }
+    if (action === 'fact-record') {
+        assertAllowedFlags(parsed, [
+            'expectedVersion',
+            'idempotencyKey',
+            'field',
+            'amount',
+            'currency',
+            'status',
+            'asOf',
+        ]);
+        const status = getStringFlag(parsed.flags, 'status');
+        const asOf = getStringFlag(parsed.flags, 'asOf');
+        return recordAccountFinancialWorkspaceFact(config, {
+            kind: 'financial_workspace_fact_record_command.v1',
+            expectedVersion: requiredIntegerFlag(parsed, 'expectedVersion', true),
+            idempotencyKey: requireFlag(parsed, 'idempotencyKey', '--idempotency-key'),
+            field: requireFlag(parsed, 'field', '--field'),
+            value: {
+                kind: 'money.v1',
+                amount: requireFlag(parsed, 'amount', '--amount'),
+                currency: requireFlag(parsed, 'currency', '--currency'),
+            },
+            ...(status === undefined ? {} : { status: status }),
+            ...(asOf === undefined ? {} : { asOf }),
+        }, dependencies);
+    }
+    throw new Error(`Unknown workspace command: ${action || ''}`);
+}
+async function runAuthCommand(config, action, parsed) {
+    if (action === 'status') {
+        return authStatus(config);
+    }
+    if (action === 'login') {
+        return login(config, {
+            port: numberFlag(parsed, 'port') ?? 8787,
+            openBrowser: !getBooleanFlag(parsed.flags, 'noOpen'),
+        });
+    }
+    if (action === 'logout') {
+        return logout();
+    }
+    throw new Error(`Unknown auth command: ${action || ''}`);
+}
+async function runPlanCommand(config, action, maybeId, parsed) {
+    if (action === 'list') {
+        return requestChooseFire(config, '/choosefire/fire-plans');
+    }
+    if (action === 'get') {
+        const id = requireValue(maybeId, 'plan id');
+        return requestChooseFire(config, `/choosefire/fire-plans/${encodeURIComponent(id)}`);
+    }
+    if (action === 'update-inputs') {
+        const id = requireValue(maybeId, 'plan id');
+        const patch = readInputPatch(parsed);
+        return requestChooseFire(config, `/choosefire/fire-plans/${encodeURIComponent(id)}/commands/update-inputs`, {
+            method: 'POST',
+            source: 'cli',
+            body: commandBody(parsed, { patch }),
+        });
+    }
+    if (action === 'duplicate') {
+        const id = requireValue(maybeId, 'plan id');
+        const name = requireValue(getStringFlag(parsed.flags, 'name'), '--name');
+        return requestChooseFire(config, `/choosefire/fire-plans/${encodeURIComponent(id)}/commands/duplicate`, {
+            method: 'POST',
+            source: 'cli',
+            body: commandBody(parsed, {
+                name,
+                patch: readSetPatch(parsed),
+            }),
+        });
+    }
+    if (action === 'set-default') {
+        const id = requireValue(maybeId, 'plan id');
+        return requestChooseFire(config, `/choosefire/fire-plans/${encodeURIComponent(id)}/commands/set-default`, {
+            method: 'POST',
+            source: 'cli',
+            body: commandBody(parsed, {}),
+        });
+    }
+    if (action === 'archive') {
+        const id = requireValue(maybeId, 'plan id');
+        return requestChooseFire(config, `/choosefire/fire-plans/${encodeURIComponent(id)}/commands/archive`, {
+            method: 'POST',
+            source: 'cli',
+            body: commandBody(parsed, {}),
+        });
+    }
+    throw new Error(`Unknown plan command: ${action || ''}`);
+}
+async function runAssetCommand(config, action, parsed) {
+    const planId = requireValue(getStringFlag(parsed.flags, 'plan'), '--plan');
+    if (action === 'upsert') {
+        const account = readAssetAccountPatch(parsed);
+        return requestChooseFire(config, `/choosefire/fire-plans/${encodeURIComponent(planId)}/commands/upsert-asset-account`, {
+            method: 'POST',
+            source: 'cli',
+            body: commandBody(parsed, {
+                accountId: getStringFlag(parsed.flags, 'accountId'),
+                account,
+            }),
+        });
+    }
+    if (action === 'remove') {
+        return requestChooseFire(config, `/choosefire/fire-plans/${encodeURIComponent(planId)}/commands/remove-asset-account`, {
+            method: 'POST',
+            source: 'cli',
+            body: commandBody(parsed, {
+                accountId: requireValue(getStringFlag(parsed.flags, 'accountId'), '--account-id'),
+            }),
+        });
+    }
+    throw new Error(`Unknown asset command: ${action || ''}`);
+}
+async function runVisualCommand(config, action, parsed) {
+    if (action !== 'dataset') {
+        throw new Error(`Unknown visual command: ${action || ''}`);
+    }
+    const planId = requireValue(getStringFlag(parsed.flags, 'plan'), '--plan');
+    const kind = getStringFlag(parsed.flags, 'kind') || 'overview';
+    return requestChooseFire(config, `/choosefire/fire-plans/${encodeURIComponent(planId)}/visual-dataset?kind=${encodeURIComponent(kind)}`);
+}
+function commandBody(parsed, body) {
+    return {
+        ...body,
+        dryRun: !getBooleanFlag(parsed.flags, 'apply'),
+        expectedUpdatedAt: getStringFlag(parsed.flags, 'expectedUpdatedAt'),
+        reason: getStringFlag(parsed.flags, 'reason'),
+    };
+}
+function readInputPatch(parsed) {
+    const patch = {};
+    setNumberIfPresent(patch, 'currentSavings', getStringFlag(parsed.flags, 'currentSavings'));
+    setNumberIfPresent(patch, 'annualReturn', getStringFlag(parsed.flags, 'annualReturn'));
+    setNumberIfPresent(patch, 'annualInflation', getStringFlag(parsed.flags, 'annualInflation'));
+    setNumberIfPresent(patch, 'annualExpenses', getStringFlag(parsed.flags, 'annualExpenses'));
+    setNumberIfPresent(patch, 'monthlyContribution', getStringFlag(parsed.flags, 'monthlyContribution'));
+    setNumberIfPresent(patch, 'safeWithdrawalRate', getStringFlag(parsed.flags, 'safeWithdrawalRate'));
+    for (const assignment of getRepeatedStringFlag(parsed.flags, 'set')) {
+        const [key, rawValue] = splitAssignment(assignment);
+        setNumberIfPresent(patch, key, rawValue);
+    }
+    if (Object.keys(patch).length === 0) {
+        throw new Error('No input patch provided');
+    }
+    return patch;
+}
+function readSetPatch(parsed) {
+    const patch = {};
+    for (const assignment of getRepeatedStringFlag(parsed.flags, 'set')) {
+        const [key, rawValue] = splitAssignment(assignment);
+        setNumberIfPresent(patch, key, rawValue);
+    }
+    return Object.keys(patch).length > 0 ? patch : undefined;
+}
+function readAssetAccountPatch(parsed) {
+    const account = {};
+    setStringIfPresent(account, 'name', getStringFlag(parsed.flags, 'name'));
+    setStringIfPresent(account, 'assetClass', getStringFlag(parsed.flags, 'assetClass'));
+    setStringIfPresent(account, 'riskLevel', getStringFlag(parsed.flags, 'riskLevel'));
+    setStringIfPresent(account, 'liquidityLevel', getStringFlag(parsed.flags, 'liquidityLevel'));
+    setStringIfPresent(account, 'notes', getStringFlag(parsed.flags, 'notes'));
+    setNumberIfPresent(account, 'amount', getStringFlag(parsed.flags, 'amount'));
+    setNumberIfPresent(account, 'expectedReturn', getStringFlag(parsed.flags, 'expectedReturn'));
+    if (Object.keys(account).length === 0) {
+        throw new Error('No asset account patch provided');
+    }
+    return account;
+}
+function setNumberIfPresent(target, key, value) {
+    if (value === undefined)
+        return;
+    const numericValue = Number(value);
+    if (!Number.isFinite(numericValue)) {
+        throw new Error(`${key} must be a finite number`);
+    }
+    target[key] = numericValue;
+}
+function setStringIfPresent(target, key, value) {
+    if (value === undefined)
+        return;
+    target[key] = value;
+}
+function splitAssignment(value) {
+    const index = value.indexOf('=');
+    if (index <= 0) {
+        throw new Error(`Invalid --set assignment: ${value}`);
+    }
+    return [value.slice(0, index), value.slice(index + 1)];
+}
+function requireValue(value, label) {
+    if (!value) {
+        throw new Error(`Missing ${label}`);
+    }
+    return value;
+}
+function numberFlag(parsed, name) {
+    const value = getStringFlag(parsed.flags, name);
+    if (value === undefined)
+        return undefined;
+    const numericValue = Number(value);
+    if (!Number.isInteger(numericValue) || numericValue <= 0) {
+        throw new Error(`--${name} must be a positive integer`);
+    }
+    return numericValue;
+}
+function requiredIntegerFlag(parsed, name, allowZero = false) {
+    const raw = requireFlag(parsed, name, `--${flagName(name)}`);
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || (allowZero ? value < 0 : value <= 0)) {
+        throw new Error(`--${flagName(name)} must be ${allowZero ? 'a non-negative' : 'a positive'} integer`);
+    }
+    return value;
+}
+function requireFlag(parsed, name, label) {
+    return requireValue(getStringFlag(parsed.flags, name), label);
+}
+function assertAllowedFlags(parsed, allowed) {
+    const allowedFlags = new Set([...allowed, 'json']);
+    const unexpected = Object.keys(parsed.flags).find((flag) => !allowedFlags.has(flag));
+    if (unexpected)
+        throw new Error(`Unknown workspace flag: --${flagName(unexpected)}`);
+    for (const flag of allowed) {
+        const value = parsed.flags[flag];
+        if (value !== undefined && typeof value !== 'string') {
+            throw new Error(`--${flagName(flag)} must be provided exactly once with a value`);
+        }
+    }
+    const json = parsed.flags.json;
+    if (json !== undefined && json !== true) {
+        throw new Error('--json must be provided at most once without a value');
+    }
+}
+function flagName(value) {
+    return value.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+function help() {
+    return {
+        usage: [
+            'choosefire auth status --json',
+            'choosefire auth login --json',
+            'choosefire auth logout --json',
+            'choosefire workspace initialize --idempotency-key <key> --json',
+            'choosefire workspace snapshot --json',
+            'choosefire workspace summary --json',
+            'choosefire workspace activity --limit <1-100> [--cursor <cursor>] --json',
+            'choosefire workspace fact-record --expected-version <n> --idempotency-key <key> --field <field> --amount <decimal> --currency <code> [--status confirmed|estimated] [--as-of <iso>] --json',
+            'choosefire household init --idempotency-key <key> --base-currency CNY --timezone Asia/Shanghai [--command-id <uuid>] [--json]',
+            'choosefire household summary [--json]',
+            'choosefire activity list --limit <1-100> [--cursor <cursor>] [--json]',
+            'choosefire wealth overview [--json]',
+            'choosefire wealth account-create --account-id <uuid> --name <name> --account-type <type> --owner-subject-id <uuid> --currency <code> --expected-workspace-version <n> --idempotency-key <key> [--visibility household|private] [--maintenance-mode simplified|detailed] [--no-aggregation-consent] [--json]',
+            'choosefire wealth account-update --account-id <uuid> --name <name> --account-type <type> --owner-subject-id <uuid> --currency <code> --expected-object-revision <n> --expected-workspace-version <n> --idempotency-key <key> [--visibility household|private] [--maintenance-mode simplified|detailed] [--no-aggregation-consent] [--json]',
+            'choosefire wealth account-archive --account-id <uuid> --reason <reason> --expected-object-revision <n> --expected-workspace-version <n> --idempotency-key <key> [--json]',
+            'choosefire wealth valuation-append --snapshot-id <uuid> --scope-id <uuid> --amount <decimal> --currency <code> --as-of <iso> --expected-workspace-version <n> --idempotency-key <key> [--quality confirmed|estimated|unknown] [--json]',
+            'choosefire wealth classify --classification-revision-id <uuid> --scope-id <uuid> --expected-object-revision <n> --expected-workspace-version <n> --effective-from <iso> --asset-class <code=basis-points> --purpose <code=basis-points> --idempotency-key <key> [--json]',
+            'choosefire mcp token issue --client-id <client-id> [--ttl-seconds 300] [--json]',
+            'choosefire mcp token revoke --access-token <token> [--json]',
+            'choosefire plan list --json',
+            'choosefire plan get <plan-id> --json',
+            'choosefire plan update-inputs <plan-id> --annual-return 0.035 --expected-updated-at <iso> --dry-run --json',
+            'choosefire plan duplicate <plan-id> --name "Conservative" --set annualReturn=0.035 --expected-updated-at <iso> --dry-run --json',
+            'choosefire plan set-default <plan-id> --expected-updated-at <iso> --dry-run --json',
+            'choosefire plan archive <plan-id> --expected-updated-at <iso> --reason "cleanup" --dry-run --json',
+            'choosefire asset upsert --plan <plan-id> --account-id asset-bank --amount 300000 --expected-return 0.02 --expected-updated-at <iso> --dry-run --json',
+            'choosefire asset remove --plan <plan-id> --account-id asset-bank --reason "duplicate account" --expected-updated-at <iso> --dry-run --json',
+            'choosefire visual dataset --plan <plan-id> --kind overview --json',
+        ],
+    };
+}
+//# sourceMappingURL=commands.js.map