@eldrforge/kodrdriv 0.0.17 → 0.0.19

package/dist/main.js

@@ -1,21 +1,3705 @@
 #!/usr/bin/env node
 import * as Cardigantime from '@theunwalked/cardigantime';
 import 'dotenv/config';
-import { configure } from './arguments.js';
-import { execute as execute$1 } from './commands/audio-commit.js';
-import { execute as execute$6 } from './commands/audio-review.js';
-import { execute as execute$7 } from './commands/clean.js';
-import { execute } from './commands/commit.js';
-import { execute as execute$4 } from './commands/link.js';
-import { execute as execute$3 } from './commands/publish.js';
-import { execute as execute$2 } from './commands/release.js';
-import { execute as execute$8 } from './commands/review.js';
-import { execute as execute$9 } from './commands/select-audio.js';
-import { execute as execute$5 } from './commands/unlink.js';
-import { DEFAULT_CONFIG_DIR, COMMAND_CHECK_CONFIG, COMMAND_INIT_CONFIG, COMMAND_COMMIT, COMMAND_AUDIO_COMMIT, COMMAND_RELEASE, COMMAND_PUBLISH, COMMAND_LINK, COMMAND_UNLINK, COMMAND_AUDIO_REVIEW, COMMAND_CLEAN, COMMAND_REVIEW, COMMAND_SELECT_AUDIO } from './constants.js';
-import { getLogger, setLogLevel } from './logging.js';
-import { ConfigSchema } from './types.js';
+import { Command } from 'commander';
+import { z } from 'zod';
+import os from 'os';
+import path from 'path';
+import winston from 'winston';
+import * as fs from 'fs';
+import { glob } from 'glob';
+import crypto from 'crypto';
+import { quick, Formatter, cook, configureTemplates } from '@riotprompt/riotprompt';
+import shellescape from 'shell-escape';
+import { exec, spawnSync } from 'child_process';
+import util from 'util';
+import { fileURLToPath } from 'url';
+import { OpenAI } from 'openai';
+import { processAudio, selectAndConfigureAudioDevice } from '@theunwalked/unplayable';
+import { Octokit } from '@octokit/rest';
+import fs$1 from 'fs/promises';
+import yaml from 'js-yaml';
 
