@proletariat/cli 0.3.45 → 0.3.47

package/bin/validate-better-sqlite3.cjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+const SUPPORTED_NODE_MAJORS = [20, 22, 23, 24, 25]
+
+function parseNodeMajor(version) {
+  const match = /^v?(\d+)/.exec(version)
+  return match ? Number.parseInt(match[1], 10) : null
+}
+
+function runtimeInfo() {
+  return {
+    nodeVersion: process.version,
+    nodeMajor: parseNodeMajor(process.version),
+    abi: process.versions.modules,
+    platform: process.platform,
+    arch: process.arch,
+  }
+}
+
+function buildMessage(error, context) {
+  const info = runtimeInfo()
+  const nodeMajorHint = info.nodeMajor === null || SUPPORTED_NODE_MAJORS.includes(info.nodeMajor)
+    ? ''
+    : `\n- Unsupported Node major for this CLI: ${info.nodeMajor} (supported: ${SUPPORTED_NODE_MAJORS.join(', ')})`
+  const reason = error instanceof Error ? error.message : String(error)
+
+  return [
+    `better-sqlite3 native module validation failed (${context}).`,
+    `Runtime: node ${info.nodeVersion} (ABI ${info.abi}) on ${info.platform}-${info.arch}.${nodeMajorHint}`,
+    `Load error: ${reason}`,
+    '',
+    'Fix steps:',
+    '1. Rebuild native bindings for this runtime: npm rebuild better-sqlite3',
+    '2. Verify runtime architecture: node -p "process.platform + \'-\' + process.arch + \' abi=\' + process.versions.modules"',
+    '3. Reinstall with your active Node version if needed: npm uninstall -g @proletariat/cli && npm install -g @proletariat/cli',
+  ].join('\n')
+}
+
+function validate(context) {
+  try {
+    const Database = require('better-sqlite3')
+    const db = new Database(':memory:')
+    db.pragma('foreign_keys = ON')
+    db.close()
+  } catch (error) {
+    throw new Error(buildMessage(error, context))
+  }
+}
+
+try {
+  validate('postinstall')
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error))
+  process.exit(1)
+}

package/dist/commands/config/index.js

