@grunnverk/kodrdriv 1.3.0

package/temp-dist/constants.js

@@ -0,0 +1,202 @@
+import os from 'os';
+import path from 'path';
+export const VERSION = '__VERSION__ (__GIT_BRANCH__/__GIT_COMMIT__ __GIT_TAGS__ __GIT_COMMIT_DATE__) __SYSTEM_INFO__';
+export const PROGRAM_NAME = 'kodrdriv';
+export const DEFAULT_CHARACTER_ENCODING = 'utf-8';
+export const DEFAULT_BINARY_TO_TEXT_ENCODING = 'base64';
+export const DEFAULT_DIFF = true;
+export const DEFAULT_LOG = false;
+export const DEFAULT_OVERRIDES = false;
+export const DATE_FORMAT_MONTH_DAY = 'MM-DD';
+export const DATE_FORMAT_YEAR = 'YYYY';
+export const DATE_FORMAT_YEAR_MONTH = 'YYYY-MM';
+export const DATE_FORMAT_YEAR_MONTH_DAY = 'YYYY-MM-DD';
+export const DATE_FORMAT_YEAR_MONTH_DAY_SLASH = 'YYYY/MM/DD';
+export const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES = 'YYYY-MM-DD-HHmm';
+export const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS = 'YYYY-MM-DD-HHmmss';
+export const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS = 'YYYY-MM-DD-HHmmss.SSS';
+export const DATE_FORMAT_SHORT_TIMESTAMP = 'YYMMdd-HHmm';
+export const DATE_FORMAT_MONTH = 'MM';
+export const DATE_FORMAT_DAY = 'DD';
+export const DATE_FORMAT_HOURS = 'HHmm';
+export const DATE_FORMAT_MINUTES = 'mm';
+export const DATE_FORMAT_SECONDS = 'ss';
+export const DATE_FORMAT_MILLISECONDS = 'SSS';
+export const DEFAULT_VERBOSE = false;
+export const DEFAULT_DRY_RUN = false;
+export const DEFAULT_DEBUG = false;
+export const DEFAULT_MODEL = 'gpt-4o-mini';
+export const DEFAULT_MODEL_STRONG = 'gpt-4o';
+export const DEFAULT_OUTPUT_DIRECTORY = 'output/kodrdriv';
+// Buffer size for git commands that may produce large output (like git log)
+export const DEFAULT_GIT_COMMAND_MAX_BUFFER = 50 * 1024 * 1024; // 50MB
+export const DEFAULT_CONTEXT_DIRECTORIES = [];
+export const DEFAULT_CONFIG_DIR = '.kodrdriv';
+export const DEFAULT_PREFERENCES_DIRECTORY = path.join(os.homedir(), '.kodrdriv');
+export const DEFAULT_FROM_COMMIT_ALIAS = 'origin/HEAD';
+export const DEFAULT_TO_COMMIT_ALIAS = 'HEAD';
+export const DEFAULT_ADD = false;
+export const DEFAULT_CACHED = false;
+export const DEFAULT_SENDIT_MODE = false;
+export const DEFAULT_INTERACTIVE_MODE = false;
+export const DEFAULT_MESSAGE_LIMIT = 50;
+export const DEFAULT_MAX_DIFF_BYTES = 2048; // 2KB default limit per file
+export const DEFAULT_MERGE_METHOD = 'squash';
+export const DEFAULT_EXCLUDED_PATTERNS = [
+    'node_modules', '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'
+];
+export const COMMAND_COMMIT = 'commit';
+export const COMMAND_AUDIO_COMMIT = 'audio-commit';
+export const COMMAND_SELECT_AUDIO = 'select-audio';
+export const COMMAND_RELEASE = 'release';
+export const COMMAND_REVIEW = 'review';
+export const COMMAND_AUDIO_REVIEW = 'audio-review';
+export const COMMAND_PUBLISH = 'publish';
+export const COMMAND_TREE = 'tree';
+export const COMMAND_LINK = 'link';
+export const COMMAND_UNLINK = 'unlink';
+export const COMMAND_CLEAN = 'clean';
+export const COMMAND_CHECK_CONFIG = 'check-config';
+export const COMMAND_INIT_CONFIG = 'init-config';
+export const ALLOWED_COMMANDS = [
+    COMMAND_COMMIT,
+    COMMAND_AUDIO_COMMIT,
+    COMMAND_SELECT_AUDIO,
+    COMMAND_RELEASE,
+    COMMAND_REVIEW,
+    COMMAND_AUDIO_REVIEW,
+    COMMAND_PUBLISH,
+    COMMAND_TREE,
+    COMMAND_LINK,
+    COMMAND_UNLINK,
+    COMMAND_CLEAN
+];
+export const DEFAULT_COMMAND = COMMAND_COMMIT;
+export const DEFAULT_INSTRUCTIONS_DIR = `instructions`;
+export const DEFAULT_PERSONA_DIR = `personas`;
+export const DEFAULT_INSTRUCTIONS_COMMIT_FILE = `${DEFAULT_INSTRUCTIONS_DIR}/commit.md`;
+export const DEFAULT_INSTRUCTIONS_RELEASE_FILE = `${DEFAULT_INSTRUCTIONS_DIR}/release.md`;
+export const DEFAULT_INSTRUCTIONS_REVIEW_FILE = `${DEFAULT_INSTRUCTIONS_DIR}/review.md`;
+export const DEFAULT_PERSONA_RELEASER_FILE = `${DEFAULT_PERSONA_DIR}/releaser.md`;
+export const DEFAULT_PERSONA_YOU_FILE = `${DEFAULT_PERSONA_DIR}/you.md`;
+// Default instructions for each persona
+export const DEFAULT_INSTRUCTIONS_MAP = {
+    [COMMAND_COMMIT]: DEFAULT_INSTRUCTIONS_COMMIT_FILE,
+    [COMMAND_AUDIO_COMMIT]: DEFAULT_INSTRUCTIONS_COMMIT_FILE, // Reuse commit instructions
+    [COMMAND_RELEASE]: DEFAULT_INSTRUCTIONS_RELEASE_FILE,
+    [COMMAND_REVIEW]: DEFAULT_INSTRUCTIONS_REVIEW_FILE, // Reuse audio-review instructions for now
+    [COMMAND_AUDIO_REVIEW]: DEFAULT_INSTRUCTIONS_REVIEW_FILE,
+};
+// Default personas for each command
+export const DEFAULT_PERSONA_MAP = {
+    [COMMAND_COMMIT]: DEFAULT_PERSONA_YOU_FILE,
+    [COMMAND_AUDIO_COMMIT]: DEFAULT_PERSONA_YOU_FILE, // Use You persona
+    [COMMAND_RELEASE]: DEFAULT_PERSONA_RELEASER_FILE,
+    [COMMAND_REVIEW]: DEFAULT_PERSONA_YOU_FILE, // Use You persona
+    [COMMAND_AUDIO_REVIEW]: DEFAULT_PERSONA_YOU_FILE,
+};
+// Used by child process to create paths
+export const DEFAULT_PATH_SEPARATOR = '/';
+// Used by util/general for file filtering
+export const DEFAULT_IGNORE_PATTERNS = [
+    'node_modules/**',
+    '**/*.log',
+    '.git/**',
+    'dist/**',
+    'build/**',
+    'coverage/**',
+    '.DS_Store',
+    '*.tmp',
+    '*.cache',
+];
+// Used by util/storage for directory names
+export const DEFAULT_DIRECTORY_PREFIX = '.kodrdriv';
+// Used by other commands but not exposed in CLI
+export const INTERNAL_DEFAULT_OUTPUT_FILE = 'output.txt';
+export const INTERNAL_DATETIME_FORMAT = 'YYYY-MM-DD_HH-mm-ss';
+// Define defaults in one place
+export 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,
+        interactive: DEFAULT_INTERACTIVE_MODE,
+        messageLimit: DEFAULT_MESSAGE_LIMIT,
+        skipFileCheck: false,
+        maxDiffBytes: DEFAULT_MAX_DIFF_BYTES,
+    },
+    release: {
+        from: DEFAULT_FROM_COMMIT_ALIAS,
+        to: DEFAULT_TO_COMMIT_ALIAS,
+        messageLimit: DEFAULT_MESSAGE_LIMIT,
+        interactive: DEFAULT_INTERACTIVE_MODE,
+        maxDiffBytes: DEFAULT_MAX_DIFF_BYTES,
+    },
+    audioCommit: {
+        maxRecordingTime: 300, // 5 minutes default
+        audioDevice: undefined, // Auto-detect by default
+    },
+    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, // 5 minutes default
+        audioDevice: undefined, // Auto-detect by default
+        directory: undefined, // No default directory
+    },
+    publish: {
+        mergeMethod: DEFAULT_MERGE_METHOD,
+        requiredEnvVars: ['GITHUB_TOKEN', 'OPENAI_API_KEY'],
+        linkWorkspacePackages: true,
+        unlinkWorkspacePackages: true,
+        sendit: DEFAULT_SENDIT_MODE,
+        targetBranch: 'main',
+    },
+    link: {
+        scopeRoots: {},
+        dryRun: false,
+    },
+    tree: {
+        directories: undefined,
+        excludedPatterns: undefined,
+        startFrom: undefined,
+        cmd: undefined,
+        parallel: false,
+        builtInCommand: undefined,
+        continue: false,
+    },
+    excludedPatterns: DEFAULT_EXCLUDED_PATTERNS,
+};