+const VERSION = '0.0.19 (HEAD/d4fa693 T:v0.0.19 2025-07-04 20:16:23 -0700) linux x64 v22.16.0';
+const PROGRAM_NAME = 'kodrdriv';
+const DEFAULT_OVERRIDES = false;
+const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS = 'YYYY-MM-DD-HHmmss.SSS';
+const DEFAULT_VERBOSE = false;
+const DEFAULT_DRY_RUN = false;
+const DEFAULT_DEBUG = false;
+const DEFAULT_MODEL = 'gpt-4o-mini';
+const DEFAULT_OUTPUT_DIRECTORY = 'output/kodrdriv';
+const DEFAULT_CONTEXT_DIRECTORIES = [];
+const DEFAULT_CONFIG_DIR = '.kodrdriv';
+const DEFAULT_PREFERENCES_DIRECTORY = path.join(os.homedir(), '.kodrdriv');
+const DEFAULT_FROM_COMMIT_ALIAS = 'origin/HEAD';
+const DEFAULT_TO_COMMIT_ALIAS = 'HEAD';
+const DEFAULT_ADD = false;
+const DEFAULT_CACHED = false;
+const DEFAULT_SENDIT_MODE = false;
+const DEFAULT_MESSAGE_LIMIT = 50;
+const DEFAULT_MERGE_METHOD = 'squash';
+const DEFAULT_EXCLUDED_PATTERNS = [
+    'node_modules',
+    'pnpm-lock.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lockb',
+    'composer.lock',
+    'Cargo.lock',
+    'Gemfile.lock',
+    'dist',
+    'build',
+    'out',
+    '.next',
+    '.nuxt',
+    'coverage',
+    '.vscode',
+    '.idea',
+    '.DS_Store',
+    '.git',
+    '.gitignore',
+    'logs',
+    'tmp',
+    '.cache',
+    '*.log',
+    '.env',
+    '.env.*',
+    '*.pem',
+    '*.crt',
+    '*.key',
+    '*.sqlite',
+    '*.db',
+    '*.zip',
+    '*.tar',
+    '*.gz',
+    '*.exe',
+    '*.bin'
+];
+const COMMAND_COMMIT = 'commit';
+const COMMAND_AUDIO_COMMIT = 'audio-commit';
+const COMMAND_SELECT_AUDIO = 'select-audio';
+const COMMAND_RELEASE = 'release';
+const COMMAND_REVIEW = 'review';
+const COMMAND_AUDIO_REVIEW = 'audio-review';
+const COMMAND_PUBLISH = 'publish';
+const COMMAND_LINK = 'link';
+const COMMAND_UNLINK = 'unlink';
+const COMMAND_CLEAN = 'clean';
+const COMMAND_CHECK_CONFIG = 'check-config';
+const COMMAND_INIT_CONFIG = 'init-config';
+const ALLOWED_COMMANDS = [
+    COMMAND_COMMIT,
+    COMMAND_AUDIO_COMMIT,
+    COMMAND_SELECT_AUDIO,
+    COMMAND_RELEASE,
+    COMMAND_REVIEW,
+    COMMAND_AUDIO_REVIEW,
+    COMMAND_PUBLISH,
+    COMMAND_LINK,
+    COMMAND_UNLINK,
+    COMMAND_CLEAN
+];
+const DEFAULT_COMMAND = COMMAND_COMMIT;
+const DEFAULT_INSTRUCTIONS_DIR = `instructions`;
+const DEFAULT_PERSONA_DIR = `personas`;
+const DEFAULT_INSTRUCTIONS_COMMIT_FILE = `${DEFAULT_INSTRUCTIONS_DIR}/commit.md`;
+const DEFAULT_INSTRUCTIONS_RELEASE_FILE = `${DEFAULT_INSTRUCTIONS_DIR}/release.md`;
+const DEFAULT_INSTRUCTIONS_REVIEW_FILE = `${DEFAULT_INSTRUCTIONS_DIR}/review.md`;
+const DEFAULT_PERSONA_RELEASER_FILE = `${DEFAULT_PERSONA_DIR}/releaser.md`;
+const DEFAULT_PERSONA_YOU_FILE = `${DEFAULT_PERSONA_DIR}/you.md`;
+// Define defaults in one place
+const KODRDRIV_DEFAULTS = {
+    dryRun: DEFAULT_DRY_RUN,
+    verbose: DEFAULT_VERBOSE,
+    debug: DEFAULT_DEBUG,
+    overrides: DEFAULT_OVERRIDES,
+    model: DEFAULT_MODEL,
+    contextDirectories: DEFAULT_CONTEXT_DIRECTORIES,
+    commandName: DEFAULT_COMMAND,
+    configDirectory: DEFAULT_CONFIG_DIR,
+    outputDirectory: DEFAULT_OUTPUT_DIRECTORY,
+    preferencesDirectory: DEFAULT_PREFERENCES_DIRECTORY,
+    commit: {
+        add: DEFAULT_ADD,
+        cached: DEFAULT_CACHED,
+        sendit: DEFAULT_SENDIT_MODE,
+        messageLimit: DEFAULT_MESSAGE_LIMIT
+    },
+    release: {
+        from: DEFAULT_FROM_COMMIT_ALIAS,
+        to: DEFAULT_TO_COMMIT_ALIAS,
+        messageLimit: DEFAULT_MESSAGE_LIMIT
+    },
+    audioCommit: {
+        maxRecordingTime: 300,
+        audioDevice: undefined
+    },
+    review: {
+        includeCommitHistory: true,
+        includeRecentDiffs: true,
+        includeReleaseNotes: false,
+        includeGithubIssues: true,
+        commitHistoryLimit: 10,
+        diffHistoryLimit: 5,
+        releaseNotesLimit: 3,
+        githubIssuesLimit: 20,
+        sendit: DEFAULT_SENDIT_MODE
+    },
+    audioReview: {
+        includeCommitHistory: true,
+        includeRecentDiffs: true,
+        includeReleaseNotes: false,
+        includeGithubIssues: true,
+        commitHistoryLimit: 10,
+        diffHistoryLimit: 5,
+        releaseNotesLimit: 3,
+        githubIssuesLimit: 20,
+        sendit: DEFAULT_SENDIT_MODE,
+        maxRecordingTime: 300,
+        audioDevice: undefined
+    },
+    publish: {
+        mergeMethod: DEFAULT_MERGE_METHOD,
+        requiredEnvVars: [
+            'GITHUB_TOKEN',
+            'OPENAI_API_KEY'
+        ],
+        linkWorkspacePackages: true,
+        unlinkWorkspacePackages: true
+    },
+    link: {
+        scopeRoots: {},
+        workspaceFile: 'pnpm-workspace.yaml',
+        dryRun: false
+    },
+    excludedPatterns: DEFAULT_EXCLUDED_PATTERNS
+};
+
+// Track if debug directory has been ensured for this session
+let debugDirectoryEnsured = false;
+const ensureDebugDirectory = ()=>{
+    if (debugDirectoryEnsured) return;
+    const debugDir = path.join(DEFAULT_OUTPUT_DIRECTORY, 'debug');
+    try {
+        fs.mkdirSync(debugDir, {
+            recursive: true
+        });
+        debugDirectoryEnsured = true;
+    } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error(`Failed to create debug directory ${debugDir}:`, error);
+    }
+};
+const generateDebugLogFilename = ()=>{
+    const now = new Date();
+    const timestamp = now.toISOString().replace(/[-:]/g, '').replace(/\./g, '').replace('T', '-').replace('Z', '');
+    return `${timestamp}-debug.log`;
+};
+const createTransports = (level)=>{
+    const transports = [];
+    // Always add console transport for info level and above
+    if (level === 'info') {
+        transports.push(new winston.transports.Console({
+            format: winston.format.combine(winston.format.colorize(), winston.format.printf(({ level, message })=>{
+                return `${level}: ${message}`;
+            }))
+        }));
+    } else {
+        // For debug/verbose levels, add console transport that shows info and above
+        transports.push(new winston.transports.Console({
+            level: 'info',
+            format: winston.format.combine(winston.format.colorize(), winston.format.printf(({ timestamp, level, message, ...meta })=>{
+                // For info level messages, use simpler format without timestamp
+                if (level.includes('info')) {
+                    return String(message);
+                }
+                const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
+                return `${timestamp} ${level}: ${String(message)}${metaStr}`;
+            }))
+        }));
+        // Add file transport for debug levels (debug and silly)
+        if (level === 'debug' || level === 'silly') {
+            ensureDebugDirectory();
+            const debugLogPath = path.join(DEFAULT_OUTPUT_DIRECTORY, 'debug', generateDebugLogFilename());
+            transports.push(new winston.transports.File({
+                filename: debugLogPath,
+                level: 'debug',
+                format: winston.format.combine(winston.format.timestamp({
+                    format: DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS
+                }), winston.format.errors({
+                    stack: true
+                }), winston.format.splat(), winston.format.printf(({ timestamp, level, message, ...meta })=>{
+                    const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
+                    return `${timestamp} ${level}: ${message}${metaStr}`;
+                }))
+            }));
+        }
+    }
+    return transports;
+};
+const createFormat = (level)=>{
+    if (level === 'info') {
+        return winston.format.combine(winston.format.errors({
+            stack: true
+        }), winston.format.splat());
+    }
+    return winston.format.combine(winston.format.timestamp({
+        format: DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS
+    }), winston.format.errors({
+        stack: true
+    }), winston.format.splat(), winston.format.json());
+};
+// Create the logger instance once
+const logger = winston.createLogger({
+    level: 'info',
+    format: createFormat('info'),
+    defaultMeta: {
+        service: PROGRAM_NAME
+    },
+    transports: createTransports('info')
+});
+const setLogLevel = (level)=>{
+    // Reconfigure the existing logger instead of creating a new one
+    logger.configure({
+        level,
+        format: createFormat(level),
+        defaultMeta: {
+            service: PROGRAM_NAME
+        },
+        transports: createTransports(level)
+    });
+};
+const getLogger = ()=>logger;
+
+// eslint-disable-next-line no-restricted-imports
+const create$2 = (params)=>{
+    // eslint-disable-next-line no-console
+    const log = params.log || console.log;
+    const exists = async (path)=>{
+        try {
+            await fs.promises.stat(path);
+            return true;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (error) {
+            return false;
+        }
+    };
+    const isDirectory = async (path)=>{
+        const stats = await fs.promises.stat(path);
+        if (!stats.isDirectory()) {
+            log(`${path} is not a directory`);
+            return false;
+        }
+        return true;
+    };
+    const isFile = async (path)=>{
+        const stats = await fs.promises.stat(path);
+        if (!stats.isFile()) {
+            log(`${path} is not a file`);
+            return false;
+        }
+        return true;
+    };
+    const isReadable = async (path)=>{
+        try {
+            await fs.promises.access(path, fs.constants.R_OK);
+        } catch (error) {
+            log(`${path} is not readable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isWritable = async (path)=>{
+        try {
+            await fs.promises.access(path, fs.constants.W_OK);
+        } catch (error) {
+            log(`${path} is not writable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isFileReadable = async (path)=>{
+        return await exists(path) && await isFile(path) && await isReadable(path);
+    };
+    const isDirectoryWritable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isWritable(path);
+    };
+    const isDirectoryReadable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isReadable(path);
+    };
+    const createDirectory = async (path)=>{
+        try {
+            await fs.promises.mkdir(path, {
+                recursive: true
+            });
+        } catch (mkdirError) {
+            throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);
+        }
+    };
+    const ensureDirectory = async (path)=>{
+        if (!await exists(path)) {
+            await createDirectory(path);
+        }
+    };
+    const removeDirectory = async (path)=>{
+        try {
+            if (await exists(path)) {
+                await fs.promises.rm(path, {
+                    recursive: true,
+                    force: true
+                });
+            }
+        } catch (rmError) {
+            throw new Error(`Failed to remove directory ${path}: ${rmError.message} ${rmError.stack}`);
+        }
+    };
+    const readFile = async (path, encoding)=>{
+        return await fs.promises.readFile(path, {
+            encoding: encoding
+        });
+    };
+    const writeFile = async (path, data, encoding)=>{
+        await fs.promises.writeFile(path, data, {
+            encoding: encoding
+        });
+    };
+    const rename = async (oldPath, newPath)=>{
+        await fs.promises.rename(oldPath, newPath);
+    };
+    const forEachFileIn = async (directory, callback, options = {
+        pattern: '*.*'
+    })=>{
+        try {
+            const files = await glob(options.pattern, {
+                cwd: directory,
+                nodir: true
+            });
+            for (const file of files){
+                await callback(path.join(directory, file));
+            }
+        } catch (err) {
+            throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);
+        }
+    };
+    const readStream = async (path)=>{
+        return fs.createReadStream(path);
+    };
+    const hashFile = async (path, length)=>{
+        const file = await readFile(path, 'utf8');
+        return crypto.createHash('sha256').update(file).digest('hex').slice(0, length);
+    };
+    const listFiles = async (directory)=>{
+        return await fs.promises.readdir(directory);
+    };
+    return {
+        exists,
+        isDirectory,
+        isFile,
+        isReadable,
+        isWritable,
+        isFileReadable,
+        isDirectoryWritable,
+        isDirectoryReadable,
+        createDirectory,
+        ensureDirectory,
+        readFile,
+        readStream,
+        writeFile,
+        rename,
+        forEachFileIn,
+        hashFile,
+        listFiles,
+        removeDirectory
+    };
+};
+
+// Function to read from STDIN if available
+async function readStdin() {
+    // In test environment, allow mocking to work by skipping TTY check
+    if (process.env.NODE_ENV === 'test' || process.env.VITEST === 'true') {
+        return new Promise((resolve)=>{
+            let input = '';
+            let hasData = false;
+            const timeout = setTimeout(()=>{
+                if (!hasData) {
+                    resolve(null);
+                }
+            }, 10); // Very short timeout for tests
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', (chunk)=>{
+                hasData = true;
+                clearTimeout(timeout);
+                input += chunk;
+            });
+            process.stdin.on('end', ()=>{
+                resolve(input.trim() || null);
+            });
+            process.stdin.on('error', ()=>{
+                clearTimeout(timeout);
+                resolve(null);
+            });
+            process.stdin.resume();
+        });
+    }
+    return new Promise((resolve)=>{
+        // Check if stdin is TTY (interactive terminal)
+        if (process.stdin.isTTY) {
+            resolve(null);
+            return;
+        }
+        let input = '';
+        let hasData = false;
+        const timeout = setTimeout(()=>{
+            if (!hasData) {
+                resolve(null);
+            }
+        }, 100); // Short timeout to detect if data is available
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk)=>{
+            hasData = true;
+            clearTimeout(timeout);
+            input += chunk;
+        });
+        process.stdin.on('end', ()=>{
+            resolve(input.trim() || null);
+        });
+        process.stdin.on('error', ()=>{
+            clearTimeout(timeout);
+            resolve(null);
+        });
+        // If no data comes in quickly, assume no stdin
+        process.stdin.resume();
+    });
+}
+
+z.object({
+    dryRun: z.boolean().optional(),
+    verbose: z.boolean().optional(),
+    debug: z.boolean().optional(),
+    overrides: z.boolean().optional(),
+    checkConfig: z.boolean().optional(),
+    initConfig: z.boolean().optional(),
+    model: z.string().optional(),
+    contextDirectories: z.array(z.string()).optional(),
+    configDir: z.string().optional(),
+    outputDir: z.string().optional(),
+    preferencesDir: z.string().optional(),
+    cached: z.boolean().optional(),
+    add: z.boolean().optional(),
+    sendit: z.boolean().optional(),
+    from: z.string().optional(),
+    to: z.string().optional(),
+    excludedPatterns: z.array(z.string()).optional(),
+    context: z.string().optional(),
+    note: z.string().optional(),
+    direction: z.string().optional(),
+    messageLimit: z.number().optional(),
+    mergeMethod: z.enum([
+        'merge',
+        'squash',
+        'rebase'
+    ]).optional(),
+    scopeRoots: z.string().optional(),
+    workspaceFile: z.string().optional(),
+    includeCommitHistory: z.boolean().optional(),
+    includeRecentDiffs: z.boolean().optional(),
+    includeReleaseNotes: z.boolean().optional(),
+    includeGithubIssues: z.boolean().optional(),
+    commitHistoryLimit: z.number().optional(),
+    diffHistoryLimit: z.number().optional(),
+    releaseNotesLimit: z.number().optional(),
+    githubIssuesLimit: z.number().optional(),
+    file: z.string().optional(),
+    keepTemp: z.boolean().optional()
+});
+// Function to transform flat CLI args into nested Config structure
+const transformCliArgs = (finalCliArgs)=>{
+    const transformedCliArgs = {};
+    // Direct mappings from Input to Config
+    if (finalCliArgs.dryRun !== undefined) transformedCliArgs.dryRun = finalCliArgs.dryRun;
+    if (finalCliArgs.verbose !== undefined) transformedCliArgs.verbose = finalCliArgs.verbose;
+    if (finalCliArgs.debug !== undefined) transformedCliArgs.debug = finalCliArgs.debug;
+    if (finalCliArgs.overrides !== undefined) transformedCliArgs.overrides = finalCliArgs.overrides;
+    if (finalCliArgs.model !== undefined) transformedCliArgs.model = finalCliArgs.model;
+    if (finalCliArgs.contextDirectories !== undefined) transformedCliArgs.contextDirectories = finalCliArgs.contextDirectories;
+    // Map configDir (CLI) to configDirectory (Cardigantime standard)
+    if (finalCliArgs.configDir !== undefined) transformedCliArgs.configDirectory = finalCliArgs.configDir;
+    // Map outputDir (CLI) to outputDirectory (Config standard)
+    if (finalCliArgs.outputDir !== undefined) transformedCliArgs.outputDirectory = finalCliArgs.outputDir;
+    // Map preferencesDir (CLI) to preferencesDirectory (Config standard)
+    if (finalCliArgs.preferencesDir !== undefined) transformedCliArgs.preferencesDirectory = finalCliArgs.preferencesDir;
+    // Nested mappings for 'commit' options
+    if (finalCliArgs.cached !== undefined || finalCliArgs.sendit !== undefined || finalCliArgs.add !== undefined) {
+        transformedCliArgs.commit = {};
+        if (finalCliArgs.add !== undefined) transformedCliArgs.commit.add = finalCliArgs.add;
+        if (finalCliArgs.cached !== undefined) transformedCliArgs.commit.cached = finalCliArgs.cached;
+        if (finalCliArgs.sendit !== undefined) transformedCliArgs.commit.sendit = finalCliArgs.sendit;
+        if (finalCliArgs.messageLimit !== undefined) transformedCliArgs.commit.messageLimit = finalCliArgs.messageLimit;
+        if (finalCliArgs.context !== undefined) transformedCliArgs.commit.context = finalCliArgs.context;
+        if (finalCliArgs.direction !== undefined) transformedCliArgs.commit.direction = finalCliArgs.direction;
+    }
+    // Nested mappings for 'audioCommit' options
+    if (finalCliArgs.file !== undefined || finalCliArgs.keepTemp !== undefined) {
+        transformedCliArgs.audioCommit = {};
+        if (finalCliArgs.file !== undefined) transformedCliArgs.audioCommit.file = finalCliArgs.file;
+        if (finalCliArgs.keepTemp !== undefined) transformedCliArgs.audioCommit.keepTemp = finalCliArgs.keepTemp;
+    }
+    // Nested mappings for 'release' options
+    if (finalCliArgs.from !== undefined || finalCliArgs.to !== undefined) {
+        transformedCliArgs.release = {};
+        if (finalCliArgs.from !== undefined) transformedCliArgs.release.from = finalCliArgs.from;
+        if (finalCliArgs.to !== undefined) transformedCliArgs.release.to = finalCliArgs.to;
+        if (finalCliArgs.context !== undefined) transformedCliArgs.release.context = finalCliArgs.context;
+        if (finalCliArgs.messageLimit !== undefined) transformedCliArgs.release.messageLimit = finalCliArgs.messageLimit;
+    }
+    // Nested mappings for 'publish' options
+    if (finalCliArgs.mergeMethod !== undefined) {
+        transformedCliArgs.publish = {};
+        if (finalCliArgs.mergeMethod !== undefined) transformedCliArgs.publish.mergeMethod = finalCliArgs.mergeMethod;
+    }
+    // Nested mappings for 'link' and 'unlink' options (both use the same configuration)
+    if (finalCliArgs.scopeRoots !== undefined || finalCliArgs.workspaceFile !== undefined) {
+        transformedCliArgs.link = {};
+        if (finalCliArgs.scopeRoots !== undefined) {
+            try {
+                transformedCliArgs.link.scopeRoots = JSON.parse(finalCliArgs.scopeRoots);
+            } catch (error) {
+                throw new Error(`Invalid JSON for scope-roots: ${finalCliArgs.scopeRoots}`);
+            }
+        }
+        if (finalCliArgs.workspaceFile !== undefined) transformedCliArgs.link.workspaceFile = finalCliArgs.workspaceFile;
+    }
+    // Nested mappings for 'audio-review' options
+    if (finalCliArgs.includeCommitHistory !== undefined || finalCliArgs.includeRecentDiffs !== undefined || finalCliArgs.includeReleaseNotes !== undefined || finalCliArgs.includeGithubIssues !== undefined || finalCliArgs.commitHistoryLimit !== undefined || finalCliArgs.diffHistoryLimit !== undefined || finalCliArgs.releaseNotesLimit !== undefined || finalCliArgs.githubIssuesLimit !== undefined || finalCliArgs.file !== undefined || finalCliArgs.keepTemp !== undefined) {
+        transformedCliArgs.audioReview = {};
+        if (finalCliArgs.includeCommitHistory !== undefined) transformedCliArgs.audioReview.includeCommitHistory = finalCliArgs.includeCommitHistory;
+        if (finalCliArgs.includeRecentDiffs !== undefined) transformedCliArgs.audioReview.includeRecentDiffs = finalCliArgs.includeRecentDiffs;
+        if (finalCliArgs.includeReleaseNotes !== undefined) transformedCliArgs.audioReview.includeReleaseNotes = finalCliArgs.includeReleaseNotes;
+        if (finalCliArgs.includeGithubIssues !== undefined) transformedCliArgs.audioReview.includeGithubIssues = finalCliArgs.includeGithubIssues;
+        if (finalCliArgs.commitHistoryLimit !== undefined) transformedCliArgs.audioReview.commitHistoryLimit = finalCliArgs.commitHistoryLimit;
+        if (finalCliArgs.diffHistoryLimit !== undefined) transformedCliArgs.audioReview.diffHistoryLimit = finalCliArgs.diffHistoryLimit;
+        if (finalCliArgs.releaseNotesLimit !== undefined) transformedCliArgs.audioReview.releaseNotesLimit = finalCliArgs.releaseNotesLimit;
+        if (finalCliArgs.githubIssuesLimit !== undefined) transformedCliArgs.audioReview.githubIssuesLimit = finalCliArgs.githubIssuesLimit;
+        if (finalCliArgs.context !== undefined) transformedCliArgs.audioReview.context = finalCliArgs.context;
+        if (finalCliArgs.sendit !== undefined) transformedCliArgs.audioReview.sendit = finalCliArgs.sendit;
+        if (finalCliArgs.file !== undefined) transformedCliArgs.audioReview.file = finalCliArgs.file;
+        if (finalCliArgs.keepTemp !== undefined) transformedCliArgs.audioReview.keepTemp = finalCliArgs.keepTemp;
+    }
+    // Nested mappings for 'review' options
+    if (finalCliArgs.includeCommitHistory !== undefined || finalCliArgs.includeRecentDiffs !== undefined || finalCliArgs.includeReleaseNotes !== undefined || finalCliArgs.includeGithubIssues !== undefined || finalCliArgs.commitHistoryLimit !== undefined || finalCliArgs.diffHistoryLimit !== undefined || finalCliArgs.releaseNotesLimit !== undefined || finalCliArgs.githubIssuesLimit !== undefined || finalCliArgs.context !== undefined || finalCliArgs.sendit !== undefined || finalCliArgs.note !== undefined) {
+        transformedCliArgs.review = {};
+        if (finalCliArgs.note !== undefined) transformedCliArgs.review.note = finalCliArgs.note;
+        // Include optional review configuration options if specified
+        if (finalCliArgs.includeCommitHistory !== undefined) transformedCliArgs.review.includeCommitHistory = finalCliArgs.includeCommitHistory;
+        if (finalCliArgs.includeRecentDiffs !== undefined) transformedCliArgs.review.includeRecentDiffs = finalCliArgs.includeRecentDiffs;
+        if (finalCliArgs.includeReleaseNotes !== undefined) transformedCliArgs.review.includeReleaseNotes = finalCliArgs.includeReleaseNotes;
+        if (finalCliArgs.includeGithubIssues !== undefined) transformedCliArgs.review.includeGithubIssues = finalCliArgs.includeGithubIssues;
+        if (finalCliArgs.commitHistoryLimit !== undefined) transformedCliArgs.review.commitHistoryLimit = finalCliArgs.commitHistoryLimit;
+        if (finalCliArgs.diffHistoryLimit !== undefined) transformedCliArgs.review.diffHistoryLimit = finalCliArgs.diffHistoryLimit;
+        if (finalCliArgs.releaseNotesLimit !== undefined) transformedCliArgs.review.releaseNotesLimit = finalCliArgs.releaseNotesLimit;
+        if (finalCliArgs.githubIssuesLimit !== undefined) transformedCliArgs.review.githubIssuesLimit = finalCliArgs.githubIssuesLimit;
+        if (finalCliArgs.context !== undefined) transformedCliArgs.review.context = finalCliArgs.context;
+        if (finalCliArgs.sendit !== undefined) transformedCliArgs.review.sendit = finalCliArgs.sendit;
+    }
+    if (finalCliArgs.excludedPatterns !== undefined) transformedCliArgs.excludedPatterns = finalCliArgs.excludedPatterns;
+    // Note: openaiApiKey is handled separately via environment variable only
+    return transformedCliArgs;
+};
+// Update configure signature to accept cardigantime
+const configure = async (cardigantime)=>{
+    var _config_contextDirectories, _config_link;
+    const logger = getLogger();
+    let program = new Command();
+    // Configure program basics
+    program.name(PROGRAM_NAME).summary('Create Intelligent Release Notes or Change Logs from Git').description('Create Intelligent Release Notes or Change Logs from Git').version(VERSION);
+    // Let cardigantime add its arguments first
+    program = await cardigantime.configure(program);
+    // Check if --check-config is in process.argv early
+    if (process.argv.includes('--check-config')) {
+        // For check-config, use CardiganTime's built-in checkConfig method
+        program.parse();
+        const cliArgs = program.opts();
+        // Transform the flat CLI args
+        const transformedCliArgs = transformCliArgs(cliArgs);
+        // Use CardiganTime's built-in checkConfig method which displays
+        // hierarchical configuration information in a well-formatted way
+        await cardigantime.checkConfig(transformedCliArgs);
+        // Return minimal config for consistency, but main processing is done
+        const config = await validateAndProcessOptions({});
+        const secureConfig = await validateAndProcessSecureOptions();
+        const commandConfig = {
+            commandName: 'check-config'
+        };
+        return [
+            config,
+            secureConfig,
+            commandConfig
+        ];
+    }
+    // Check if --init-config is in process.argv early
+    if (process.argv.includes('--init-config')) {
+        // For init-config, use CardiganTime's built-in generateConfig method
+        program.parse();
+        const cliArgs = program.opts();
+        // Transform the flat CLI args
+        const transformedCliArgs = transformCliArgs(cliArgs);
+        // Use CardiganTime's built-in generateConfig method
+        await cardigantime.generateConfig(transformedCliArgs.configDirectory || KODRDRIV_DEFAULTS.configDirectory);
+        // Return minimal config for consistency, but main processing is done
+        const config = await validateAndProcessOptions({});
+        const secureConfig = await validateAndProcessSecureOptions();
+        const commandConfig = {
+            commandName: 'init-config'
+        };
+        return [
+            config,
+            secureConfig,
+            commandConfig
+        ];
+    }
+    // Get CLI arguments using the new function
+    const [finalCliArgs, commandConfig] = await getCliConfig(program);
+    logger.silly('Loaded Command Line Options: %s', JSON.stringify(finalCliArgs, null, 2));
+    // Transform the flat CLI args using the new function
+    const transformedCliArgs = transformCliArgs(finalCliArgs);
+    logger.silly('Transformed CLI Args for merging: %s', JSON.stringify(transformedCliArgs, null, 2));
+    // Get values from config file using Cardigantime's hierarchical configuration
+    const fileValues = await cardigantime.read(transformedCliArgs);
+    // Merge configurations: Defaults -> File -> CLI
+    // Properly merge the link section to preserve scope roots from config file
+    const mergedLink = {
+        ...KODRDRIV_DEFAULTS.link,
+        ...fileValues.link,
+        ...transformedCliArgs.link
+    };
+    const partialConfig = {
+        ...KODRDRIV_DEFAULTS,
+        ...fileValues,
+        ...transformedCliArgs,
+        link: mergedLink
+    }; // Cast to Partial<Config> initially
+    // Specific validation and processing after merge
+    const config = await validateAndProcessOptions(partialConfig);
+    // Log effective configuration summary at verbose level
+    logger.verbose('Configuration complete. Effective settings:');
+    logger.verbose(`  Command: ${commandConfig.commandName}`);
+    logger.verbose(`  Model: ${config.model}`);
+    logger.verbose(`  Dry run: ${config.dryRun}`);
+    logger.verbose(`  Debug: ${config.debug}`);
+    logger.verbose(`  Verbose: ${config.verbose}`);
+    logger.verbose(`  Config directory: ${config.configDirectory}`);
+    logger.verbose(`  Output directory: ${config.outputDirectory}`);
+    logger.verbose(`  Context directories: ${((_config_contextDirectories = config.contextDirectories) === null || _config_contextDirectories === void 0 ? void 0 : _config_contextDirectories.join(', ')) || 'none'}`);
+    if (config.excludedPatterns && config.excludedPatterns.length > 0) {
+        logger.verbose(`  Excluded patterns: ${config.excludedPatterns.join(', ')}`);
+    }
+    if (Object.keys(((_config_link = config.link) === null || _config_link === void 0 ? void 0 : _config_link.scopeRoots) || {}).length > 0) {
+        logger.verbose(`  Link scope roots: ${Object.keys(config.link.scopeRoots).join(', ')}`);
+    }
+    logger.silly('Final configuration: %s', JSON.stringify(config, null, 2));
+    const secureConfig = await validateAndProcessSecureOptions();
+    return [
+        config,
+        secureConfig,
+        commandConfig
+    ];
+};
+// Function to handle CLI argument parsing and processing
+async function getCliConfig(program) {
+    const addSharedOptions = (command)=>{
+        command.option('--dry-run', 'perform a dry run without saving files') // Removed default, will be handled by merging
+        .option('--verbose', 'enable verbose logging').option('--debug', 'enable debug logging').option('--overrides', 'enable overrides').option('--model <model>', 'OpenAI model to use').option('-d, --context-directories [contextDirectories...]', 'directories to scan for context').option('--config-dir <configDir>', 'configuration directory') // Keep config-dir for specifying location
+        .option('--output-dir <outputDir>', 'output directory for generated files').option('--preferences-dir <preferencesDir>', 'preferences directory for personal settings').option('--excluded-paths [excludedPatterns...]', 'paths to exclude from the diff').option('--keep-temp', 'keep temporary recording files');
+    };
+    // Add global options to the main program
+    // (cardigantime already adds most global options like --verbose, --debug, --config-dir)
+    // Add subcommands
+    const commitCommand = program.command('commit').argument('[direction]', 'direction or guidance for the commit message').description('Generate commit notes').option('--context <context>', 'context for the commit message').option('--cached', 'use cached diff').option('--add', 'add all changes before committing').option('--sendit', 'Commit with the message generated. No review.').option('--message-limit <messageLimit>', 'limit the number of messages to generate');
+    // Add shared options to commit command
+    addSharedOptions(commitCommand);
+    // Customize help output for commit command
+    commitCommand.configureHelp({
+        formatHelp: (cmd, helper)=>{
+            const nameAndVersion = `${helper.commandUsage(cmd)}\n\n${helper.commandDescription(cmd)}\n`;
+            const commitOptions = [
+                [
+                    '--context <context>',
+                    'context for the commit message'
+                ]
+            ];
+            const behavioralOptions = [
+                [
+                    '--cached',
+                    'use cached diff'
+                ],
+                [
+                    '--add',
+                    'add all changes before committing'
+                ],
+                [
+                    '--sendit',
+                    'Commit with the message generated. No review.'
+                ],
+                [
+                    '--message-limit <messageLimit>',
+                    'limit the number of messages to generate'
+                ]
+            ];
+            const globalOptions = [
+                [
+                    '--dry-run',
+                    'perform a dry run without saving files'
+                ],
+                [
+                    '--verbose',
+                    'enable verbose logging'
+                ],
+                [
+                    '--debug',
+                    'enable debug logging'
+                ],
+                [
+                    '--overrides',
+                    'enable overrides'
+                ],
+                [
+                    '--model <model>',
+                    'OpenAI model to use'
+                ],
+                [
+                    '-d, --context-directories [contextDirectories...]',
+                    'directories to scan for context'
+                ],
+                [
+                    '--config-dir <configDir>',
+                    'configuration directory'
+                ],
+                [
+                    '--excluded-paths [excludedPatterns...]',
+                    'paths to exclude from the diff'
+                ],
+                [
+                    '-h, --help',
+                    'display help for command'
+                ]
+            ];
+            const formatOptionsSection = (title, options)=>{
+                const maxWidth = Math.max(...options.map(([flag])=>flag.length));
+                return `${title}:\n` + options.map(([flag, desc])=>`  ${flag.padEnd(maxWidth + 2)} ${desc}`).join('\n') + '\n';
+            };
+            return nameAndVersion + '\n' + formatOptionsSection('Commit Message Options', commitOptions) + '\n' + formatOptionsSection('Behavioral Options', behavioralOptions) + '\n' + formatOptionsSection('Global Options', globalOptions) + '\n' + 'Environment Variables:\n' + '  OPENAI_API_KEY          OpenAI API key (required)\n';
+        }
+    });
+    const audioCommitCommand = program.command('audio-commit').option('--cached', 'use cached diff').option('--add', 'add all changes before committing').option('--sendit', 'Commit with the message generated. No review.').option('--direction <direction>', 'direction or guidance for the commit message').option('--message-limit <messageLimit>', 'limit the number of messages to generate').option('--file <file>', 'audio file path').description('Record audio to provide context, then generate and optionally commit with AI-generated message');
+    addSharedOptions(audioCommitCommand);
+    const releaseCommand = program.command('release').option('--from <from>', 'branch to generate release notes from').option('--to <to>', 'branch to generate release notes to').option('--context <context>', 'context for the commit message').description('Generate release notes');
+    addSharedOptions(releaseCommand);
+    const publishCommand = program.command('publish').option('--merge-method <method>', 'method to merge PR (merge, squash, rebase)', 'squash').description('Publish a release');
+    addSharedOptions(publishCommand);
+    const linkCommand = program.command('link').option('--scope-roots <scopeRoots>', 'JSON mapping of scopes to root directories (e.g., \'{"@company": "../"}\')').option('--workspace-file <workspaceFile>', 'path to workspace file', 'pnpm-workspace.yaml').description('Manage pnpm workspace links for local development');
+    addSharedOptions(linkCommand);
+    const unlinkCommand = program.command('unlink').option('--scope-roots <scopeRoots>', 'JSON mapping of scopes to root directories (e.g., \'{"@company": "../"}\')').option('--workspace-file <workspaceFile>', 'path to workspace file', 'pnpm-workspace.yaml').description('Remove pnpm workspace links and rebuild dependencies');
+    addSharedOptions(unlinkCommand);
+    const audioReviewCommand = program.command('audio-review').option('--include-commit-history', 'include recent commit log messages in context (default: true)').option('--no-include-commit-history', 'exclude commit log messages from context').option('--include-recent-diffs', 'include recent commit diffs in context (default: true)').option('--no-include-recent-diffs', 'exclude recent diffs from context').option('--include-release-notes', 'include recent release notes in context (default: false)').option('--no-include-release-notes', 'exclude release notes from context').option('--include-github-issues', 'include open GitHub issues in context (default: true)').option('--no-include-github-issues', 'exclude GitHub issues from context').option('--commit-history-limit <limit>', 'number of recent commits to include', parseInt).option('--diff-history-limit <limit>', 'number of recent commit diffs to include', parseInt).option('--release-notes-limit <limit>', 'number of recent release notes to include', parseInt).option('--github-issues-limit <limit>', 'number of open GitHub issues to include (max 20)', parseInt).option('--context <context>', 'additional context for the audio review').option('--file <file>', 'audio file path').description('Record audio, transcribe with Whisper, and analyze for project issues using AI');
+    addSharedOptions(audioReviewCommand);
+    const reviewCommand = program.command('review').argument('[note]', 'review note to analyze for project issues').option('--include-commit-history', 'include recent commit log messages in context (default: true)').option('--no-include-commit-history', 'exclude commit log messages from context').option('--include-recent-diffs', 'include recent commit diffs in context (default: true)').option('--no-include-recent-diffs', 'exclude recent diffs from context').option('--include-release-notes', 'include recent release notes in context (default: false)').option('--no-include-release-notes', 'exclude release notes from context').option('--include-github-issues', 'include open GitHub issues in context (default: true)').option('--no-include-github-issues', 'exclude GitHub issues from context').option('--commit-history-limit <limit>', 'number of recent commits to include', parseInt).option('--diff-history-limit <limit>', 'number of recent commit diffs to include', parseInt).option('--release-notes-limit <limit>', 'number of recent release notes to include', parseInt).option('--github-issues-limit <limit>', 'number of open GitHub issues to include (max 20)', parseInt).option('--context <context>', 'additional context for the review').option('--sendit', 'Create GitHub issues automatically without confirmation').description('Analyze review note for project issues using AI');
+    addSharedOptions(reviewCommand);
+    // Customize help output for review command
+    reviewCommand.configureHelp({
+        formatHelp: (cmd, helper)=>{
+            const nameAndVersion = `kodrdriv review [note] [options]\n\nAnalyze review note for project issues using AI\n`;
+            const argumentsSection = [
+                [
+                    'note',
+                    'review note to analyze for project issues (can also be piped via STDIN)'
+                ]
+            ];
+            const reviewOptions = [
+                [
+                    '--context <context>',
+                    'additional context for the review'
+                ]
+            ];
+            const gitContextOptions = [
+                [
+                    '--include-commit-history',
+                    'include recent commit log messages in context (default: true)'
+                ],
+                [
+                    '--no-include-commit-history',
+                    'exclude commit log messages from context'
+                ],
+                [
+                    '--include-recent-diffs',
+                    'include recent commit diffs in context (default: true)'
+                ],
+                [
+                    '--no-include-recent-diffs',
+                    'exclude recent diffs from context'
+                ],
+                [
+                    '--include-release-notes',
+                    'include recent release notes in context (default: false)'
+                ],
+                [
+                    '--no-include-release-notes',
+                    'exclude release notes from context'
+                ],
+                [
+                    '--include-github-issues',
+                    'include open GitHub issues in context (default: true)'
+                ],
+                [
+                    '--no-include-github-issues',
+                    'exclude GitHub issues from context'
+                ],
+                [
+                    '--commit-history-limit <limit>',
+                    'number of recent commits to include'
+                ],
+                [
+                    '--diff-history-limit <limit>',
+                    'number of recent commit diffs to include'
+                ],
+                [
+                    '--release-notes-limit <limit>',
+                    'number of recent release notes to include'
+                ],
+                [
+                    '--github-issues-limit <limit>',
+                    'number of open GitHub issues to include (max 20)'
+                ]
+            ];
+            const behavioralOptions = [
+                [
+                    '--sendit',
+                    'Create GitHub issues automatically without confirmation'
+                ]
+            ];
+            const globalOptions = [
+                [
+                    '--dry-run',
+                    'perform a dry run without saving files'
+                ],
+                [
+                    '--verbose',
+                    'enable verbose logging'
+                ],
+                [
+                    '--debug',
+                    'enable debug logging'
+                ],
+                [
+                    '--overrides',
+                    'enable overrides'
+                ],
+                [
+                    '--model <model>',
+                    'OpenAI model to use'
+                ],
+                [
+                    '-d, --context-directories [contextDirectories...]',
+                    'directories to scan for context'
+                ],
+                [
+                    '--config-dir <configDir>',
+                    'configuration directory'
+                ],
+                [
+                    '--output-dir <outputDir>',
+                    'output directory for generated files'
+                ],
+                [
+                    '--excluded-paths [excludedPatterns...]',
+                    'paths to exclude from the diff'
+                ],
+                [
+                    '-h, --help',
+                    'display help for command'
+                ]
+            ];
+            const formatOptionsSection = (title, options)=>{
+                const maxWidth = Math.max(...options.map(([flag])=>flag.length));
+                return `${title}:\n` + options.map(([flag, desc])=>`  ${flag.padEnd(maxWidth + 2)} ${desc}`).join('\n') + '\n';
+            };
+            return nameAndVersion + '\n' + formatOptionsSection('Arguments', argumentsSection) + '\n' + formatOptionsSection('Options', reviewOptions) + '\n' + formatOptionsSection('Git Context Parameters', gitContextOptions) + '\n' + formatOptionsSection('Behavioral Options', behavioralOptions) + '\n' + formatOptionsSection('Global Options', globalOptions) + '\n' + 'Environment Variables:\n' + '  OPENAI_API_KEY          OpenAI API key (required)\n';
+        }
+    });
+    const cleanCommand = program.command('clean').description('Remove the output directory and all generated files');
+    addSharedOptions(cleanCommand);
+    const selectAudioCommand = program.command('select-audio').description('Interactively select and save audio device for recording');
+    addSharedOptions(selectAudioCommand);
+    program.parse();
+    const cliArgs = program.opts(); // Get all opts initially
+    // Determine which command is being run
+    let commandName = DEFAULT_COMMAND;
+    let commandOptions = {}; // Store specific command options
+    if (program.args.length > 0) {
+        commandName = program.args[0];
+        validateCommand(commandName);
+    }
+    // Only proceed with command-specific options if validation passed
+    if (ALLOWED_COMMANDS.includes(commandName)) {
+        if (commandName === 'commit' && commitCommand.opts) {
+            commandOptions = commitCommand.opts();
+            // Handle positional argument for direction
+            const args = commitCommand.args;
+            if (args && args.length > 0 && args[0]) {
+                commandOptions.direction = args[0];
+            }
+            // Check for STDIN input for direction (takes precedence over positional argument)
+            const stdinInput = await readStdin();
+            if (stdinInput) {
+                commandOptions.direction = stdinInput;
+            }
+        } else if (commandName === 'audio-commit' && audioCommitCommand.opts) {
+            commandOptions = audioCommitCommand.opts();
+        } else if (commandName === 'release' && releaseCommand.opts) {
+            commandOptions = releaseCommand.opts();
+        } else if (commandName === 'publish' && publishCommand.opts) {
+            commandOptions = publishCommand.opts();
+        } else if (commandName === 'link' && linkCommand.opts) {
+            commandOptions = linkCommand.opts();
+        } else if (commandName === 'unlink' && unlinkCommand.opts) {
+            commandOptions = unlinkCommand.opts();
+        } else if (commandName === 'audio-review' && audioReviewCommand.opts) {
+            commandOptions = audioReviewCommand.opts();
+        } else if (commandName === 'review' && reviewCommand.opts) {
+            commandOptions = reviewCommand.opts();
+            // Handle positional argument for note
+            const args = reviewCommand.args;
+            if (args && args.length > 0 && args[0]) {
+                commandOptions.note = args[0];
+            }
+            // Check for STDIN input for note (takes precedence over positional argument)
+            const stdinInput = await readStdin();
+            if (stdinInput) {
+                commandOptions.note = stdinInput;
+            }
+        } else if (commandName === 'clean' && cleanCommand.opts) {
+            commandOptions = cleanCommand.opts();
+        } else if (commandName === 'select-audio' && selectAudioCommand.opts) {
+            commandOptions = selectAudioCommand.opts();
+        }
+    }
+    // Include command name in CLI args for merging
+    const finalCliArgs = {
+        ...cliArgs,
+        ...commandOptions
+    };
+    const commandConfig = {
+        commandName
+    };
+    return [
+        finalCliArgs,
+        commandConfig
+    ];
+}
+async function validateAndProcessSecureOptions() {
+    // For check-config and init-config commands, we don't want to throw an error for missing API key
+    const isCheckConfig = process.argv.includes('--check-config');
+    const isInitConfig = process.argv.includes('--init-config');
+    if (!process.env.OPENAI_API_KEY && !isCheckConfig && !isInitConfig) {
+        throw new Error('OpenAI API key is required. Please set the OPENAI_API_KEY environment variable.');
+    }
+    // Prefer CLI key if provided, otherwise use env var (might be undefined for check-config/init-config)
+    const openaiApiKey = process.env.OPENAI_API_KEY;
+    const secureConfig = {
+        openaiApiKey: openaiApiKey
+    };
+    return secureConfig;
+}
+// Renamed validation function to reflect its broader role
+async function validateAndProcessOptions(options) {
+    var _options_commit, _options_commit1, _options_commit2, _options_commit3, _options_commit4, _options_commit5, _options_audioCommit, _options_audioCommit1, _options_audioCommit2, _options_audioCommit3, _options_release, _options_release1, _options_release2, _options_release3, _options_audioReview, _options_audioReview1, _options_audioReview2, _options_audioReview3, _options_audioReview4, _options_audioReview5, _options_audioReview6, _options_audioReview7, _options_audioReview8, _options_audioReview9, _options_audioReview10, _options_audioReview11, _options_audioReview12, _options_audioReview13, _options_review, _options_review1, _options_review2, _options_review3, _options_review4, _options_review5, _options_review6, _options_review7, _options_review8, _options_review9, _options_review10, _options_publish, _options_publish1, _options_publish2, _options_publish3, _options_publish4, _options_link, _options_link1, _options_link2;
+    const contextDirectories = await validateContextDirectories(options.contextDirectories || KODRDRIV_DEFAULTS.contextDirectories);
+    const configDir = options.configDirectory || KODRDRIV_DEFAULTS.configDirectory;
+    var _options_dryRun, _options_verbose, _options_debug, _options_overrides, _options_model, _options_outputDirectory, _options_preferencesDirectory, _options_discoveredConfigDirs, _options_resolvedConfigDirs, _options_commit_add, _options_commit_cached, _options_commit_sendit, _options_commit_messageLimit, _options_audioCommit_maxRecordingTime, _options_audioCommit_audioDevice, _options_release_from, _options_release_to, _options_release_messageLimit, _options_audioReview_includeCommitHistory, _options_audioReview_includeRecentDiffs, _options_audioReview_includeReleaseNotes, _options_audioReview_includeGithubIssues, _options_audioReview_commitHistoryLimit, _options_audioReview_diffHistoryLimit, _options_audioReview_releaseNotesLimit, _options_audioReview_githubIssuesLimit, _options_audioReview_sendit, _options_audioReview_maxRecordingTime, _options_audioReview_audioDevice, _options_review_includeCommitHistory, _options_review_includeRecentDiffs, _options_review_includeReleaseNotes, _options_review_includeGithubIssues, _options_review_commitHistoryLimit, _options_review_diffHistoryLimit, _options_review_releaseNotesLimit, _options_review_githubIssuesLimit, _options_review_sendit, _options_publish_mergeMethod, _options_publish_requiredEnvVars, _options_publish_linkWorkspacePackages, _options_publish_unlinkWorkspacePackages, _options_link_scopeRoots, _options_link_workspaceFile, _options_link_dryRun, _options_excludedPatterns;
+    // Skip config directory validation since Cardigantime handles hierarchical lookup
+    // Ensure all required fields are present and have correct types after merging
+    const finalConfig = {
+        dryRun: (_options_dryRun = options.dryRun) !== null && _options_dryRun !== void 0 ? _options_dryRun : KODRDRIV_DEFAULTS.dryRun,
+        verbose: (_options_verbose = options.verbose) !== null && _options_verbose !== void 0 ? _options_verbose : KODRDRIV_DEFAULTS.verbose,
+        debug: (_options_debug = options.debug) !== null && _options_debug !== void 0 ? _options_debug : KODRDRIV_DEFAULTS.debug,
+        overrides: (_options_overrides = options.overrides) !== null && _options_overrides !== void 0 ? _options_overrides : KODRDRIV_DEFAULTS.overrides,
+        model: (_options_model = options.model) !== null && _options_model !== void 0 ? _options_model : KODRDRIV_DEFAULTS.model,
+        contextDirectories: contextDirectories,
+        configDirectory: configDir,
+        outputDirectory: (_options_outputDirectory = options.outputDirectory) !== null && _options_outputDirectory !== void 0 ? _options_outputDirectory : KODRDRIV_DEFAULTS.outputDirectory,
+        preferencesDirectory: (_options_preferencesDirectory = options.preferencesDirectory) !== null && _options_preferencesDirectory !== void 0 ? _options_preferencesDirectory : KODRDRIV_DEFAULTS.preferencesDirectory,
+        // Cardigantime-specific properties (from fileValues or defaults)
+        discoveredConfigDirs: (_options_discoveredConfigDirs = options.discoveredConfigDirs) !== null && _options_discoveredConfigDirs !== void 0 ? _options_discoveredConfigDirs : [],
+        resolvedConfigDirs: (_options_resolvedConfigDirs = options.resolvedConfigDirs) !== null && _options_resolvedConfigDirs !== void 0 ? _options_resolvedConfigDirs : [],
+        // Command-specific options with defaults
+        commit: {
+            add: (_options_commit_add = (_options_commit = options.commit) === null || _options_commit === void 0 ? void 0 : _options_commit.add) !== null && _options_commit_add !== void 0 ? _options_commit_add : KODRDRIV_DEFAULTS.commit.add,
+            cached: (_options_commit_cached = (_options_commit1 = options.commit) === null || _options_commit1 === void 0 ? void 0 : _options_commit1.cached) !== null && _options_commit_cached !== void 0 ? _options_commit_cached : KODRDRIV_DEFAULTS.commit.cached,
+            sendit: (_options_commit_sendit = (_options_commit2 = options.commit) === null || _options_commit2 === void 0 ? void 0 : _options_commit2.sendit) !== null && _options_commit_sendit !== void 0 ? _options_commit_sendit : KODRDRIV_DEFAULTS.commit.sendit,
+            messageLimit: (_options_commit_messageLimit = (_options_commit3 = options.commit) === null || _options_commit3 === void 0 ? void 0 : _options_commit3.messageLimit) !== null && _options_commit_messageLimit !== void 0 ? _options_commit_messageLimit : KODRDRIV_DEFAULTS.commit.messageLimit,
+            context: (_options_commit4 = options.commit) === null || _options_commit4 === void 0 ? void 0 : _options_commit4.context,
+            direction: (_options_commit5 = options.commit) === null || _options_commit5 === void 0 ? void 0 : _options_commit5.direction
+        },
+        audioCommit: {
+            maxRecordingTime: (_options_audioCommit_maxRecordingTime = (_options_audioCommit = options.audioCommit) === null || _options_audioCommit === void 0 ? void 0 : _options_audioCommit.maxRecordingTime) !== null && _options_audioCommit_maxRecordingTime !== void 0 ? _options_audioCommit_maxRecordingTime : KODRDRIV_DEFAULTS.audioCommit.maxRecordingTime,
+            audioDevice: (_options_audioCommit_audioDevice = (_options_audioCommit1 = options.audioCommit) === null || _options_audioCommit1 === void 0 ? void 0 : _options_audioCommit1.audioDevice) !== null && _options_audioCommit_audioDevice !== void 0 ? _options_audioCommit_audioDevice : KODRDRIV_DEFAULTS.audioCommit.audioDevice,
+            file: (_options_audioCommit2 = options.audioCommit) === null || _options_audioCommit2 === void 0 ? void 0 : _options_audioCommit2.file,
+            keepTemp: (_options_audioCommit3 = options.audioCommit) === null || _options_audioCommit3 === void 0 ? void 0 : _options_audioCommit3.keepTemp
+        },
+        release: {
+            from: (_options_release_from = (_options_release = options.release) === null || _options_release === void 0 ? void 0 : _options_release.from) !== null && _options_release_from !== void 0 ? _options_release_from : KODRDRIV_DEFAULTS.release.from,
+            to: (_options_release_to = (_options_release1 = options.release) === null || _options_release1 === void 0 ? void 0 : _options_release1.to) !== null && _options_release_to !== void 0 ? _options_release_to : KODRDRIV_DEFAULTS.release.to,
+            messageLimit: (_options_release_messageLimit = (_options_release2 = options.release) === null || _options_release2 === void 0 ? void 0 : _options_release2.messageLimit) !== null && _options_release_messageLimit !== void 0 ? _options_release_messageLimit : KODRDRIV_DEFAULTS.release.messageLimit,
+            context: (_options_release3 = options.release) === null || _options_release3 === void 0 ? void 0 : _options_release3.context
+        },
+        audioReview: {
+            includeCommitHistory: (_options_audioReview_includeCommitHistory = (_options_audioReview = options.audioReview) === null || _options_audioReview === void 0 ? void 0 : _options_audioReview.includeCommitHistory) !== null && _options_audioReview_includeCommitHistory !== void 0 ? _options_audioReview_includeCommitHistory : KODRDRIV_DEFAULTS.audioReview.includeCommitHistory,
+            includeRecentDiffs: (_options_audioReview_includeRecentDiffs = (_options_audioReview1 = options.audioReview) === null || _options_audioReview1 === void 0 ? void 0 : _options_audioReview1.includeRecentDiffs) !== null && _options_audioReview_includeRecentDiffs !== void 0 ? _options_audioReview_includeRecentDiffs : KODRDRIV_DEFAULTS.audioReview.includeRecentDiffs,
+            includeReleaseNotes: (_options_audioReview_includeReleaseNotes = (_options_audioReview2 = options.audioReview) === null || _options_audioReview2 === void 0 ? void 0 : _options_audioReview2.includeReleaseNotes) !== null && _options_audioReview_includeReleaseNotes !== void 0 ? _options_audioReview_includeReleaseNotes : KODRDRIV_DEFAULTS.audioReview.includeReleaseNotes,
+            includeGithubIssues: (_options_audioReview_includeGithubIssues = (_options_audioReview3 = options.audioReview) === null || _options_audioReview3 === void 0 ? void 0 : _options_audioReview3.includeGithubIssues) !== null && _options_audioReview_includeGithubIssues !== void 0 ? _options_audioReview_includeGithubIssues : KODRDRIV_DEFAULTS.audioReview.includeGithubIssues,
+            commitHistoryLimit: (_options_audioReview_commitHistoryLimit = (_options_audioReview4 = options.audioReview) === null || _options_audioReview4 === void 0 ? void 0 : _options_audioReview4.commitHistoryLimit) !== null && _options_audioReview_commitHistoryLimit !== void 0 ? _options_audioReview_commitHistoryLimit : KODRDRIV_DEFAULTS.audioReview.commitHistoryLimit,
+            diffHistoryLimit: (_options_audioReview_diffHistoryLimit = (_options_audioReview5 = options.audioReview) === null || _options_audioReview5 === void 0 ? void 0 : _options_audioReview5.diffHistoryLimit) !== null && _options_audioReview_diffHistoryLimit !== void 0 ? _options_audioReview_diffHistoryLimit : KODRDRIV_DEFAULTS.audioReview.diffHistoryLimit,
+            releaseNotesLimit: (_options_audioReview_releaseNotesLimit = (_options_audioReview6 = options.audioReview) === null || _options_audioReview6 === void 0 ? void 0 : _options_audioReview6.releaseNotesLimit) !== null && _options_audioReview_releaseNotesLimit !== void 0 ? _options_audioReview_releaseNotesLimit : KODRDRIV_DEFAULTS.audioReview.releaseNotesLimit,
+            githubIssuesLimit: (_options_audioReview_githubIssuesLimit = (_options_audioReview7 = options.audioReview) === null || _options_audioReview7 === void 0 ? void 0 : _options_audioReview7.githubIssuesLimit) !== null && _options_audioReview_githubIssuesLimit !== void 0 ? _options_audioReview_githubIssuesLimit : KODRDRIV_DEFAULTS.audioReview.githubIssuesLimit,
+            context: (_options_audioReview8 = options.audioReview) === null || _options_audioReview8 === void 0 ? void 0 : _options_audioReview8.context,
+            sendit: (_options_audioReview_sendit = (_options_audioReview9 = options.audioReview) === null || _options_audioReview9 === void 0 ? void 0 : _options_audioReview9.sendit) !== null && _options_audioReview_sendit !== void 0 ? _options_audioReview_sendit : KODRDRIV_DEFAULTS.audioReview.sendit,
+            maxRecordingTime: (_options_audioReview_maxRecordingTime = (_options_audioReview10 = options.audioReview) === null || _options_audioReview10 === void 0 ? void 0 : _options_audioReview10.maxRecordingTime) !== null && _options_audioReview_maxRecordingTime !== void 0 ? _options_audioReview_maxRecordingTime : KODRDRIV_DEFAULTS.audioReview.maxRecordingTime,
+            audioDevice: (_options_audioReview_audioDevice = (_options_audioReview11 = options.audioReview) === null || _options_audioReview11 === void 0 ? void 0 : _options_audioReview11.audioDevice) !== null && _options_audioReview_audioDevice !== void 0 ? _options_audioReview_audioDevice : KODRDRIV_DEFAULTS.audioReview.audioDevice,
+            file: (_options_audioReview12 = options.audioReview) === null || _options_audioReview12 === void 0 ? void 0 : _options_audioReview12.file,
+            keepTemp: (_options_audioReview13 = options.audioReview) === null || _options_audioReview13 === void 0 ? void 0 : _options_audioReview13.keepTemp
+        },
+        review: {
+            includeCommitHistory: (_options_review_includeCommitHistory = (_options_review = options.review) === null || _options_review === void 0 ? void 0 : _options_review.includeCommitHistory) !== null && _options_review_includeCommitHistory !== void 0 ? _options_review_includeCommitHistory : KODRDRIV_DEFAULTS.review.includeCommitHistory,
+            includeRecentDiffs: (_options_review_includeRecentDiffs = (_options_review1 = options.review) === null || _options_review1 === void 0 ? void 0 : _options_review1.includeRecentDiffs) !== null && _options_review_includeRecentDiffs !== void 0 ? _options_review_includeRecentDiffs : KODRDRIV_DEFAULTS.review.includeRecentDiffs,
+            includeReleaseNotes: (_options_review_includeReleaseNotes = (_options_review2 = options.review) === null || _options_review2 === void 0 ? void 0 : _options_review2.includeReleaseNotes) !== null && _options_review_includeReleaseNotes !== void 0 ? _options_review_includeReleaseNotes : KODRDRIV_DEFAULTS.review.includeReleaseNotes,
+            includeGithubIssues: (_options_review_includeGithubIssues = (_options_review3 = options.review) === null || _options_review3 === void 0 ? void 0 : _options_review3.includeGithubIssues) !== null && _options_review_includeGithubIssues !== void 0 ? _options_review_includeGithubIssues : KODRDRIV_DEFAULTS.review.includeGithubIssues,
+            commitHistoryLimit: (_options_review_commitHistoryLimit = (_options_review4 = options.review) === null || _options_review4 === void 0 ? void 0 : _options_review4.commitHistoryLimit) !== null && _options_review_commitHistoryLimit !== void 0 ? _options_review_commitHistoryLimit : KODRDRIV_DEFAULTS.review.commitHistoryLimit,
+            diffHistoryLimit: (_options_review_diffHistoryLimit = (_options_review5 = options.review) === null || _options_review5 === void 0 ? void 0 : _options_review5.diffHistoryLimit) !== null && _options_review_diffHistoryLimit !== void 0 ? _options_review_diffHistoryLimit : KODRDRIV_DEFAULTS.review.diffHistoryLimit,
+            releaseNotesLimit: (_options_review_releaseNotesLimit = (_options_review6 = options.review) === null || _options_review6 === void 0 ? void 0 : _options_review6.releaseNotesLimit) !== null && _options_review_releaseNotesLimit !== void 0 ? _options_review_releaseNotesLimit : KODRDRIV_DEFAULTS.review.releaseNotesLimit,
+            githubIssuesLimit: (_options_review_githubIssuesLimit = (_options_review7 = options.review) === null || _options_review7 === void 0 ? void 0 : _options_review7.githubIssuesLimit) !== null && _options_review_githubIssuesLimit !== void 0 ? _options_review_githubIssuesLimit : KODRDRIV_DEFAULTS.review.githubIssuesLimit,
+            context: (_options_review8 = options.review) === null || _options_review8 === void 0 ? void 0 : _options_review8.context,
+            sendit: (_options_review_sendit = (_options_review9 = options.review) === null || _options_review9 === void 0 ? void 0 : _options_review9.sendit) !== null && _options_review_sendit !== void 0 ? _options_review_sendit : KODRDRIV_DEFAULTS.review.sendit,
+            note: (_options_review10 = options.review) === null || _options_review10 === void 0 ? void 0 : _options_review10.note
+        },
+        publish: {
+            mergeMethod: (_options_publish_mergeMethod = (_options_publish = options.publish) === null || _options_publish === void 0 ? void 0 : _options_publish.mergeMethod) !== null && _options_publish_mergeMethod !== void 0 ? _options_publish_mergeMethod : KODRDRIV_DEFAULTS.publish.mergeMethod,
+            dependencyUpdatePatterns: (_options_publish1 = options.publish) === null || _options_publish1 === void 0 ? void 0 : _options_publish1.dependencyUpdatePatterns,
+            requiredEnvVars: (_options_publish_requiredEnvVars = (_options_publish2 = options.publish) === null || _options_publish2 === void 0 ? void 0 : _options_publish2.requiredEnvVars) !== null && _options_publish_requiredEnvVars !== void 0 ? _options_publish_requiredEnvVars : KODRDRIV_DEFAULTS.publish.requiredEnvVars,
+            linkWorkspacePackages: (_options_publish_linkWorkspacePackages = (_options_publish3 = options.publish) === null || _options_publish3 === void 0 ? void 0 : _options_publish3.linkWorkspacePackages) !== null && _options_publish_linkWorkspacePackages !== void 0 ? _options_publish_linkWorkspacePackages : KODRDRIV_DEFAULTS.publish.linkWorkspacePackages,
+            unlinkWorkspacePackages: (_options_publish_unlinkWorkspacePackages = (_options_publish4 = options.publish) === null || _options_publish4 === void 0 ? void 0 : _options_publish4.unlinkWorkspacePackages) !== null && _options_publish_unlinkWorkspacePackages !== void 0 ? _options_publish_unlinkWorkspacePackages : KODRDRIV_DEFAULTS.publish.unlinkWorkspacePackages
+        },
+        link: {
+            scopeRoots: (_options_link_scopeRoots = (_options_link = options.link) === null || _options_link === void 0 ? void 0 : _options_link.scopeRoots) !== null && _options_link_scopeRoots !== void 0 ? _options_link_scopeRoots : KODRDRIV_DEFAULTS.link.scopeRoots,
+            workspaceFile: (_options_link_workspaceFile = (_options_link1 = options.link) === null || _options_link1 === void 0 ? void 0 : _options_link1.workspaceFile) !== null && _options_link_workspaceFile !== void 0 ? _options_link_workspaceFile : KODRDRIV_DEFAULTS.link.workspaceFile,
+            dryRun: (_options_link_dryRun = (_options_link2 = options.link) === null || _options_link2 === void 0 ? void 0 : _options_link2.dryRun) !== null && _options_link_dryRun !== void 0 ? _options_link_dryRun : KODRDRIV_DEFAULTS.link.dryRun
+        },
+        excludedPatterns: (_options_excludedPatterns = options.excludedPatterns) !== null && _options_excludedPatterns !== void 0 ? _options_excludedPatterns : KODRDRIV_DEFAULTS.excludedPatterns
+    };
+    // Final validation against the MainConfig shape (optional, cardigantime might handle it)
+    // You could potentially use ConfigShape.parse(finalConfig) here if needed
+    return finalConfig;
+}
+// Export for testing
+function validateCommand(commandName) {
+    if (!ALLOWED_COMMANDS.includes(commandName)) {
+        throw new Error(`Invalid command: ${commandName}, allowed commands: ${ALLOWED_COMMANDS.join(', ')}`);
+    }
+    return commandName;
+}
+// Export for testing
+async function validateContextDirectories(contextDirectories) {
+    const logger = getLogger();
+    const storage = create$2({
+        log: logger.info
+    });
+    // Filter out directories that don't exist
+    const validDirectories = [];
+    for (const dir of contextDirectories){
+        try {
+            if (await storage.isDirectoryReadable(dir)) {
+                validDirectories.push(dir);
+            } else {
+                logger.warn(`Directory not readable: ${dir}`);
+            }
+        } catch (error) {
+            logger.warn(`Error validating directory ${dir}: ${error.message}`);
+        }
+    }
+    return validDirectories;
+}
+
+class ExitError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'ExitError';
+    }
+}
+
+async function run(command, options = {}) {
+    const execPromise = util.promisify(exec);
+    return execPromise(command, options);
+}
+async function runWithDryRunSupport(command, isDryRun, options = {}) {
+    const logger = getLogger();
+    if (isDryRun) {
+        logger.info(`DRY RUN: Would execute command: ${command}`);
+        return {
+            stdout: '',
+            stderr: ''
+        };
+    }
+    return run(command, options);
+}
+
+// Enhanced exclusion patterns specifically for review context
+// These focus on excluding large files, binaries, and content that doesn't help with issue analysis
+const getReviewExcludedPatterns = (basePatterns)=>{
+    const reviewSpecificExclusions = [
+        // Lock files and dependency files (often massive)
+        "*lock*",
+        "*.lock",
+        "pnpm-lock.yaml",
+        "package-lock.json",
+        "yarn.lock",
+        "bun.lockb",
+        "composer.lock",
+        "Cargo.lock",
+        "Gemfile.lock",
+        "Pipfile.lock",
+        "poetry.lock",
+        // Image files (binary and large)
+        "*.png",
+        "*.jpg",
+        "*.jpeg",
+        "*.gif",
+        "*.bmp",
+        "*.tiff",
+        "*.webp",
+        "*.svg",
+        "*.ico",
+        "*.icns",
+        // Video and audio files
+        "*.mp4",
+        "*.avi",
+        "*.mov",
+        "*.wmv",
+        "*.flv",
+        "*.mp3",
+        "*.wav",
+        "*.flac",
+        // Archives and compressed files
+        "*.zip",
+        "*.tar",
+        "*.tar.gz",
+        "*.tgz",
+        "*.rar",
+        "*.7z",
+        "*.bz2",
+        "*.xz",
+        // Binary executables and libraries
+        "*.exe",
+        "*.dll",
+        "*.so",
+        "*.dylib",
+        "*.bin",
+        "*.app",
+        // Database files
+        "*.db",
+        "*.sqlite",
+        "*.sqlite3",
+        "*.mdb",
+        // Large generated files
+        "*.map",
+        "*.min.js",
+        "*.min.css",
+        "bundle.*",
+        "vendor.*",
+        // Documentation that's often large
+        "*.pdf",
+        "*.doc",
+        "*.docx",
+        "*.ppt",
+        "*.pptx",
+        // IDE and OS generated files
+        ".DS_Store",
+        "Thumbs.db",
+        "*.swp",
+        "*.tmp",
+        // Certificate and key files
+        "*.pem",
+        "*.crt",
+        "*.key",
+        "*.p12",
+        "*.pfx",
+        // Large config/data files that are often auto-generated
+        "tsconfig.tsbuildinfo",
+        "*.cache",
+        ".eslintcache"
+    ];
+    // Combine base patterns with review specific exclusions, removing duplicates
+    const combinedPatterns = [
+        ...new Set([
+            ...basePatterns,
+            ...reviewSpecificExclusions
+        ])
+    ];
+    return combinedPatterns;
+};
+// Function to truncate overly large diff content while preserving structure
+const truncateLargeDiff = (diffContent, maxLength = 5000)=>{
+    if (diffContent.length <= maxLength) {
+        return diffContent;
+    }
+    const lines = diffContent.split('\n');
+    const truncatedLines = [];
+    let currentLength = 0;
+    let truncated = false;
+    for (const line of lines){
+        if (currentLength + line.length + 1 > maxLength) {
+            truncated = true;
+            break;
+        }
+        truncatedLines.push(line);
+        currentLength += line.length + 1; // +1 for newline
+    }
+    if (truncated) {
+        truncatedLines.push('');
+        truncatedLines.push(`... [TRUNCATED: Original diff was ${diffContent.length} characters, showing first ${currentLength}] ...`);
+    }
+    return truncatedLines.join('\n');
+};
+const create$1 = async (options)=>{
+    const logger = getLogger();
+    async function get() {
+        try {
+            logger.verbose('Gathering change information from Git');
+            try {
+                logger.debug('Executing git diff');
+                const excludeString = options.excludedPatterns.map((p)=>`':(exclude)${p}'`).join(' ');
+                let range = '';
+                if (options.from && options.to) {
+                    range = `${options.from}..${options.to}`;
+                } else if (options.from) {
+                    range = `${options.from}`;
+                } else if (options.to) {
+                    range = `${options.to}`;
+                }
+                let command = '';
+                if (options.cached) {
+                    command = `git diff --cached${range ? ' ' + range : ''} -- . ${excludeString}`;
+                } else {
+                    command = `git diff${range ? ' ' + range : ''} -- . ${excludeString}`;
+                }
+                const { stdout, stderr } = await run(command);
+                if (stderr) {
+                    logger.warn('Git log produced stderr: %s', stderr);
+                }
+                logger.debug('Git log output: %s', stdout);
+                return stdout;
+            } catch (error) {
+                logger.error('Failed to execute git log: %s', error.message);
+                throw error;
+            }
+        } catch (error) {
+            logger.error('Error occurred during gather change phase: %s %s', error.message, error.stack);
+            throw new ExitError('Error occurred during gather change phase');
+        }
+    }
+    return {
+        get
+    };
+};
+const hasStagedChanges = async ()=>{
+    const logger = getLogger();
+    try {
+        logger.debug('Checking for staged changes');
+        const { stderr } = await run('git diff --cached --quiet');
+        if (stderr) {
+            logger.warn('Git diff produced stderr: %s', stderr);
+        }
+        // If there are staged changes, git diff --cached --quiet will return non-zero
+        // So if we get here without an error, there are no staged changes
+        return false;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (error) {
+        // If we get an error, it means there are staged changes
+        return true;
+    }
+};
+// High-level function to get recent diffs formatted for review context
+const getRecentDiffsForReview = async (options)=>{
+    const logger = getLogger();
+    const diffLimit = options.limit || 5;
+    // Get enhanced exclusion patterns for review context
+    const reviewExcluded = getReviewExcludedPatterns(options.baseExcludedPatterns);
+    logger.debug('Using %d exclusion patterns for diff context (including %d review specific)', reviewExcluded.length, reviewExcluded.length - options.baseExcludedPatterns.length);
+    logger.debug('Sample exclusions: %s', reviewExcluded.slice(0, 10).join(', ') + (reviewExcluded.length > 10 ? '...' : ''));
+    const diffSections = [];
+    // Get recent commits and their diffs
+    for(let i = 0; i < diffLimit; i++){
+        try {
+            const diffRange = i === 0 ? 'HEAD~1' : `HEAD~${i + 1}..HEAD~${i}`;
+            const diff = await create$1({
+                from: `HEAD~${i + 1}`,
+                to: `HEAD~${i}`,
+                excludedPatterns: reviewExcluded
+            });
+            const diffContent = await diff.get();
+            if (diffContent.trim()) {
+                const truncatedDiff = truncateLargeDiff(diffContent);
+                diffSections.push(`[Recent Diff ${i + 1} (${diffRange})]\n${truncatedDiff}`);
+                if (truncatedDiff.length < diffContent.length) {
+                    logger.debug('Added diff %d to context (%d characters, truncated from %d)', i + 1, truncatedDiff.length, diffContent.length);
+                } else {
+                    logger.debug('Added diff %d to context (%d characters)', i + 1, diffContent.length);
+                }
+            } else {
+                logger.debug('Diff %d was empty after exclusions', i + 1);
+            }
+        } catch (error) {
+            logger.debug('Could not fetch diff %d: %s', i + 1, error.message);
+            break; // Stop if we can't fetch more diffs
+        }
+    }
+    return diffSections.length > 0 ? '\n\n' + diffSections.join('\n\n') : '';
+};
+
+const create = async (options)=>{
+    const logger = getLogger();
+    async function get() {
+        try {
+            logger.verbose('Gathering change information from Git');
+            try {
+                logger.debug('Executing git log');
+                // Build git log range
+                let range = '';
+                let extraArgs = '';
+                // If currentBranchOnly, show only commits unique to HEAD vs. to-branch (or main/master if not provided)
+                if (options.currentBranchOnly) {
+                    const toBranch = options.to || 'main'; // Default to 'main' if not provided
+                    range = `${toBranch}..HEAD`;
+                } else if (options.from && options.to) {
+                    range = `${options.from}..${options.to}`;
+                } else if (options.from) {
+                    range = `${options.from}`;
+                } else if (options.to) {
+                    range = `${options.to}`;
+                } // else, no range: show all
+                if (options.limit && options.limit > 0) {
+                    extraArgs += ` -n ${options.limit}`;
+                }
+                const gitLogCmd = `git log${range ? ' ' + range : ''}${extraArgs}`;
+                logger.debug('Git log command: %s', gitLogCmd);
+                const { stdout, stderr } = await run(gitLogCmd);
+                if (stderr) {
+                    logger.warn('Git log produced stderr: %s', stderr);
+                }
+                logger.debug('Git log output: %s', stdout);
+                return stdout;
+            } catch (error) {
+                logger.error('Failed to execute git log: %s', error.message);
+                throw error;
+            }
+        } catch (error) {
+            logger.error('Error occurred during gather change phase: %s %s', error.message, error.stack);
+            throw new ExitError('Error occurred during gather change phase');
+        }
+    }
+    return {
+        get
+    };
+};
+
+const __filename$2 = fileURLToPath(import.meta.url);
+const __dirname$2 = path.dirname(__filename$2);
+/**
+ * Build a commit prompt using RiotPrompt Recipes.
+ *
+ * @param runConfig   The runtime configuration provided by the CLI
+ * @param content     Mandatory content inputs (e.g. diff)
+ * @param ctx         Optional contextual inputs configured by the user
+ */ const createPrompt$2 = async ({ overridePaths, overrides }, { diffContent, userDirection }, { logContext, context, directories } = {})=>{
+    // Use the new quick.commit recipe - much simpler!
+    // Adjust basePath for single-file build
+    const basePath = path.resolve(__dirname$2, 'src', 'prompt');
+    return quick.commit(diffContent, {
+        basePath,
+        overridePaths: overridePaths || [],
+        overrides: overrides || false,
+        userDirection,
+        context,
+        directories
+    });
+};
+
+//Recursive implementation of jSON.stringify;
+const stringifyJSON = function(obj, options = {
+    depth: 0
+}) {
+    if (options.depth > 10) {
+        return '{"error": "Maximum depth reached"}';
+    }
+    const arrOfKeyVals = [];
+    const arrVals = [];
+    let objKeys = [];
+    /*********CHECK FOR PRIMITIVE TYPES**********/ if (typeof obj === 'number' || typeof obj === 'boolean' || obj === null) return '' + obj;
+    else if (typeof obj === 'string') return '"' + obj + '"';
+    else if (Array.isArray(obj)) {
+        //check for empty array
+        if (obj[0] === undefined) return '[]';
+        else {
+            obj.forEach(function(el) {
+                arrVals.push(stringifyJSON(el, {
+                    depth: options.depth + 1
+                }));
+            });
+            return '[' + arrVals + ']';
+        }
+    } else if (obj instanceof Object) {
+        //get object keys
+        objKeys = Object.keys(obj);
+        //set key output;
+        objKeys.forEach(function(key) {
+            const keyOut = '"' + key + '":';
+            const keyValOut = obj[key];
+            //skip functions and undefined properties
+            if (keyValOut instanceof Function || keyValOut === undefined) arrOfKeyVals.push('');
+            else if (typeof keyValOut === 'string') arrOfKeyVals.push(keyOut + '"' + keyValOut + '"');
+            else if (typeof keyValOut === 'boolean' || typeof keyValOut === 'number' || keyValOut === null) arrOfKeyVals.push(keyOut + keyValOut);
+            else if (keyValOut instanceof Object) {
+                arrOfKeyVals.push(keyOut + stringifyJSON(keyValOut, {
+                    depth: options.depth + 1
+                }));
+            }
+        });
+        return '{' + arrOfKeyVals + '}';
+    }
+    return '';
+};
+const incrementPatchVersion = (version)=>{
+    const parts = version.split('.');
+    if (parts.length !== 3) {
+        throw new Error(`Invalid version string: ${version}`);
+    }
+    const patch = parseInt(parts[2], 10);
+    if (isNaN(patch)) {
+        throw new Error(`Invalid patch version: ${parts[2]}`);
+    }
+    parts[2] = (patch + 1).toString();
+    return parts.join('.');
+};
+const getOutputPath = (outputDirectory, filename)=>{
+    return path.join(outputDirectory, filename);
+};
+const getTimestampedFilename = (baseName, extension = '.json')=>{
+    const now = new Date();
+    // Format as YYMMdd-HHmm (e.g., 250701-1030)
+    const yy = now.getFullYear().toString().slice(-2);
+    const mm = (now.getMonth() + 1).toString().padStart(2, '0');
+    const dd = now.getDate().toString().padStart(2, '0');
+    const hh = now.getHours().toString().padStart(2, '0');
+    const min = now.getMinutes().toString().padStart(2, '0');
+    const timestamp = `${yy}${mm}${dd}-${hh}${min}`;
+    return `${timestamp}-${baseName}${extension}`;
+};
+const getTimestampedRequestFilename = (baseName)=>{
+    return getTimestampedFilename(baseName, '.request.json');
+};
+const getTimestampedResponseFilename = (baseName)=>{
+    return getTimestampedFilename(baseName, '.response.json');
+};
+const getTimestampedCommitFilename = ()=>{
+    return getTimestampedFilename('commit-message', '.md');
+};
+const getTimestampedReleaseNotesFilename = ()=>{
+    return getTimestampedFilename('release-notes', '.md');
+};
+const getTimestampedAudioFilename = ()=>{
+    return getTimestampedFilename('audio-recording', '.wav');
+};
+const getTimestampedReviewFilename = ()=>{
+    return getTimestampedFilename('review-analysis', '.md');
+};
+const getTimestampedReviewNotesFilename = ()=>{
+    return getTimestampedFilename('review-notes', '.md');
+};
+
+class OpenAIError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'OpenAIError';
+    }
+}
+async function createCompletion(messages, options = {
+    model: "gpt-4o-mini"
+}) {
+    const logger = getLogger();
+    const storage = create$2({
+        log: logger.debug
+    });
+    let openai = null;
+    try {
+        var _completion_choices__message_content, _completion_choices__message, _completion_choices_;
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+            throw new OpenAIError('OPENAI_API_KEY environment variable is not set');
+        }
+        // Create the client which we'll close in the finally block.
+        openai = new OpenAI({
+            apiKey: apiKey
+        });
+        logger.debug('Sending prompt to OpenAI: %j', messages);
+        // Save request debug file if enabled
+        if (options.debug && (options.debugRequestFile || options.debugFile)) {
+            const requestData = {
+                model: options.model || "gpt-4o-mini",
+                messages,
+                max_completion_tokens: 10000,
+                response_format: options.responseFormat
+            };
+            const debugFile = options.debugRequestFile || options.debugFile;
+            await storage.writeFile(debugFile, JSON.stringify(requestData, null, 2), 'utf8');
+            logger.debug('Wrote request debug file to %s', debugFile);
+        }
+        const completion = await openai.chat.completions.create({
+            model: options.model || "gpt-4o-mini",
+            messages,
+            max_completion_tokens: 10000,
+            response_format: options.responseFormat
+        });
+        // Save response debug file if enabled
+        if (options.debug && (options.debugResponseFile || options.debugFile)) {
+            const debugFile = options.debugResponseFile || options.debugFile;
+            await storage.writeFile(debugFile, JSON.stringify(completion, null, 2), 'utf8');
+            logger.debug('Wrote response debug file to %s', debugFile);
+        }
+        const response = (_completion_choices_ = completion.choices[0]) === null || _completion_choices_ === void 0 ? void 0 : (_completion_choices__message = _completion_choices_.message) === null || _completion_choices__message === void 0 ? void 0 : (_completion_choices__message_content = _completion_choices__message.content) === null || _completion_choices__message_content === void 0 ? void 0 : _completion_choices__message_content.trim();
+        if (!response) {
+            throw new OpenAIError('No response received from OpenAI');
+        }
+        logger.debug('Received response from OpenAI: %s...', response.substring(0, 30));
+        if (options.responseFormat) {
+            return JSON.parse(response);
+        } else {
+            return response;
+        }
+    } catch (error) {
+        logger.error('Error calling OpenAI API: %s %s', error.message, error.stack);
+        throw new OpenAIError(`Failed to create completion: ${error.message}`);
+    } finally{
+        // Ensure we close the OpenAI client to release underlying keep-alive sockets
+        try {
+            // openai.close() returns a promise; awaiting ensures proper cleanup
+            // but if it throws we silently ignore as it's best-effort.
+            if (openai && typeof openai.close === 'function') {
+                await openai.close();
+            }
+        } catch (closeErr) {
+            logger.debug('Failed to close OpenAI client: %s', closeErr.message);
+        }
+    }
+}
+async function transcribeAudio(filePath, options = {
+    model: "whisper-1"
+}) {
+    const logger = getLogger();
+    const storage = create$2({
+        log: logger.debug
+    });
+    let openai = null;
+    let audioStream = null;
+    try {
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+            throw new OpenAIError('OPENAI_API_KEY environment variable is not set');
+        }
+        openai = new OpenAI({
+            apiKey: apiKey
+        });
+        logger.debug('Transcribing audio file: %s', filePath);
+        // Save request debug file if enabled
+        if (options.debug && (options.debugRequestFile || options.debugFile)) {
+            const requestData = {
+                model: options.model || "whisper-1",
+                file: filePath,
+                response_format: "json"
+            };
+            const debugFile = options.debugRequestFile || options.debugFile;
+            await storage.writeFile(debugFile, JSON.stringify(requestData, null, 2), 'utf8');
+            logger.debug('Wrote request debug file to %s', debugFile);
+        }
+        audioStream = await storage.readStream(filePath);
+        const transcription = await openai.audio.transcriptions.create({
+            model: options.model || "whisper-1",
+            file: audioStream,
+            response_format: "json"
+        });
+        // Save response debug file if enabled
+        if (options.debug && (options.debugResponseFile || options.debugFile)) {
+            const debugFile = options.debugResponseFile || options.debugFile;
+            await storage.writeFile(debugFile, JSON.stringify(transcription, null, 2), 'utf8');
+            logger.debug('Wrote response debug file to %s', debugFile);
+        }
+        const response = transcription;
+        if (!response) {
+            throw new OpenAIError('No transcription received from OpenAI');
+        }
+        logger.debug('Received transcription from OpenAI: %s', response);
+        return response;
+    } catch (error) {
+        logger.error('Error transcribing audio file: %s %s', error.message, error.stack);
+        throw new OpenAIError(`Failed to transcribe audio: ${error.message}`);
+    } finally{
+        // Ensure the audio stream is properly closed to release file handles
+        try {
+            if (audioStream) {
+                audioStream.close();
+            }
+        } catch (streamErr) {
+            logger.debug('Failed to close audio read stream: %s', streamErr.message);
+        }
+        try {
+            if (openai && typeof openai.close === 'function') {
+                await openai.close();
+            }
+        } catch (closeErr) {
+            logger.debug('Failed to close OpenAI client: %s', closeErr.message);
+        }
+    }
+}
+
+const execute$9 = async (runConfig)=>{
+    var _runConfig_commit, _runConfig_commit1, _runConfig_commit2, _runConfig_commit3, _runConfig_commit4, _runConfig_commit5, _runConfig_commit6, _runConfig_commit7;
+    const logger = getLogger();
+    const isDryRun = runConfig.dryRun || false;
+    if ((_runConfig_commit = runConfig.commit) === null || _runConfig_commit === void 0 ? void 0 : _runConfig_commit.add) {
+        if (isDryRun) {
+            logger.info('DRY RUN: Would add all changes to the index with: git add -A');
+        } else {
+            logger.verbose('Adding all changes to the index...');
+            await run('git add -A');
+        }
+    }
+    let diffContent = '';
+    let cached = (_runConfig_commit1 = runConfig.commit) === null || _runConfig_commit1 === void 0 ? void 0 : _runConfig_commit1.cached;
+    // If `add` is used, we should always look at staged changes.
+    if ((_runConfig_commit2 = runConfig.commit) === null || _runConfig_commit2 === void 0 ? void 0 : _runConfig_commit2.add) {
+        cached = true;
+    } else if (cached === undefined) {
+        // If cached is undefined? We're going to look for a staged commit; otherwise, we'll use the supplied setting.
+        cached = await hasStagedChanges();
+    }
+    // Fix: Exit early if sendit is true but no changes are staged
+    if (((_runConfig_commit3 = runConfig.commit) === null || _runConfig_commit3 === void 0 ? void 0 : _runConfig_commit3.sendit) && !cached && !isDryRun) {
+        logger.warn('SendIt mode enabled, but no changes to commit.');
+        process.exit(1);
+    }
+    var _runConfig_excludedPatterns;
+    const options = {
+        cached,
+        excludedPatterns: (_runConfig_excludedPatterns = runConfig.excludedPatterns) !== null && _runConfig_excludedPatterns !== void 0 ? _runConfig_excludedPatterns : DEFAULT_EXCLUDED_PATTERNS
+    };
+    const diff = await create$1(options);
+    diffContent = await diff.get();
+    const logOptions = {
+        limit: (_runConfig_commit4 = runConfig.commit) === null || _runConfig_commit4 === void 0 ? void 0 : _runConfig_commit4.messageLimit
+    };
+    const log = await create(logOptions);
+    const logContext = await log.get();
+    const promptConfig = {
+        overridePaths: runConfig.discoveredConfigDirs || [],
+        overrides: runConfig.overrides || false
+    };
+    const promptContent = {
+        diffContent,
+        userDirection: (_runConfig_commit5 = runConfig.commit) === null || _runConfig_commit5 === void 0 ? void 0 : _runConfig_commit5.direction
+    };
+    const promptContext = {
+        logContext,
+        context: (_runConfig_commit6 = runConfig.commit) === null || _runConfig_commit6 === void 0 ? void 0 : _runConfig_commit6.context,
+        directories: runConfig.contextDirectories
+    };
+    const prompt = await createPrompt$2(promptConfig, promptContent, promptContext);
+    if (runConfig.debug) {
+        const formattedPrompt = Formatter.create({
+            logger
+        }).formatPrompt("gpt-4o-mini", prompt);
+        logger.silly('Formatted Prompt: %s', stringifyJSON(formattedPrompt));
+    }
+    const request = Formatter.create({
+        logger
+    }).formatPrompt(runConfig.model, prompt);
+    // Always ensure output directory exists for request/response files
+    const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+    const storage = create$2({
+        log: logger.info
+    });
+    await storage.ensureDirectory(outputDirectory);
+    const summary = await createCompletion(request.messages, {
+        model: runConfig.model,
+        debug: runConfig.debug,
+        debugRequestFile: getOutputPath(runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY, getTimestampedRequestFilename('commit')),
+        debugResponseFile: getOutputPath(runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY, getTimestampedResponseFilename('commit'))
+    });
+    // Save timestamped copy of commit message to output directory
+    try {
+        const timestampedFilename = getTimestampedCommitFilename();
+        const outputPath = getOutputPath(outputDirectory, timestampedFilename);
+        await storage.writeFile(outputPath, summary, 'utf-8');
+        logger.debug('Saved timestamped commit message: %s', outputPath);
+    } catch (error) {
+        logger.warn('Failed to save timestamped commit message: %s', error.message);
+    }
+    if ((_runConfig_commit7 = runConfig.commit) === null || _runConfig_commit7 === void 0 ? void 0 : _runConfig_commit7.sendit) {
+        if (!cached && !isDryRun) {
+            logger.error('SendIt mode enabled, but no changes to commit. Message: \n\n%s\n\n', summary);
+            process.exit(1);
+        }
+        if (isDryRun) {
+            logger.info('DRY RUN: Would commit with message: \n\n%s\n\n', summary);
+            logger.info('DRY RUN: Would execute: git commit -m <generated-message>');
+        } else {
+            logger.info('SendIt mode enabled. Committing with message: \n\n%s\n\n', summary);
+            try {
+                const escapedSummary = shellescape([
+                    summary
+                ]);
+                await run(`git commit -m ${escapedSummary}`);
+                logger.info('Commit successful!');
+            } catch (error) {
+                logger.error('Failed to commit:', error);
+                process.exit(1);
+            }
+        }
+    } else if (isDryRun) {
+        logger.info('DRY RUN: Generated commit message: \n\n%s\n\n', summary);
+    }
+    return summary;
+};
+
+const execute$8 = async (runConfig)=>{
+    var _runConfig_commit;
+    const logger = getLogger();
+    const isDryRun = runConfig.dryRun || false;
+    if (isDryRun) {
+        var _runConfig_audioCommit, _runConfig_commit1;
+        if ((_runConfig_audioCommit = runConfig.audioCommit) === null || _runConfig_audioCommit === void 0 ? void 0 : _runConfig_audioCommit.file) {
+            logger.info('DRY RUN: Would process audio file: %s', runConfig.audioCommit.file);
+            logger.info('DRY RUN: Would transcribe audio and use as context for commit message generation');
+        } else {
+            logger.info('DRY RUN: Would start audio recording for commit context');
+            logger.info('DRY RUN: Would transcribe audio and use as context for commit message generation');
+        }
+        logger.info('DRY RUN: Would then delegate to regular commit command');
+        // In dry run, just call the regular commit command with empty audio context
+        return execute$9({
+            ...runConfig,
+            commit: {
+                ...runConfig.commit,
+                direction: ((_runConfig_commit1 = runConfig.commit) === null || _runConfig_commit1 === void 0 ? void 0 : _runConfig_commit1.direction) || ''
+            }
+        });
+    }
+    let audioContext;
+    try {
+        var _runConfig_audioCommit1, _runConfig_audioCommit2, _runConfig_audioCommit3, _runConfig_audioCommit4;
+        // Step 1: Record audio using unplayable with new key handling
+        logger.info('🎙️  Starting audio recording for commit context...');
+        if (!((_runConfig_audioCommit1 = runConfig.audioCommit) === null || _runConfig_audioCommit1 === void 0 ? void 0 : _runConfig_audioCommit1.file)) {
+            logger.info('Press ENTER to stop recording or C to cancel');
+        }
+        // Use processAudio with proper configuration
+        const audioResult = await processAudio({
+            file: (_runConfig_audioCommit2 = runConfig.audioCommit) === null || _runConfig_audioCommit2 === void 0 ? void 0 : _runConfig_audioCommit2.file,
+            maxRecordingTime: (_runConfig_audioCommit3 = runConfig.audioCommit) === null || _runConfig_audioCommit3 === void 0 ? void 0 : _runConfig_audioCommit3.maxRecordingTime,
+            outputDirectory: runConfig.outputDirectory || 'output',
+            debug: runConfig.debug
+        });
+        // Check if recording was cancelled
+        if (audioResult.cancelled) {
+            logger.info('❌ Audio commit cancelled by user');
+            process.exit(0);
+        }
+        // Step 2: Get the audio file path from the result
+        let audioFilePath;
+        if ((_runConfig_audioCommit4 = runConfig.audioCommit) === null || _runConfig_audioCommit4 === void 0 ? void 0 : _runConfig_audioCommit4.file) {
+            // Use the provided file path
+            audioFilePath = runConfig.audioCommit.file;
+        } else if (audioResult.audioFilePath) {
+            // Use the file path returned by processAudio
+            audioFilePath = audioResult.audioFilePath;
+        } else {
+            // Fallback to generated filename (this should rarely happen now)
+            const outputDir = runConfig.outputDirectory || 'output';
+            audioFilePath = path.join(outputDir, getTimestampedAudioFilename());
+            logger.warn('Using generated filename for recorded audio: %s', audioFilePath);
+            logger.warn('Note: This may not match the actual file created by unplayable');
+        }
+        // Step 3: Use kodrdriv's transcription functionality
+        logger.info('🤖 Transcribing audio locally using OpenAI Whisper...');
+        const transcription = await transcribeAudio(audioFilePath, {
+            model: "whisper-1",
+            debug: runConfig.debug
+        });
+        audioContext = transcription.text;
+        if (!audioContext.trim()) {
+            logger.warn('No audio content was transcribed. Proceeding without audio context.');
+            audioContext = '';
+        } else {
+            logger.info('📝 Successfully transcribed audio using kodrdriv');
+            logger.debug('Transcribed text: %s', audioContext);
+        }
+    } catch (error) {
+        logger.error('Audio processing failed: %s', error.message);
+        logger.info('Proceeding with commit generation without audio context...');
+        audioContext = '';
+    }
+    // Now delegate to the regular commit command with the audio context
+    logger.info('🤖 Generating commit message using audio context...');
+    const result = await execute$9({
+        ...runConfig,
+        commit: {
+            ...runConfig.commit,
+            direction: audioContext.trim() || ((_runConfig_commit = runConfig.commit) === null || _runConfig_commit === void 0 ? void 0 : _runConfig_commit.direction) || ''
+        }
+    });
+    return result;
+};
+
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+const createPrompt$1 = async ({ overridePaths, overrides }, { notes }, { logContext, diffContext, releaseNotesContext, issuesContext, context, directories } = {})=>{
+    // Prepare content array for the recipe
+    const content = [
+        {
+            content: notes,
+            title: 'Review Notes',
+            weight: 1.0
+        }
+    ];
+    // Prepare context array for the recipe
+    const contextArray = [];
+    if (logContext) {
+        contextArray.push({
+            content: logContext,
+            title: 'Log Context',
+            weight: 0.5
+        });
+    }
+    if (diffContext) {
+        contextArray.push({
+            content: diffContext,
+            title: 'Diff Context',
+            weight: 0.5
+        });
+    }
+    if (releaseNotesContext) {
+        contextArray.push({
+            content: releaseNotesContext,
+            title: 'Release Notes Context',
+            weight: 0.5
+        });
+    }
+    if (issuesContext) {
+        contextArray.push({
+            content: issuesContext,
+            title: 'Issues Context',
+            weight: 0.5
+        });
+    }
+    if (context) {
+        contextArray.push({
+            content: context,
+            title: 'User Context',
+            weight: 1.0
+        });
+    }
+    if (directories === null || directories === void 0 ? void 0 : directories.length) {
+        contextArray.push({
+            directories,
+            weight: 0.5
+        });
+    }
+    // Use the new cook recipe with template
+    // Adjust basePath for single-file build
+    const basePath = path.resolve(__dirname$1, 'src', 'prompt');
+    return cook({
+        basePath,
+        overridePaths: overridePaths || [],
+        overrides: overrides || false,
+        template: 'review',
+        content,
+        context: contextArray
+    });
+};
+
+const getOctokit = ()=>{
+    const logger = getLogger();
+    const token = process.env.GITHUB_TOKEN;
+    if (!token) {
+        logger.error('GITHUB_TOKEN environment variable is not set.');
+        throw new Error('GITHUB_TOKEN is not set.');
+    }
+    return new Octokit({
+        auth: token
+    });
+};
+const getCurrentBranchName = async ()=>{
+    const { stdout } = await run('git rev-parse --abbrev-ref HEAD');
+    return stdout.trim();
+};
+const getRepoDetails = async ()=>{
+    const { stdout } = await run('git remote get-url origin');
+    const url = stdout.trim();
+    // git@github.com:owner/repo.git or https://github.com/owner/repo.git
+    const match = url.match(/github\.com[/:]([\w-]+)\/([\w.-]+)\.git/);
+    if (!match) {
+        throw new Error(`Could not parse repository owner and name from origin URL: "${url}". Expected format: git@github.com:owner/repo.git or https://github.com/owner/repo.git`);
+    }
+    return {
+        owner: match[1],
+        repo: match[2]
+    };
+};
+const createPullRequest = async (title, body, head, base = 'main')=>{
+    const octokit = getOctokit();
+    const { owner, repo } = await getRepoDetails();
+    const response = await octokit.pulls.create({
+        owner,
+        repo,
+        title,
+        body,
+        head,
+        base
+    });
+    return response.data;
+};
+const findOpenPullRequestByHeadRef = async (head)=>{
+    const octokit = getOctokit();
+    const { owner, repo } = await getRepoDetails();
+    const logger = getLogger();
+    try {
+        logger.debug(`Searching for open pull requests with head: ${owner}:${head} in ${owner}/${repo}`);
+        const response = await octokit.pulls.list({
+            owner,
+            repo,
+            state: 'open',
+            head: `${owner}:${head}`
+        });
+        logger.debug(`Found ${response.data.length} open pull requests`);
+        var _response_data_;
+        return (_response_data_ = response.data[0]) !== null && _response_data_ !== void 0 ? _response_data_ : null;
+    } catch (error) {
+        logger.error(`Failed to find open pull requests: ${error.message}`);
+        if (error.status === 404) {
+            logger.error(`Repository ${owner}/${repo} not found or access denied. Please check your GITHUB_TOKEN permissions.`);
+        }
+        throw error;
+    }
+};
+const delay = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
+const waitForPullRequestChecks = async (prNumber)=>{
+    const octokit = getOctokit();
+    const { owner, repo } = await getRepoDetails();
+    const logger = getLogger();
+    while(true){
+        const pr = await octokit.pulls.get({
+            owner,
+            repo,
+            pull_number: prNumber
+        });
+        const checkRunsResponse = await octokit.checks.listForRef({
+            owner,
+            repo,
+            ref: pr.data.head.sha
+        });
+        const checkRuns = checkRunsResponse.data.check_runs;
+        if (checkRuns.length === 0) {
+            logger.info(`PR #${prNumber}: No checks found. Waiting...`);
+            await delay(10000);
+            continue;
+        }
+        const failingChecks = checkRuns.filter((cr)=>cr.conclusion && [
+                'failure',
+                'timed_out',
+                'cancelled'
+            ].includes(cr.conclusion));
+        if (failingChecks.length > 0) {
+            logger.error(`PR #${prNumber} has failing checks:`);
+            for (const check of failingChecks){
+                logger.error(`- ${check.name}: ${check.conclusion}`);
+            }
+            throw new Error(`PR #${prNumber} checks failed.`);
+        }
+        const allChecksCompleted = checkRuns.every((cr)=>cr.status === 'completed');
+        if (allChecksCompleted) {
+            logger.info(`All checks for PR #${prNumber} have completed successfully.`);
+            return;
+        }
+        const completedCount = checkRuns.filter((cr)=>cr.status === 'completed').length;
+        logger.info(`PR #${prNumber} checks: ${completedCount}/${checkRuns.length} completed. Waiting...`);
+        await delay(10000); // wait 10 seconds
+    }
+};
+const mergePullRequest = async (prNumber, mergeMethod = 'squash')=>{
+    const octokit = getOctokit();
+    const { owner, repo } = await getRepoDetails();
+    const logger = getLogger();
+    logger.info(`Merging PR #${prNumber} using ${mergeMethod} method...`);
+    const pr = await octokit.pulls.get({
+        owner,
+        repo,
+        pull_number: prNumber
+    });
+    const headBranch = pr.data.head.ref;
+    await octokit.pulls.merge({
+        owner,
+        repo,
+        pull_number: prNumber,
+        merge_method: mergeMethod
+    });
+    logger.info(`PR #${prNumber} merged using ${mergeMethod} method.`);
+    logger.info(`Deleting branch ${headBranch}...`);
+    await octokit.git.deleteRef({
+        owner,
+        repo,
+        ref: `heads/${headBranch}`
+    });
+    logger.info(`Branch ${headBranch} deleted.`);
+};
+const createRelease = async (tagName, title, notes)=>{
+    const octokit = getOctokit();
+    const { owner, repo } = await getRepoDetails();
+    const logger = getLogger();
+    logger.info(`Creating release for tag ${tagName}...`);
+    await octokit.repos.createRelease({
+        owner,
+        repo,
+        tag_name: tagName,
+        name: title,
+        body: notes
+    });
+    logger.info(`Release ${tagName} created.`);
+};
+const getOpenIssues = async (limit = 20)=>{
+    const octokit = getOctokit();
+    const { owner, repo } = await getRepoDetails();
+    const logger = getLogger();
+    try {
+        logger.debug(`Fetching up to ${limit} open GitHub issues...`);
+        const response = await octokit.issues.listForRepo({
+            owner,
+            repo,
+            state: 'open',
+            per_page: Math.min(limit, 100),
+            sort: 'updated',
+            direction: 'desc'
+        });
+        const issues = response.data.filter((issue)=>!issue.pull_request); // Filter out PRs
+        if (issues.length === 0) {
+            logger.debug('No open issues found');
+            return '';
+        }
+        const issueStrings = issues.slice(0, limit).map((issue)=>{
+            var _issue_body;
+            const labels = issue.labels.map((label)=>typeof label === 'string' ? label : label.name).join(', ');
+            return [
+                `Issue #${issue.number}: ${issue.title}`,
+                `Labels: ${labels || 'none'}`,
+                `Created: ${issue.created_at}`,
+                `Updated: ${issue.updated_at}`,
+                `Body: ${((_issue_body = issue.body) === null || _issue_body === void 0 ? void 0 : _issue_body.substring(0, 500)) || 'No description'}${issue.body && issue.body.length > 500 ? '...' : ''}`,
+                '---'
+            ].join('\n');
+        });
+        logger.debug(`Fetched ${issues.length} open issues`);
+        return issueStrings.join('\n\n');
+    } catch (error) {
+        logger.warn('Failed to fetch GitHub issues: %s', error.message);
+        return '';
+    }
+};
+const createIssue = async (title, body, labels)=>{
+    const octokit = getOctokit();
+    const { owner, repo } = await getRepoDetails();
+    const response = await octokit.issues.create({
+        owner,
+        repo,
+        title,
+        body,
+        labels: labels || []
+    });
+    return {
+        number: response.data.number,
+        html_url: response.data.html_url
+    };
+};
+
+// Function to truncate overly large content while preserving structure
+const truncateContent = (content, maxLength = 3000)=>{
+    if (content.length <= maxLength) {
+        return content;
+    }
+    const lines = content.split('\n');
+    const truncatedLines = [];
+    let currentLength = 0;
+    for (const line of lines){
+        if (currentLength + line.length + 1 > maxLength) {
+            break;
+        }
+        truncatedLines.push(line);
+        currentLength += line.length + 1; // +1 for newline
+    }
+    truncatedLines.push('');
+    truncatedLines.push(`... [TRUNCATED: Original content was ${content.length} characters, showing first ${currentLength}] ...`);
+    return truncatedLines.join('\n');
+};
+// Function to fetch recent releases from GitHub API
+const findRecentReleaseNotes = async (limit)=>{
+    const logger = getLogger();
+    const releaseNotes = [];
+    if (limit <= 0) {
+        return releaseNotes;
+    }
+    try {
+        const octokit = getOctokit();
+        const { owner, repo } = await getRepoDetails();
+        logger.debug(`Fetching up to ${limit} recent releases from GitHub...`);
+        const response = await octokit.repos.listReleases({
+            owner,
+            repo,
+            per_page: Math.min(limit, 100)
+        });
+        const releases = response.data;
+        if (releases.length === 0) {
+            logger.debug('No releases found in GitHub repository');
+            return releaseNotes;
+        }
+        for (const release of releases.slice(0, limit)){
+            const releaseContent = [
+                `# ${release.name || release.tag_name}`,
+                `**Tag:** ${release.tag_name}`,
+                `**Published:** ${release.published_at}`,
+                release.prerelease ? '**Type:** Pre-release' : '**Type:** Release',
+                release.draft ? '**Status:** Draft' : '**Status:** Published',
+                '',
+                release.body || 'No release notes provided'
+            ].join('\n');
+            const truncatedContent = truncateContent(releaseContent);
+            releaseNotes.push(`=== GitHub Release: ${release.tag_name} ===\n${truncatedContent}`);
+            if (truncatedContent.length < releaseContent.length) {
+                logger.debug(`Found release ${release.tag_name} (%d characters, truncated from %d)`, truncatedContent.length, releaseContent.length);
+            } else {
+                logger.debug(`Found release ${release.tag_name} (%d characters)`, releaseContent.length);
+            }
+        }
+        logger.debug(`Fetched ${releaseNotes.length} releases from GitHub`);
+    } catch (error) {
+        logger.warn('Error fetching releases from GitHub API: %s', error.message);
+        // If we have a GitHub API error, we could fall back to checking for local release notes
+        // This maintains some backward compatibility
+        logger.debug('Falling back to local RELEASE_NOTES.md file...');
+        try {
+            const fs = await import('fs/promises');
+            const content = await fs.readFile('RELEASE_NOTES.md', 'utf-8');
+            if (content.trim()) {
+                const truncatedContent = truncateContent(content);
+                releaseNotes.push(`=== Local RELEASE_NOTES.md ===\n${truncatedContent}`);
+                logger.debug(`Found local release notes (%d characters)`, content.length);
+            }
+        } catch  {
+            // No local file either, return empty array
+            logger.debug('No local RELEASE_NOTES.md file found either');
+        }
+    }
+    return releaseNotes.slice(0, limit);
+};
+const get$1 = async (options = {})=>{
+    const { limit = 3 } = options;
+    const releaseNotes = await findRecentReleaseNotes(limit);
+    return releaseNotes.join('\n\n');
+};
+
+// Get GitHub issues content
+const get = async (options = {})=>{
+    const logger = getLogger();
+    const { limit = 20 } = options;
+    try {
+        logger.debug('Fetching open GitHub issues...');
+        const issuesLimit = Math.min(limit, 20); // Cap at 20
+        const githubIssues = await getOpenIssues(issuesLimit);
+        if (githubIssues.trim()) {
+            logger.debug('Added GitHub issues to context (%d characters)', githubIssues.length);
+            return githubIssues;
+        } else {
+            logger.debug('No open GitHub issues found');
+            return '';
+        }
+    } catch (error) {
+        logger.warn('Failed to fetch GitHub issues: %s', error.message);
+        return '';
+    }
+};
+// Helper function to get user choice interactively
+async function getUserChoice(prompt, choices) {
+    const logger = getLogger();
+    logger.info(prompt);
+    choices.forEach((choice)=>{
+        logger.info(`   [${choice.key}] ${choice.label}`);
+    });
+    logger.info('');
+    return new Promise((resolve)=>{
+        // Ensure stdin is referenced so the process doesn't exit while waiting for input
+        if (typeof process.stdin.ref === 'function') {
+            process.stdin.ref();
+        }
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('data', (key)=>{
+            const keyStr = key.toString().toLowerCase();
+            const choice = choices.find((c)=>c.key === keyStr);
+            if (choice) {
+                process.stdin.setRawMode(false);
+                process.stdin.pause();
+                // Detach stdin again now that we're done
+                if (typeof process.stdin.unref === 'function') {
+                    process.stdin.unref();
+                }
+                logger.info(`Selected: ${choice.label}\n`);
+                resolve(choice.key);
+            }
+        });
+    });
+}
+// Helper function to edit issue interactively
+async function editIssueInteractively(issue) {
+    const logger = getLogger();
+    const readline = await import('readline');
+    // Ensure stdin is referenced during readline interaction
+    if (typeof process.stdin.ref === 'function') {
+        process.stdin.ref();
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const question = (prompt)=>{
+        return new Promise((resolve)=>{
+            rl.question(prompt, resolve);
+        });
+    };
+    try {
+        logger.info('📝 Edit issue details (press Enter to keep current value):');
+        const newTitle = await question(`Title [${issue.title}]: `);
+        const newDescription = await question(`Description [${issue.description}]: `);
+        const newPriority = await question(`Priority (low/medium/high) [${issue.priority}]: `);
+        const newCategory = await question(`Category (ui/content/functionality/accessibility/performance/other) [${issue.category}]: `);
+        const updatedIssue = {
+            title: newTitle.trim() || issue.title,
+            description: newDescription.trim() || issue.description,
+            priority: newPriority.trim() || issue.priority,
+            category: newCategory.trim() || issue.category,
+            suggestions: issue.suggestions
+        };
+        logger.info('✅ Issue updated successfully');
+        return updatedIssue;
+    } finally{
+        rl.close();
+        // Detach stdin after interactive edit completes
+        if (typeof process.stdin.unref === 'function') {
+            process.stdin.unref();
+        }
+    }
+}
+// Helper function to format issue body for GitHub
+function formatIssueBody(issue) {
+    let body = `## Description\n\n${issue.description}\n\n`;
+    body += `## Details\n\n`;
+    body += `- **Priority:** ${issue.priority}\n`;
+    body += `- **Category:** ${issue.category}\n`;
+    body += `- **Source:** Review\n\n`;
+    if (issue.suggestions && issue.suggestions.length > 0) {
+        body += `## Suggestions\n\n`;
+        issue.suggestions.forEach((suggestion)=>{
+            body += `- ${suggestion}\n`;
+        });
+        body += '\n';
+    }
+    body += `---\n\n`;
+    body += `*This issue was automatically created from a review session.*`;
+    return body;
+}
+// Helper function to format results with created GitHub issues
+function formatReviewResultsWithIssues(result, createdIssues) {
+    let output = `📝 Review Results\n\n`;
+    output += `📋 Summary: ${result.summary}\n`;
+    output += `📊 Total Issues Found: ${result.totalIssues}\n`;
+    output += `🚀 GitHub Issues Created: ${createdIssues.length}\n\n`;
+    if (result.issues && result.issues.length > 0) {
+        output += `📝 Issues Identified:\n\n`;
+        result.issues.forEach((issue, index)=>{
+            const priorityEmoji = issue.priority === 'high' ? '🔴' : issue.priority === 'medium' ? '🟡' : '🟢';
+            const categoryEmoji = issue.category === 'ui' ? '🎨' : issue.category === 'content' ? '📝' : issue.category === 'functionality' ? '⚙️' : issue.category === 'accessibility' ? '♿' : issue.category === 'performance' ? '⚡' : '🔧';
+            output += `${index + 1}. ${priorityEmoji} ${issue.title}\n`;
+            output += `   ${categoryEmoji} Category: ${issue.category} | Priority: ${issue.priority}\n`;
+            output += `   📖 Description: ${issue.description}\n`;
+            // Check if this issue was created as a GitHub issue
+            const createdIssue = createdIssues.find((ci)=>ci.issue === issue);
+            if (createdIssue) {
+                output += `   🔗 GitHub Issue: #${createdIssue.number} - ${createdIssue.githubUrl}\n`;
+            }
+            if (issue.suggestions && issue.suggestions.length > 0) {
+                output += `   💡 Suggestions:\n`;
+                issue.suggestions.forEach((suggestion)=>{
+                    output += `      • ${suggestion}\n`;
+                });
+            }
+            output += `\n`;
+        });
+    } else {
+        output += `✅ No specific issues identified from the review.\n\n`;
+    }
+    if (createdIssues.length > 0) {
+        output += `\n🎯 Created GitHub Issues:\n`;
+        createdIssues.forEach((createdIssue)=>{
+            output += `• #${createdIssue.number}: ${createdIssue.issue.title} - ${createdIssue.githubUrl}\n`;
+        });
+        output += `\n`;
+    }
+    output += `🚀 Next Steps: Review the created GitHub issues and prioritize them in your development workflow.`;
+    return output;
+}
+function formatReviewResults(result) {
+    let output = `📝 Review Results\n\n`;
+    output += `📋 Summary: ${result.summary}\n`;
+    output += `📊 Total Issues Found: ${result.totalIssues}\n\n`;
+    if (result.issues && result.issues.length > 0) {
+        output += `📝 Issues Identified:\n\n`;
+        result.issues.forEach((issue, index)=>{
+            const priorityEmoji = issue.priority === 'high' ? '🔴' : issue.priority === 'medium' ? '🟡' : '🟢';
+            const categoryEmoji = issue.category === 'ui' ? '🎨' : issue.category === 'content' ? '📝' : issue.category === 'functionality' ? '⚙️' : issue.category === 'accessibility' ? '♿' : issue.category === 'performance' ? '⚡' : '🔧';
+            output += `${index + 1}. ${priorityEmoji} ${issue.title}\n`;
+            output += `   ${categoryEmoji} Category: ${issue.category} | Priority: ${issue.priority}\n`;
+            output += `   📖 Description: ${issue.description}\n`;
+            if (issue.suggestions && issue.suggestions.length > 0) {
+                output += `   💡 Suggestions:\n`;
+                issue.suggestions.forEach((suggestion)=>{
+                    output += `      • ${suggestion}\n`;
+                });
+            }
+            output += `\n`;
+        });
+    } else {
+        output += `✅ No specific issues identified from the review.\n\n`;
+    }
+    output += `🚀 Next Steps: Review the identified issues and prioritize them for your development workflow.`;
+    return output;
+}
+// Handle GitHub issue creation workflow
+const handleIssueCreation = async (result, senditMode = false)=>{
+    const logger = getLogger();
+    const createdIssues = [];
+    if (!result.issues || result.issues.length === 0) {
+        return formatReviewResults(result);
+    }
+    logger.info(`🔍 Found ${result.issues.length} issues to potentially create as GitHub issues`);
+    for(let i = 0; i < result.issues.length; i++){
+        const issue = result.issues[i];
+        let shouldCreateIssue = senditMode;
+        if (!senditMode) {
+            // Interactive confirmation for each issue
+            logger.info(`\n📋 Issue ${i + 1} of ${result.issues.length}:`);
+            logger.info(`   Title: ${issue.title}`);
+            logger.info(`   Priority: ${issue.priority} | Category: ${issue.category}`);
+            logger.info(`   Description: ${issue.description}`);
+            if (issue.suggestions && issue.suggestions.length > 0) {
+                logger.info(`   Suggestions: ${issue.suggestions.join(', ')}`);
+            }
+            // Get user choice
+            const choice = await getUserChoice('\nWhat would you like to do with this issue?', [
+                {
+                    key: 'c',
+                    label: 'Create GitHub issue'
+                },
+                {
+                    key: 's',
+                    label: 'Skip this issue'
+                },
+                {
+                    key: 'e',
+                    label: 'Edit issue details'
+                }
+            ]);
+            if (choice === 'c') {
+                shouldCreateIssue = true;
+            } else if (choice === 'e') {
+                // Allow user to edit the issue
+                const editedIssue = await editIssueInteractively(issue);
+                result.issues[i] = editedIssue;
+                shouldCreateIssue = true;
+            }
+        // If choice is 's', shouldCreateIssue remains false
+        }
+        if (shouldCreateIssue) {
+            try {
+                logger.info(`🚀 Creating GitHub issue: "${issue.title}"`);
+                // Format issue body with additional details
+                const issueBody = formatIssueBody(issue);
+                // Create labels based on priority and category
+                const labels = [
+                    `priority-${issue.priority}`,
+                    `category-${issue.category}`,
+                    'review'
+                ];
+                const createdIssue = await createIssue(issue.title, issueBody, labels);
+                createdIssues.push({
+                    issue,
+                    githubUrl: createdIssue.html_url,
+                    number: createdIssue.number
+                });
+                logger.info(`✅ Created GitHub issue #${createdIssue.number}: ${createdIssue.html_url}`);
+            } catch (error) {
+                logger.error(`❌ Failed to create GitHub issue for "${issue.title}": ${error.message}`);
+            }
+        }
+    }
+    // Return formatted results
+    if (createdIssues.length > 0) {
+        return formatReviewResultsWithIssues(result, createdIssues);
+    } else {
+        return formatReviewResults(result);
+    }
+};
+
+const execute$7 = async (runConfig)=>{
+    var _runConfig_review, _runConfig_review1, _runConfig_review2, _runConfig_review3, _runConfig_review4, _runConfig_review5, _runConfig_review6, _runConfig_review7, _runConfig_review8, _runConfig_review9, _runConfig_review10, _runConfig_review11, _runConfig_review12, _runConfig_review13, _runConfig_review_context, _runConfig_review14, _runConfig_review15, _analysisResult_issues, _runConfig_review16;
+    const logger = getLogger();
+    const isDryRun = runConfig.dryRun || false;
+    // Show configuration even in dry-run mode
+    logger.debug('Review context configuration:');
+    logger.debug('  Include commit history: %s', (_runConfig_review = runConfig.review) === null || _runConfig_review === void 0 ? void 0 : _runConfig_review.includeCommitHistory);
+    logger.debug('  Include recent diffs: %s', (_runConfig_review1 = runConfig.review) === null || _runConfig_review1 === void 0 ? void 0 : _runConfig_review1.includeRecentDiffs);
+    logger.debug('  Include release notes: %s', (_runConfig_review2 = runConfig.review) === null || _runConfig_review2 === void 0 ? void 0 : _runConfig_review2.includeReleaseNotes);
+    logger.debug('  Include GitHub issues: %s', (_runConfig_review3 = runConfig.review) === null || _runConfig_review3 === void 0 ? void 0 : _runConfig_review3.includeGithubIssues);
+    logger.debug('  Commit history limit: %d', (_runConfig_review4 = runConfig.review) === null || _runConfig_review4 === void 0 ? void 0 : _runConfig_review4.commitHistoryLimit);
+    logger.debug('  Diff history limit: %d', (_runConfig_review5 = runConfig.review) === null || _runConfig_review5 === void 0 ? void 0 : _runConfig_review5.diffHistoryLimit);
+    logger.debug('  Release notes limit: %d', (_runConfig_review6 = runConfig.review) === null || _runConfig_review6 === void 0 ? void 0 : _runConfig_review6.releaseNotesLimit);
+    logger.debug('  GitHub issues limit: %d', (_runConfig_review7 = runConfig.review) === null || _runConfig_review7 === void 0 ? void 0 : _runConfig_review7.githubIssuesLimit);
+    logger.debug('  Sendit mode (auto-create issues): %s', (_runConfig_review8 = runConfig.review) === null || _runConfig_review8 === void 0 ? void 0 : _runConfig_review8.sendit);
+    if (isDryRun) {
+        var _runConfig_review17, _runConfig_review18;
+        logger.info('DRY RUN: Would analyze provided note for review');
+        logger.info('DRY RUN: Would gather additional context based on configuration above');
+        logger.info('DRY RUN: Would analyze note and identify issues');
+        if ((_runConfig_review17 = runConfig.review) === null || _runConfig_review17 === void 0 ? void 0 : _runConfig_review17.sendit) {
+            logger.info('DRY RUN: Would automatically create GitHub issues (sendit mode enabled)');
+        } else {
+            logger.info('DRY RUN: Would prompt for confirmation before creating GitHub issues');
+        }
+        // Show what exclusion patterns would be used in dry-run mode
+        if ((_runConfig_review18 = runConfig.review) === null || _runConfig_review18 === void 0 ? void 0 : _runConfig_review18.includeRecentDiffs) {
+            var _runConfig_excludedPatterns;
+            const basePatterns = (_runConfig_excludedPatterns = runConfig.excludedPatterns) !== null && _runConfig_excludedPatterns !== void 0 ? _runConfig_excludedPatterns : DEFAULT_EXCLUDED_PATTERNS;
+            const reviewExcluded = getReviewExcludedPatterns(basePatterns);
+            logger.info('DRY RUN: Would use %d exclusion patterns for diff context', reviewExcluded.length);
+            logger.debug('DRY RUN: Sample exclusions: %s', reviewExcluded.slice(0, 15).join(', ') + (reviewExcluded.length > 15 ? '...' : ''));
+        }
+        return 'DRY RUN: Review command would analyze note, gather context, and create GitHub issues';
+    }
+    // Get the review note from configuration
+    let reviewNote = (_runConfig_review9 = runConfig.review) === null || _runConfig_review9 === void 0 ? void 0 : _runConfig_review9.note;
+    // If no review note was provided via CLI arg or STDIN, open the user's editor to capture it.
+    if (!reviewNote || !reviewNote.trim()) {
+        const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
+        // Create a temporary file for the user to edit.
+        const tmpDir = os.tmpdir();
+        const tmpFilePath = path.join(tmpDir, `kodrdriv_review_${Date.now()}.md`);
+        // Pre-populate the file with a helpful header so users know what to do.
+        const templateContent = [
+            '# Kodrdriv Review Note',
+            '',
+            '# Please enter your review note below. Lines starting with "#" will be ignored.',
+            '# Save and close the editor when you are done.',
+            '',
+            ''
+        ].join('\n');
+        await fs$1.writeFile(tmpFilePath, templateContent, 'utf8');
+        logger.info(`No review note provided – opening ${editor} to capture input...`);
+        // Open the editor synchronously so execution resumes after the user closes it.
+        const result = spawnSync(editor, [
+            tmpFilePath
+        ], {
+            stdio: 'inherit'
+        });
+        if (result.error) {
+            throw new Error(`Failed to launch editor '${editor}': ${result.error.message}`);
+        }
+        // Read the file back in, stripping comment lines and whitespace.
+        const fileContent = (await fs$1.readFile(tmpFilePath, 'utf8')).split('\n').filter((line)=>!line.trim().startsWith('#')).join('\n').trim();
+        // Clean up the temporary file (best-effort – ignore errors).
+        try {
+            await fs$1.unlink(tmpFilePath);
+        } catch  {
+        /* ignore */ }
+        if (!fileContent) {
+            throw new Error('Review note is empty – aborting. Provide a note as an argument, via STDIN, or through the editor.');
+        }
+        reviewNote = fileContent;
+        // If the original runConfig.review object exists, update it so downstream code has the note.
+        if (runConfig.review) {
+            runConfig.review.note = reviewNote;
+        }
+    }
+    logger.info('📝 Starting review analysis...');
+    logger.debug('Review note: %s', reviewNote);
+    logger.debug('Review note length: %d characters', reviewNote.length);
+    // Gather additional context based on configuration
+    let logContext = '';
+    let diffContext = '';
+    let releaseNotesContext = '';
+    let issuesContext = '';
+    // Fetch commit history if enabled
+    if ((_runConfig_review10 = runConfig.review) === null || _runConfig_review10 === void 0 ? void 0 : _runConfig_review10.includeCommitHistory) {
+        try {
+            logger.debug('Fetching recent commit history...');
+            const log = await create({
+                limit: runConfig.review.commitHistoryLimit
+            });
+            const logContent = await log.get();
+            if (logContent.trim()) {
+                logContext += `\n\n[Recent Commit History]\n${logContent}`;
+                logger.debug('Added commit history to context (%d characters)', logContent.length);
+            }
+        } catch (error) {
+            logger.warn('Failed to fetch commit history: %s', error.message);
+        }
+    }
+    // Fetch recent diffs if enabled
+    if ((_runConfig_review11 = runConfig.review) === null || _runConfig_review11 === void 0 ? void 0 : _runConfig_review11.includeRecentDiffs) {
+        try {
+            logger.debug('Fetching recent commit diffs...');
+            var _runConfig_excludedPatterns1;
+            const basePatterns = (_runConfig_excludedPatterns1 = runConfig.excludedPatterns) !== null && _runConfig_excludedPatterns1 !== void 0 ? _runConfig_excludedPatterns1 : DEFAULT_EXCLUDED_PATTERNS;
+            const recentDiffs = await getRecentDiffsForReview({
+                limit: runConfig.review.diffHistoryLimit,
+                baseExcludedPatterns: basePatterns
+            });
+            diffContext += recentDiffs;
+        } catch (error) {
+            logger.warn('Failed to fetch recent diffs: %s', error.message);
+        }
+    }
+    // Fetch release notes if enabled
+    if ((_runConfig_review12 = runConfig.review) === null || _runConfig_review12 === void 0 ? void 0 : _runConfig_review12.includeReleaseNotes) {
+        try {
+            logger.debug('Fetching recent release notes from GitHub...');
+            const releaseNotesContent = await get$1({
+                limit: runConfig.review.releaseNotesLimit || 3
+            });
+            if (releaseNotesContent.trim()) {
+                releaseNotesContext += `\n\n[Recent Release Notes]\n${releaseNotesContent}`;
+                logger.debug('Added release notes to context (%d characters)', releaseNotesContent.length);
+            }
+        } catch (error) {
+            logger.warn('Failed to fetch release notes: %s', error.message);
+        }
+    }
+    // Fetch GitHub issues if enabled
+    if ((_runConfig_review13 = runConfig.review) === null || _runConfig_review13 === void 0 ? void 0 : _runConfig_review13.includeGithubIssues) {
+        try {
+            logger.debug('Fetching open GitHub issues...');
+            issuesContext = await get({
+                limit: runConfig.review.githubIssuesLimit || 20
+            });
+            logger.debug('Added GitHub issues to context (%d characters)', issuesContext.length);
+        } catch (error) {
+            logger.warn('Failed to fetch GitHub issues: %s', error.message);
+        }
+    }
+    // Analyze review note for issues using OpenAI
+    logger.info('🤖 Analyzing review note for project issues...');
+    logger.debug('Context summary:');
+    logger.debug('  - Review note: %d chars', reviewNote.length);
+    logger.debug('  - Log context: %d chars', logContext.length);
+    logger.debug('  - Diff context: %d chars', diffContext.length);
+    logger.debug('  - Release notes context: %d chars', releaseNotesContext.length);
+    logger.debug('  - Issues context: %d chars', issuesContext.length);
+    logger.debug('  - User context: %d chars', ((_runConfig_review14 = runConfig.review) === null || _runConfig_review14 === void 0 ? void 0 : (_runConfig_review_context = _runConfig_review14.context) === null || _runConfig_review_context === void 0 ? void 0 : _runConfig_review_context.length) || 0);
+    const promptConfig = {
+        overridePaths: runConfig.discoveredConfigDirs || [],
+        overrides: runConfig.overrides || false
+    };
+    const promptContent = {
+        notes: reviewNote
+    };
+    const promptContext = {
+        context: (_runConfig_review15 = runConfig.review) === null || _runConfig_review15 === void 0 ? void 0 : _runConfig_review15.context,
+        logContext,
+        diffContext,
+        releaseNotesContext,
+        issuesContext
+    };
+    const prompt = await createPrompt$1(promptConfig, promptContent, promptContext);
+    const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+    const storage = create$2({
+        log: logger.info
+    });
+    await storage.ensureDirectory(outputDirectory);
+    // Save timestamped copy of review notes and context to output directory
+    try {
+        var _runConfig_review_context1, _runConfig_review19;
+        // Save the original review note
+        const reviewNotesFilename = getTimestampedReviewNotesFilename();
+        const reviewNotesPath = getOutputPath(outputDirectory, reviewNotesFilename);
+        let reviewNotesContent = `# Review Notes\n\n${reviewNote}\n\n`;
+        // Add all context sections if they exist
+        if (logContext.trim()) {
+            reviewNotesContent += `# Commit History Context\n\n${logContext}\n\n`;
+        }
+        if (diffContext.trim()) {
+            reviewNotesContent += `# Recent Diffs Context\n\n${diffContext}\n\n`;
+        }
+        if (releaseNotesContext.trim()) {
+            reviewNotesContent += `# Release Notes Context\n\n${releaseNotesContext}\n\n`;
+        }
+        if (issuesContext.trim()) {
+            reviewNotesContent += `# GitHub Issues Context\n\n${issuesContext}\n\n`;
+        }
+        if ((_runConfig_review19 = runConfig.review) === null || _runConfig_review19 === void 0 ? void 0 : (_runConfig_review_context1 = _runConfig_review19.context) === null || _runConfig_review_context1 === void 0 ? void 0 : _runConfig_review_context1.trim()) {
+            reviewNotesContent += `# User Context\n\n${runConfig.review.context}\n\n`;
+        }
+        await storage.writeFile(reviewNotesPath, reviewNotesContent, 'utf-8');
+        logger.debug('Saved timestamped review notes and context: %s', reviewNotesPath);
+    } catch (error) {
+        logger.warn('Failed to save timestamped review notes: %s', error.message);
+    }
+    const request = Formatter.create({
+        logger
+    }).formatPrompt(runConfig.model, prompt);
+    const analysisResult = await createCompletion(request.messages, {
+        model: runConfig.model,
+        responseFormat: {
+            type: 'json_object'
+        },
+        debug: runConfig.debug,
+        debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('review-analysis')),
+        debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('review-analysis'))
+    });
+    logger.info('✅ Analysis completed');
+    logger.debug('Analysis result summary: %s', analysisResult.summary);
+    logger.debug('Total issues found: %d', analysisResult.totalIssues);
+    logger.debug('Issues array length: %d', ((_analysisResult_issues = analysisResult.issues) === null || _analysisResult_issues === void 0 ? void 0 : _analysisResult_issues.length) || 0);
+    if (analysisResult.issues && analysisResult.issues.length > 0) {
+        analysisResult.issues.forEach((issue, index)=>{
+            logger.debug('  Issue %d: [%s] %s', index + 1, issue.priority, issue.title);
+        });
+    }
+    // Save timestamped copy of analysis result to output directory
+    try {
+        const reviewFilename = getTimestampedReviewFilename();
+        const reviewPath = getOutputPath(outputDirectory, reviewFilename);
+        // Format the analysis result as markdown
+        const reviewContent = `# Review Analysis Result\n\n` + `## Summary\n${analysisResult.summary}\n\n` + `## Total Issues Found\n${analysisResult.totalIssues}\n\n` + `## Issues\n\n${JSON.stringify(analysisResult.issues, null, 2)}\n\n` + `---\n\n*Analysis completed at ${new Date().toISOString()}*`;
+        await storage.writeFile(reviewPath, reviewContent, 'utf-8');
+        logger.debug('Saved timestamped review analysis: %s', reviewPath);
+    } catch (error) {
+        logger.warn('Failed to save timestamped review analysis: %s', error.message);
+    }
+    // Handle GitHub issue creation using the issues module
+    const senditMode = ((_runConfig_review16 = runConfig.review) === null || _runConfig_review16 === void 0 ? void 0 : _runConfig_review16.sendit) || false;
+    return await handleIssueCreation(analysisResult, senditMode);
+};
+
+const execute$6 = async (runConfig)=>{
+    var _runConfig_audioReview, _runConfig_audioReview1, _runConfig_audioReview2, _runConfig_audioReview3, _runConfig_audioReview4, _runConfig_audioReview5, _runConfig_audioReview6, _runConfig_audioReview7, _runConfig_audioReview8, _runConfig_audioReview9, _runConfig_review;
+    const logger = getLogger();
+    const isDryRun = runConfig.dryRun || false;
+    if (isDryRun) {
+        var _runConfig_audioReview10, _runConfig_review1;
+        if ((_runConfig_audioReview10 = runConfig.audioReview) === null || _runConfig_audioReview10 === void 0 ? void 0 : _runConfig_audioReview10.file) {
+            logger.info('DRY RUN: Would process audio file: %s', runConfig.audioReview.file);
+            logger.info('DRY RUN: Would transcribe audio and use as context for review analysis');
+        } else {
+            logger.info('DRY RUN: Would start audio recording for review context');
+            logger.info('DRY RUN: Would transcribe audio and use as context for review analysis');
+        }
+        logger.info('DRY RUN: Would then delegate to regular review command');
+        // In dry run, just call the regular review command with empty note
+        return execute$7({
+            ...runConfig,
+            review: {
+                ...runConfig.review,
+                note: ((_runConfig_review1 = runConfig.review) === null || _runConfig_review1 === void 0 ? void 0 : _runConfig_review1.note) || ''
+            }
+        });
+    }
+    let audioContext;
+    try {
+        var _runConfig_audioReview11, _runConfig_audioReview12, _runConfig_audioReview13, _runConfig_audioReview14;
+        // Step 1: Record audio using unplayable (for audio file acquisition only)
+        logger.info('🎙️  Starting audio recording for review context...');
+        if (!((_runConfig_audioReview11 = runConfig.audioReview) === null || _runConfig_audioReview11 === void 0 ? void 0 : _runConfig_audioReview11.file)) {
+            logger.info('Press Ctrl+C after you finish speaking to generate your review analysis');
+        }
+        // Use processAudio but ignore its transcription - we only want the audio file
+        const audioResult = await processAudio({
+            file: (_runConfig_audioReview12 = runConfig.audioReview) === null || _runConfig_audioReview12 === void 0 ? void 0 : _runConfig_audioReview12.file,
+            maxRecordingTime: (_runConfig_audioReview13 = runConfig.audioReview) === null || _runConfig_audioReview13 === void 0 ? void 0 : _runConfig_audioReview13.maxRecordingTime
+        });
+        // Check if recording was cancelled
+        if (audioResult.cancelled) {
+            logger.info('❌ Audio review cancelled by user');
+            process.exit(0);
+        }
+        // Step 2: Determine the audio file path
+        let audioFilePath;
+        if ((_runConfig_audioReview14 = runConfig.audioReview) === null || _runConfig_audioReview14 === void 0 ? void 0 : _runConfig_audioReview14.file) {
+            // Use the provided file path
+            audioFilePath = runConfig.audioReview.file;
+        } else {
+            // For recorded audio, we need to determine where unplayable saved the file
+            // This is a temporary solution - ideally unplayable should return the file path
+            const outputDir = runConfig.outputDirectory || 'output';
+            audioFilePath = path.join(outputDir, getTimestampedAudioFilename());
+            logger.warn('Using generated filename for recorded audio: %s', audioFilePath);
+            logger.warn('Note: This may not match the actual file created by unplayable');
+        }
+        // Step 3: Use kodrdriv's transcription functionality instead of unplayable's
+        logger.info('🤖 Transcribing audio locally using OpenAI Whisper...');
+        logger.info('📝 Ignoring transcript from unplayable, using kodrdriv transcription');
+        const transcription = await transcribeAudio(audioFilePath, {
+            model: "whisper-1",
+            debug: runConfig.debug
+        });
+        audioContext = transcription.text;
+        if (!audioContext.trim()) {
+            logger.warn('No audio content was transcribed. Proceeding without audio context.');
+            audioContext = '';
+        } else {
+            logger.info('📝 Successfully transcribed audio using kodrdriv');
+            logger.debug('Transcribed text: %s', audioContext);
+        }
+    } catch (error) {
+        logger.error('Audio processing failed: %s', error.message);
+        logger.info('Proceeding with review analysis without audio context...');
+        audioContext = '';
+    }
+    // Now delegate to the regular review command with the audio context
+    logger.info('🤖 Analyzing review using audio context...');
+    const result = await execute$7({
+        ...runConfig,
+        review: {
+            // Map audioReview configuration to review configuration
+            includeCommitHistory: (_runConfig_audioReview = runConfig.audioReview) === null || _runConfig_audioReview === void 0 ? void 0 : _runConfig_audioReview.includeCommitHistory,
+            includeRecentDiffs: (_runConfig_audioReview1 = runConfig.audioReview) === null || _runConfig_audioReview1 === void 0 ? void 0 : _runConfig_audioReview1.includeRecentDiffs,
+            includeReleaseNotes: (_runConfig_audioReview2 = runConfig.audioReview) === null || _runConfig_audioReview2 === void 0 ? void 0 : _runConfig_audioReview2.includeReleaseNotes,
+            includeGithubIssues: (_runConfig_audioReview3 = runConfig.audioReview) === null || _runConfig_audioReview3 === void 0 ? void 0 : _runConfig_audioReview3.includeGithubIssues,
+            commitHistoryLimit: (_runConfig_audioReview4 = runConfig.audioReview) === null || _runConfig_audioReview4 === void 0 ? void 0 : _runConfig_audioReview4.commitHistoryLimit,
+            diffHistoryLimit: (_runConfig_audioReview5 = runConfig.audioReview) === null || _runConfig_audioReview5 === void 0 ? void 0 : _runConfig_audioReview5.diffHistoryLimit,
+            releaseNotesLimit: (_runConfig_audioReview6 = runConfig.audioReview) === null || _runConfig_audioReview6 === void 0 ? void 0 : _runConfig_audioReview6.releaseNotesLimit,
+            githubIssuesLimit: (_runConfig_audioReview7 = runConfig.audioReview) === null || _runConfig_audioReview7 === void 0 ? void 0 : _runConfig_audioReview7.githubIssuesLimit,
+            sendit: (_runConfig_audioReview8 = runConfig.audioReview) === null || _runConfig_audioReview8 === void 0 ? void 0 : _runConfig_audioReview8.sendit,
+            context: (_runConfig_audioReview9 = runConfig.audioReview) === null || _runConfig_audioReview9 === void 0 ? void 0 : _runConfig_audioReview9.context,
+            // Use the transcribed audio as content
+            note: audioContext.trim() || ((_runConfig_review = runConfig.review) === null || _runConfig_review === void 0 ? void 0 : _runConfig_review.note) || ''
+        }
+    });
+    return result;
+};
+
+const execute$5 = async (runConfig)=>{
+    const logger = getLogger();
+    const storage = create$2({
+        log: logger.info
+    });
+    const isDryRun = runConfig.dryRun || false;
+    const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+    logger.info(isDryRun ? `DRY RUN: Would remove output directory: ${outputDirectory}` : `Removing output directory: ${outputDirectory}`);
+    if (isDryRun) {
+        if (await storage.exists(outputDirectory)) {
+            logger.info('DRY RUN: Output directory exists and would be removed');
+        } else {
+            logger.info('DRY RUN: Output directory does not exist, nothing to clean');
+        }
+        return;
+    }
+    try {
+        if (await storage.exists(outputDirectory)) {
+            await storage.removeDirectory(outputDirectory);
+            logger.info(`Successfully removed output directory: ${outputDirectory}`);
+        } else {
+            logger.info(`Output directory does not exist: ${outputDirectory}`);
+        }
+    } catch (error) {
+        logger.error(`Failed to clean output directory: ${error.message}`);
+        throw error;
+    }
+};
+
+const scanDirectoryForPackages$1 = async (rootDir, storage)=>{
+    const logger = getLogger();
+    const packageMap = new Map(); // packageName -> relativePath
+    const absoluteRootDir = path.resolve(process.cwd(), rootDir);
+    logger.verbose(`Scanning directory for packages: ${absoluteRootDir}`);
+    if (!await storage.exists(absoluteRootDir) || !await storage.isDirectory(absoluteRootDir)) {
+        logger.verbose(`Root directory does not exist or is not a directory: ${absoluteRootDir}`);
+        return packageMap;
+    }
+    try {
+        // Get all subdirectories in the root directory
+        const items = await storage.listFiles(absoluteRootDir);
+        for (const item of items){
+            const itemPath = path.join(absoluteRootDir, item);
+            if (await storage.isDirectory(itemPath)) {
+                const packageJsonPath = path.join(itemPath, 'package.json');
+                if (await storage.exists(packageJsonPath)) {
+                    try {
+                        const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+                        const packageJson = JSON.parse(packageJsonContent);
+                        if (packageJson.name) {
+                            const relativePath = path.relative(process.cwd(), itemPath);
+                            packageMap.set(packageJson.name, relativePath);
+                            logger.debug(`Found package: ${packageJson.name} at ${relativePath}`);
+                        }
+                    } catch (error) {
+                        logger.debug(`Failed to parse package.json at ${packageJsonPath}: ${error}`);
+                    }
+                }
+            }
+        }
+    } catch (error) {
+        logger.warn(`Failed to read directory ${absoluteRootDir}: ${error}`);
+    }
+    return packageMap;
+};
+const findPackagesByScope = async (dependencies, scopeRoots, storage)=>{
+    const logger = getLogger();
+    const workspacePackages = new Map();
+    logger.silly(`Checking dependencies against scope roots: ${JSON.stringify(scopeRoots)}`);
+    // First, scan all scope roots to build a comprehensive map of available packages
+    const allPackages = new Map(); // packageName -> relativePath
+    for (const [scope, rootDir] of Object.entries(scopeRoots)){
+        logger.verbose(`Scanning scope ${scope} at root directory: ${rootDir}`);
+        const scopePackages = await scanDirectoryForPackages$1(rootDir, storage);
+        // Add packages from this scope to the overall map
+        for (const [packageName, packagePath] of scopePackages){
+            if (packageName.startsWith(scope)) {
+                allPackages.set(packageName, packagePath);
+                logger.debug(`Registered package: ${packageName} -> ${packagePath}`);
+            }
+        }
+    }
+    // Now check each dependency against our discovered packages
+    for (const [depName, depVersion] of Object.entries(dependencies)){
+        logger.debug(`Processing dependency: ${depName}@${depVersion}`);
+        if (allPackages.has(depName)) {
+            const packagePath = allPackages.get(depName);
+            workspacePackages.set(depName, packagePath);
+            logger.verbose(`Found sibling package: ${depName} at ${packagePath}`);
+        }
+    }
+    return workspacePackages;
+};
+const readCurrentWorkspaceFile$1 = async (workspaceFilePath, storage)=>{
+    if (await storage.exists(workspaceFilePath)) {
+        try {
+            const content = await storage.readFile(workspaceFilePath, 'utf-8');
+            return yaml.load(content) || {};
+        } catch (error) {
+            throw new Error(`Failed to parse existing workspace file: ${error}`);
+        }
+    }
+    return {};
+};
+const writeWorkspaceFile$1 = async (workspaceFilePath, config, storage)=>{
+    const yamlContent = yaml.dump(config, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true,
+        sortKeys: false
+    });
+    await storage.writeFile(workspaceFilePath, yamlContent, 'utf-8');
+};
+const execute$4 = async (runConfig)=>{
+    var _runConfig_link, _runConfig_link1, _runConfig_link2;
+    const logger = getLogger();
+    const storage = create$2({
+        log: logger.info
+    });
+    logger.verbose('Starting pnpm workspace link management using overrides...');
+    // Read current package.json
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    if (!await storage.exists(packageJsonPath)) {
+        throw new Error('package.json not found in current directory.');
+    }
+    let packageJson;
+    try {
+        const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+        packageJson = JSON.parse(packageJsonContent);
+    } catch (error) {
+        throw new Error(`Failed to parse package.json: ${error}`);
+    }
+    logger.verbose(`Processing package: ${packageJson.name || 'unnamed'}`);
+    // Get configuration
+    const scopeRoots = ((_runConfig_link = runConfig.link) === null || _runConfig_link === void 0 ? void 0 : _runConfig_link.scopeRoots) || {};
+    const workspaceFileName = ((_runConfig_link1 = runConfig.link) === null || _runConfig_link1 === void 0 ? void 0 : _runConfig_link1.workspaceFile) || 'pnpm-workspace.yaml';
+    const isDryRun = runConfig.dryRun || ((_runConfig_link2 = runConfig.link) === null || _runConfig_link2 === void 0 ? void 0 : _runConfig_link2.dryRun) || false;
+    logger.silly('Extracted scopeRoots:', JSON.stringify(scopeRoots));
+    logger.debug('Extracted workspaceFileName:', workspaceFileName);
+    logger.debug('Extracted isDryRun:', isDryRun);
+    if (Object.keys(scopeRoots).length === 0) {
+        logger.verbose('No scope roots configured. Skipping link management.');
+        return 'No scope roots configured. Skipping link management.';
+    }
+    logger.silly(`Configured scope roots: ${JSON.stringify(scopeRoots)}`);
+    // Collect all dependencies
+    const allDependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+        ...packageJson.peerDependencies
+    };
+    logger.verbose(`Found ${Object.keys(allDependencies).length} total dependencies`);
+    // Find matching sibling packages
+    const packagesToLink = await findPackagesByScope(allDependencies, scopeRoots, storage);
+    if (packagesToLink.size === 0) {
+        logger.verbose('No matching sibling packages found for linking.');
+        return 'No matching sibling packages found for linking.';
+    }
+    logger.verbose(`Found ${packagesToLink.size} packages to link: ${[
+        ...packagesToLink.keys()
+    ].join(', ')}`);
+    // Read existing workspace configuration
+    const workspaceFilePath = path.join(process.cwd(), workspaceFileName);
+    const workspaceConfig = await readCurrentWorkspaceFile$1(workspaceFilePath, storage);
+    // Create overrides
+    const newOverrides = {};
+    for (const [packageName, packagePath] of packagesToLink.entries()){
+        newOverrides[packageName] = `link:${packagePath}`;
+    }
+    const updatedOverrides = {
+        ...workspaceConfig.overrides || {},
+        ...newOverrides
+    };
+    const sortedOverrides = Object.keys(updatedOverrides).sort().reduce((obj, key)=>{
+        obj[key] = updatedOverrides[key];
+        return obj;
+    }, {});
+    const updatedConfig = {
+        ...workspaceConfig,
+        overrides: sortedOverrides
+    };
+    // Write the updated workspace file
+    if (isDryRun) {
+        logger.verbose('DRY RUN: Would write the following workspace configuration:');
+        logger.silly(yaml.dump(updatedConfig, {
+            indent: 2
+        }));
+    } else {
+        await writeWorkspaceFile$1(workspaceFilePath, updatedConfig, storage);
+        logger.verbose(`Updated ${workspaceFileName} with ${packagesToLink.size} linked packages in overrides.`);
+        // Rebuild pnpm lock file and node_modules
+        logger.verbose('Running pnpm install to apply links...');
+        try {
+            await run('pnpm install');
+            logger.verbose('Successfully applied links.');
+        } catch (error) {
+            logger.warn(`Failed to run pnpm install: ${error}. You may need to run 'pnpm install' manually.`);
+        }
+    }
+    const summary = `Successfully linked ${packagesToLink.size} sibling packages:\n${[
+        ...packagesToLink.entries()
+    ].map(([name, path])=>`  - ${name}: link:${path}`).join('\n')}`;
+    return summary;
+};
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Build a release prompt using RiotPrompt Recipes.
+ */ const createPrompt = async ({ overrides, overridePaths }, { logContent, diffContent }, { releaseFocus, context, directories } = {})=>{
+    // Use the new quick.release recipe - much simpler!
+    // Adjust basePath for single-file build
+    const basePath = path.resolve(__dirname, 'src', 'prompt');
+    return quick.release(logContent, diffContent, {
+        basePath,
+        overridePaths: overridePaths || [],
+        overrides: overrides || false,
+        releaseFocus,
+        context,
+        directories
+    });
+};
+
+const execute$3 = async (runConfig)=>{
+    var _runConfig_release, _runConfig_release1, _runConfig_release2, _runConfig_release3, _runConfig_release4;
+    const logger = getLogger();
+    const isDryRun = runConfig.dryRun || false;
+    var _runConfig_release_from, _runConfig_release_to;
+    const log = await create({
+        from: (_runConfig_release_from = (_runConfig_release = runConfig.release) === null || _runConfig_release === void 0 ? void 0 : _runConfig_release.from) !== null && _runConfig_release_from !== void 0 ? _runConfig_release_from : DEFAULT_FROM_COMMIT_ALIAS,
+        to: (_runConfig_release_to = (_runConfig_release1 = runConfig.release) === null || _runConfig_release1 === void 0 ? void 0 : _runConfig_release1.to) !== null && _runConfig_release_to !== void 0 ? _runConfig_release_to : DEFAULT_TO_COMMIT_ALIAS
+    });
+    let logContent = '';
+    var _runConfig_release_from1, _runConfig_release_to1, _runConfig_excludedPatterns;
+    const diff = await create$1({
+        from: (_runConfig_release_from1 = (_runConfig_release2 = runConfig.release) === null || _runConfig_release2 === void 0 ? void 0 : _runConfig_release2.from) !== null && _runConfig_release_from1 !== void 0 ? _runConfig_release_from1 : DEFAULT_FROM_COMMIT_ALIAS,
+        to: (_runConfig_release_to1 = (_runConfig_release3 = runConfig.release) === null || _runConfig_release3 === void 0 ? void 0 : _runConfig_release3.to) !== null && _runConfig_release_to1 !== void 0 ? _runConfig_release_to1 : DEFAULT_TO_COMMIT_ALIAS,
+        excludedPatterns: (_runConfig_excludedPatterns = runConfig.excludedPatterns) !== null && _runConfig_excludedPatterns !== void 0 ? _runConfig_excludedPatterns : DEFAULT_EXCLUDED_PATTERNS
+    });
+    let diffContent = '';
+    diffContent = await diff.get();
+    logContent = await log.get();
+    const promptConfig = {
+        overridePaths: runConfig.discoveredConfigDirs || [],
+        overrides: runConfig.overrides || false
+    };
+    const promptContent = {
+        logContent,
+        diffContent
+    };
+    const promptContext = {
+        context: (_runConfig_release4 = runConfig.release) === null || _runConfig_release4 === void 0 ? void 0 : _runConfig_release4.context
+    };
+    const prompt = await createPrompt(promptConfig, promptContent, promptContext);
+    const request = Formatter.create({
+        logger
+    }).formatPrompt(runConfig.model, prompt);
+    // Always ensure output directory exists for request/response files
+    const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+    const storage = create$2({
+        log: logger.info
+    });
+    await storage.ensureDirectory(outputDirectory);
+    const summary = await createCompletion(request.messages, {
+        model: runConfig.model,
+        responseFormat: {
+            type: 'json_object'
+        },
+        debug: runConfig.debug,
+        debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('release')),
+        debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('release'))
+    });
+    // Save timestamped copy of release notes to output directory
+    try {
+        const timestampedFilename = getTimestampedReleaseNotesFilename();
+        const outputPath = getOutputPath(outputDirectory, timestampedFilename);
+        // Format the release notes as markdown
+        const releaseSummary = summary;
+        const releaseNotesContent = `# ${releaseSummary.title}\n\n${releaseSummary.body}`;
+        await storage.writeFile(outputPath, releaseNotesContent, 'utf-8');
+        logger.debug('Saved timestamped release notes: %s', outputPath);
+    } catch (error) {
+        logger.warn('Failed to save timestamped release notes: %s', error.message);
+    }
+    if (isDryRun) {
+        logger.info('DRY RUN: Generated release summary:');
+        logger.info('Title: %s', summary.title);
+        logger.info('Body: %s', summary.body);
+    }
+    return summary;
+};
+
+const scanDirectoryForPackages = async (rootDir, storage)=>{
+    const logger = getLogger();
+    const packageMap = new Map(); // packageName -> relativePath
+    const absoluteRootDir = path.resolve(process.cwd(), rootDir);
+    logger.verbose(`Scanning directory for packages: ${absoluteRootDir}`);
+    if (!await storage.exists(absoluteRootDir) || !await storage.isDirectory(absoluteRootDir)) {
+        logger.verbose(`Root directory does not exist or is not a directory: ${absoluteRootDir}`);
+        return packageMap;
+    }
+    try {
+        // Get all subdirectories in the root directory
+        const items = await storage.listFiles(absoluteRootDir);
+        for (const item of items){
+            const itemPath = path.join(absoluteRootDir, item);
+            if (await storage.isDirectory(itemPath)) {
+                const packageJsonPath = path.join(itemPath, 'package.json');
+                if (await storage.exists(packageJsonPath)) {
+                    try {
+                        const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+                        const packageJson = JSON.parse(packageJsonContent);
+                        if (packageJson.name) {
+                            const relativePath = path.relative(process.cwd(), itemPath);
+                            packageMap.set(packageJson.name, relativePath);
+                            logger.debug(`Found package: ${packageJson.name} at ${relativePath}`);
+                        }
+                    } catch (error) {
+                        logger.debug(`Failed to parse package.json at ${packageJsonPath}: ${error}`);
+                    }
+                }
+            }
+        }
+    } catch (error) {
+        logger.warn(`Failed to read directory ${absoluteRootDir}: ${error}`);
+    }
+    return packageMap;
+};
+const findPackagesToUnlink = async (scopeRoots, storage)=>{
+    const logger = getLogger();
+    const packagesToUnlink = [];
+    logger.silly(`Finding packages to unlink from scope roots: ${JSON.stringify(scopeRoots)}`);
+    // Scan all scope roots to build a comprehensive map of packages that should be unlinked
+    const allScopePackages = new Map(); // packageName -> relativePath
+    for (const [scope, rootDir] of Object.entries(scopeRoots)){
+        logger.verbose(`Scanning scope ${scope} at root directory: ${rootDir}`);
+        const scopePackages = await scanDirectoryForPackages(rootDir, storage);
+        // Add packages from this scope to the overall map
+        for (const [packageName, packagePath] of scopePackages){
+            if (packageName.startsWith(scope)) {
+                allScopePackages.set(packageName, packagePath);
+                packagesToUnlink.push(packagePath);
+                logger.debug(`Package to unlink: ${packageName} -> ${packagePath}`);
+            }
+        }
+    }
+    return packagesToUnlink;
+};
+const readCurrentWorkspaceFile = async (workspaceFilePath, storage)=>{
+    if (await storage.exists(workspaceFilePath)) {
+        try {
+            const content = await storage.readFile(workspaceFilePath, 'utf-8');
+            return yaml.load(content) || {};
+        } catch (error) {
+            throw new Error(`Failed to parse existing workspace file: ${error}`);
+        }
+    }
+    return {};
+};
+const writeWorkspaceFile = async (workspaceFilePath, config, storage)=>{
+    let yamlContent = yaml.dump(config, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true,
+        sortKeys: false,
+        quotingType: "'",
+        forceQuotes: true
+    });
+    // Post-process to fix numeric values that shouldn't be quoted
+    yamlContent = yamlContent.replace(/: '(\d+(?:\.\d+)*)'/g, ': $1');
+    await storage.writeFile(workspaceFilePath, yamlContent, 'utf-8');
+};
+const execute$2 = async (runConfig)=>{
+    var _runConfig_link, _runConfig_link1, _runConfig_link2;
+    const logger = getLogger();
+    const storage = create$2({
+        log: logger.info
+    });
+    logger.verbose('Starting pnpm workspace unlink management...');
+    // Read current package.json
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    if (!await storage.exists(packageJsonPath)) {
+        throw new Error('package.json not found in current directory.');
+    }
+    let packageJson;
+    try {
+        const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+        packageJson = JSON.parse(packageJsonContent);
+    } catch (error) {
+        throw new Error(`Failed to parse package.json: ${error}`);
+    }
+    logger.verbose(`Processing package: ${packageJson.name || 'unnamed'}`);
+    // Get configuration
+    const scopeRoots = ((_runConfig_link = runConfig.link) === null || _runConfig_link === void 0 ? void 0 : _runConfig_link.scopeRoots) || {};
+    const workspaceFileName = ((_runConfig_link1 = runConfig.link) === null || _runConfig_link1 === void 0 ? void 0 : _runConfig_link1.workspaceFile) || 'pnpm-workspace.yaml';
+    const isDryRun = runConfig.dryRun || ((_runConfig_link2 = runConfig.link) === null || _runConfig_link2 === void 0 ? void 0 : _runConfig_link2.dryRun) || false;
+    logger.silly('Extracted scopeRoots:', JSON.stringify(scopeRoots));
+    logger.debug('Extracted workspaceFileName:', workspaceFileName);
+    logger.debug('Extracted isDryRun:', isDryRun);
+    if (Object.keys(scopeRoots).length === 0) {
+        logger.verbose('No scope roots configured. Skipping unlink management.');
+        return 'No scope roots configured. Skipping unlink management.';
+    }
+    logger.silly(`Configured scope roots: ${JSON.stringify(scopeRoots)}`);
+    // Find packages to unlink based on scope roots
+    const packagesToUnlinkPaths = await findPackagesToUnlink(scopeRoots, storage);
+    if (packagesToUnlinkPaths.length === 0) {
+        logger.verbose('No packages found matching scope roots for unlinking.');
+        return 'No packages found matching scope roots for unlinking.';
+    }
+    logger.verbose(`Found ${packagesToUnlinkPaths.length} packages that could be unlinked: ${packagesToUnlinkPaths.join(', ')}`);
+    // Read existing workspace configuration
+    const workspaceFilePath = path.join(process.cwd(), workspaceFileName);
+    const workspaceConfig = await readCurrentWorkspaceFile(workspaceFilePath, storage);
+    if (!workspaceConfig.overrides || Object.keys(workspaceConfig.overrides).length === 0) {
+        logger.verbose('No overrides found in workspace file. Nothing to do.');
+        return 'No overrides found in workspace file. Nothing to do.';
+    }
+    // Filter out packages that match our scope roots from overrides
+    const existingOverrides = workspaceConfig.overrides || {};
+    const remainingOverrides = {};
+    const actuallyRemovedPackages = [];
+    const packagesToUnlinkSet = new Set(packagesToUnlinkPaths.map((p)=>`link:${p}`));
+    for (const [pkgName, pkgLink] of Object.entries(existingOverrides)){
+        if (packagesToUnlinkSet.has(pkgLink)) {
+            actuallyRemovedPackages.push(pkgName);
+        } else {
+            remainingOverrides[pkgName] = pkgLink;
+        }
+    }
+    if (actuallyRemovedPackages.length === 0) {
+        logger.verbose('No linked packages found in workspace file that match scope roots.');
+        return 'No linked packages found in workspace file that match scope roots.';
+    }
+    const updatedConfig = {
+        ...workspaceConfig,
+        overrides: remainingOverrides
+    };
+    if (Object.keys(remainingOverrides).length === 0) {
+        delete updatedConfig.overrides;
+    }
+    // Write the updated workspace file
+    if (isDryRun) {
+        logger.verbose('DRY RUN: Would write the following workspace configuration:');
+        logger.silly(yaml.dump(updatedConfig, {
+            indent: 2
+        }));
+        logger.verbose(`DRY RUN: Would remove ${actuallyRemovedPackages.length} packages: ${actuallyRemovedPackages.join(', ')}`);
+    } else {
+        await writeWorkspaceFile(workspaceFilePath, updatedConfig, storage);
+        logger.verbose(`Updated ${workspaceFileName} - removed ${actuallyRemovedPackages.length} linked packages from overrides.`);
+        // Rebuild pnpm lock file and node_modules
+        logger.verbose('Rebuilding pnpm lock file and node_modules...');
+        try {
+            await run('pnpm install');
+            logger.verbose('Successfully rebuilt pnpm lock file and node_modules');
+        } catch (error) {
+            logger.warn(`Failed to rebuild dependencies: ${error}. You may need to run 'pnpm install' manually.`);
+        }
+    }
+    const summary = `Successfully unlinked ${actuallyRemovedPackages.length} sibling packages:\n${actuallyRemovedPackages.map((pkg)=>`  - ${pkg}`).join('\n')}`;
+    return summary;
+};
+
+const scanNpmrcForEnvVars = async (storage)=>{
+    const npmrcPath = path.join(process.cwd(), '.npmrc');
+    const envVars = [];
+    if (await storage.exists(npmrcPath)) {
+        try {
+            const npmrcContent = await storage.readFile(npmrcPath, 'utf-8');
+            // Match environment variable patterns like ${VAR_NAME} or $VAR_NAME
+            const envVarMatches = npmrcContent.match(/\$\{([^}]+)\}|\$([A-Z_][A-Z0-9_]*)/g);
+            if (envVarMatches) {
+                for (const match of envVarMatches){
+                    // Extract variable name from ${VAR_NAME} or $VAR_NAME format
+                    const varName = match.replace(/\$\{|\}|\$/g, '');
+                    if (varName && !envVars.includes(varName)) {
+                        envVars.push(varName);
+                    }
+                }
+            }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (error) {
+        // If we can't read .npmrc, that's okay - just continue
+        }
+    }
+    return envVars;
+};
+const validateEnvironmentVariables = (requiredEnvVars, isDryRun)=>{
+    const logger = getLogger();
+    const missingEnvVars = [];
+    for (const envVar of requiredEnvVars){
+        if (!process.env[envVar]) {
+            missingEnvVars.push(envVar);
+        }
+    }
+    if (missingEnvVars.length > 0) {
+        if (isDryRun) {
+            logger.warn(`DRY RUN: Missing required environment variables: ${missingEnvVars.join(', ')}`);
+        } else {
+            logger.error(`Missing required environment variables: ${missingEnvVars.join(', ')}`);
+            throw new Error(`Missing required environment variables: ${missingEnvVars.join(', ')}. Please set these environment variables before running publish.`);
+        }
+    }
+};
+const runPrechecks = async (runConfig)=>{
+    var _runConfig_publish;
+    const logger = getLogger();
+    const storage = create$2({
+        log: logger.info
+    });
+    const isDryRun = runConfig.dryRun || false;
+    logger.info(isDryRun ? 'DRY RUN: Running prechecks...' : 'Running prechecks...');
+    // Check if we're in a git repository
+    try {
+        if (isDryRun) {
+            logger.info('DRY RUN: Would check git repository with: git rev-parse --git-dir');
+        } else {
+            await run('git rev-parse --git-dir');
+        }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (error) {
+        if (!isDryRun) {
+            throw new Error('Not in a git repository. Please run this command from within a git repository.');
+        }
+    }
+    // Check for uncommitted changes
+    logger.info(isDryRun ? 'DRY RUN: Would check for uncommitted changes...' : 'Checking for uncommitted changes...');
+    try {
+        if (isDryRun) {
+            logger.info('DRY RUN: Would check git status with: git status --porcelain');
+        } else {
+            const { stdout } = await run('git status --porcelain');
+            if (stdout.trim()) {
+                throw new Error('Working directory has uncommitted changes. Please commit or stash your changes before running publish.');
+            }
+        }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (error) {
+        if (!isDryRun) {
+            throw new Error('Failed to check git status. Please ensure you are in a valid git repository.');
+        }
+    }
+    // Check if we're on a release branch
+    logger.info(isDryRun ? 'DRY RUN: Would check current branch...' : 'Checking current branch...');
+    if (isDryRun) {
+        logger.info('DRY RUN: Would verify current branch is a release branch (starts with "release/")');
+    } else {
+        const currentBranch = await getCurrentBranchName();
+        if (!currentBranch.startsWith('release/')) {
+            throw new Error(`Current branch '${currentBranch}' is not a release branch. Please switch to a release branch (e.g., release/1.0.0) before running publish.`);
+        }
+    }
+    // Check if prepublishOnly script exists in package.json
+    logger.info(isDryRun ? 'DRY RUN: Would check for prepublishOnly script...' : 'Checking for prepublishOnly script...');
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    if (!await storage.exists(packageJsonPath)) {
+        if (!isDryRun) {
+            throw new Error('package.json not found in current directory.');
+        } else {
+            logger.warn('DRY RUN: package.json not found in current directory.');
+        }
+    } else {
+        var _packageJson_scripts;
+        let packageJson;
+        try {
+            const packageJsonContents = await storage.readFile(packageJsonPath, 'utf-8');
+            packageJson = JSON.parse(packageJsonContents);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (error) {
+            if (!isDryRun) {
+                throw new Error('Failed to parse package.json. Please ensure it contains valid JSON.');
+            } else {
+                logger.warn('DRY RUN: Failed to parse package.json. Please ensure it contains valid JSON.');
+            }
+        }
+        if (packageJson && !((_packageJson_scripts = packageJson.scripts) === null || _packageJson_scripts === void 0 ? void 0 : _packageJson_scripts.prepublishOnly)) {
+            if (!isDryRun) {
+                throw new Error('prepublishOnly script is required in package.json but was not found. Please add a prepublishOnly script that runs your pre-flight checks (e.g., clean, lint, build, test).');
+            } else {
+                logger.warn('DRY RUN: prepublishOnly script is required in package.json but was not found.');
+            }
+        }
+    }
+    // Check required environment variables
+    logger.verbose(isDryRun ? 'DRY RUN: Would check required environment variables...' : 'Checking required environment variables...');
+    const coreRequiredEnvVars = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.requiredEnvVars) || [];
+    const npmrcEnvVars = isDryRun ? [] : await scanNpmrcForEnvVars(storage); // Skip .npmrc scan in dry run
+    const allRequiredEnvVars = [
+        ...new Set([
+            ...coreRequiredEnvVars,
+            ...npmrcEnvVars
+        ])
+    ];
+    if (allRequiredEnvVars.length > 0) {
+        logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Required environment variables: ${allRequiredEnvVars.join(', ')}`);
+        validateEnvironmentVariables(allRequiredEnvVars, isDryRun);
+    } else {
+        logger.verbose(isDryRun ? 'DRY RUN: No required environment variables specified.' : 'No required environment variables specified.');
+    }
+    logger.info(isDryRun ? 'DRY RUN: All prechecks would pass.' : 'All prechecks passed.');
+};
+const execute$1 = async (runConfig)=>{
+    const logger = getLogger();
+    const storage = create$2({
+        log: logger.info
+    });
+    const isDryRun = runConfig.dryRun || false;
+    // Run prechecks before starting any work
+    await runPrechecks(runConfig);
+    logger.info(isDryRun ? 'DRY RUN: Would start release process...' : 'Starting release process...');
+    try {
+        var _runConfig_publish, _runConfig_publish1;
+        // Unlink all workspace packages before starting (if enabled)
+        const shouldUnlink = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.unlinkWorkspacePackages) !== false; // default to true
+        if (shouldUnlink) {
+            logger.verbose(isDryRun ? 'DRY RUN: Would unlink workspace packages...' : 'Unlinking workspace packages...');
+            await execute$2(runConfig);
+        } else {
+            logger.verbose(isDryRun ? 'DRY RUN: Would skip unlink workspace packages (disabled in config).' : 'Skipping unlink workspace packages (disabled in config).');
+        }
+        let pr = null;
+        if (isDryRun) {
+            logger.info('DRY RUN: Would check for existing pull request');
+            logger.info('DRY RUN: Assuming no existing PR found for demo purposes');
+        } else {
+            const branchName = await getCurrentBranchName();
+            pr = await findOpenPullRequestByHeadRef(branchName);
+        }
+        if (pr) {
+            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Found existing pull request for branch: ${pr.html_url}`);
+        } else {
+            var _runConfig_publish2;
+            logger.info(isDryRun ? 'DRY RUN: No open pull request found, would start new release publishing process...' : 'No open pull request found, starting new release publishing process...');
+            // 1. Prepare for release
+            logger.verbose(isDryRun ? 'DRY RUN: Would prepare for release: switching from workspace to remote dependencies.' : 'Preparing for release: switching from workspace to remote dependencies.');
+            logger.verbose(isDryRun ? 'DRY RUN: Would update dependencies to latest versions from registry' : 'Updating dependencies to latest versions from registry');
+            const updatePatterns = (_runConfig_publish2 = runConfig.publish) === null || _runConfig_publish2 === void 0 ? void 0 : _runConfig_publish2.dependencyUpdatePatterns;
+            if (updatePatterns && updatePatterns.length > 0) {
+                logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Updating dependencies matching patterns: ${updatePatterns.join(', ')}`);
+                const patternsArg = updatePatterns.join(' ');
+                await runWithDryRunSupport(`pnpm update --latest ${patternsArg}`, isDryRun);
+            } else {
+                logger.verbose(isDryRun ? 'DRY RUN: No dependency update patterns specified, would update all dependencies' : 'No dependency update patterns specified, updating all dependencies');
+                await runWithDryRunSupport('pnpm update --latest', isDryRun);
+            }
+            logger.verbose(isDryRun ? 'DRY RUN: Would stage changes for release commit' : 'Staging changes for release commit');
+            await runWithDryRunSupport('git add package.json pnpm-lock.yaml', isDryRun);
+            logger.info(isDryRun ? 'DRY RUN: Would run prepublishOnly script...' : 'Running prepublishOnly script...');
+            await runWithDryRunSupport('pnpm run prepublishOnly', isDryRun);
+            logger.verbose(isDryRun ? 'DRY RUN: Would check for staged changes...' : 'Checking for staged changes...');
+            if (isDryRun) {
+                logger.verbose('DRY RUN: Assuming staged changes exist for demo purposes');
+                logger.verbose('DRY RUN: Would create commit...');
+                await execute$9(runConfig);
+            } else {
+                if (await hasStagedChanges()) {
+                    logger.verbose('Staged changes found, creating commit...');
+                    await execute$9(runConfig);
+                } else {
+                    logger.verbose('No changes to commit, skipping commit.');
+                }
+            }
+            logger.info(isDryRun ? 'DRY RUN: Would bump version...' : 'Bumping version...');
+            await runWithDryRunSupport('pnpm version patch', isDryRun);
+            logger.info(isDryRun ? 'DRY RUN: Would generate release notes...' : 'Generating release notes...');
+            const releaseSummary = await execute$3(runConfig);
+            if (isDryRun) {
+                logger.info('DRY RUN: Would write release notes to RELEASE_NOTES.md and RELEASE_TITLE.md in output directory');
+            } else {
+                const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+                await storage.ensureDirectory(outputDirectory);
+                const releaseNotesPath = getOutputPath(outputDirectory, 'RELEASE_NOTES.md');
+                const releaseTitlePath = getOutputPath(outputDirectory, 'RELEASE_TITLE.md');
+                await storage.writeFile(releaseNotesPath, releaseSummary.body, 'utf-8');
+                await storage.writeFile(releaseTitlePath, releaseSummary.title, 'utf-8');
+                logger.info(`Release notes and title generated and saved to ${releaseNotesPath} and ${releaseTitlePath}.`);
+            }
+            logger.info(isDryRun ? 'DRY RUN: Would push to origin...' : 'Pushing to origin...');
+            await runWithDryRunSupport('git push --follow-tags', isDryRun);
+            logger.info(isDryRun ? 'DRY RUN: Would create pull request...' : 'Creating pull request...');
+            if (isDryRun) {
+                logger.info('DRY RUN: Would get commit title and create PR with GitHub API');
+                pr = {
+                    number: 123,
+                    html_url: 'https://github.com/mock/repo/pull/123',
+                    labels: []
+                };
+            } else {
+                const { stdout: commitTitle } = await run('git log -1 --pretty=%B');
+                pr = await createPullRequest(commitTitle, 'Automated release PR.', await getCurrentBranchName());
+                if (!pr) {
+                    throw new Error('Failed to create pull request.');
+                }
+                logger.info(`Pull request created: ${pr.html_url}`);
+            }
+        }
+        logger.info(`${isDryRun ? 'DRY RUN: Would wait for' : 'Waiting for'} PR #${pr.number} checks to complete...`);
+        if (!isDryRun) {
+            await waitForPullRequestChecks(pr.number);
+        }
+        const mergeMethod = ((_runConfig_publish1 = runConfig.publish) === null || _runConfig_publish1 === void 0 ? void 0 : _runConfig_publish1.mergeMethod) || 'squash';
+        if (isDryRun) {
+            logger.info(`DRY RUN: Would merge PR #${pr.number} using ${mergeMethod} method`);
+        } else {
+            await mergePullRequest(pr.number, mergeMethod);
+        }
+        logger.info(isDryRun ? 'DRY RUN: Would checkout main branch...' : 'Checking out main branch...');
+        await runWithDryRunSupport('git checkout main', isDryRun);
+        await runWithDryRunSupport('git pull origin main', isDryRun);
+        logger.info(isDryRun ? 'DRY RUN: Would create GitHub release...' : 'Creating GitHub release...');
+        if (isDryRun) {
+            logger.info('DRY RUN: Would read package.json version and create GitHub release');
+        } else {
+            const packageJsonContents = await storage.readFile('package.json', 'utf-8');
+            const { version } = JSON.parse(packageJsonContents);
+            const tagName = `v${version}`;
+            const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+            const releaseNotesPath = getOutputPath(outputDirectory, 'RELEASE_NOTES.md');
+            const releaseTitlePath = getOutputPath(outputDirectory, 'RELEASE_TITLE.md');
+            const releaseNotesContent = await storage.readFile(releaseNotesPath, 'utf-8');
+            const releaseTitle = await storage.readFile(releaseTitlePath, 'utf-8');
+            await createRelease(tagName, releaseTitle, releaseNotesContent);
+        }
+        logger.info(isDryRun ? 'DRY RUN: Would create new release branch...' : 'Creating new release branch...');
+        if (isDryRun) {
+            logger.info('DRY RUN: Would create next release branch (e.g., release/1.0.1) and push to origin');
+        } else {
+            const packageJsonContents = await storage.readFile('package.json', 'utf-8');
+            const { version } = JSON.parse(packageJsonContents);
+            const nextVersion = incrementPatchVersion(version);
+            const newBranchName = `release/${nextVersion}`;
+            await run(`git checkout -b ${newBranchName}`);
+            await run(`git push -u origin ${newBranchName}`);
+            logger.info(`Branch ${newBranchName} created and pushed to origin.`);
+        }
+        logger.info(isDryRun ? 'DRY RUN: Preparation would be complete.' : 'Preparation complete.');
+    } finally{
+        var _runConfig_publish3;
+        // Restore linked packages (if enabled)
+        const shouldLink = ((_runConfig_publish3 = runConfig.publish) === null || _runConfig_publish3 === void 0 ? void 0 : _runConfig_publish3.linkWorkspacePackages) !== false; // default to true
+        if (shouldLink) {
+            logger.verbose(isDryRun ? 'DRY RUN: Would restore linked packages...' : 'Restoring linked packages...');
+            await execute$4(runConfig);
+        } else {
+            logger.verbose(isDryRun ? 'DRY RUN: Would skip restore linked packages (disabled in config).' : 'Skipping restore linked packages (disabled in config).');
+        }
+    }
+};
+
+const getUnplayableConfigPath = ()=>{
+    return path.join(os.homedir(), '.unplayable', 'audio-device.json');
+};
+const execute = async (runConfig)=>{
+    const logger = getLogger();
+    const isDryRun = runConfig.dryRun || false;
+    if (isDryRun) {
+        logger.info('DRY RUN: Would start audio device selection process');
+        logger.info('DRY RUN: Would save selected device to %s', getUnplayableConfigPath());
+        return 'Audio device selection completed (dry run)';
+    }
+    try {
+        const preferencesDir = path.join(os.homedir(), '.unplayable');
+        const result = await selectAndConfigureAudioDevice(preferencesDir, logger, runConfig.debug);
+        return result;
+    } catch (error) {
+        logger.error('❌ Audio device selection failed: %s', error.message);
+        process.exit(1);
+    }
+};
+
+const ConfigSchema = z.object({
+    dryRun: z.boolean().optional(),
+    verbose: z.boolean().optional(),
+    debug: z.boolean().optional(),
+    overrides: z.boolean().optional(),
+    model: z.string().optional(),
+    contextDirectories: z.array(z.string()).optional(),
+    outputDirectory: z.string().optional(),
+    preferencesDirectory: z.string().optional(),
+    commit: z.object({
+        add: z.boolean().optional(),
+        cached: z.boolean().optional(),
+        sendit: z.boolean().optional(),
+        messageLimit: z.number().optional(),
+        context: z.string().optional(),
+        direction: z.string().optional()
+    }).optional(),
+    audioCommit: z.object({
+        maxRecordingTime: z.number().optional(),
+        audioDevice: z.string().optional(),
+        file: z.string().optional(),
+        keepTemp: z.boolean().optional()
+    }).optional(),
+    release: z.object({
+        from: z.string().optional(),
+        to: z.string().optional(),
+        messageLimit: z.number().optional(),
+        context: z.string().optional()
+    }).optional(),
+    review: z.object({
+        includeCommitHistory: z.boolean().optional(),
+        includeRecentDiffs: z.boolean().optional(),
+        includeReleaseNotes: z.boolean().optional(),
+        includeGithubIssues: z.boolean().optional(),
+        commitHistoryLimit: z.number().optional(),
+        diffHistoryLimit: z.number().optional(),
+        releaseNotesLimit: z.number().optional(),
+        githubIssuesLimit: z.number().optional(),
+        context: z.string().optional(),
+        sendit: z.boolean().optional(),
+        note: z.string().optional()
+    }).optional(),
+    audioReview: z.object({
+        includeCommitHistory: z.boolean().optional(),
+        includeRecentDiffs: z.boolean().optional(),
+        includeReleaseNotes: z.boolean().optional(),
+        includeGithubIssues: z.boolean().optional(),
+        commitHistoryLimit: z.number().optional(),
+        diffHistoryLimit: z.number().optional(),
+        releaseNotesLimit: z.number().optional(),
+        githubIssuesLimit: z.number().optional(),
+        context: z.string().optional(),
+        sendit: z.boolean().optional(),
+        maxRecordingTime: z.number().optional(),
+        audioDevice: z.string().optional(),
+        file: z.string().optional(),
+        keepTemp: z.boolean().optional()
+    }).optional(),
+    publish: z.object({
+        mergeMethod: z.enum([
+            'merge',
+            'squash',
+            'rebase'
+        ]).optional(),
+        dependencyUpdatePatterns: z.array(z.string()).optional(),
+        requiredEnvVars: z.array(z.string()).optional(),
+        linkWorkspacePackages: z.boolean().optional(),
+        unlinkWorkspacePackages: z.boolean().optional()
+    }).optional(),
+    link: z.object({
+        scopeRoots: z.record(z.string(), z.string()).optional(),
+        workspaceFile: z.string().optional(),
+        dryRun: z.boolean().optional()
+    }).optional(),
+    excludedPatterns: z.array(z.string()).optional()
+});
+z.object({
+    openaiApiKey: z.string().optional()
+});
+z.object({
+    commandName: z.string().optional()
+});
+
+// Configure RiotPrompt templates once for the entire application
+configureTemplates({
+    commit: {
+        persona: {
+            path: DEFAULT_PERSONA_YOU_FILE,
+            title: 'Developer Persona'
+        },
+        instructions: [
+            {
+                path: DEFAULT_INSTRUCTIONS_COMMIT_FILE,
+                title: 'Commit Instructions'
+            }
+        ]
+    },
+    release: {
+        persona: {
+            path: DEFAULT_PERSONA_RELEASER_FILE,
+            title: 'Release Manager Persona'
+        },
+        instructions: [
+            {
+                path: DEFAULT_INSTRUCTIONS_RELEASE_FILE,
+                title: 'Release Instructions'
+            }
+        ]
+    },
+    review: {
+        persona: {
+            path: DEFAULT_PERSONA_YOU_FILE,
+            title: 'Developer Persona'
+        },
+        instructions: [
+            {
+                path: DEFAULT_INSTRUCTIONS_REVIEW_FILE,
+                title: 'Review Instructions'
+            }
+        ]
+    }
+});
 /**
  * Configure early logging based on command line flags.
  * 
@@ -36,7 +3720,9 @@ import { ConfigSchema } from './types.js';
 async function main() {
     // Configure logging early, before CardiganTime initialization
     configureEarlyLogging();
-    const cardigantime = Cardigantime.create({
+    // Cast create to `any` to avoid excessive type instantiation issues in TS compiler
+    const createCardigantime = Cardigantime.create;
+    const cardigantime = createCardigantime({
         defaults: {
             configDirectory: DEFAULT_CONFIG_DIR,
             // Move pathResolution INSIDE defaults
@@ -90,27 +3776,27 @@ async function main() {
         }
         let summary = '';
         if (commandName === COMMAND_COMMIT) {
-            summary = await execute(runConfig);
+            summary = await execute$9(runConfig);
         } else if (commandName === COMMAND_AUDIO_COMMIT) {
-            summary = await execute$1(runConfig);
+            summary = await execute$8(runConfig);
         } else if (commandName === COMMAND_RELEASE) {
-            const releaseSummary = await execute$2(runConfig);
+            const releaseSummary = await execute$3(runConfig);
             summary = `${releaseSummary.title}\n\n${releaseSummary.body}`;
         } else if (commandName === COMMAND_PUBLISH) {
-            await execute$3(runConfig);
+            await execute$1(runConfig);
         } else if (commandName === COMMAND_LINK) {
             summary = await execute$4(runConfig);
         } else if (commandName === COMMAND_UNLINK) {
-            summary = await execute$5(runConfig);
+            summary = await execute$2(runConfig);
         } else if (commandName === COMMAND_AUDIO_REVIEW) {
             summary = await execute$6(runConfig);
         } else if (commandName === COMMAND_CLEAN) {
-            await execute$7(runConfig);
+            await execute$5(runConfig);
             summary = 'Output directory cleaned successfully.';
         } else if (commandName === COMMAND_REVIEW) {
-            summary = await execute$8(runConfig);
+            summary = await execute$7(runConfig);
         } else if (commandName === COMMAND_SELECT_AUDIO) {
-            await execute$9(runConfig);
+            await execute(runConfig);
             summary = 'Audio selection completed successfully.';
         }
         // eslint-disable-next-line no-console