@proletariat/cli 0.3.44 → 0.3.46

package/dist/commands/linear/import.js

@@ -0,0 +1,260 @@
+import { Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { colors } from '../../lib/colors.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { LinearClient, isLinearConfigured, loadLinearConfig, LinearMapper, } from '../../lib/linear/index.js';
+export default class LinearImport extends PMOCommand {
+    static description = 'Import Linear issues into PMO as tickets';
+    static strict = false; // Allow variadic issue identifier args
+    static examples = [
+        '<%= config.bin %> <%= command.id %>                           # Interactive: select team and issues',
+        '<%= config.bin %> <%= command.id %> ENG-123 ENG-124           # Import specific issues by identifier',
+        '<%= config.bin %> <%= command.id %> --team ENG                # Import from a specific team',
+        '<%= config.bin %> <%= command.id %> --team ENG --state "In Progress"  # Filter by state',
+        '<%= config.bin %> <%= command.id %> --team ENG --label bug    # Filter by label',
+        '<%= config.bin %> <%= command.id %> --limit 20 --json         # Import up to 20 issues, JSON output',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        team: Flags.string({
+            char: 't',
+            description: 'Linear team key (e.g., ENG)',
+        }),
+        state: Flags.string({
+            description: 'Filter by Linear state name (e.g., "In Progress", "Backlog")',
+        }),
+        'state-type': Flags.string({
+            description: 'Filter by Linear state type',
+            options: ['triage', 'backlog', 'unstarted', 'started', 'completed', 'canceled'],
+        }),
+        label: Flags.string({
+            description: 'Filter by Linear label name',
+        }),
+        assignee: Flags.string({
+            description: 'Filter by assignee name or "me"',
+        }),
+        cycle: Flags.string({
+            description: 'Filter by cycle ID',
+        }),
+        limit: Flags.integer({
+            char: 'n',
+            description: 'Maximum number of issues to import',
+            default: 50,
+        }),
+        all: Flags.boolean({
+            char: 'a',
+            description: 'Import all matching issues without interactive selection',
+            default: false,
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Preview issues that would be imported without creating tickets',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags, argv } = await this.parse(LinearImport);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        // Check Linear is configured
+        if (!isLinearConfigured(db)) {
+            if (jsonMode) {
+                outputErrorAsJson('LINEAR_NOT_CONFIGURED', 'Linear is not configured. Run "prlt linear auth" first.', createMetadata('linear import', flags));
+                this.exit(1);
+            }
+            this.error('Linear is not configured. Run "prlt linear auth" first.');
+        }
+        const config = loadLinearConfig(db);
+        const client = new LinearClient(config.apiKey);
+        const mapper = new LinearMapper(db);
+        // Parse explicit issue identifiers from args
+        const issueIdentifiers = argv;
+        // Get project for import
+        const projectId = await this.requireProject({
+            jsonMode: jsonMode ? {
+                flags,
+                commandName: 'linear import',
+                baseCommand: `${this.config.bin} linear import`,
+            } : undefined,
+        });
+        // Get the project's workflow statuses for mapping
+        const workflow = await this.storage.getProjectWorkflow(projectId);
+        if (!workflow) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_WORKFLOW', 'Project has no workflow configured.', createMetadata('linear import', flags));
+                this.exit(1);
+            }
+            this.error('Project has no workflow configured.');
+        }
+        const statuses = await this.storage.listStatuses(workflow.id);
+        let issues;
+        if (issueIdentifiers.length > 0) {
+            // Fetch specific issues by identifier
+            this.log(colors.textMuted(`Fetching ${issueIdentifiers.length} issue(s) from Linear...`));
+            issues = [];
+            for (const id of issueIdentifiers) {
+                // eslint-disable-next-line no-await-in-loop
+                const issue = await client.getIssueByIdentifier(id);
+                if (issue) {
+                    issues.push(issue);
+                }
+                else {
+                    this.log(colors.warning(`Issue not found: ${id}`));
+                }
+            }
+        }
+        else {
+            // Build filter from flags
+            const filter = {
+                teamKey: flags.team ?? config.defaultTeamKey,
+                stateName: flags.state,
+                stateType: flags['state-type'],
+                labelName: flags.label,
+                assigneeMe: flags.assignee?.toLowerCase() === 'me' ? true : undefined,
+                assigneeId: flags.assignee && flags.assignee.toLowerCase() !== 'me' ? flags.assignee : undefined,
+                cycleId: flags.cycle,
+                limit: flags.limit,
+            };
+            // If no team specified and no default, prompt
+            if (!filter.teamKey && !filter.teamId) {
+                const teams = await client.listTeams();
+                if (teams.length === 0) {
+                    if (jsonMode) {
+                        outputErrorAsJson('NO_TEAMS', 'No teams found in your Linear workspace.', createMetadata('linear import', flags));
+                        this.exit(1);
+                    }
+                    this.error('No teams found in your Linear workspace.');
+                }
+                if (teams.length === 1) {
+                    filter.teamKey = teams[0].key;
+                }
+                else {
+                    if (jsonMode) {
+                        const teamChoices = teams.map((t) => ({
+                            name: `${t.name} (${t.key})`,
+                            value: t.key,
+                        }));
+                        outputPromptAsJson(buildPromptConfig('list', 'teamKey', 'Select a team to import from:', teamChoices), createMetadata('linear import', flags));
+                    }
+                    const teamChoices = teams.map((t) => ({
+                        name: `${t.name} (${t.key})`,
+                        value: t.key,
+                    }));
+                    const { teamKey } = await inquirer.prompt([{
+                            type: 'list',
+                            name: 'teamKey',
+                            message: 'Select a team to import from:',
+                            choices: teamChoices,
+                        }]);
+                    filter.teamKey = teamKey;
+                }
+            }
+            this.log(colors.textMuted(`Fetching issues from Linear (team: ${filter.teamKey})...`));
+            issues = await client.listIssues(filter);
+        }
+        if (issues.length === 0) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    imported: 0,
+                    message: 'No matching issues found.',
+                }, createMetadata('linear import', flags));
+                return;
+            }
+            this.log(colors.warning('No matching issues found.'));
+            return;
+        }
+        // Check which are already imported
+        const newIssues = [];
+        const alreadyImported = [];
+        for (const issue of issues) {
+            const existing = mapper.getByLinearId(issue.id);
+            if (existing) {
+                alreadyImported.push(issue);
+            }
+            else {
+                newIssues.push(issue);
+            }
+        }
+        if (newIssues.length === 0) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    imported: 0,
+                    skipped: alreadyImported.length,
+                    message: 'All matching issues are already imported.',
+                }, createMetadata('linear import', flags));
+                return;
+            }
+            this.log(colors.textMuted(`All ${alreadyImported.length} matching issue(s) already imported.`));
+            return;
+        }
+        // Interactive selection (unless --all or explicit IDs)
+        let selectedIssues = newIssues;
+        if (!flags.all && issueIdentifiers.length === 0 && !jsonMode) {
+            const issueChoices = newIssues.map((issue) => ({
+                name: `${issue.identifier}  ${issue.title}  [${issue.state.name}]  ${issue.priority > 0 ? `P${issue.priority - 1}` : ''}`,
+                value: issue.id,
+                checked: true,
+            }));
+            const { selectedIds } = await inquirer.prompt([{
+                    type: 'checkbox',
+                    name: 'selectedIds',
+                    message: `Select issues to import (${newIssues.length} new, ${alreadyImported.length} already imported):`,
+                    choices: issueChoices,
+                }]);
+            selectedIssues = newIssues.filter((i) => selectedIds.includes(i.id));
+        }
+        if (selectedIssues.length === 0) {
+            this.log(colors.textMuted('No issues selected.'));
+            return;
+        }
+        // Dry run mode
+        if (flags['dry-run']) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    dryRun: true,
+                    wouldImport: selectedIssues.map((i) => ({
+                        identifier: i.identifier,
+                        title: i.title,
+                        state: i.state.name,
+                        priority: i.priority,
+                    })),
+                }, createMetadata('linear import', flags));
+                return;
+            }
+            this.log('');
+            this.log(colors.primary('Dry run - would import:'));
+            for (const issue of selectedIssues) {
+                this.log(`  ${colors.textSecondary(issue.identifier)}  ${issue.title}`);
+            }
+            this.log('');
+            this.log(colors.textMuted(`${selectedIssues.length} issue(s) would be imported.`));
+            return;
+        }
+        // Import issues
+        this.log('');
+        this.log(colors.textMuted(`Importing ${selectedIssues.length} issue(s)...`));
+        const result = await mapper.importIssues(selectedIssues, projectId, this.storage, statuses);
+        if (jsonMode) {
+            outputSuccessAsJson({
+                imported: result.imported,
+                updated: result.updated,
+                skipped: result.skipped,
+                errors: result.errors,
+            }, createMetadata('linear import', flags));
+            return;
+        }
+        this.log('');
+        if (result.imported > 0) {
+            this.log(colors.success(`Imported ${result.imported} issue(s) into PMO`));
+        }
+        if (result.skipped > 0) {
+            this.log(colors.textMuted(`  Skipped ${result.skipped} (already imported)`));
+        }
+        if (result.errors.length > 0) {
+            this.log(colors.error(`  ${result.errors.length} error(s):`));
+            for (const err of result.errors) {
+                this.log(colors.textMuted(`    ${err.identifier}: ${err.error}`));
+            }
+        }
+    }
+}