package/temp-dist/logging.js

@@ -0,0 +1,130 @@
+import winston from 'winston';
+// eslint-disable-next-line no-restricted-imports
+import * as fs from 'fs';
+import path from 'path';
+import { DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS, PROGRAM_NAME, DEFAULT_OUTPUT_DIRECTORY } from './constants';
+// 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, dryRun }) => {
+                const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+                // For info level messages, don't show the level prefix
+                if (level.includes('info')) {
+                    return `${dryRunPrefix}${String(message)}`;
+                }
+                // For warn, error, etc., show the level prefix
+                return `${level}: ${dryRunPrefix}${String(message)}`;
+            }))
+        }));
+    }
+    else {
+        // For debug/verbose levels, add console transport that shows info and above
+        transports.push(new winston.transports.Console({
+            level: 'info', // Show info, warn, and error on console
+            format: winston.format.combine(winston.format.colorize(), winston.format.printf(({ timestamp, level, message, dryRun, ...meta }) => {
+                // For info level messages, use simpler format without timestamp
+                if (level.includes('info')) {
+                    const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+                    return `${dryRunPrefix}${String(message)}`;
+                }
+                const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
+                const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+                return `${timestamp} ${level}: ${dryRunPrefix}${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', // Capture debug and above in the file
+                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) => {
+    const baseFormats = [
+        winston.format.errors({ stack: true }),
+        winston.format.splat(),
+    ];
+    if (level === 'info') {
+        return winston.format.combine(...baseFormats, winston.format.printf(({ message, dryRun, ..._meta }) => {
+            // Auto-format dry-run messages
+            if (dryRun) {
+                return `🔍 DRY RUN: ${message}`;
+            }
+            return String(message);
+        }));
+    }
+    return winston.format.combine(winston.format.timestamp({ format: DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS }), ...baseFormats, winston.format.printf(({ timestamp, level, message, dryRun, ...meta }) => {
+        const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
+        const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+        return `${timestamp} ${level}: ${dryRunPrefix}${String(message)}${metaStr}`;
+    }));
+};
+// Create the logger instance once
+const logger = winston.createLogger({
+    level: 'info',
+    format: createFormat('info'),
+    defaultMeta: { service: PROGRAM_NAME },
+    transports: createTransports('info'),
+});
+export 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),
+    });
+};
+export const getLogger = () => logger;
+/**
+ * Get a logger that automatically formats messages for dry-run mode
+ */
+export const getDryRunLogger = (isDryRun) => {
+    if (!isDryRun) {
+        return logger;
+    }
+    // Return a wrapper that adds dry-run context to all log calls
+    return {
+        info: (message, ...args) => logger.info(message, { dryRun: true }, ...args),
+        warn: (message, ...args) => logger.warn(message, { dryRun: true }, ...args),
+        error: (message, ...args) => logger.error(message, { dryRun: true }, ...args),
+        debug: (message, ...args) => logger.debug(message, { dryRun: true }, ...args),
+        verbose: (message, ...args) => logger.verbose(message, { dryRun: true }, ...args),
+        silly: (message, ...args) => logger.silly(message, { dryRun: true }, ...args),
+    };
+};

package/temp-dist/types.js

@@ -0,0 +1,112 @@
+import { z } from "zod";
+export 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(),
+        interactive: z.boolean().optional(),
+        messageLimit: z.number().optional(),
+        context: z.string().optional(),
+        direction: z.string().optional(),
+        skipFileCheck: z.boolean().optional(),
+        maxDiffBytes: z.number().optional(),
+        model: 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(),
+        interactive: z.boolean().optional(),
+        focus: z.string().optional(),
+        maxDiffBytes: z.number().optional(),
+        model: 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(),
+        editorTimeout: z.number().optional(),
+        maxContextErrors: z.number().optional(),
+        model: 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(),
+        directory: 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(),
+        checksTimeout: z.number().optional(),
+        skipUserConfirmation: z.boolean().optional(),
+        sendit: z.boolean().optional(),
+        waitForReleaseWorkflows: z.boolean().optional(),
+        releaseWorkflowsTimeout: z.number().optional(),
+        releaseWorkflowNames: z.array(z.string()).optional(),
+        targetBranch: z.string().optional(),
+    }).optional(),
+    link: z.object({
+        scopeRoots: z.record(z.string(), z.string()).optional(),
+        dryRun: z.boolean().optional(),
+    }).optional(),
+    unlink: z.object({
+        scopeRoots: z.record(z.string(), z.string()).optional(),
+        workspaceFile: z.string().optional(),
+        dryRun: z.boolean().optional(),
+        cleanNodeModules: z.boolean().optional(),
+    }).optional(),
+    tree: z.object({
+        directories: z.array(z.string()).optional(),
+        excludedPatterns: z.array(z.string()).optional(),
+        startFrom: z.string().optional(),
+        cmd: z.string().optional(),
+        parallel: z.boolean().optional(),
+        builtInCommand: z.string().optional(),
+        continue: z.boolean().optional(),
+    }).optional(),
+    excludedPatterns: z.array(z.string()).optional(),
+});
+export const SecureConfigSchema = z.object({
+    openaiApiKey: z.string().optional(),
+});
+export const CommandConfigSchema = z.object({
+    commandName: z.string().optional(),
+});

package/temp-dist/util/stdin.js

@@ -0,0 +1,132 @@
+// Function to read from STDIN if available
+export 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;
+            let resolved = false;
+            const timeout = setTimeout(() => {
+                if (!hasData && !resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve(null);
+                }
+            }, 10); // Very short timeout for tests
+            const onData = (chunk) => {
+                hasData = true;
+                clearTimeout(timeout);
+                input += chunk;
+            };
+            const onEnd = () => {
+                if (!resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve(input.trim() || null);
+                }
+            };
+            const onError = () => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    cleanup();
+                    resolve(null);
+                }
+            };
+            const cleanup = () => {
+                process.stdin.removeListener('data', onData);
+                process.stdin.removeListener('end', onEnd);
+                process.stdin.removeListener('error', onError);
+                process.stdin.pause();
+            };
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', onData);
+            process.stdin.on('end', onEnd);
+            process.stdin.on('error', onError);
+            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;
+        let resolved = false;
+        const timeout = setTimeout(() => {
+            if (!hasData && !resolved) {
+                resolved = true;
+                cleanup();
+                resolve(null);
+            }
+        }, 100); // Short timeout to detect if data is available
+        const onData = (chunk) => {
+            hasData = true;
+            clearTimeout(timeout);
+            input += chunk;
+        };
+        const onEnd = () => {
+            if (!resolved) {
+                resolved = true;
+                cleanup();
+                resolve(input.trim() || null);
+            }
+        };
+        const onError = () => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                cleanup();
+                resolve(null);
+            }
+        };
+        const cleanup = () => {
+            process.stdin.removeListener('data', onData);
+            process.stdin.removeListener('end', onEnd);
+            process.stdin.removeListener('error', onError);
+            process.stdin.pause();
+        };
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', onData);
+        process.stdin.on('end', onEnd);
+        process.stdin.on('error', onError);
+        // If no data comes in quickly, assume no stdin
+        process.stdin.resume();
+    });
+}
+// Function to prompt user for confirmation (y/n)
+export async function promptConfirmation(message) {
+    // In test environment, return true by default
+    if (process.env.NODE_ENV === 'test' || process.env.VITEST === 'true') {
+        return true;
+    }
+    // Use process.stdout.write instead of console.log to avoid linter issues
+    process.stdout.write(message + '\n');
+    process.stdout.write('Please enter "y" for yes or "n" for no: ');
+    return new Promise((resolve) => {
+        const handleInput = (chunk) => {
+            const input = chunk.toString().trim().toLowerCase();
+            if (input === 'y' || input === 'yes') {
+                cleanup();
+                resolve(true);
+            }
+            else if (input === 'n' || input === 'no') {
+                cleanup();
+                resolve(false);
+            }
+            else {
+                process.stdout.write('Please enter "y" for yes or "n" for no: ');
+                // Continue listening for input
+            }
+        };
+        const cleanup = () => {
+            process.stdin.removeListener('data', handleInput);
+            process.stdin.pause();
+        };
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', handleInput);
+        process.stdin.resume();
+    });
+}