@centry-digital/bukku-cli 2.0.0

package/build/commands/custom/location-write.js

@@ -0,0 +1,95 @@
+import { withAuth } from '../wrapper.js';
+import { outputJson } from '../../output/json.js';
+import { outputDryRun } from '../../output/dry-run.js';
+import { outputTable } from '../../output/table.js';
+import { outputError, ExitCode } from '../../output/error.js';
+import { readJsonInput } from '../../input/json.js';
+/**
+ * Parse and validate a positional ID argument.
+ */
+function parseId(idArg) {
+    const parsed = parseInt(idArg, 10);
+    if (isNaN(parsed) || parsed <= 0) {
+        outputError({ error: 'ID must be a positive integer', code: 'VALIDATION_ERROR' }, ExitCode.VALIDATION);
+    }
+    return parsed;
+}
+/**
+ * Register location get/update/delete commands using singular /location/{id} path.
+ *
+ * The Bukku API uses /locations (plural) for list/create but /location/{id} (singular)
+ * for get/update/delete. The factory only generates list and create for locations,
+ * so these custom commands handle the singular-path operations.
+ */
+export function registerLocationWriteCommands(program) {
+    // Find existing control-panel group and locations resource
+    const groupCmd = program.commands.find((c) => c.name() === 'control-panel');
+    if (!groupCmd)
+        return;
+    const resourceCmd = groupCmd.commands.find((c) => c.name() === 'locations');
+    if (!resourceCmd)
+        return;
+    // Add get subcommand
+    const getHandler = withAuth(async ({ client, opts }) => {
+        const id = opts._entityId;
+        const data = await client.get(`/location/${id}`);
+        const format = opts.format;
+        if (format === 'table') {
+            const response = data;
+            const item = response['location'];
+            outputTable(item ? [item] : [], ['location']);
+        }
+        else {
+            outputJson(data);
+        }
+    });
+    resourceCmd
+        .command('get <id>')
+        .description('Get a single location by ID')
+        .option('--format <format>', 'Output format (json, table)', 'json')
+        .action(function (idArg, ...rest) {
+        const id = parseId(idArg);
+        this.setOptionValue('_entityId', id);
+        return getHandler.call(this, idArg, ...rest);
+    });
+    // Add update subcommand
+    const updateHandler = withAuth(async ({ client, opts, auth }) => {
+        const id = opts._entityId;
+        const body = await readJsonInput(opts);
+        if (opts.dryRun) {
+            outputDryRun({ method: 'PUT', path: `/location/${id}`, token: auth.apiToken, subdomain: auth.companySubdomain, body });
+            return;
+        }
+        const data = await client.put(`/location/${id}`, body);
+        outputJson(data);
+    });
+    resourceCmd
+        .command('update <id>')
+        .description('Update a location')
+        .option('--data <json>', 'JSON data (or pipe to stdin)')
+        .option('--dry-run', 'Show request details without executing', false)
+        .action(function (idArg, ...rest) {
+        const id = parseId(idArg);
+        this.setOptionValue('_entityId', id);
+        return updateHandler.call(this, idArg, ...rest);
+    });
+    // Add delete subcommand
+    const deleteHandler = withAuth(async ({ client, opts, auth }) => {
+        const id = opts._entityId;
+        if (opts.dryRun) {
+            outputDryRun({ method: 'DELETE', path: `/location/${id}`, token: auth.apiToken, subdomain: auth.companySubdomain });
+            return;
+        }
+        await client.delete(`/location/${id}`);
+        outputJson({});
+    });
+    resourceCmd
+        .command('delete <id>')
+        .description('Delete a location')
+        .option('--dry-run', 'Show request details without executing', false)
+        .action(function (idArg, ...rest) {
+        const id = parseId(idArg);
+        this.setOptionValue('_entityId', id);
+        return deleteHandler.call(this, idArg, ...rest);
+    });
+}

package/build/commands/custom/reference-data.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Reference data CLI commands.
+ *
+ * Reference data (tax codes, currencies, payment methods, etc.) is accessed
+ * via Bukku's unified POST /v2/lists endpoint, not standard GET CRUD endpoints.
+ * These are short-lived CLI commands, so no caching is needed.
+ */
+import { Command } from 'commander';
+/**
+ * Register all reference data list commands under a `ref-data` top-level group.
+ */
+export declare function registerReferenceDataCommands(program: Command): void;
+//# sourceMappingURL=reference-data.d.ts.map

