@hyperdrive.bot/cli 1.0.12 → 1.0.16

package/dist/commands/tracker/project/list-modules.js

@@ -0,0 +1,117 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
+import { printTable } from '../../../utils/table.js';
+import { selectTrackerProject } from '../../../utils/tracker-project-flow.js';
+export default class TrackerProjectListModules extends Command {
+    static description = 'List modules linked to a tracker project';
+    static examples = [
+        '<%= config.bin %> tracker project list-modules',
+        '<%= config.bin %> tracker project list-modules --tracker-project-id tp-abc123',
+        '<%= config.bin %> tracker project list-modules --tracker-project-id tp-abc123 --json',
+        '<%= config.bin %> tracker project list-modules --domain my-tenant.hyperdrivebot.dev',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            default: false,
+            description: 'Output raw JSON response',
+        }),
+        'tracker-project-id': Flags.string({
+            description: 'Tracker project ID (skips interactive selection)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TrackerProjectListModules);
+        const isJson = flags.json;
+        const service = new HyperdriveSigV4Service(flags.domain);
+        try {
+            // Select tracker project (interactive or via flag)
+            const project = await selectTrackerProject(service, flags['tracker-project-id']);
+            const spinner = isJson ? null : ora('Fetching linked modules...').start();
+            // Fetch linked modules and all modules in parallel
+            const [linkedModules, allModules] = await Promise.all([
+                service.trackerProjectListModules(project.trackerProjectId),
+                service.moduleList(),
+            ]);
+            spinner?.stop();
+            // Build module name lookup map (projectId → name)
+            const moduleNameMap = new Map();
+            for (const mod of allModules) {
+                if (mod.projectId) {
+                    moduleNameMap.set(mod.projectId, mod.name || mod.slug || mod.projectId);
+                }
+            }
+            // Enrich linked modules with human-readable names
+            const enriched = linkedModules.map(link => ({
+                ...link,
+                moduleName: moduleNameMap.get(link.moduleId) || link.moduleId,
+            }));
+            // Empty state
+            if (enriched.length === 0) {
+                if (isJson) {
+                    this.log(JSON.stringify([], null, 2));
+                }
+                else {
+                    this.log(chalk.yellow('\nNo modules linked to this tracker project.'));
+                }
+                return;
+            }
+            // JSON output
+            if (isJson) {
+                this.log(JSON.stringify(enriched, null, 2));
+                return;
+            }
+            // Table output
+            this.log('');
+            printTable(enriched, {
+                moduleName: {
+                    header: 'Module',
+                    minWidth: 20,
+                    get: (row) => {
+                        const r = row;
+                        return chalk.cyan(r.moduleName);
+                    },
+                },
+                role: {
+                    header: 'Role',
+                    minWidth: 14,
+                    get: (row) => {
+                        const r = row;
+                        if (r.role === 'primary')
+                            return chalk.green('primary');
+                        return chalk.dim(r.role || 'supporting');
+                    },
+                },
+                linkedAt: {
+                    header: 'Linked At',
+                    minWidth: 24,
+                    get: (row) => {
+                        const r = row;
+                        return r.linkedAt || chalk.gray('-');
+                    },
+                },
+            }, (msg) => this.log(msg));
+            // Count footer
+            this.log(`\n${enriched.length} modules linked to ${chalk.cyan(project.externalProjectKey)} (${project.externalProjectName})`);
+            // Hooks info footer
+            this.log(`ℹ  All hooks on this tracker project apply to every linked module. Use 'hd tracker project link-module' or 'unlink-module' to manage.`);
+        }
+        catch (error) {
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            if (status === 404) {
+                this.log(chalk.red('\n❌ Tracker project not found.'));
+                this.log(chalk.gray('Run "hd tracker project list" to see available projects.'));
+            }
+            else {
+                this.log(chalk.red(`\n❌ ${axiosError.response?.data?.message ?? axiosError.message}`));
+            }
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/tracker/project/list.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class TrackerProjectList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tracker/project/list.js

@@ -0,0 +1,90 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
+import { printTable } from '../../../utils/table.js';
+const PROVIDER_ICONS = {
+    'github-issues': '⚫ GitHub',
+    jira: '🔷 Jira',
+    linear: '🟣 Linear',
+};
+export default class TrackerProjectList extends Command {
+    static description = 'List all configured tracker projects';
+    static examples = [
+        '<%= config.bin %> tracker project list',
+        '<%= config.bin %> tracker project list --json',
+        '<%= config.bin %> tracker project list --domain my-tenant.hyperdrivebot.dev',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            default: false,
+            description: 'Output raw JSON response',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TrackerProjectList);
+        const isJson = flags.json;
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const spinner = isJson ? null : ora('Fetching tracker projects...').start();
+        try {
+            const projects = await service.trackerProjectList();
+            spinner?.stop();
+            if (isJson) {
+                this.log(JSON.stringify(projects, null, 2));
+                return;
+            }
+            if (!projects || projects.length === 0) {
+                this.log(chalk.yellow('\nNo tracker projects found.'));
+                this.log(chalk.gray('Run "hd tracker project init" to create one.'));
+                return;
+            }
+            this.log(chalk.green(`\n${projects.length} tracker project(s) found:\n`));
+            printTable(projects, {
+                trackerProjectId: {
+                    header: 'ID',
+                    minWidth: 18,
+                    get: (row) => {
+                        const tp = row;
+                        return chalk.cyan(tp.trackerProjectId.length > 16 ? tp.trackerProjectId.slice(0, 16) + '…' : tp.trackerProjectId);
+                    },
+                },
+                provider: {
+                    header: 'Provider',
+                    minWidth: 14,
+                    get: (row) => {
+                        const tp = row;
+                        return PROVIDER_ICONS[tp.provider] ?? tp.provider;
+                    },
+                },
+                externalProjectKey: {
+                    header: 'External Key',
+                    minWidth: 14,
+                },
+                statusMappingCount: {
+                    header: 'Statuses',
+                    get: (row) => {
+                        const tp = row;
+                        return String(Object.keys(tp.statusMapping || {}).length);
+                    },
+                },
+                createdAt: {
+                    header: 'Created',
+                    get: (row) => {
+                        const tp = row;
+                        return tp.createdAt ? new Date(tp.createdAt).toLocaleDateString() : chalk.gray('-');
+                    },
+                },
+            }, (msg) => this.log(msg));
+        }
+        catch (error) {
+            spinner?.fail('Failed to fetch tracker projects');
+            const axiosError = error;
+            this.log(chalk.red(`\n❌ ${axiosError.response?.data?.message ?? axiosError.message}`));
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/tracker/project/status.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class TrackerProjectStatus extends Command {
+    static args: {
+        'tracker-project': import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tracker/project/status.js

@@ -0,0 +1,168 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
+import { printHeader, printTable } from '../../../utils/table.js';
+const PROVIDER_ICONS = {
+    'github-issues': '⚫ GitHub',
+    jira: '🔷 Jira',
+    linear: '🟣 Linear',
+};
+function getSummaryFreshness(module) {
+    if (!module.lastSyncedAt || module.summaryStatus === 'not_generated')
+        return 'missing';
+    const daysSinceSync = (Date.now() - new Date(module.lastSyncedAt).getTime()) / (1000 * 60 * 60 * 24);
+    return daysSinceSync > 7 ? 'stale' : 'fresh';
+}
+function colorFreshness(status) {
+    if (status === 'fresh')
+        return chalk.green(status);
+    if (status === 'stale')
+        return chalk.yellow(status);
+    return chalk.red(status);
+}
+export default class TrackerProjectStatus extends Command {
+    static args = {
+        'tracker-project': Args.string({
+            description: 'Tracker project ID',
+            required: true,
+        }),
+    };
+    static description = 'Show detailed status of a tracker project';
+    static examples = [
+        '<%= config.bin %> tracker project status tp-abc123',
+        '<%= config.bin %> tracker project status tp-abc123 --json',
+        '<%= config.bin %> tracker project status tp-abc123 --domain my-tenant.hyperdrivebot.dev',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            default: false,
+            description: 'Output raw JSON response',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TrackerProjectStatus);
+        const trackerProjectId = args['tracker-project'];
+        const isJson = flags.json;
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const spinner = isJson ? null : ora('Fetching tracker project context...').start();
+        try {
+            const data = await service.trackerProjectGetContext(trackerProjectId);
+            spinner?.succeed('Context retrieved');
+            if (isJson) {
+                this.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const tp = data.trackerProject;
+            // Tracker Info section
+            printHeader('Tracker Info', (msg) => this.log(msg));
+            this.log(`  Provider:            ${PROVIDER_ICONS[tp.provider] ?? tp.provider}`);
+            this.log(`  External Project Key: ${chalk.cyan(tp.externalProjectKey)}`);
+            this.log(`  External Project:    ${tp.externalProjectName}`);
+            this.log(`  Tracker ID:          ${chalk.dim(tp.trackerId)}`);
+            this.log(`  Tracker Project ID:  ${chalk.dim(tp.trackerProjectId)}`);
+            // Linked Modules section
+            printHeader('Linked Modules', (msg) => this.log(msg));
+            if (data.linkedModules.length === 0) {
+                this.log(chalk.gray('  No modules linked.'));
+            }
+            else {
+                printTable(data.linkedModules, {
+                    name: {
+                        header: 'Name',
+                        minWidth: 20,
+                        get: (row) => {
+                            const m = row;
+                            return chalk.cyan(m.metadata.name);
+                        },
+                    },
+                    summaryStatus: {
+                        header: 'Summary Status',
+                        minWidth: 16,
+                        get: (row) => {
+                            const m = row;
+                            return colorFreshness(getSummaryFreshness(m));
+                        },
+                    },
+                    lastSyncedAt: {
+                        header: 'Last Synced',
+                        minWidth: 22,
+                        get: (row) => {
+                            const m = row;
+                            return m.lastSyncedAt ? new Date(m.lastSyncedAt).toLocaleString() : chalk.gray('never');
+                        },
+                    },
+                }, (msg) => this.log(msg));
+            }
+            // Status Mapping section
+            printHeader('Status Mapping', (msg) => this.log(msg));
+            const mappingEntries = Object.entries(tp.statusMapping || {});
+            if (mappingEntries.length === 0) {
+                this.log(chalk.gray('  No status mapping configured.'));
+            }
+            else {
+                const mappingRows = mappingEntries.map(([providerStatus, normalizedState]) => ({
+                    normalizedState,
+                    providerStatus,
+                }));
+                printTable(mappingRows, {
+                    providerStatus: {
+                        header: 'Provider Status',
+                        minWidth: 22,
+                    },
+                    normalizedState: {
+                        header: 'Normalized State',
+                        minWidth: 22,
+                        get: (row) => chalk.cyan(String(row.normalizedState)),
+                    },
+                }, (msg) => this.log(msg));
+            }
+            // Hooks section
+            printHeader('Hooks', (msg) => this.log(msg));
+            const hookEntries = Object.entries(data.hooksSummary || {});
+            if (hookEntries.length === 0) {
+                this.log(chalk.gray('  No hooks configured.'));
+            }
+            else {
+                const hookRows = hookEntries.flatMap(([triggerStatus, actions]) => actions.map((action) => ({ action, triggerStatus })));
+                printTable(hookRows, {
+                    triggerStatus: {
+                        header: 'Trigger Status',
+                        minWidth: 22,
+                    },
+                    action: {
+                        header: 'Action Type',
+                        minWidth: 22,
+                    },
+                }, (msg) => this.log(msg));
+            }
+            // Warning banner for stale/missing modules
+            const issueModules = data.linkedModules.filter((m) => {
+                const freshness = getSummaryFreshness(m);
+                return freshness === 'stale' || freshness === 'missing';
+            });
+            if (issueModules.length > 0) {
+                this.log('');
+                this.log(chalk.yellow(`⚠  Warning: ${issueModules.length} module(s) have stale or missing architecture summaries. Run "hd module sync {module}" to refresh.`));
+            }
+            this.log('');
+        }
+        catch (error) {
+            spinner?.fail('Failed to fetch tracker project');
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            if (status === 404) {
+                this.log(chalk.red('\n❌ Tracker project not found.'));
+                this.log(chalk.gray('Run "hd tracker project list" to see available projects.'));
+            }
+            else {
+                this.log(chalk.red(`\n❌ ${axiosError.response?.data?.message ?? axiosError.message}`));
+            }
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/tracker/project/unlink-module.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class TrackerProjectUnlinkModule extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        modules: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'tracker-project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tracker/project/unlink-module.js

@@ -0,0 +1,251 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
+import { printTable } from '../../../utils/table.js';
+import { selectTrackerProject } from '../../../utils/tracker-project-flow.js';
+export default class TrackerProjectUnlinkModule extends Command {
+    static description = 'Unlink one or more modules from an existing tracker project';
+    static examples = [
+        '<%= config.bin %> tracker project unlink-module',
+        '<%= config.bin %> tracker project unlink-module --tracker-project-id abc123',
+        '<%= config.bin %> tracker project unlink-module --tracker-project-id abc123 --modules mod1,mod2 --yes',
+        '<%= config.bin %> tracker project unlink-module --json',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            default: false,
+            description: 'Output raw JSON response',
+        }),
+        modules: Flags.string({
+            description: 'Comma-separated module IDs to unlink (non-interactive)',
+        }),
+        'tracker-project-id': Flags.string({
+            description: 'Tracker project ID (skips interactive selection)',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'Skip confirmation prompt',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TrackerProjectUnlinkModule);
+        const isJson = flags.json;
+        const isNonInteractive = Boolean(flags.modules);
+        // Auth
+        let service;
+        const authSpinner = isJson ? null : ora('Checking authentication...').start();
+        try {
+            service = new HyperdriveSigV4Service(flags.domain);
+            authSpinner?.succeed('Authenticated');
+        }
+        catch (error) {
+            authSpinner?.fail('Not authenticated');
+            this.error(`${error.message}\n\n` +
+                `Please authenticate first with: ${chalk.cyan('hd auth login')}`);
+        }
+        try {
+            // Step 1: Select tracker project
+            const project = await selectTrackerProject(service, flags['tracker-project-id']);
+            if (!isJson) {
+                this.log(`\nTracker project: ${chalk.cyan(project.externalProjectKey)} — ${project.externalProjectName}\n`);
+            }
+            // Step 2: Fetch linked modules and enrich with names
+            const fetchSpinner = isJson ? null : ora('Fetching linked modules...').start();
+            const [linkedModules, allModules] = await Promise.all([
+                service.trackerProjectListModules(project.trackerProjectId),
+                service.moduleList(),
+            ]);
+            fetchSpinner?.succeed(`Found ${linkedModules.length} linked module(s)`);
+            // Build module name lookup map
+            const moduleNameMap = new Map();
+            for (const mod of allModules) {
+                if (mod.projectId) {
+                    moduleNameMap.set(mod.projectId, mod.name || mod.slug || mod.projectId);
+                }
+            }
+            // Enrich linked modules with names
+            const enriched = linkedModules.map(link => ({
+                ...link,
+                moduleName: moduleNameMap.get(link.moduleId) || link.moduleId,
+            }));
+            // Empty state: no modules linked
+            if (enriched.length === 0) {
+                if (isJson) {
+                    this.log(JSON.stringify({ message: 'No modules linked to this tracker project.', results: [] }, null, 2));
+                }
+                else {
+                    this.log(chalk.yellow('\nNo modules linked to this tracker project.'));
+                }
+                return;
+            }
+            // Step 3: Select modules to unlink
+            let modulesToUnlink;
+            if (isNonInteractive) {
+                // Non-interactive: parse --modules flag
+                const moduleIds = flags.modules.split(',').map(s => s.trim()).filter(Boolean);
+                modulesToUnlink = [];
+                for (const id of moduleIds) {
+                    const linked = enriched.find(m => m.moduleId === id);
+                    if (!linked) {
+                        this.warn(`Module "${id}" is not linked to this project — skipping`);
+                        continue;
+                    }
+                    modulesToUnlink.push({
+                        moduleId: linked.moduleId,
+                        moduleName: linked.moduleName,
+                        role: linked.role || 'supporting',
+                    });
+                }
+            }
+            else {
+                // Interactive: checkbox prompt
+                const { selectedModules } = await inquirer.prompt([{
+                        choices: enriched.map(m => ({
+                            name: `${m.moduleName} [${m.role || 'supporting'}]`,
+                            value: { moduleId: m.moduleId, moduleName: m.moduleName, role: m.role || 'supporting' },
+                        })),
+                        message: 'Select modules to unlink (space to select, enter to confirm):',
+                        name: 'selectedModules',
+                        type: 'checkbox',
+                        validate: (input) => input.length > 0 ? true : 'Select at least one module',
+                    }]);
+                modulesToUnlink = selectedModules;
+            }
+            if (modulesToUnlink.length === 0) {
+                this.log(chalk.yellow('\nNo modules to unlink.'));
+                return;
+            }
+            // Step 4: Primary module warning
+            const hasPrimary = modulesToUnlink.some(m => m.role === 'primary');
+            if (hasPrimary && !isJson) {
+                this.log('');
+                this.log(chalk.yellow('\u26A0  You are unlinking the primary module. No module will be marked as primary after this.'));
+            }
+            // Step 5: Unlink info banner
+            if (!isJson) {
+                this.log('');
+                this.log(chalk.blue('\u2139  Unlinking a module removes it from this tracker project\'s automation scope.'));
+                this.log(chalk.blue('   Existing hooks will no longer fire for issues related to the unlinked module.'));
+                this.log('');
+                // Display summary
+                this.log(chalk.bold('Modules to unlink:'));
+                for (const mod of modulesToUnlink) {
+                    const roleTag = mod.role === 'primary' ? chalk.green(` [${mod.role}]`) : chalk.dim(` [${mod.role}]`);
+                    this.log(`  - ${mod.moduleName}${roleTag}`);
+                }
+                this.log('');
+            }
+            // Step 6: Confirmation
+            if (!flags.yes && !isNonInteractive && !isJson) {
+                const { confirmed } = await inquirer.prompt([{
+                        default: true,
+                        message: 'Unlink these modules?',
+                        name: 'confirmed',
+                        type: 'confirm',
+                    }]);
+                if (!confirmed) {
+                    this.log(chalk.yellow('Cancelled. No modules were unlinked.'));
+                    return;
+                }
+            }
+            // Step 7: Execute unlinking
+            const results = [];
+            for (const mod of modulesToUnlink) {
+                const spinner = isJson ? null : ora(`Unlinking ${chalk.cyan(mod.moduleName)}...`).start();
+                try {
+                    await service.trackerProjectUnlinkModule(project.trackerProjectId, mod.moduleId);
+                    spinner?.succeed(`Module ${chalk.cyan(mod.moduleName)} unlinked`);
+                    results.push({
+                        moduleId: mod.moduleId,
+                        moduleName: mod.moduleName,
+                        role: mod.role,
+                        status: 'unlinked',
+                    });
+                }
+                catch (error) {
+                    const status = error.response?.status;
+                    if (status === 404) {
+                        spinner?.warn(`Module ${chalk.cyan(mod.moduleName)} is not linked — skipping`);
+                        this.warn(`Module "${mod.moduleName}" is not linked — skipping`);
+                        results.push({
+                            moduleId: mod.moduleId,
+                            moduleName: mod.moduleName,
+                            role: mod.role,
+                            status: 'skipped',
+                            warning: 'Not linked',
+                        });
+                    }
+                    else {
+                        const msg = error.response?.data?.message || error.response?.data?.error || error.message;
+                        spinner?.warn(`Failed to unlink ${chalk.cyan(mod.moduleName)}: ${msg}`);
+                        this.warn(`Failed to unlink "${mod.moduleName}": ${msg}`);
+                        results.push({
+                            moduleId: mod.moduleId,
+                            moduleName: mod.moduleName,
+                            role: mod.role,
+                            status: 'skipped',
+                            warning: msg,
+                        });
+                    }
+                }
+            }
+            // Step 8: Output results
+            if (isJson) {
+                this.log(JSON.stringify(results, null, 2));
+                return;
+            }
+            const unlinked = results.filter(r => r.status === 'unlinked');
+            const skipped = results.filter(r => r.status === 'skipped');
+            if (unlinked.length > 0) {
+                this.log('');
+                printTable(unlinked, {
+                    moduleName: {
+                        header: 'Module',
+                        minWidth: 20,
+                    },
+                    role: {
+                        get: (row) => {
+                            const r = row;
+                            return r.role === 'primary' ? chalk.green(r.role) : chalk.dim(r.role || 'supporting');
+                        },
+                        header: 'Role',
+                        minWidth: 14,
+                    },
+                    status: {
+                        get: () => chalk.green('unlinked'),
+                        header: 'Status',
+                    },
+                }, (msg) => this.log(msg));
+            }
+            this.log('');
+            this.log(chalk.green(`${unlinked.length} module(s) unlinked successfully.`));
+            if (skipped.length > 0) {
+                this.log(chalk.yellow(`${skipped.length} module(s) skipped (not linked or error).`));
+            }
+            this.log('');
+        }
+        catch (error) {
+            let errorMessage = error.message;
+            if (error.response) {
+                const data = error.response.data;
+                if (error.response.status === 401) {
+                    errorMessage = 'Authentication failed — please run "hd auth login"';
+                }
+                else if (data?.error) {
+                    errorMessage = data.error;
+                }
+                else if (data?.message) {
+                    errorMessage = data.message;
+                }
+            }
+            this.error(errorMessage);
+        }
+    }
+}