package/dist/commands/linear/status.d.ts

@@ -0,0 +1,11 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class LinearStatus extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/linear/status.js

@@ -0,0 +1,88 @@
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { colors } from '../../lib/colors.js';
+import { shouldOutputJson, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { LinearClient, isLinearConfigured, loadLinearConfig, } from '../../lib/linear/index.js';
+import { LinearMapper } from '../../lib/linear/mapper.js';
+export default class LinearStatus extends PMOCommand {
+    static description = 'Show Linear integration status and connection info';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    async execute() {
+        const { flags } = await this.parse(LinearStatus);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        if (!isLinearConfigured(db)) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    configured: false,
+                    message: 'Linear is not configured. Run "prlt linear auth" to connect.',
+                }, createMetadata('linear status', flags));
+                return;
+            }
+            this.log(colors.warning('Linear is not configured'));
+            this.log(colors.textMuted('Run "prlt linear auth" to connect your Linear workspace.'));
+            return;
+        }
+        const config = loadLinearConfig(db);
+        // Verify connection
+        let connectionInfo = null;
+        let connectionError = null;
+        try {
+            const client = new LinearClient(config.apiKey);
+            connectionInfo = await client.verify();
+        }
+        catch (error) {
+            connectionError = error instanceof Error ? error.message : String(error);
+        }
+        // Count mapped issues
+        const mapper = new LinearMapper(db);
+        const mappings = mapper.listMappings();
+        if (jsonMode) {
+            outputSuccessAsJson({
+                configured: true,
+                connected: connectionInfo !== null,
+                organization: connectionInfo?.organizationName ?? config.organizationName ?? null,
+                user: connectionInfo?.userName ?? null,
+                email: connectionInfo?.email ?? null,
+                defaultTeam: config.defaultTeamKey ?? null,
+                mappedIssues: mappings.length,
+                error: connectionError,
+            }, createMetadata('linear status', flags));
+            return;
+        }
+        this.log(colors.primary('Linear Integration Status'));
+        this.log('');
+        if (connectionInfo) {
+            this.log(`  ${colors.success('Connected')}`);
+            this.log(colors.textMuted(`  Organization: ${connectionInfo.organizationName}`));
+            this.log(colors.textMuted(`  User: ${connectionInfo.userName} (${connectionInfo.email})`));
+        }
+        else {
+            this.log(`  ${colors.error('Connection failed')}`);
+            if (connectionError) {
+                this.log(colors.textMuted(`  Error: ${connectionError}`));
+            }
+        }
+        if (config.defaultTeamKey) {
+            this.log(colors.textMuted(`  Default team: ${config.defaultTeamKey}`));
+        }
+        this.log('');
+        this.log(colors.textMuted(`  Mapped issues: ${mappings.length}`));
+        if (mappings.length > 0) {
+            const recent = mappings.slice(0, 5);
+            this.log('');
+            this.log(colors.textMuted('  Recent mappings:'));
+            for (const m of recent) {
+                this.log(colors.textMuted(`    ${m.linearIdentifier} → ${m.pmoTicketId}`));
+            }
+            if (mappings.length > 5) {
+                this.log(colors.textMuted(`    ... and ${mappings.length - 5} more`));
+            }
+        }
+    }
+}