package/build/commands/custom/reference-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-data.d.ts","sourceRoot":"","sources":["../../../src/commands/custom/reference-data.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA6DpC;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA6BpE"}

package/build/commands/custom/reference-data.js

@@ -0,0 +1,95 @@
+/**
+ * Reference data CLI commands.
+ *
+ * Reference data (tax codes, currencies, payment methods, etc.) is accessed
+ * via Bukku's unified POST /v2/lists endpoint, not standard GET CRUD endpoints.
+ * These are short-lived CLI commands, so no caching is needed.
+ */
+import { withAuth } from '../wrapper.js';
+import { outputJson } from '../../output/json.js';
+import { outputTable } from '../../output/table.js';
+/**
+ * Reference data types available from POST /v2/lists endpoint.
+ */
+const REFERENCE_TYPES = [
+    {
+        type: 'tax_codes',
+        commandName: 'tax-codes',
+        description: 'List tax codes (tax rate definitions)',
+    },
+    {
+        type: 'currencies',
+        commandName: 'currencies',
+        description: 'List activated currencies',
+    },
+    {
+        type: 'payment_methods',
+        commandName: 'payment-methods',
+        description: 'List payment methods',
+    },
+    {
+        type: 'terms',
+        commandName: 'terms',
+        description: 'List payment terms',
+    },
+    {
+        type: 'accounts',
+        commandName: 'accounts',
+        description: 'List accounts from chart of accounts (quick lookup)',
+    },
+    {
+        type: 'price_levels',
+        commandName: 'price-levels',
+        description: 'List price levels',
+    },
+    {
+        type: 'countries',
+        commandName: 'countries',
+        description: 'List countries',
+    },
+    {
+        type: 'classification_code_list',
+        commandName: 'classification-codes',
+        description: 'List product classification codes (Malaysia LHDN e-Invoice)',
+    },
+    {
+        type: 'numberings',
+        commandName: 'numberings',
+        description: 'List document numbering schemes',
+    },
+    {
+        type: 'state_list',
+        commandName: 'states',
+        description: 'List geographic states/provinces',
+    },
+];
+/**
+ * Register all reference data list commands under a `ref-data` top-level group.
+ */
+export function registerReferenceDataCommands(program) {
+    const refDataCmd = program
+        .command('ref-data')
+        .description('Reference data lookups (tax codes, currencies, terms, etc.)');
+    for (const { type, commandName, description } of REFERENCE_TYPES) {
+        refDataCmd
+            .command(commandName)
+            .description(description)
+            .option('--format <format>', 'Output format (json, table)', 'json')
+            .action(withAuth(async ({ client, opts }) => {
+            const result = await client.post('/v2/lists', {
+                lists: [type],
+                params: [],
+            });
+            const format = opts.format;
+            if (format === 'table') {
+                // Reference data results are keyed by type name
+                const response = result;
+                const items = response[type] || [];
+                outputTable(items);
+            }
+            else {
+                outputJson(result);
+            }
+        }));
+    }
+}

package/build/commands/custom/search-accounts.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Search accounts custom command.
+ *
+ * Provides filtered search of the chart of accounts via GET /accounts.
+ * Registered under the `accounting` group command.
+ */
+import type { Command } from 'commander';
+/**
+ * Register the search-accounts command under the existing `accounting` group.
+ */
+export declare function registerSearchAccountsCommand(program: Command): void;
+//# sourceMappingURL=search-accounts.d.ts.map

package/build/commands/custom/search-accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-accounts.d.ts","sourceRoot":"","sources":["../../../src/commands/custom/search-accounts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKzC;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA4CpE"}

package/build/commands/custom/search-accounts.js