@@ -6,7 +6,7 @@ import { PromptCommand } from '../../lib/prompt-command.js';
 import { machineOutputFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { getWorkspaceInfo } from '../../lib/agents/commands.js';
-import { loadExecutionConfig, saveTerminalApp, saveTerminalOpenInBackground, saveTmuxControlMode, saveShell, } from '../../lib/execution/config.js';
+import { loadExecutionConfig, saveTerminalApp, saveTerminalOpenInBackground, saveTmuxControlMode, saveShell, saveCreatePrDefault, saveFirewallAllowlistDomains, } from '../../lib/execution/config.js';
 import { shouldOutputJson, isNonTTY, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class Config extends PromptCommand {
     static description = 'View and update workspace configuration';
@@ -15,6 +15,7 @@ export default class Config extends PromptCommand {
         '<%= config.bin %> <%= command.id %> --json             # Output current config as JSON',
         '<%= config.bin %> <%= command.id %> --set terminal.app iTerm',
         '<%= config.bin %> <%= command.id %> --set terminal.openInBackground true',
+        '<%= config.bin %> <%= command.id %> --set firewall.allowlistDomains "api.staging.example.com"',
         '<%= config.bin %> <%= command.id %> --setting terminal.app --json  # Show terminal app choices',
     ];
     static flags = {
@@ -93,6 +94,10 @@ export default class Config extends PromptCommand {
                         defaultEnvironment: config.defaultEnvironment,
                         outputMode: config.outputMode,
                         sandboxed: config.sandboxed,
+                        createPrDefault: config.createPrDefault ?? null,
+                        firewall: {
+                            allowlistDomains: config.firewall.allowlistDomains,
+                        },
                     }, createMetadata('config', flags));
                 }
                 else {
@@ -115,6 +120,8 @@ export default class Config extends PromptCommand {
                     this.log(`  defaultEnvironment: ${config.defaultEnvironment}`);
                     this.log(`  outputMode:       ${config.outputMode}`);
                     this.log(`  sandboxed:        ${config.sandboxed}`);
+                    this.log(`  createPrDefault:  ${config.createPrDefault ?? 'not set (will prompt)'}`);
+                    this.log(`  firewall.allowlistDomains: ${config.firewall.allowlistDomains.join(', ') || '(none)'}`);
                     this.log('');
                 }
                 db.close();
@@ -132,6 +139,7 @@ export default class Config extends PromptCommand {
                 { name: `Open Tabs in Background: ${config.terminal.openInBackground}`, value: 'terminal.openInBackground', command: 'prlt config --setting terminal.openInBackground --json' },
                 { name: `Shell: ${config.shell}`, value: 'shell', command: 'prlt config --setting shell --json' },
                 { name: `Tmux Control Mode (iTerm -CC): ${config.tmux.controlMode}`, value: 'tmux.controlMode', command: 'prlt config --setting tmux.controlMode --json' },
+                { name: `Firewall allowlist domains: ${config.firewall.allowlistDomains.length || 0}`, value: 'firewall.allowlistDomains', command: 'prlt config --setting firewall.allowlistDomains --json' },
             ];
             const { setting } = await this.prompt([
                 {
@@ -145,6 +153,8 @@ export default class Config extends PromptCommand {
                         settingChoices[2],
                         new inquirer.Separator('── Tmux ──'),
                         settingChoices[3],
+                        new inquirer.Separator('── Execution ──'),
+                        settingChoices[4],
                         new inquirer.Separator(),
                         { name: 'Exit', value: '__exit__' },
                     ],
@@ -247,6 +257,23 @@ export default class Config extends PromptCommand {
                 this.log(styles.success(`Tmux control mode set to: ${controlMode}`));
                 break;
             }
+            case 'firewall.allowlistDomains': {
+                const { domainsInput } = await this.prompt([
+                    {
+                        type: 'input',
+                        name: 'domainsInput',
+                        message: 'Extra firewall allowlist domains (comma-separated, leave empty to clear):',
+                        default: config.firewall.allowlistDomains.join(', '),
+                    },
+                ], jsonModeConfig);
+                const domains = domainsInput
+                    .split(',')
+                    .map(domain => domain.trim())
+                    .filter(Boolean);
+                saveFirewallAllowlistDomains(db, domains);
+                this.log(styles.success(`Firewall allowlist domains set (${domains.length})`));
+                break;
+            }
             default: {
                 const jsonMode = shouldOutputJson(jsonModeConfig?.flags ?? {});
                 if (jsonMode) {
@@ -271,6 +298,17 @@ export default class Config extends PromptCommand {
             case 'tmux.controlmode':
                 saveTmuxControlMode(db, value.toLowerCase() === 'true');
                 break;
+            case 'execution.create_pr_default':
+                saveCreatePrDefault(db, value.toLowerCase() === 'true');
+                break;
+            case 'firewall.allowlistdomains': {
+                const domains = value
+                    .split(',')
+                    .map(domain => domain.trim())
+                    .filter(Boolean);
+                saveFirewallAllowlistDomains(db, domains);
+                break;
+            }
             default:
                 if (jsonMode) {
                     outputErrorAsJson('UNKNOWN_KEY', `Unknown config key: ${key}`, createMetadata('config', {}));

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

@@ -0,0 +1,14 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class LinearAuth extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        check: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        disconnect: 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/auth.js

@@ -0,0 +1,211 @@
+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, createMetadata, } from '../../lib/prompt-json.js';
+import { LinearClient, loadLinearConfig, saveLinearApiKey, saveLinearDefaultTeam, saveLinearOrganization, clearLinearConfig, getLinearApiKey, } from '../../lib/linear/index.js';
+export default class LinearAuth extends PMOCommand {
+    static description = 'Authenticate with Linear and configure workspace connection';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --check',
+        '<%= config.bin %> <%= command.id %> --force',
+        'LINEAR_API_KEY=lin_api_... <%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        check: Flags.boolean({
+            description: 'Only check if Linear credentials exist (do not prompt)',
+            default: false,
+        }),
+        force: Flags.boolean({
+            description: 'Force re-authentication even if credentials exist',
+            default: false,
+        }),
+        disconnect: Flags.boolean({
+            description: 'Remove stored Linear credentials',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(LinearAuth);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        // Handle --disconnect
+        if (flags.disconnect) {
+            clearLinearConfig(db);
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    disconnected: true,
+                    message: 'Linear credentials removed.',
+                }, createMetadata('linear auth', flags));
+                return;
+            }
+            this.log(colors.success('Linear credentials removed.'));
+            return;
+        }
+        // Handle --check
+        if (flags.check) {
+            const config = loadLinearConfig(db);
+            if (config) {
+                // Try to verify the connection
+                try {
+                    const client = new LinearClient(config.apiKey);
+                    const info = await client.verify();
+                    if (jsonMode) {
+                        outputSuccessAsJson({
+                            authenticated: true,
+                            organization: info.organizationName,
+                            user: info.userName,
+                            email: info.email,
+                            defaultTeam: config.defaultTeamKey ?? null,
+                        }, createMetadata('linear auth', flags));
+                        return;
+                    }
+                    this.log(colors.success('Linear connection is active'));
+                    this.log(colors.textMuted(`  Organization: ${info.organizationName}`));
+                    this.log(colors.textMuted(`  User: ${info.userName} (${info.email})`));
+                    if (config.defaultTeamKey) {
+                        this.log(colors.textMuted(`  Default team: ${config.defaultTeamKey}`));
+                    }
+                }
+                catch (error) {
+                    if (jsonMode) {
+                        outputErrorAsJson('LINEAR_AUTH_INVALID', 'Stored Linear API key is invalid or expired.', createMetadata('linear auth', flags));
+                        this.exit(1);
+                    }
+                    this.log(colors.error('Stored Linear API key is invalid or expired.'));
+                    this.log(colors.textMuted('Run "prlt linear auth --force" to re-authenticate.'));
+                    this.exit(1);
+                }
+            }
+            else {
+                if (jsonMode) {
+                    outputErrorAsJson('LINEAR_NOT_CONFIGURED', 'Linear is not configured. Run "prlt linear auth" to authenticate.', createMetadata('linear auth', flags));
+                    this.exit(1);
+                }
+                this.log(colors.warning('Linear is not configured.'));
+                this.log(colors.textMuted('Run "prlt linear auth" to authenticate.'));
+                this.exit(1);
+            }
+            return;
+        }
+        // Check for existing config
+        const existingConfig = loadLinearConfig(db);
+        if (existingConfig && !flags.force) {
+            try {
+                const client = new LinearClient(existingConfig.apiKey);
+                const info = await client.verify();
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        authenticated: true,
+                        organization: info.organizationName,
+                        user: info.userName,
+                        message: 'Already authenticated. Use --force to re-authenticate.',
+                    }, createMetadata('linear auth', flags));
+                    return;
+                }
+                this.log(colors.success('Already connected to Linear'));
+                this.log(colors.textMuted(`  Organization: ${info.organizationName}`));
+                this.log(colors.textMuted(`  User: ${info.userName}`));
+                this.log('');
+                this.log(colors.textMuted('Use --force to re-authenticate.'));
+                return;
+            }
+            catch {
+                // Stored key is bad, proceed with re-auth
+            }
+        }
+        // Try environment variable first
+        const envKey = getLinearApiKey(db);
+        let apiKey = envKey;
+        if (!apiKey) {
+            // Prompt for API key
+            if (jsonMode) {
+                outputErrorAsJson('API_KEY_REQUIRED', 'Linear API key required. Set LINEAR_API_KEY or PRLT_LINEAR_API_KEY environment variable, or run interactively.', createMetadata('linear auth', flags));
+                this.exit(1);
+            }
+            this.log('');
+            this.log(colors.primary('Linear Authentication'));
+            this.log('');
+            this.log('Create a personal API key at:');
+            this.log(colors.textSecondary('  https://linear.app/settings/api'));
+            this.log('');
+            const { inputKey } = await inquirer.prompt([{
+                    type: 'password',
+                    name: 'inputKey',
+                    message: 'Enter your Linear API key:',
+                    mask: '*',
+                    validate: (input) => {
+                        if (!input.trim())
+                            return 'API key is required';
+                        if (!input.startsWith('lin_api_'))
+                            return 'Linear API keys start with "lin_api_"';
+                        return true;
+                    },
+                }]);
+            apiKey = inputKey;
+        }
+        // Verify the API key
+        this.log('');
+        this.log(colors.textMuted('Verifying API key...'));
+        let client;
+        try {
+            client = new LinearClient(apiKey);
+            const info = await client.verify();
+            // Save API key and org name
+            saveLinearApiKey(db, apiKey);
+            saveLinearOrganization(db, info.organizationName);
+            if (jsonMode) {
+                // Don't prompt for team in JSON mode, just save the key
+                outputSuccessAsJson({
+                    authenticated: true,
+                    organization: info.organizationName,
+                    user: info.userName,
+                    email: info.email,
+                }, createMetadata('linear auth', flags));
+                return;
+            }
+            this.log(colors.success(`Connected to ${info.organizationName}`));
+            this.log(colors.textMuted(`  Signed in as ${info.userName} (${info.email})`));
+        }
+        catch (error) {
+            if (jsonMode) {
+                outputErrorAsJson('LINEAR_AUTH_FAILED', `Authentication failed: ${error instanceof Error ? error.message : String(error)}`, createMetadata('linear auth', flags));
+                this.exit(1);
+            }
+            this.error(`Authentication failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Prompt for default team selection
+        this.log('');
+        const teams = await client.listTeams();
+        if (teams.length === 0) {
+            this.log(colors.warning('No teams found in your Linear workspace.'));
+            return;
+        }
+        if (teams.length === 1) {
+            // Auto-select the only team
+            saveLinearDefaultTeam(db, teams[0].id, teams[0].key);
+            this.log(colors.textMuted(`  Default team set to: ${teams[0].name} (${teams[0].key})`));
+        }
+        else {
+            const teamChoices = teams.map((t) => ({
+                name: `${t.name} (${t.key})`,
+                value: t.id,
+            }));
+            const { selectedTeamId } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedTeamId',
+                    message: 'Select your default team:',
+                    choices: teamChoices,
+                }]);
+            const selectedTeam = teams.find((t) => t.id === selectedTeamId);
+            saveLinearDefaultTeam(db, selectedTeam.id, selectedTeam.key);
+            this.log(colors.textMuted(`  Default team set to: ${selectedTeam.name} (${selectedTeam.key})`));
+        }
+        this.log('');
+        this.log(colors.success('Linear integration configured!'));
+        this.log(colors.textMuted('  Run "prlt linear import" to pull issues into PMO'));
+        this.log(colors.textMuted('  Run "prlt work spawn --from-linear" to pull and spawn agents'));
+    }
+}

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

@@ -0,0 +1,21 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class LinearImport extends PMOCommand {
+    static description: string;
+    static strict: boolean;
+    static examples: string[];
+    static flags: {
+        team: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        state: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'state-type': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        label: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        assignee: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        cycle: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        '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/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>;
+}