package/dist/commands/linear/sync.d.ts

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class LinearSyncCommand extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        ticket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'pr-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'pr-title': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/linear/sync.js

@@ -0,0 +1,233 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { colors } from '../../lib/colors.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { LinearClient, LinearMapper, LinearSync, isLinearConfigured, loadLinearConfig, } from '../../lib/linear/index.js';
+export default class LinearSyncCommand extends PMOCommand {
+    static description = 'Sync PMO ticket status and PR links back to Linear';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>                    # Sync all mapped tickets',
+        '<%= config.bin %> <%= command.id %> --ticket TKT-001   # Sync a specific ticket',
+        '<%= config.bin %> <%= command.id %> --pr-url https://github.com/... --ticket TKT-001  # Attach PR to Linear issue',
+        '<%= config.bin %> <%= command.id %> --dry-run          # Preview what would be synced',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        ticket: Flags.string({
+            description: 'PMO ticket ID to sync (syncs all if omitted)',
+        }),
+        'pr-url': Flags.string({
+            description: 'PR URL to attach to the Linear issue',
+        }),
+        'pr-title': Flags.string({
+            description: 'PR title for the attachment (defaults to ticket title)',
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Preview what would be synced without making changes',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(LinearSyncCommand);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        if (!isLinearConfigured(db)) {
+            if (jsonMode) {
+                outputErrorAsJson('LINEAR_NOT_CONFIGURED', 'Linear is not configured. Run "prlt linear auth" first.', createMetadata('linear sync', flags));
+                this.exit(1);
+            }
+            this.error('Linear is not configured. Run "prlt linear auth" first.');
+        }
+        const config = loadLinearConfig(db);
+        const client = new LinearClient(config.apiKey);
+        const mapper = new LinearMapper(db);
+        const sync = new LinearSync(client, mapper);
+        // Handle PR link attachment
+        if (flags['pr-url'] && flags.ticket) {
+            const prTitle = flags['pr-title'] ?? (await this.storage.getTicket(flags.ticket))?.title ?? 'Pull Request';
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        dryRun: true,
+                        action: 'attach-pr',
+                        ticketId: flags.ticket,
+                        prUrl: flags['pr-url'],
+                        prTitle,
+                    }, createMetadata('linear sync', flags));
+                    return;
+                }
+                this.log(colors.textMuted(`Would attach PR to ${flags.ticket}: ${flags['pr-url']}`));
+                return;
+            }
+            const attached = await sync.syncPRLink(flags.ticket, flags['pr-url'], prTitle);
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    action: 'attach-pr',
+                    ticketId: flags.ticket,
+                    prUrl: flags['pr-url'],
+                    synced: attached,
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            if (attached) {
+                this.log(colors.success(`PR linked to Linear issue for ${flags.ticket}`));
+            }
+            else {
+                this.log(colors.warning(`No Linear mapping found for ${flags.ticket}`));
+            }
+            return;
+        }
+        // Sync ticket status(es) back to Linear
+        if (flags.ticket) {
+            // Single ticket sync
+            const ticket = await this.storage.getTicket(flags.ticket);
+            if (!ticket) {
+                if (jsonMode) {
+                    outputErrorAsJson('TICKET_NOT_FOUND', `Ticket ${flags.ticket} not found.`, createMetadata('linear sync', flags));
+                    this.exit(1);
+                }
+                this.error(`Ticket ${flags.ticket} not found.`);
+            }
+            const mapping = mapper.getByTicketId(flags.ticket);
+            if (!mapping) {
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        synced: false,
+                        message: `Ticket ${flags.ticket} has no Linear mapping.`,
+                    }, createMetadata('linear sync', flags));
+                    return;
+                }
+                this.log(colors.warning(`Ticket ${flags.ticket} has no Linear mapping.`));
+                return;
+            }
+            // Get Linear states for the team
+            const team = await client.getTeamByKey(mapping.linearTeamKey);
+            if (!team) {
+                if (jsonMode) {
+                    outputErrorAsJson('TEAM_NOT_FOUND', `Linear team ${mapping.linearTeamKey} not found.`, createMetadata('linear sync', flags));
+                    this.exit(1);
+                }
+                this.error(`Linear team ${mapping.linearTeamKey} not found.`);
+            }
+            const linearStates = await client.listStates(team.id);
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        dryRun: true,
+                        action: 'sync-status',
+                        ticketId: flags.ticket,
+                        linearIdentifier: mapping.linearIdentifier,
+                        currentStatus: ticket.statusName,
+                        statusCategory: ticket.statusCategory,
+                    }, createMetadata('linear sync', flags));
+                    return;
+                }
+                this.log(colors.textMuted(`Would sync ${flags.ticket} (${mapping.linearIdentifier}): status "${ticket.statusName}" (${ticket.statusCategory})`));
+                return;
+            }
+            const synced = await sync.syncTicketStatus(ticket, linearStates);
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    action: 'sync-status',
+                    ticketId: flags.ticket,
+                    linearIdentifier: mapping.linearIdentifier,
+                    synced,
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            if (synced) {
+                this.log(colors.success(`Synced ${mapping.linearIdentifier} status to Linear`));
+            }
+            else {
+                this.log(colors.warning(`Could not find matching Linear state for ${ticket.statusCategory}`));
+            }
+            return;
+        }
+        // Bulk sync: sync all mapped tickets
+        const mappings = mapper.listMappings();
+        if (mappings.length === 0) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    synced: 0,
+                    message: 'No mapped tickets to sync.',
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            this.log(colors.textMuted('No mapped tickets to sync.'));
+            return;
+        }
+        if (!jsonMode) {
+            this.log(colors.textMuted(`Syncing ${mappings.length} mapped ticket(s) to Linear...`));
+        }
+        // Group mappings by team to fetch states efficiently
+        const teamKeys = [...new Set(mappings.map((m) => m.linearTeamKey))];
+        const statesByTeam = {};
+        for (const teamKey of teamKeys) {
+            // eslint-disable-next-line no-await-in-loop
+            const team = await client.getTeamByKey(teamKey);
+            if (team) {
+                // eslint-disable-next-line no-await-in-loop
+                statesByTeam[teamKey] = await client.listStates(team.id);
+            }
+        }
+        if (flags['dry-run']) {
+            const preview = [];
+            for (const mapping of mappings) {
+                // eslint-disable-next-line no-await-in-loop
+                const ticket = await this.storage.getTicket(mapping.pmoTicketId);
+                preview.push({
+                    ticketId: mapping.pmoTicketId,
+                    linearIdentifier: mapping.linearIdentifier,
+                    currentStatus: ticket?.statusName,
+                    statusCategory: ticket?.statusCategory,
+                });
+            }
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    dryRun: true,
+                    action: 'sync-all',
+                    tickets: preview,
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            this.log('');
+            for (const item of preview) {
+                this.log(colors.textMuted(`  ${item.linearIdentifier} → ${item.currentStatus} (${item.statusCategory})`));
+            }
+            return;
+        }
+        // Perform the sync for each team
+        let totalSynced = 0;
+        let totalSkipped = 0;
+        let totalErrors = 0;
+        for (const teamKey of teamKeys) {
+            const teamStates = statesByTeam[teamKey];
+            if (!teamStates) {
+                totalErrors += mappings.filter((m) => m.linearTeamKey === teamKey).length;
+                continue;
+            }
+            const teamMappings = mappings.filter((m) => m.linearTeamKey === teamKey);
+            // eslint-disable-next-line no-await-in-loop
+            const result = await sync.syncAllStatuses(this.storage, teamMappings, teamStates);
+            totalSynced += result.synced;
+            totalSkipped += result.skipped;
+            totalErrors += result.errors;
+        }
+        if (jsonMode) {
+            outputSuccessAsJson({
+                action: 'sync-all',
+                synced: totalSynced,
+                skipped: totalSkipped,
+                errors: totalErrors,
+            }, createMetadata('linear sync', flags));
+            return;
+        }
+        this.log('');
+        if (totalSynced > 0)
+            this.log(colors.success(`Synced: ${totalSynced}`));
+        if (totalSkipped > 0)
+            this.log(colors.textMuted(`Skipped: ${totalSkipped}`));
+        if (totalErrors > 0)
+            this.log(colors.error(`Errors: ${totalErrors}`));
+    }
+}

package/dist/commands/orchestrator/attach.d.ts

@@ -1,13 +1,21 @@
 import { PromptCommand } from '../../lib/prompt-command.js';
+/**
+ * Detect the terminal emulator from environment variables.
+ * Returns a terminal app name suitable for AppleScript tab creation,
+ * or null if detection fails or we're in a remote/headless environment.
+ */
+export declare function detectTerminalApp(): string | null;
 export default class OrchestratorAttach extends PromptCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        'new-tab': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        terminal: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'current-terminal': import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        terminal: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    private attachInCurrentTerminal;
     private openInNewTab;
 }