@@ -0,0 +1,59 @@
+/**
+ * Search accounts custom command.
+ *
+ * Provides filtered search of the chart of accounts via GET /accounts.
+ * Registered under the `accounting` group command.
+ */
+import { withAuth } from '../wrapper.js';
+import { outputJson } from '../../output/json.js';
+import { outputTable } from '../../output/table.js';
+/**
+ * Register the search-accounts command under the existing `accounting` group.
+ */
+export function registerSearchAccountsCommand(program) {
+    // Find the accounting group (created by registerEntityCommands)
+    let accountingCmd = program.commands.find((c) => c.name() === 'accounting');
+    if (!accountingCmd) {
+        accountingCmd = program
+            .command('accounting')
+            .description('Chart of accounts and journal entries');
+    }
+    accountingCmd
+        .command('search-accounts')
+        .description('Search and filter accounts from the chart of accounts')
+        .option('--search <text>', 'Search by name, code, or description')
+        .option('--category <cat>', 'Filter by category (assets, liabilities, equity, income, expenses)')
+        .option('--is-archived', 'Include archived accounts', false)
+        .option('--sort-by <field>', 'Sort by field (code, name, balance)')
+        .option('--sort-dir <dir>', 'Sort direction (asc, desc)')
+        .option('--page <n>', 'Page number')
+        .option('--limit <n>', 'Items per page')
+        .option('--format <format>', 'Output format (json, table)', 'json')
+        .action(withAuth(async ({ client, opts }) => {
+        const params = {};
+        if (opts.search != null)
+            params.search = opts.search;
+        if (opts.category != null)
+            params.category = opts.category;
+        if (opts.isArchived)
+            params.is_archived = 'true';
+        if (opts.sortBy != null)
+            params.sort_by = opts.sortBy;
+        if (opts.sortDir != null)
+            params.sort_dir = opts.sortDir;
+        if (opts.page != null)
+            params.page = Number(opts.page);
+        if (opts.limit != null)
+            params.page_size = Number(opts.limit);
+        const result = await client.get('/accounts', params);
+        const format = opts.format;
+        if (format === 'table') {
+            const response = result;
+            const items = response['accounts'] || [];
+            outputTable(items, ['account']);
+        }
+        else {
+            outputJson(result);
+        }
+    }));
+}

package/build/commands/factory.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+/**
+ * Register all entity CRUD commands on the Commander program.
+ *
+ * Iterates allEntityConfigs from core, creates group and resource subcommands,
+ * and adds list/get subcommands based on each entity's supported operations.
+ */
+export declare function registerEntityCommands(program: Command): void;
+//# sourceMappingURL=factory.d.ts.map

package/build/commands/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/commands/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA6WpC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAmD7D"}

package/build/commands/factory.js

