cherrypick-interactive 1.7.1 → 1.8.0

package/cli.js

@@ -7,6 +7,7 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import semver from 'semver';
 import simpleGit from 'simple-git';
+import isSafeRegex from 'safe-regex2';
 import updateNotifier from 'update-notifier';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
@@ -35,88 +36,214 @@ if (upd && semver.valid(upd.latest) && semver.valid(pkg.version) && semver.gt(up
 const argv = yargs(hideBin(process.argv))
     .scriptName('cherrypick-interactive')
     .usage('$0 [options]')
+    // ── Cherry-pick options ──
     .option('dev', {
         type: 'string',
         default: 'origin/dev',
         describe: 'Source branch (contains commits you want).',
+        group: 'Cherry-pick options:',
     })
     .option('main', {
         type: 'string',
         default: 'origin/main',
         describe: 'Comparison branch (commits present here will be filtered out).',
+        group: 'Cherry-pick options:',
     })
     .option('since', {
         type: 'string',
         default: '1 week ago',
         describe: 'Time window passed to git --since (e.g. "2 weeks ago", "1 month ago").',
+        group: 'Cherry-pick options:',
     })
     .option('no-fetch', {
         type: 'boolean',
         default: false,
         describe: "Skip 'git fetch --prune'.",
+        group: 'Cherry-pick options:',
     })
     .option('all-yes', {
         type: 'boolean',
         default: false,
         describe: 'Non-interactive: cherry-pick ALL missing commits (oldest → newest).',
+        group: 'Cherry-pick options:',
     })
-    .option('dry-run', {
-        type: 'boolean',
-        default: false,
-        describe: 'Print what would be cherry-picked and exit.',
+    .option('ignore-commits', {
+        type: 'string',
+        describe:
+            'Comma-separated regex patterns. If a commit message matches any, it will be omitted from the commit list.',
+        group: 'Cherry-pick options:',
     })
+
+    // ── Version options ──
     .option('semantic-versioning', {
         type: 'boolean',
         default: true,
         describe: 'Compute next semantic version from selected (or missing) commits.',
+        group: 'Version options:',
     })
     .option('current-version', {
         type: 'string',
         describe: 'Current version (X.Y.Z). Required when --semantic-versioning is set.',
+        group: 'Version options:',
+    })
+    .option('version-file', {
+        type: 'string',
+        default: './package.json',
+        describe: 'Path to package.json (read current version; optional replacement for --current-version)',
+        group: 'Version options:',
+    })
+    .option('version-commit-message', {
+        type: 'string',
+        default: 'chore(release): bump version to {{version}}',
+        describe: 'Commit message template for version bump. Use {{version}} placeholder.',
+        group: 'Version options:',
     })
+    .option('ignore-semver', {
+        type: 'string',
+        describe:
+            'Comma-separated regex patterns. If a commit message matches any, it will be treated as a chore for semantic versioning.',
+        group: 'Version options:',
+    })
+
+    // ── Release options ──
     .option('create-release', {
         type: 'boolean',
         default: true,
         describe: 'Create a release branch from --main named release/<computed-version> before cherry-picking.',
+        group: 'Release options:',
     })
     .option('push-release', {
         type: 'boolean',
         default: true,
         describe: 'After creating the release branch, push and set upstream (origin).',
+        group: 'Release options:',
     })
     .option('draft-pr', {
         type: 'boolean',
         default: false,
         describe: 'Create the release PR as a draft.',
+        group: 'Release options:',
     })
-    .option('version-file', {
+
+    // ── CI options ──
+    .option('ci', {
+        type: 'boolean',
+        default: false,
+        describe: 'Enable CI mode (fully non-interactive).',
+        group: 'CI options:',
+    })
+    .option('conflict-strategy', {
         type: 'string',
-        default: './package.json',
-        describe: 'Path to package.json (read current version; optional replacement for --current-version)',
+        default: 'fail',
+        describe: 'How to handle conflicts: fail, ours, theirs, skip.',
+        choices: ['fail', 'ours', 'theirs', 'skip'],
+        group: 'CI options:',
     })
-    .option('version-commit-message', {
+    .option('format', {
         type: 'string',
-        default: 'chore(release): bump version to {{version}}',
-        describe: 'Commit message template for version bump. Use {{version}} placeholder.',
+        default: 'text',
+        describe: 'Output format: text or json. JSON goes to stdout, logs to stderr.',
+        choices: ['text', 'json'],
+        group: 'CI options:',
     })
-    .option('ignore-semver', {
+    .option('dependency-strategy', {
         type: 'string',
-        describe:
-            'Comma-separated regex patterns. If a commit message matches any, it will be treated as a chore for semantic versioning.',
+        default: 'warn',
+        describe: 'How to handle detected dependencies: warn, fail, ignore.',
+        choices: ['warn', 'fail', 'ignore'],
+        group: 'CI options:',
     })
-    .option('ignore-commits', {
+
+    // ── Tracker options ──
+    .option('tracker', {
         type: 'string',
-        describe:
-            'Comma-separated regex patterns. If a commit message matches any, it will be omitted from the commit list.',
+        describe: 'Built-in preset: clickup, jira, linear. Sets ticket-pattern automatically.',
+        choices: ['clickup', 'jira', 'linear'],
+        group: 'Tracker options:',
+    })
+    .option('ticket-pattern', {
+        type: 'string',
+        describe: 'Custom regex to capture ticket ID from commit message (must have one capture group).',
+        group: 'Tracker options:',
+    })
+    .option('tracker-url', {
+        type: 'string',
+        describe: 'URL template with {{id}} placeholder (required when using tracker).',
+        group: 'Tracker options:',
+    })
+
+    // ── Profile options ──
+    .option('profile', {
+        type: 'string',
+        describe: 'Load a named profile from .cherrypickrc.json.',
+        group: 'Profile options:',
+    })
+    .option('save-profile', {
+        type: 'string',
+        describe: 'Save current CLI flags as a named profile.',
+        group: 'Profile options:',
+    })
+    .option('list-profiles', {
+        type: 'boolean',
+        default: false,
+        describe: 'List available profiles and exit.',
+        group: 'Profile options:',
+    })
+
+    // ── Session options ──
+    .option('undo', {
+        type: 'boolean',
+        default: false,
+        describe: 'Reset current release branch to pre-cherry-pick state.',
+        group: 'Session options:',
     })
-    .wrap(200)
+
+    // ── UI options ──
+    .option('no-tui', {
+        type: 'boolean',
+        default: false,
+        describe: 'Disable TUI dashboard, use simple inquirer checkbox instead.',
+        group: 'UI options:',
+    })
+    .option('dry-run', {
+        type: 'boolean',
+        default: false,
+        describe: 'Print what would be cherry-picked and exit.',
+        group: 'UI options:',
+    })
+
+    .wrap(Math.min(120, process.stdout.columns || 120))
     .help()
     .alias('h', 'help')
     .alias('v', 'version').argv;
 
-const log = (...a) => console.log(...a);
+// When --format json, all log output goes to stderr so stdout is clean JSON
+const isJsonFormat = process.argv.some((a, i) =>
+    (a === '--format' && process.argv[i + 1] === 'json') || a === '--format=json',
+);
+if (isJsonFormat) {
+    // Disable chalk colors for clean stderr in JSON mode
+    process.env.NO_COLOR = '1';
+}
+const log = (...a) => (isJsonFormat ? console.error(...a) : console.log(...a));
 const err = (...a) => console.error(...a);
 
+// CI result collector (populated during execution, output at end)
+const ciResult = {
+    version: { previous: null, next: null, bump: null },
+    branch: null,
+    commits: { applied: [], skipped: [], total: 0 },
+    changelog: null,
+    pr: { url: null },
+};
+
+class ExitError extends Error {
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.exitCode = exitCode;
+    }
+}
+
 async function gitRaw(args) {
     const out = await git.raw(args);
     return out.trim();
@@ -183,8 +310,43 @@ async function handleCherryPickConflict(hash) {
         return 'skipped';
     }
 
+    const strategy = argv['conflict-strategy'] || 'fail';
+
+    // CI mode: auto-resolve based on strategy
+    if (argv.ci) {
+        err(chalk.red(`\n✖ Cherry-pick has conflicts on ${hash} (${shortSha(hash)}).`));
+
+        if (strategy === 'fail') {
+            await gitRaw(['cherry-pick', '--abort']);
+            throw new ExitError('Conflict detected with --conflict-strategy fail. Aborting.', 1);
+        }
+
+        if (strategy === 'skip') {
+            await gitRaw(['cherry-pick', '--skip']);
+            log(chalk.yellow(`↷ Skipped commit ${chalk.dim(`(${shortSha(hash)})`)}`));
+            return 'skipped';
+        }
+
+        if (strategy === 'ours') {
+            await gitRaw(['checkout', '--ours', '.']);
+            await gitRaw(['add', '.']);
+            await gitRaw(['cherry-pick', '--continue']);
+            log(chalk.yellow(`⚠ Resolved with --ours: ${chalk.dim(`(${shortSha(hash)})`)}`));
+            return 'continued';
+        }
+
+        if (strategy === 'theirs') {
+            await gitRaw(['checkout', '--theirs', '.']);
+            await gitRaw(['add', '.']);
+            await gitRaw(['cherry-pick', '--continue']);
+            log(chalk.yellow(`⚠ Resolved with --theirs: ${chalk.dim(`(${shortSha(hash)})`)}`));
+            return 'continued';
+        }
+    }
+
+    // Interactive mode
     while (true) {
-        err(chalk.red(`\n✖ Cherry-pick has conflicts on ${hash} (${hash.slice(0, 7)}).`));
+        err(chalk.red(`\n✖ Cherry-pick has conflicts on ${hash} (${shortSha(hash)}).`));
         await showConflictsList(); // prints conflicted files (if any)
 
         const { action } = await inquirer.prompt([
@@ -202,7 +364,7 @@ async function handleCherryPickConflict(hash) {
 
         if (action === 'skip') {
             await gitRaw(['cherry-pick', '--skip']);
-            log(chalk.yellow(`↷ Skipped commit ${chalk.dim(`(${hash.slice(0, 7)})`)}`));
+            log(chalk.yellow(`↷ Skipped commit ${chalk.dim(`(${shortSha(hash)})`)}`));
             return 'skipped';
         }
 
@@ -490,24 +652,26 @@ async function conflictsResolutionWizard(hash) {
 }
 
 async function cherryPickSequential(hashes) {
-    const result = { applied: 0, skipped: 0 };
+    const result = { applied: 0, skipped: 0, appliedHashes: [], skippedHashes: [] };
 
     for (const hash of hashes) {
         try {
             await gitRaw(['cherry-pick', hash]);
             const subject = await gitRaw(['show', '--format=%s', '-s', hash]);
-            log(`${chalk.green('✓')} cherry-picked ${chalk.dim(`(${hash.slice(0, 7)})`)} ${subject}`);
+            log(`${chalk.green('✓')} cherry-picked ${chalk.dim(`(${shortSha(hash)})`)} ${subject}`);
             result.applied += 1;
+            result.appliedHashes.push(hash);
         } catch (e) {
             try {
                 const action = await handleCherryPickConflict(hash);
                 if (action === 'skipped') {
                     result.skipped += 1;
+                    result.skippedHashes.push(hash);
                     continue;
                 }
                 if (action === 'continued') {
-                    // --continue başarıyla commit oluşturdu
                     result.applied += 1;
+                    result.appliedHashes.push(hash);
                 }
             } catch (abortErr) {
                 err(chalk.red(`✖ Cherry-pick aborted on ${hash}`));
@@ -616,8 +780,483 @@ async function computeSemanticBumpForCommits(hashes, gitRawFn, semverignore) {
     return collapseBumps(levels);
 }
 
+// ── Profile helpers ──
+
+const RC_FILENAME = '.cherrypickrc.json';
+
+/** Allowlist of flags that can be saved in a profile */
+const SAVEABLE_FLAGS = new Set([
+    'dev', 'main', 'since', 'no-fetch', 'all-yes', 'ignore-commits',
+    'semantic-versioning', 'current-version', 'version-file', 'version-commit-message', 'ignore-semver',
+    'create-release', 'push-release', 'draft-pr', 'dry-run',
+    'tracker', 'ticket-pattern', 'tracker-url',
+    'no-tui',
+]);
+
+async function getRepoRoot() {
+    return (await gitRaw(['rev-parse', '--show-toplevel'])).trim();
+}
+
+async function getRcPath() {
+    const root = await getRepoRoot();
+    return join(root, RC_FILENAME);
+}
+
+async function loadRcConfig() {
+    const rcPath = await getRcPath();
+    return (await readJson(rcPath)) || {};
+}
+
+async function saveRcConfig(config) {
+    const rcPath = await getRcPath();
+    await writeJson(rcPath, config);
+}
+
+async function loadProfile(name) {
+    const config = await loadRcConfig();
+    const profiles = config.profiles || {};
+    if (!profiles[name]) {
+        throw new Error(`Profile "${name}" not found in ${RC_FILENAME}. Available: ${Object.keys(profiles).join(', ') || '(none)'}`);
+    }
+    return profiles[name];
+}
+
+async function saveProfile(name, flags) {
+    const config = await loadRcConfig();
+    config.profiles = config.profiles || {};
+
+    if (config.profiles[name]) {
+        const { overwrite } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: `Profile "${name}" already exists. Overwrite?`,
+                default: false,
+            },
+        ]);
+        if (!overwrite) {
+            log(chalk.yellow('Aborted — profile not saved.'));
+            return false;
+        }
+    }
+
+    const filtered = {};
+    for (const [key, value] of Object.entries(flags)) {
+        if (SAVEABLE_FLAGS.has(key)) {
+            filtered[key] = value;
+        }
+    }
+
+    config.profiles[name] = filtered;
+    await saveRcConfig(config);
+
+    log(chalk.green(`\n✓ Profile "${name}" saved to ${RC_FILENAME}:`));
+    log(JSON.stringify(filtered, null, 2));
+    return true;
+}
+
+async function listProfiles() {
+    const config = await loadRcConfig();
+    const profiles = config.profiles || {};
+    const names = Object.keys(profiles);
+
+    if (names.length === 0) {
+        log(chalk.yellow(`No profiles found in ${RC_FILENAME}.`));
+        return;
+    }
+
+    log(chalk.cyan(`\nProfiles in ${RC_FILENAME}:\n`));
+    for (const name of names) {
+        const flags = profiles[name];
+        const summary = Object.entries(flags)
+            .map(([k, v]) => `${k}=${v}`)
+            .join(', ');
+        log(`  ${chalk.bold(name)}  ${chalk.dim(summary)}`);
+    }
+    log('');
+}
+
+function applyProfile(profile, currentArgv) {
+    for (const [key, value] of Object.entries(profile)) {
+        // CLI flags (explicit) override profile values.
+        // yargs sets properties from defaults — we detect explicit CLI flags
+        // by checking if the key is in the raw process.argv
+        const cliFlag = `--${key}`;
+        const wasExplicit = process.argv.some((a) => a === cliFlag || a.startsWith(`${cliFlag}=`));
+        if (!wasExplicit) {
+            currentArgv[key] = value;
+            // Also set camelCase version for yargs compatibility
+            const camel = key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+            if (camel !== key) currentArgv[camel] = value;
+        }
+    }
+}
+
+// ── TUI detection ──
+
+const MIN_TUI_ROWS = 15;
+const MIN_TUI_COLS = 60;
+
+function shouldUseTui() {
+    // Explicit opt-out
+    if (argv['no-tui'] || argv.noTui) return false;
+    // CI mode or all-yes: no interactive UI needed
+    if (argv.ci || argv['all-yes']) return false;
+    // Non-interactive terminal
+    if (!process.stdout.isTTY) return false;
+    // CI environment variable
+    if (process.env.CI === 'true' || process.env.CI === '1') return false;
+    // Windows: fallback to inquirer
+    if (process.platform === 'win32') return false;
+    // Terminal too small
+    const rows = process.stdout.rows || 24;
+    const cols = process.stdout.columns || 80;
+    if (rows < MIN_TUI_ROWS || cols < MIN_TUI_COLS) return false;
+    return true;
+}
+
+async function selectCommitsWithTuiOrFallback(commits) {
+    if (shouldUseTui()) {
+        const { renderCommitSelector } = await import('./src/tui/index.js');
+        return renderCommitSelector(commits, gitRaw, {
+            devBranch: argv.dev,
+            mainBranch: argv.main,
+            since: argv.since,
+        });
+    }
+    return selectCommitsInteractive(commits);
+}
+
+// ── Session helpers (undo/rollback) ──
+
+const SESSION_FILENAME = '.cherrypick-session.json';
+
+async function getSessionPath() {
+    const root = await getRepoRoot();
+    return join(root, SESSION_FILENAME);
+}
+
+async function saveSession({ branch, checkpoint, commits }) {
+    const sessionPath = await getSessionPath();
+    const data = {
+        branch,
+        checkpoint,
+        timestamp: new Date().toISOString(),
+        commits,
+    };
+    await writeJson(sessionPath, data);
+}
+
+async function loadSession() {
+    const sessionPath = await getSessionPath();
+    return readJson(sessionPath);
+}
+
+async function deleteSession() {
+    const sessionPath = await getSessionPath();
+    try {
+        await fsPromises.unlink(sessionPath);
+    } catch (e) {
+        if (e.code !== 'ENOENT') throw e;
+    }
+}
+
+async function hasRemoteTrackingBranch() {
+    try {
+        await gitRaw(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function handleUndo() {
+    // --undo + --ci is not allowed
+    if (argv.ci) {
+        throw new ExitError('--undo is interactive-only and cannot be used with --ci. In CI, re-run the pipeline instead.', 1);
+    }
+
+    const session = await loadSession();
+    if (!session) {
+        throw new ExitError(`No active session to undo. (${SESSION_FILENAME} not found)`, 1);
+    }
+
+    const currentBranch = await gitRaw(['rev-parse', '--abbrev-ref', 'HEAD']);
+
+    // Warn if on a different branch
+    if (currentBranch !== session.branch) {
+        log(chalk.yellow(`⚠ You are on "${currentBranch}" but the session was created on "${session.branch}".`));
+        const { switchBranch } = await inquirer.prompt([
+            { type: 'confirm', name: 'switchBranch', message: `Switch to ${session.branch}?`, default: true },
+        ]);
+        if (switchBranch) {
+            await gitRaw(['checkout', session.branch]);
+        } else {
+            log(chalk.yellow('Aborted.'));
+            return;
+        }
+    }
+
+    // Validate checkpoint is an ancestor of current HEAD
+    try {
+        await gitRaw(['merge-base', '--is-ancestor', session.checkpoint, 'HEAD']);
+    } catch {
+        throw new ExitError(`Checkpoint ${shortSha(session.checkpoint)} is not an ancestor of current HEAD. Session may be corrupt.`, 1);
+    }
+
+    // Divergence check: count commits between checkpoint and HEAD
+    const revCount = await gitRaw(['rev-list', '--count', `${session.checkpoint}..HEAD`]);
+    const commitsSinceCheckpoint = Number.parseInt(revCount.trim(), 10);
+    const expectedCommits = session.commits?.length || 0;
+
+    if (commitsSinceCheckpoint > expectedCommits) {
+        throw new ExitError(
+            `Branch has diverged: ${commitsSinceCheckpoint} commits since checkpoint, but session recorded ${expectedCommits}. Someone else may have pushed. Aborting to prevent data loss.`,
+            1,
+        );
+    }
+
+    // Confirmation
+    log(chalk.yellow(`\n⚠ WARNING: This will rewrite remote history for ${session.branch}.`));
+    log(chalk.yellow('  Anyone else working on this branch will be affected.\n'));
+    log(`  Checkpoint: ${chalk.dim(shortSha(session.checkpoint))}`);
+    log(`  Commits to discard: ${commitsSinceCheckpoint}`);
+    log(chalk.gray('  This is an all-or-nothing rollback — individual commits cannot be selectively removed.\n'));
+
+    const { proceed } = await inquirer.prompt([
+        { type: 'confirm', name: 'proceed', message: 'Continue?', default: false },
+    ]);
+
+    if (!proceed) {
+        log(chalk.yellow('Aborted.'));
+        return;
+    }
+
+    // Reset
+    await gitRaw(['reset', '--hard', session.checkpoint]);
+    log(chalk.green(`✓ Branch reset to ${shortSha(session.checkpoint)}.`));
+
+    // Force push if remote exists
+    if (await hasRemoteTrackingBranch()) {
+        await gitRaw(['push', '--force-with-lease']);
+        log(chalk.green('✓ Force pushed with --force-with-lease.'));
+    } else {
+        log(chalk.gray('(No remote tracking branch — skipped push)'));
+    }
+
+    // Clean up
+    await deleteSession();
+
+    // Summary
+    log(chalk.green(`\nBranch ${session.branch} has been reset to ${shortSha(session.checkpoint)}. You can now re-select commits.`));
+
+    // Offer to re-open selection
+    const { reopen } = await inquirer.prompt([
+        { type: 'confirm', name: 'reopen', message: 'Re-open commit selection?', default: true },
+    ]);
+
+    return reopen;
+}
+
+// ── Dependency detection helpers ──
+
+const MAX_DEPENDENCY_COMMITS = 200;
+
+/**
+ * Batch-fetch changed files for a list of commit hashes in a single git call.
+ * Returns Map<hash, Set<filePath>>.
+ */
+async function batchGetChangedFiles(hashes, gitRawFn) {
+    if (hashes.length === 0) return new Map();
+
+    const fileMap = new Map();
+    for (const h of hashes) fileMap.set(h, new Set());
+
+    // Single batched call: git log --name-only --pretty=format:COMMIT:%H
+    const raw = await gitRawFn([
+        'log', '--name-only', '--pretty=format:COMMIT:%H',
+        '--no-walk', ...hashes,
+    ]);
+
+    let currentHash = null;
+    for (const line of raw.split('\n')) {
+        if (line.startsWith('COMMIT:')) {
+            currentHash = line.slice(7);
+        } else if (currentHash && line.trim()) {
+            const set = fileMap.get(currentHash);
+            if (set) set.add(line.trim());
+        }
+    }
+
+    return fileMap;
+}
+
+/**
+ * Detect potential dependencies: selected commits that share files with
+ * earlier unselected commits.
+ *
+ * @param {string[]} selected - selected hashes (oldest→newest order)
+ * @param {Array<{hash,subject}>} unselected - unselected commit objects
+ * @param {Array<{hash,subject}>} allCommits - all commits in original order (newest→oldest)
+ * @param {Function} gitRawFn
+ * @returns {Array<{selected, dependency, sharedFiles}>}
+ */
+async function detectDependencies(selected, unselected, allCommits, gitRawFn) {
+    const totalCommits = selected.length + unselected.length;
+    if (totalCommits > MAX_DEPENDENCY_COMMITS) {
+        log(chalk.yellow(`⚠ Skipping dependency detection: ${totalCommits} commits exceeds limit (${MAX_DEPENDENCY_COMMITS}).`));
+        return [];
+    }
+
+    const allHashes = [...selected, ...unselected.map((c) => c.hash)];
+    const fileMap = await batchGetChangedFiles(allHashes, gitRawFn);
+
+    // Build order index: position in original commit list (newest=0, oldest=N)
+    const orderIndex = new Map(allCommits.map((c, i) => [c.hash, i]));
+
+    const results = [];
+    const selectedSet = new Set(selected);
+
+    for (const selHash of selected) {
+        const selFiles = fileMap.get(selHash) || new Set();
+        const selOrder = orderIndex.get(selHash) ?? 0;
+
+        for (const unsel of unselected) {
+            const unselOrder = orderIndex.get(unsel.hash) ?? 0;
+            // Only check unselected commits that are OLDER (higher index = older in newest-first order)
+            if (unselOrder <= selOrder) continue;
+
+            const unselFiles = fileMap.get(unsel.hash) || new Set();
+            const shared = [...selFiles].filter((f) => unselFiles.has(f));
+
+            if (shared.length > 0) {
+                results.push({
+                    selected: selHash,
+                    dependency: unsel.hash,
+                    sharedFiles: shared,
+                });
+            }
+        }
+    }
+
+    return results;
+}
+
+// ── Tracker helpers ──
+
+const TRACKER_PRESETS = {
+    clickup: '#([a-z0-9]+)',
+    jira: '([A-Z]+-\\d+)',
+    linear: '\\[([A-Z]+-\\d+)\\]',
+};
+
+function parseTrackerConfig(currentArgv) {
+    let pattern = currentArgv['ticket-pattern'];
+    const url = currentArgv['tracker-url'];
+    const preset = currentArgv.tracker;
+
+    // Load from .cherrypickrc.json tracker section if not set via CLI
+    // (will be populated after loadRcConfig is called in main)
+
+    if (!pattern && !url && !preset) return null;
+
+    if (preset && !pattern) {
+        pattern = TRACKER_PRESETS[preset];
+        if (!pattern) {
+            throw new Error(`Unknown tracker preset "${preset}". Available: ${Object.keys(TRACKER_PRESETS).join(', ')}`);
+        }
+    }
+
+    if (pattern && !url) {
+        throw new Error('--ticket-pattern requires --tracker-url to be set.');
+    }
+    if (url && !pattern && !preset) {
+        throw new Error('--tracker-url requires --ticket-pattern or --tracker to be set.');
+    }
+
+    let compiled;
+    try {
+        compiled = new RegExp(pattern);
+    } catch (e) {
+        throw new Error(`Invalid --ticket-pattern regex "${pattern}": ${e.message}`);
+    }
+
+    if (!isSafeRegex(compiled)) {
+        throw new Error(`Pattern rejected — potential catastrophic backtracking: "${pattern}"`);
+    }
+
+    // Validate capture group
+    const groups = new RegExp(`${pattern}|`).exec('').length - 1;
+    if (groups < 1) {
+        throw new Error('Pattern must have one capture group for the ticket ID.');
+    }
+
+    return { pattern: compiled, url };
+}
+
+function linkifyTicket(subject, trackerConfig) {
+    if (!trackerConfig) return subject;
+    const { pattern, url } = trackerConfig;
+    const match = pattern.exec(subject);
+    if (!match) return subject;
+
+    const fullMatch = match[0]; // entire matched text (e.g., "#86c8w62wx")
+    const capturedId = match[1]; // capture group (e.g., "86c8w62wx")
+    const link = url.replace('{{id}}', capturedId);
+    return subject.replace(fullMatch, `[${fullMatch}](${link})`);
+}
+
+async function loadTrackerFromRc() {
+    try {
+        const config = await loadRcConfig();
+        return config.tracker || null;
+    } catch {
+        return null;
+    }
+}
+
 async function main() {
     try {
+        // ── Undo handling (must run before anything else) ──
+        if (argv.undo) {
+            const shouldReopen = await handleUndo();
+            if (!shouldReopen) return;
+            argv.undo = false;
+            // Fall through to normal flow (re-open selection)
+        }
+
+        // ── CI mode: implicitly enable --all-yes ──
+        if (argv.ci) {
+            argv['all-yes'] = true;
+            argv.allYes = true;
+        }
+
+        // ── Profile handling (must run before any other logic) ──
+        if (argv['list-profiles']) {
+            await listProfiles();
+            return;
+        }
+
+        if (argv['save-profile']) {
+            const name = argv['save-profile'];
+            await saveProfile(name, argv);
+            return;
+        }
+
+        if (argv['profile']) {
+            const profile = await loadProfile(argv['profile']);
+            applyProfile(profile, argv);
+        }
+
+        // ── Tracker config (merge CLI flags with .cherrypickrc.json) ──
+        if (!argv['ticket-pattern'] && !argv['tracker']) {
+            const rcTracker = await loadTrackerFromRc();
+            if (rcTracker) {
+                if (rcTracker['ticket-pattern'] && !argv['ticket-pattern']) argv['ticket-pattern'] = rcTracker['ticket-pattern'];
+                if (rcTracker['tracker-url'] && !argv['tracker-url']) argv['tracker-url'] = rcTracker['tracker-url'];
+            }
+        }
+
         // Check if gh CLI is installed when push-release is enabled
         if (argv['push-release']) {
             const ghInstalled = await checkGhCli();
@@ -670,6 +1309,7 @@ async function main() {
 
         if (filteredMissing.length === 0) {
             log(chalk.green('✅ No missing commits found in the selected window.'));
+            if (argv.ci) throw new ExitError('No commits found.', 2);
             return;
         }
 
@@ -680,49 +1320,165 @@ async function main() {
         if (argv['all-yes']) {
             selected = filteredMissing.map((m) => m.hash);
         } else {
-            selected = await selectCommitsInteractive(filteredMissing);
+            selected = await selectCommitsWithTuiOrFallback(filteredMissing);
             if (!selected.length) {
                 log(chalk.yellow('No commits selected. Exiting.'));
                 return;
             }
         }
 
-        const bottomToTop = [...selected].sort((a, b) => indexByHash.get(b) - indexByHash.get(a));
+        let bottomToTop = [...selected].sort((a, b) => indexByHash.get(b) - indexByHash.get(a));
+
+        // ── Dependency detection ──
+        const depStrategy = argv['dependency-strategy'] || 'warn';
+        if (depStrategy !== 'ignore') {
+            const selectedSet = new Set(selected);
+            const unselected = filteredMissing.filter((c) => !selectedSet.has(c.hash));
+
+            if (unselected.length > 0) {
+                const deps = await detectDependencies(bottomToTop, unselected, filteredMissing, gitRaw);
+
+                if (deps.length > 0) {
+                    // Show warnings
+                    log(chalk.yellow('\n⚠ Potential dependency detected (file-level heuristic — may be a false positive):\n'));
+                    for (const dep of deps) {
+                        const selSubj = await gitRaw(['show', '--format=%s', '-s', dep.selected]);
+                        const depSubj = await gitRaw(['show', '--format=%s', '-s', dep.dependency]);
+                        log(`  Selected:    ${chalk.dim(`(${shortSha(dep.selected)})`)} ${selSubj}`);
+                        log(`  Depends on:  ${chalk.dim(`(${shortSha(dep.dependency)})`)} ${depSubj}  ${chalk.red('[NOT SELECTED]')}`);
+                        log(`  Shared files: ${chalk.dim(dep.sharedFiles.join(', '))}\n`);
+                    }
 
-        if (argv.dry_run || argv['dry-run']) {
-            log(chalk.cyan('\n--dry-run: would cherry-pick (oldest → newest):'));
-            for (const h of bottomToTop) {
-                const subj = await gitRaw(['show', '--format=%s', '-s', h]);
-                log(`- ${chalk.dim(`(${h.slice(0, 7)})`)} ${subj}`);
+                    if (argv.ci) {
+                        if (depStrategy === 'fail') {
+                            throw new ExitError('Dependency check failed (--dependency-strategy fail). Aborting.', 4);
+                        }
+                        // warn: already logged above, continue
+                    } else {
+                        const missingHashes = [...new Set(deps.map((d) => d.dependency))];
+                        const { choice } = await inquirer.prompt([
+                            {
+                                type: 'list',
+                                name: 'choice',
+                                message: 'How would you like to proceed?',
+                                choices: [
+                                    { name: 'Include missing commits and continue', value: 'include' },
+                                    { name: 'Go back to selection', value: 'back' },
+                                    { name: 'Continue anyway (may cause conflicts)', value: 'continue' },
+                                ],
+                            },
+                        ]);
+
+                        if (choice === 'include') {
+                            log(chalk.cyan('\nCommits to be added:'));
+                            for (const h of missingHashes) {
+                                const subj = await gitRaw(['show', '--format=%s', '-s', h]);
+                                log(`  + ${chalk.dim(`(${shortSha(h)})`)} ${subj}`);
+                            }
+                            const { confirm } = await inquirer.prompt([
+                                { type: 'confirm', name: 'confirm', message: 'Add these commits?', default: true },
+                            ]);
+                            if (confirm) {
+                                selected = [...selected, ...missingHashes];
+                                bottomToTop = [...selected].sort((a, b) => indexByHash.get(b) - indexByHash.get(a));
+                                log(chalk.green(`✓ ${missingHashes.length} commit(s) added. Total: ${selected.length}`));
+                            }
+                        } else if (choice === 'back') {
+                            selected = await selectCommitsWithTuiOrFallback(filteredMissing);
+                            if (!selected.length) {
+                                log(chalk.yellow('No commits selected. Exiting.'));
+                                return;
+                            }
+                            bottomToTop = [...selected].sort((a, b) => indexByHash.get(b) - indexByHash.get(a));
+                        }
+                        // 'continue': proceed as-is
+                    }
+                }
             }
-            return;
         }
 
+        // ── Version computation (moved before preview) ──
         if (argv['version-file'] && !argv['current-version']) {
             const currentVersionFromPkg = await getPkgVersion(argv['version-file']);
             argv['current-version'] = currentVersionFromPkg;
         }
 
         let computedNextVersion = argv['current-version'];
+        let detectedBump = null;
         if (argv['semantic-versioning']) {
             if (!argv['current-version']) {
                 throw new Error(' --semantic-versioning requires --current-version X.Y.Z (or pass --version-file)');
             }
 
-            // Bump is based on the commits you are about to apply (selected).
-            const bump = await computeSemanticBumpForCommits(bottomToTop, gitRaw, semverIgnore);
-
-            computedNextVersion = bump ? incrementVersion(argv['current-version'], bump) : argv['current-version'];
+            detectedBump = await computeSemanticBumpForCommits(bottomToTop, gitRaw, semverIgnore);
+            computedNextVersion = detectedBump ? incrementVersion(argv['current-version'], detectedBump) : argv['current-version'];
 
             log('');
             log(chalk.magenta('Semantic Versioning'));
             log(
                 `  Current: ${chalk.bold(argv['current-version'])}  ` +
-                `Detected bump: ${chalk.bold(bump || 'none')}  ` +
+                `Detected bump: ${chalk.bold(detectedBump || 'none')}  ` +
                 `Next: ${chalk.bold(computedNextVersion)}`,
             );
         }
 
+        // ── Changelog preview ──
+        let trackerConfig = null;
+        try {
+            trackerConfig = parseTrackerConfig(argv);
+        } catch (e) {
+            err(chalk.red(e.message));
+        }
+
+        const previewChangelog = await buildChangelogBody({
+            version: computedNextVersion,
+            hashes: bottomToTop,
+            gitRawFn: gitRaw,
+            semverIgnore,
+            trackerConfig,
+        });
+
+        const isDryRun = argv.dry_run || argv['dry-run'];
+
+        // Show preview
+        log(chalk.cyan('\n── Changelog Preview ──────────────────'));
+        if (computedNextVersion && argv['current-version'] && computedNextVersion !== argv['current-version']) {
+            log(chalk.gray(`Previous: ${argv['current-version']} → Next: ${computedNextVersion} (${detectedBump} bump)`));
+        }
+        log('');
+        log(previewChangelog);
+        log(chalk.gray(`${bottomToTop.length} commits selected`));
+        log(chalk.cyan('──────────────────────────────────────'));
+
+        if (isDryRun) {
+            log(chalk.cyan('\n--dry-run: would cherry-pick (oldest → newest):'));
+            for (const h of bottomToTop) {
+                const subj = await gitRaw(['show', '--format=%s', '-s', h]);
+                log(`- ${chalk.dim(`(${h.slice(0, 7)})`)} ${subj}`);
+            }
+            return;
+        }
+
+        // Confirmation (skip in CI)
+        if (!argv.ci && !argv['all-yes']) {
+            const { proceed } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'proceed',
+                    message: 'Proceed with cherry-pick?',
+                    default: false,
+                },
+            ]);
+            if (!proceed) {
+                log(chalk.yellow('Aborted by user.'));
+                return;
+            }
+        }
+
+        if (argv.ci) {
+            err(chalk.gray('[CI] Changelog preview logged. Proceeding automatically.'));
+        }
+
         if (argv['create-release']) {
             if (!argv['semantic-versioning'] || !argv['current-version']) {
                 throw new Error(' --create-release requires --semantic-versioning and --current-version X.Y.Z');
@@ -735,14 +1491,7 @@ async function main() {
             const startPoint = argv.main; // e.g., 'origin/main' or a local ref
             await ensureReleaseBranchFresh(releaseBranch, startPoint);
 
-            const changelogBody = await buildChangelogBody({
-                version: computedNextVersion,
-                hashes: bottomToTop,
-                gitRawFn: gitRaw,
-                semverIgnore, // raw flag value
-            });
-
-            await fsPromises.writeFile('RELEASE_CHANGELOG.md', changelogBody, 'utf8');
+            await fsPromises.writeFile('RELEASE_CHANGELOG.md', previewChangelog, 'utf8');
             await gitRaw(['reset', 'RELEASE_CHANGELOG.md']);
             log(chalk.gray(`✅ Generated changelog for ${releaseBranch} → RELEASE_CHANGELOG.md`));
 
@@ -756,12 +1505,25 @@ async function main() {
             log(chalk.bold(`Base branch: ${currentBranch}`));
         }
 
+        // ── Save session checkpoint before cherry-pick ──
+        const checkpointHash = await gitRaw(['rev-parse', 'HEAD']);
+        const sessionBranch = await gitRaw(['rev-parse', '--abbrev-ref', 'HEAD']);
+        await saveSession({
+            branch: sessionBranch,
+            checkpoint: checkpointHash,
+            commits: bottomToTop,
+        });
+
         log(chalk.cyan(`\nCherry-picking ${bottomToTop.length} commit(s) onto ${currentBranch} (oldest → newest)...\n`));
 
         const stats = await cherryPickSequential(bottomToTop);
 
         log(chalk.gray(`\nSummary → applied: ${stats.applied}, skipped: ${stats.skipped}`));
 
+        // Populate CI result with cherry-pick stats
+        ciResult.commits.applied = stats.appliedHashes;
+        ciResult.commits.skipped = stats.skippedHashes;
+
         if (stats.applied === 0) {
             err(chalk.yellow('\nNo commits were cherry-picked (all were skipped or unresolved). Aborting.'));
             // Abort any leftover state just in case
@@ -815,10 +1577,36 @@ async function main() {
             ? await gitRaw(['rev-parse', '--abbrev-ref', 'HEAD']) // should be release/*
             : currentBranch;
 
+        // ── Populate CI result ──
+        ciResult.version.previous = argv['current-version'] || null;
+        ciResult.version.next = computedNextVersion || null;
+        ciResult.version.bump = detectedBump || null;
+        ciResult.branch = finalBranch;
+        ciResult.commits.total = bottomToTop.length;
+        ciResult.changelog = previewChangelog;
+
+        // ── JSON output (--format json) ──
+        if (isJsonFormat) {
+            console.log(JSON.stringify(ciResult, null, 2));
+        }
+
+        // Clean up session on success
+        await deleteSession();
+
         log(chalk.green(`\n✅ Done on ${finalBranch}`));
     } catch (e) {
         err(chalk.red(`\n❌ Error: ${e.message || e}`));
-        process.exit(1);
+
+        // Clean up session on error too
+        try { await deleteSession(); } catch { /* ignore cleanup errors */ }
+
+        // Output partial JSON result on error
+        if (isJsonFormat) {
+            console.log(JSON.stringify(ciResult, null, 2));
+        }
+
+        const code = e instanceof ExitError ? e.exitCode : (argv.ci ? 3 : 1);
+        process.exit(code);
     }
 }
 
@@ -878,7 +1666,7 @@ async function ensureReleaseBranchFresh(branchName, startPoint) {
     }
 }
 
-async function buildChangelogBody({ version, hashes, gitRawFn, semverIgnore }) {
+async function buildChangelogBody({ version, hashes, gitRawFn, semverIgnore, trackerConfig }) {
     const today = new Date().toISOString().slice(0, 10);
     const header = version ? `## Release ${version} — ${today}` : `## Release — ${today}`;
     const semverIgnorePatterns = parseSemverIgnore(semverIgnore);
@@ -888,10 +1676,14 @@ async function buildChangelogBody({ version, hashes, gitRawFn, semverIgnore }) {
     const fixes = [];
     const others = [];
 
+    let linkedCount = 0;
+
     for (const h of hashes) {
         const msg = await gitRawFn(['show', '--format=%B', '-s', h]);
 
-        const subject = msg.split(/\r?\n/)[0].trim(); // first line of commit message
+        const rawSubject = msg.split(/\r?\n/)[0].trim(); // first line of commit message
+        const subject = linkifyTicket(rawSubject, trackerConfig);
+        if (trackerConfig && subject !== rawSubject) linkedCount++;
         const shaDisplay = shortSha(h);
 
         // normal classification first
@@ -919,6 +1711,10 @@ async function buildChangelogBody({ version, hashes, gitRawFn, semverIgnore }) {
         }
     }
 
+    if (trackerConfig) {
+        log(chalk.gray(`Tracker: ${linkedCount} of ${hashes.length} commits had ticket IDs linked.`));
+    }
+
     const sections = [];
     if (breakings.length) {
         sections.push(`### ✨ Breaking Changes\n${breakings.join('\n')}`);
@@ -1018,7 +1814,12 @@ function parseSemverIgnore(argvValue) {
         .filter(Boolean)
         .map((pattern) => {
             try {
-                return new RegExp(pattern, 'i'); // case-insensitive on full message
+                const rx = new RegExp(pattern, 'i');
+                if (!isSafeRegex(rx)) {
+                    err(chalk.red(`Rejected --ignore-semver pattern "${pattern}" — potential catastrophic backtracking`));
+                    return null;
+                }
+                return rx;
             } catch (e) {
                 err(chalk.red(`Invalid --ignore-semver pattern "${pattern}": ${e.message || e}`));
                 return null;
@@ -1047,7 +1848,12 @@ function parseIgnoreCommits(argvValue) {
         .filter(Boolean)
         .map((pattern) => {
             try {
-                return new RegExp(pattern, 'i'); // case-insensitive matching
+                const rx = new RegExp(pattern, 'i');
+                if (!isSafeRegex(rx)) {
+                    err(chalk.red(`Rejected --ignore-commits pattern "${pattern}" — potential catastrophic backtracking`));
+                    return null;
+                }
+                return rx;
             } catch (e) {
                 err(chalk.red(`Invalid --ignore-commits pattern "${pattern}": ${e.message || e}`));
                 return null;