@@ -0,0 +1,371 @@
+import { allEntityConfigs } from 'core';
+import { withAuth } from './wrapper.js';
+import { outputJson } from '../output/json.js';
+import { outputTable } from '../output/table.js';
+import { readJsonInput } from '../input/json.js';
+import { outputDryRun } from '../output/dry-run.js';
+/**
+ * Map entity name to CLI resource subcommand name.
+ * Explicit mapping is more maintainable than prefix-stripping heuristics.
+ */
+const RESOURCE_NAME_MAP = {
+    'sales-invoice': 'invoices',
+    'sales-quote': 'quotes',
+    'sales-order': 'orders',
+    'sales-credit-note': 'credit-notes',
+    'sales-payment': 'payments',
+    'sales-refund': 'refunds',
+    'delivery-order': 'delivery-orders',
+    'purchase-bill': 'bills',
+    'purchase-order': 'orders',
+    'purchase-credit-note': 'credit-notes',
+    'purchase-payment': 'payments',
+    'purchase-refund': 'refunds',
+    'goods-received-note': 'goods-received-notes',
+    'bank-money-in': 'money-in',
+    'bank-money-out': 'money-out',
+    'bank-transfer': 'transfers',
+    'contact': 'contacts',
+    'contact-group': 'groups',
+    'product': 'products',
+    'product-bundle': 'bundles',
+    'product-group': 'groups',
+    'journal-entry': 'journal-entries',
+    'account': 'accounts',
+    'file': 'files',
+    'location': 'locations',
+    'tag': 'tags',
+    'tag-group': 'tag-groups',
+};
+/**
+ * Group descriptions for top-level CLI command groups.
+ */
+const GROUP_DESCRIPTIONS = {
+    sales: 'Sales invoices, quotes, orders, credit notes, payments, refunds',
+    purchases: 'Purchase bills, orders, credit notes, payments, refunds',
+    banking: 'Bank transactions and transfers',
+    contacts: 'Customers, suppliers, and contacts',
+    products: 'Products, bundles, and product groups',
+    accounting: 'Chart of accounts and journal entries',
+    files: 'File uploads and attachments',
+    'control-panel': 'Locations, tags, and tag groups',
+};
+/**
+ * Simple pluralization for entity descriptions.
+ * Handles common cases: "entry" -> "entries", "note" -> "notes".
+ */
+function pluralize(desc) {
+    if (desc.endsWith('y') && !desc.endsWith('ay') && !desc.endsWith('ey') && !desc.endsWith('oy') && !desc.endsWith('uy')) {
+        return desc.slice(0, -1) + 'ies';
+    }
+    if (desc.endsWith('s') || desc.endsWith('x') || desc.endsWith('z') || desc.endsWith('ch') || desc.endsWith('sh')) {
+        return desc + 'es';
+    }
+    return desc + 's';
+}
+/**
+ * Convert a flag name with hyphens to underscore parameter name.
+ * e.g., "contact-id" -> "contact_id"
+ */
+function toParamName(flag) {
+    return flag.replace(/-/g, '_');
+}
+/**
+ * Convert an underscore parameter name to a hyphenated flag name.
+ * e.g., "contact_id" -> "contact-id"
+ */
+function toFlagName(param) {
+    return param.replace(/_/g, '-');
+}
+/**
+ * Add the `list` subcommand to a resource command.
+ */
+function addListCommand(resourceCmd, config) {
+    const listCmd = resourceCmd
+        .command('list')
+        .description(`List ${pluralize(config.description)}`);
+    // Standard options
+    listCmd
+        .option('--limit <n>', 'Maximum items per page', undefined)
+        .option('--page <n>', 'Page number', undefined)
+        .option('--search <text>', 'Search text', undefined)
+        .option('--date-from <date>', 'Filter from date (YYYY-MM-DD)', undefined)
+        .option('--date-to <date>', 'Filter to date (YYYY-MM-DD)', undefined)
+        .option('--status <status>', 'Filter by status', undefined)
+        .option('--sort-by <field>', 'Sort by field', undefined)
+        .option('--sort-dir <dir>', 'Sort direction (asc, desc)', undefined)
+        .option('--all', 'Fetch all pages', false)
+        .option('--format <format>', 'Output format (json, table)', 'json');
+    // Entity-specific filter options
+    if (config.listFilters) {
+        for (const filter of config.listFilters) {
+            const flagName = toFlagName(filter);
+            // Skip filters that duplicate standard options
+            if (['search', 'status'].includes(filter))
+                continue;
+            listCmd.option(`--${flagName} <value>`, `Filter by ${filter}`, undefined);
+        }
+    }
+    listCmd.action(withAuth(async ({ client, opts }) => {
+        // Build query params
+        const params = {};
+        if (opts.limit != null)
+            params.page_size = Number(opts.limit);
+        if (opts.page != null)
+            params.page = Number(opts.page);
+        if (opts.search != null)
+            params.search = opts.search;
+        if (opts.dateFrom != null)
+            params.date_from = opts.dateFrom;
+        if (opts.dateTo != null)
+            params.date_to = opts.dateTo;
+        if (opts.status != null)
+            params.status = opts.status;
+        if (opts.sortBy != null)
+            params.sort_by = opts.sortBy;
+        if (opts.sortDir != null)
+            params.sort_dir = opts.sortDir;
+        // Entity-specific filters
+        if (config.listFilters) {
+            for (const filter of config.listFilters) {
+                if (['search', 'status'].includes(filter))
+                    continue;
+                // Commander camelCases the flag: "contact-id" -> "contactId"
+                const camelKey = toFlagName(filter)
+                    .replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+                if (opts[camelKey] != null) {
+                    params[filter] = opts[camelKey];
+                }
+            }
+        }
+        const format = opts.format;
+        if (opts.all) {
+            // Auto-pagination: fetch all pages
+            const pageSize = params.page_size ?? 100;
+            params.page_size = pageSize;
+            params.page = 1;
+            const firstResponse = await client.get(config.apiBasePath, params);
+            const paging = firstResponse.paging;
+            const allItems = [...(firstResponse[config.pluralKey] || [])];
+            const totalPages = Math.ceil(paging.total / paging.per_page);
+            if (totalPages > 1) {
+                process.stderr.write(`Fetching page 1/${totalPages}...\n`);
+            }
+            for (let page = 2; page <= totalPages; page++) {
+                process.stderr.write(`Fetching page ${page}/${totalPages}...\n`);
+                params.page = page;
+                const response = await client.get(config.apiBasePath, params);
+                const items = response[config.pluralKey] || [];
+                allItems.push(...items);
+            }
+            if (format === 'table') {
+                outputTable(allItems, [config.entity]);
+            }
+            else {
+                outputJson(allItems);
+            }
+        }
+        else {
+            const data = await client.get(config.apiBasePath, params);
+            if (format === 'table') {
+                const response = data;
+                const items = response[config.pluralKey] || [];
+                outputTable(items, [config.entity]);
+            }
+            else {
+                outputJson(data);
+            }
+        }
+    }));
+}
+/**
+ * Add the `get` subcommand to a resource command.
+ */
+function addGetCommand(resourceCmd, config) {
+    const getCmd = resourceCmd
+        .command('get <id>')
+        .description(`Get a single ${config.description} by ID`);
+    getCmd.option('--format <format>', 'Output format (json, table)', 'json');
+    // Commander passes (id, options, command) to action.
+    // withAuth ignores positional args, so we wrap with a thin function
+    // that captures the id and stores it before delegating to withAuth.
+    const wrappedHandler = withAuth(async ({ client, opts }) => {
+        const parsedId = opts._entityId;
+        const data = await client.get(`${config.apiBasePath}/${parsedId}`);
+        const format = opts.format;
+        if (format === 'table') {
+            const response = data;
+            const item = response[config.singularKey];
+            outputTable(item ? [item] : [], [config.entity]);
+        }
+        else {
+            outputJson(data);
+        }
+    });
+    getCmd.action(function (idArg, ...rest) {
+        const parsedId = parseInt(idArg, 10);
+        if (isNaN(parsedId) || parsedId <= 0) {
+            process.stderr.write(JSON.stringify({ error: 'ID must be a positive integer', code: 'VALIDATION_ERROR' }) + '\n');
+            process.exit(4);
+        }
+        // Stash parsed id into the command's opts so withAuth handler can access it
+        this.setOptionValue('_entityId', parsedId);
+        return wrappedHandler.call(this, idArg, ...rest);
+    });
+}
+/**
+ * Add the `create` subcommand to a resource command.
+ */
+function addCreateCommand(resourceCmd, config) {
+    const createCmd = resourceCmd
+        .command('create')
+        .description(`Create a new ${config.description}`)
+        .option('--data <json>', 'JSON data (or pipe to stdin)')
+        .option('--dry-run', 'Show request details without executing', false);
+    createCmd.action(withAuth(async ({ client, opts, auth }) => {
+        const body = await readJsonInput(opts);
+        if (opts.dryRun) {
+            outputDryRun({ method: 'POST', path: config.apiBasePath, token: auth.apiToken, subdomain: auth.companySubdomain, body });
+            return;
+        }
+        const data = await client.post(config.apiBasePath, body);
+        outputJson(data);
+    }));
+}
+/**
+ * Add the `update` subcommand to a resource command.
+ */
+function addUpdateCommand(resourceCmd, config) {
+    const updateCmd = resourceCmd
+        .command('update <id>')
+        .description(`Update a ${config.description}`)
+        .option('--data <json>', 'JSON data (or pipe to stdin)')
+        .option('--dry-run', 'Show request details without executing', false);
+    const wrappedHandler = withAuth(async ({ client, opts, auth }) => {
+        const parsedId = opts._entityId;
+        const body = await readJsonInput(opts);
+        if (opts.dryRun) {
+            outputDryRun({ method: 'PUT', path: `${config.apiBasePath}/${parsedId}`, token: auth.apiToken, subdomain: auth.companySubdomain, body });
+            return;
+        }
+        const data = await client.put(`${config.apiBasePath}/${parsedId}`, body);
+        outputJson(data);
+    });
+    updateCmd.action(function (idArg, ...rest) {
+        const parsedId = parseInt(idArg, 10);
+        if (isNaN(parsedId) || parsedId <= 0) {
+            process.stderr.write(JSON.stringify({ error: 'ID must be a positive integer', code: 'VALIDATION_ERROR' }) + '\n');
+            process.exit(4);
+        }
+        this.setOptionValue('_entityId', parsedId);
+        return wrappedHandler.call(this, idArg, ...rest);
+    });
+}
+/**
+ * Add the `delete` subcommand to a resource command.
+ */
+function addDeleteCommand(resourceCmd, config) {
+    const deleteCmd = resourceCmd
+        .command('delete <id>')
+        .description(`Delete a ${config.description}`)
+        .option('--dry-run', 'Show request details without executing', false);
+    const wrappedHandler = withAuth(async ({ client, opts, auth }) => {
+        const parsedId = opts._entityId;
+        if (opts.dryRun) {
+            outputDryRun({ method: 'DELETE', path: `${config.apiBasePath}/${parsedId}`, token: auth.apiToken, subdomain: auth.companySubdomain });
+            return;
+        }
+        await client.delete(`${config.apiBasePath}/${parsedId}`);
+        outputJson({});
+    });
+    deleteCmd.action(function (idArg, ...rest) {
+        const parsedId = parseInt(idArg, 10);
+        if (isNaN(parsedId) || parsedId <= 0) {
+            process.stderr.write(JSON.stringify({ error: 'ID must be a positive integer', code: 'VALIDATION_ERROR' }) + '\n');
+            process.exit(4);
+        }
+        this.setOptionValue('_entityId', parsedId);
+        return wrappedHandler.call(this, idArg, ...rest);
+    });
+}
+/**
+ * Add the `status` subcommand to a resource command.
+ * Used for entities that support status transitions (e.g., draft -> posted).
+ */
+function addStatusCommand(resourceCmd, config) {
+    const statusCmd = resourceCmd
+        .command('status <id>')
+        .description(`Update status of a ${config.description}`)
+        .requiredOption('--status <status>', 'New status value')
+        .option('--dry-run', 'Show request details without executing', false);
+    const wrappedHandler = withAuth(async ({ client, opts, auth }) => {
+        const parsedId = opts._entityId;
+        const status = opts.status;
+        if (opts.dryRun) {
+            outputDryRun({ method: 'PATCH', path: `${config.apiBasePath}/${parsedId}`, token: auth.apiToken, subdomain: auth.companySubdomain, body: { status } });
+            return;
+        }
+        const data = await client.patch(`${config.apiBasePath}/${parsedId}`, { status });
+        outputJson(data);
+    });
+    statusCmd.action(function (idArg, ...rest) {
+        const parsedId = parseInt(idArg, 10);
+        if (isNaN(parsedId) || parsedId <= 0) {
+            process.stderr.write(JSON.stringify({ error: 'ID must be a positive integer', code: 'VALIDATION_ERROR' }) + '\n');
+            process.exit(4);
+        }
+        this.setOptionValue('_entityId', parsedId);
+        return wrappedHandler.call(this, idArg, ...rest);
+    });
+}
+/**
+ * Register all entity CRUD commands on the Commander program.
+ *
+ * Iterates allEntityConfigs from core, creates group and resource subcommands,
+ * and adds list/get subcommands based on each entity's supported operations.
+ */
+export function registerEntityCommands(program) {
+    for (const config of allEntityConfigs) {
+        if (!config.cliGroup)
+            continue;
+        const groupName = config.cliGroup;
+        const resourceName = RESOURCE_NAME_MAP[config.entity];
+        if (!resourceName)
+            continue;
+        // Find or create the group command
+        let groupCmd = program.commands.find((c) => c.name() === groupName);
+        if (!groupCmd) {
+            groupCmd = program
+                .command(groupName)
+                .description(GROUP_DESCRIPTIONS[groupName] || groupName);
+        }
+        // Create resource subcommand under the group
+        const resourceCmd = groupCmd
+            .command(resourceName)
+            .description(`Manage ${pluralize(config.description)}`);
+        // Add list subcommand if supported
+        if (config.operations.includes('list')) {
+            addListCommand(resourceCmd, config);
+        }
+        // Add get subcommand if supported
+        if (config.operations.includes('get')) {
+            addGetCommand(resourceCmd, config);
+        }
+        // Add create subcommand if supported
+        if (config.operations.includes('create')) {
+            addCreateCommand(resourceCmd, config);
+        }
+        // Add update subcommand if supported
+        if (config.operations.includes('update')) {
+            addUpdateCommand(resourceCmd, config);
+        }
+        // Add delete subcommand if supported
+        if (config.operations.includes('delete')) {
+            addDeleteCommand(resourceCmd, config);
+        }
+        // Add status subcommand if entity supports status updates
+        if (config.hasStatusUpdate) {
+            addStatusCommand(resourceCmd, config);
+        }
+    }
+}