@eldrforge/core 0.1.4 → 1.0.0

package/dist/index.js

@@ -1,6 +1,7 @@
 import { ExitError, createStorage, incrementPatchVersion, validateVersionString, convertToReleaseVersion, incrementPrereleaseVersion, UserCancellationError, CommandError } from '@eldrforge/shared';
 export { calculateTargetVersion, convertToReleaseVersion, deepMerge, incrementMajorVersion, incrementMinorVersion, incrementPatchVersion, incrementPrereleaseVersion, stringifyJSON, validateVersionString } from '@eldrforge/shared';
 import winston from 'winston';
+import { Writable } from 'stream';
 import * as fs from 'fs';
 import { statSync } from 'fs';
 import * as path from 'path';
@@ -419,8 +420,11 @@ const ensureDebugDirectory = ()=>{
         });
         debugDirectoryEnsured = true;
     } catch (error) {
-        // eslint-disable-next-line no-console
-        console.error(`Failed to create debug directory ${debugDir}:`, error);
+        // Only log to console if not in MCP server mode (MCP mode requires clean stdout)
+        if (process.env.KODRDRIV_MCP_SERVER !== 'true') {
+            // eslint-disable-next-line no-console
+            console.error(`Failed to create debug directory ${debugDir}:`, error);
+        }
     }
 };
 const generateDebugLogFilename = ()=>{
@@ -430,69 +434,66 @@ const generateDebugLogFilename = ()=>{
 };
 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)}`;
-            }))
-        }));
+    // When running as MCP server, NEVER add console transports as they interfere with the protocol
+    // All output must go through log capture mechanism instead
+    const isMcpServer = process.env.KODRDRIV_MCP_SERVER === 'true';
+    if (isMcpServer) {
+        // In MCP mode, add a silent Memory transport to prevent winston from logging transport errors
+        // Winston complains when there are no transports, so we add a silent one
+        // The log capture transport will be added separately via installLogCapture
+        // Use a no-op stream that discards all output
+        const silentStream = new Writable({
+            write (_chunk, _encoding, callback) {
+                // Silent - discard all output, log capture handles actual logging
+                callback();
+            },
+            // Suppress any errors from the stream itself
+            destroy: function(_err, callback) {
+                callback();
+            }
+        });
+        // Suppress winston transport errors by catching them
+        const silentTransport = new winston.transports.Stream({
+            stream: silentStream,
+            silent: true
+        });
+        // Override error handling on the transport to prevent winston from logging to stderr
+        silentTransport.on('error', ()=>{
+        // Silently ignore transport errors - don't output to stderr
+        });
+        transports.push(silentTransport);
     } 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, dryRun, ...meta })=>{
-                // For info level messages, use simpler format without timestamp
-                if (level.includes('info')) {
+        // Add console transport for info level and above (only when NOT in MCP mode)
+        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: ' : '';
-                    return `${dryRunPrefix}${String(message)}`;
-                }
-                // Filter out winston internal metadata
-                const filteredMeta = Object.keys(meta).reduce((acc, key)=>{
-                    if (![
-                        'level',
-                        'message',
-                        'timestamp',
-                        'dryRun',
-                        'service',
-                        'splat',
-                        'Symbol(level)',
-                        'Symbol(message)'
-                    ].includes(key)) {
-                        acc[key] = meta[key];
+                    // For info level messages, don't show the level prefix
+                    if (level.includes('info')) {
+                        return `${dryRunPrefix}${String(message)}`;
                     }
-                    return acc;
-                }, {});
-                const metaStr = Object.keys(filteredMeta).length ? ` ${JSON.stringify(filteredMeta, null, 2)}` : '';
-                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__default.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, service, ...meta })=>{
-                    // Filter out winston internal metadata and properly format remaining meta
+                    // 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',
+                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)}`;
+                    }
+                    // Filter out winston internal metadata
                     const filteredMeta = Object.keys(meta).reduce((acc, key)=>{
-                        // Skip internal winston fields
                         if (![
                             'level',
                             'message',
                             'timestamp',
+                            'dryRun',
+                            'service',
                             'splat',
                             'Symbol(level)',
                             'Symbol(message)'
@@ -502,12 +503,45 @@ const createTransports = (level)=>{
                         return acc;
                     }, {});
                     const metaStr = Object.keys(filteredMeta).length ? ` ${JSON.stringify(filteredMeta, null, 2)}` : '';
-                    const serviceStr = service ? ` [${service}]` : '';
-                    return `${timestamp}${serviceStr} ${level}: ${message}${metaStr}`;
+                    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__default.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, service, ...meta })=>{
+                // Filter out winston internal metadata and properly format remaining meta
+                const filteredMeta = Object.keys(meta).reduce((acc, key)=>{
+                    // Skip internal winston fields
+                    if (![
+                        'level',
+                        'message',
+                        'timestamp',
+                        'splat',
+                        'Symbol(level)',
+                        'Symbol(message)'
+                    ].includes(key)) {
+                        acc[key] = meta[key];
+                    }
+                    return acc;
+                }, {});
+                const metaStr = Object.keys(filteredMeta).length ? ` ${JSON.stringify(filteredMeta, null, 2)}` : '';
+                const serviceStr = service ? ` [${service}]` : '';
+                return `${timestamp}${serviceStr} ${level}: ${message}${metaStr}`;
+            }))
+        }));
+    }
     return transports;
 };
 const createFormat = (level)=>{
@@ -557,17 +591,30 @@ const logger = winston.createLogger({
     defaultMeta: {
         service: PROGRAM_NAME
     },
-    transports: createTransports('info')
+    transports: createTransports('info'),
+    // Suppress winston's own error handling in MCP mode to prevent stderr pollution
+    exceptionHandlers: process.env.KODRDRIV_MCP_SERVER === 'true' ? [] : undefined,
+    rejectionHandlers: process.env.KODRDRIV_MCP_SERVER === 'true' ? [] : undefined,
+    // Prevent winston from logging transport errors to stderr
+    handleExceptions: false,
+    handleRejections: false
 });
 const setLogLevel = (level)=>{
     // Reconfigure the existing logger instead of creating a new one
+    const isMcpServer = process.env.KODRDRIV_MCP_SERVER === 'true';
     logger.configure({
         level,
         format: createFormat(level),
         defaultMeta: {
             service: PROGRAM_NAME
         },
-        transports: createTransports(level)
+        transports: createTransports(level),
+        // Suppress winston's own error handling in MCP mode to prevent stderr pollution
+        exceptionHandlers: isMcpServer ? [] : undefined,
+        rejectionHandlers: isMcpServer ? [] : undefined,
+        // Prevent winston from logging transport errors to stderr
+        handleExceptions: false,
+        handleRejections: false
     });
 };
 const getLogger = ()=>logger;
@@ -1840,7 +1887,7 @@ const interactive = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.definePropert
     return Boolean(config.enabled !== false && hasFilters);
 }
 
-function _define_property$1(obj, key, value) {
+function _define_property$4(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -1945,13 +1992,13 @@ function _define_property$1(obj, key, value) {
         return this.lockAcquired;
     }
     constructor(lockPath){
-        _define_property$1(this, "lockPath", void 0);
-        _define_property$1(this, "lockAcquired", false);
-        _define_property$1(this, "maxRetries", 100); // Maximum number of lock attempts
-        _define_property$1(this, "retryDelay", 100); // Initial retry delay in ms
-        _define_property$1(this, "maxRetryDelay", 2000); // Maximum retry delay in ms
-        _define_property$1(this, "lockTimeout", 30000); // Consider lock stale after 30 seconds
-        _define_property$1(this, "logger", getLogger());
+        _define_property$4(this, "lockPath", void 0);
+        _define_property$4(this, "lockAcquired", false);
+        _define_property$4(this, "maxRetries", 100); // Maximum number of lock attempts
+        _define_property$4(this, "retryDelay", 100); // Initial retry delay in ms
+        _define_property$4(this, "maxRetryDelay", 2000); // Maximum retry delay in ms
+        _define_property$4(this, "lockTimeout", 30000); // Consider lock stale after 30 seconds
+        _define_property$4(this, "logger", getLogger());
         this.lockPath = lockPath;
     }
 }
@@ -2067,13 +2114,13 @@ function _define_property$1(obj, key, value) {
         this.locks.clear();
     }
     constructor(){
-        _define_property$1(this, "locks", new Map());
-        _define_property$1(this, "logger", getLogger());
-        _define_property$1(this, "cleanupRegistered", false);
+        _define_property$4(this, "locks", new Map());
+        _define_property$4(this, "logger", getLogger());
+        _define_property$4(this, "cleanupRegistered", false);
     }
 }
 
-function _define_property(obj, key, value) {
+function _define_property$3(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -2114,8 +2161,8 @@ function _define_property(obj, key, value) {
         this.lockManager.destroy();
     }
     constructor(){
-        _define_property(this, "lockManager", void 0);
-        _define_property(this, "logger", getLogger());
+        _define_property$3(this, "lockManager", void 0);
+        _define_property$3(this, "logger", getLogger());
         this.lockManager = new RepositoryFileLockManager();
     }
 }
@@ -2383,9 +2430,11 @@ let globalGitMutexManager = null;
     // Truncate if too long
     if (sanitized.length > maxLength) {
         const truncated = sanitized.substring(0, maxLength - 3) + '...';
-        // Log truncation for debugging
-        // eslint-disable-next-line no-console
-        console.warn(`Direction truncated from ${sanitized.length} to ${truncated.length} characters`);
+        // Log truncation for debugging (only if not in MCP server mode)
+        if (process.env.KODRDRIV_MCP_SERVER !== 'true') {
+            // eslint-disable-next-line no-console
+            console.warn(`Direction truncated from ${sanitized.length} to ${truncated.length} characters`);
+        }
         return truncated;
     }
     return sanitized;
@@ -2465,6 +2514,104 @@ let globalGitMutexManager = null;
         warnings
     });
 
+/**
+ * Progress tracking for long-running operations
+ *
+ * Provides structured progress updates for MCP integrations
+ */ function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class ProgressTracker {
+    /**
+     * Set the total number of items
+     */ setTotal(total) {
+        this.total = total;
+    }
+    /**
+     * Start a new step
+     */ startStep(stepName) {
+        this.currentStep = stepName;
+    }
+    /**
+     * Complete the current step
+     */ completeStep() {
+        if (this.currentStep) {
+            this.completedSteps.push(this.currentStep);
+            this.current++;
+        }
+    }
+    /**
+     * Set remaining packages
+     */ setRemainingPackages(packages) {
+        this.remainingPackages = packages;
+    }
+    /**
+     * Get current progress
+     */ getProgress() {
+        return {
+            current: this.current,
+            total: this.total,
+            currentStep: this.currentStep,
+            completedSteps: [
+                ...this.completedSteps
+            ],
+            remainingPackages: [
+                ...this.remainingPackages
+            ],
+            percentage: this.total > 0 ? Math.round(this.current / this.total * 100) : 0
+        };
+    }
+    /**
+     * Reset progress
+     */ reset() {
+        this.completedSteps = [];
+        this.currentStep = '';
+        this.current = 0;
+        this.remainingPackages = [];
+    }
+    /**
+     * Create a progress update for a package execution
+     */ static forPackage(packageName, index, total, completedPackages, remainingPackages) {
+        return {
+            current: index,
+            total: total,
+            currentStep: `Processing: ${packageName}`,
+            completedSteps: completedPackages.map((pkg)=>`Completed: ${pkg}`),
+            remainingPackages: remainingPackages,
+            percentage: total > 0 ? Math.round(index / total * 100) : 0
+        };
+    }
+    /**
+     * Create a progress update for a build phase
+     */ static forPhase(phase, completedPhases, totalPhases) {
+        return {
+            current: completedPhases.length,
+            total: totalPhases,
+            currentStep: phase,
+            completedSteps: completedPhases,
+            percentage: totalPhases > 0 ? Math.round(completedPhases.length / totalPhases * 100) : 0
+        };
+    }
+    constructor(total = 0){
+        _define_property$2(this, "completedSteps", []);
+        _define_property$2(this, "currentStep", '');
+        _define_property$2(this, "current", 0);
+        _define_property$2(this, "total", 0);
+        _define_property$2(this, "remainingPackages", []);
+        this.total = total;
+    }
+}
+
 const ConfigSchema = z.object({
     dryRun: z.boolean().optional(),
     verbose: z.boolean().optional(),
@@ -2542,6 +2689,7 @@ const ConfigSchema = z.object({
         noMilestones: z.boolean().optional(),
         fromMain: z.boolean().optional(),
         currentBranch: z.string().optional(),
+        version: z.string().optional(),
         // Agentic options (always enabled)
         maxAgenticIterations: z.number().optional(),
         selfReflection: z.boolean().optional()
@@ -2594,6 +2742,9 @@ const ConfigSchema = z.object({
         ]).optional(),
         openaiMaxOutputTokens: z.number().optional()
     }).optional(),
+    precommit: z.object({
+        fix: z.boolean().optional()
+    }).optional(),
     publish: z.object({
         mergeMethod: z.enum([
             'merge',
@@ -2623,7 +2774,8 @@ const ConfigSchema = z.object({
         skipPrePublishMerge: z.boolean().optional(),
         updateDeps: z.string().optional(),
         agenticPublish: z.boolean().optional(),
-        agenticPublishMaxIterations: z.number().optional()
+        agenticPublishMaxIterations: z.number().optional(),
+        skipLinkCleanup: z.boolean().optional()
     }).optional(),
     branches: z.record(z.string(), z.object({
         targetBranch: z.string().optional(),
@@ -2669,6 +2821,7 @@ const ConfigSchema = z.object({
         packageArgument: z.string().optional(),
         cleanNodeModules: z.boolean().optional(),
         externals: z.array(z.string()).optional(),
+        fix: z.boolean().optional(),
         // Parallel execution options
         parallel: z.boolean().optional(),
         maxConcurrency: z.number().optional(),
@@ -2704,7 +2857,8 @@ const ConfigSchema = z.object({
         resetPackage: z.string().optional(),
         statusParallel: z.boolean().optional(),
         auditBranches: z.boolean().optional(),
-        validateState: z.boolean().optional()
+        validateState: z.boolean().optional(),
+        order: z.boolean().optional()
     }).optional(),
     development: z.object({
         targetVersion: z.string().optional(),
@@ -2758,5 +2912,316 @@ const CommandConfigSchema = z.object({
     commandName: z.string().optional()
 });
 
-export { ALLOWED_COMMANDS, COMMAND_AUDIO_COMMIT, COMMAND_AUDIO_REVIEW, COMMAND_CHECK_CONFIG, COMMAND_CLEAN, COMMAND_COMMIT, COMMAND_DEVELOPMENT, COMMAND_INIT_CONFIG, COMMAND_LINK, COMMAND_PRECOMMIT, COMMAND_PUBLISH, COMMAND_RELEASE, COMMAND_REVIEW, COMMAND_SELECT_AUDIO, COMMAND_TREE, COMMAND_UNLINK, COMMAND_UPDATES, COMMAND_VERSIONS, CommandConfigSchema, ConfigSchema, DATE_FORMAT_DAY, DATE_FORMAT_HOURS, DATE_FORMAT_MILLISECONDS, DATE_FORMAT_MINUTES, DATE_FORMAT_MONTH, DATE_FORMAT_MONTH_DAY, DATE_FORMAT_SECONDS, DATE_FORMAT_SHORT_TIMESTAMP, DATE_FORMAT_YEAR, DATE_FORMAT_YEAR_MONTH, DATE_FORMAT_YEAR_MONTH_DAY, DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES, DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS, DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS, DATE_FORMAT_YEAR_MONTH_DAY_SLASH, DEFAULT_ADD, DEFAULT_AMEND_MODE, DEFAULT_BINARY_TO_TEXT_ENCODING, DEFAULT_CACHED, DEFAULT_CHARACTER_ENCODING, DEFAULT_COMMAND, DEFAULT_CONFIG_DIR, DEFAULT_CONTEXT_DIRECTORIES, DEFAULT_DEBUG, DEFAULT_DIFF, DEFAULT_DIRECTORY_PREFIX, DEFAULT_DRY_RUN, DEFAULT_EXCLUDED_PATTERNS, DEFAULT_FROM_COMMIT_ALIAS, DEFAULT_GIT_COMMAND_MAX_BUFFER, DEFAULT_IGNORE_PATTERNS, DEFAULT_INSTRUCTIONS_COMMIT_FILE, DEFAULT_INSTRUCTIONS_DIR, DEFAULT_INSTRUCTIONS_MAP, DEFAULT_INSTRUCTIONS_RELEASE_FILE, DEFAULT_INSTRUCTIONS_REVIEW_FILE, DEFAULT_INTERACTIVE_MODE, DEFAULT_LOG, DEFAULT_MAX_DIFF_BYTES, DEFAULT_MERGE_METHOD, DEFAULT_MESSAGE_LIMIT, DEFAULT_MODEL, DEFAULT_MODEL_STRONG, DEFAULT_OPENAI_MAX_OUTPUT_TOKENS, DEFAULT_OPENAI_REASONING, DEFAULT_OUTPUT_DIRECTORY, DEFAULT_OVERRIDES, DEFAULT_PATH_SEPARATOR, DEFAULT_PERSONA_DIR, DEFAULT_PERSONA_MAP, DEFAULT_PERSONA_RELEASER_FILE, DEFAULT_PERSONA_YOU_FILE, DEFAULT_PREFERENCES_DIRECTORY, DEFAULT_SENDIT_MODE, DEFAULT_TO_COMMIT_ALIAS, DEFAULT_VERBOSE, diff as Diff, FileLock, files as Files, INTERNAL_DATETIME_FORMAT, INTERNAL_DEFAULT_OUTPUT_FILE, KODRDRIV_DEFAULTS, log as Log, PROGRAM_NAME, RepositoryFileLockManager, RepositoryMutexManager, SecureConfigSchema, VERSION, areInSameRepository, calculateBranchDependentVersion, checkIfTagExists, confirmVersionInteractively, createErrorResult, createLoggerAdapter, createStorageAdapter, createSuccessResult, destroyGitMutexManager, executeWithErrorHandling, filterContent, findDevelopmentBranch, getDryRunLogger, getExpectedVersionPattern, getGitMutexManager, getGitRepositoryRoot, getLogger, getNpmPublishedVersion, getOutputPath, getTagInfo, getTimestampedArchivedAudioFilename, getTimestampedArchivedTranscriptFilename, getTimestampedAudioFilename, getTimestampedCommitFilename, getTimestampedFilename, getTimestampedReleaseNotesFilename, getTimestampedRequestFilename, getTimestampedResponseFilename, getTimestampedReviewFilename, getTimestampedReviewNotesFilename, getTimestampedTranscriptFilename, getVersionFromBranch, handleCommandError, haveSamePrereleaseTag, improveContentWithLLM, isDevelopmentVersion, isInGitRepository, isReleaseVersion, isStopContextEnabled, isVersionPublishedOnNpm, runGitWithLock, sanitizeDirection, setLogLevel, toAIConfig, validateReleaseSummary, validateTranscriptionResult, validateVersionForBranch };
+/**
+ * Structured error types for kodrdriv operations
+ *
+ * These errors provide detailed context for MCP integrations and AI agents
+ * to understand failures and provide actionable recovery steps.
+ */ function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Base error class for all kodrdriv operations
+ */ class KodrdrivError extends Error {
+    constructor(message, context, recoverable = true){
+        super(message), _define_property$1(this, "context", void 0), _define_property$1(this, "recoverable", void 0), this.context = context, this.recoverable = recoverable;
+        this.name = 'KodrdrivError';
+        // Capture stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+/**
+ * Error specific to publish operations
+ */ class PublishError extends KodrdrivError {
+    constructor(message, context){
+        super(message, {
+            ...context,
+            operation: 'publish'
+        });
+        this.name = 'PublishError';
+    }
+}
+/**
+ * Error specific to tree operations (monorepo orchestration)
+ */ class TreeExecutionError extends KodrdrivError {
+    constructor(message, context, failedPackages = [], completedPackages = [], checkpointPath){
+        super(message, {
+            ...context,
+            operation: 'tree'
+        }), _define_property$1(this, "failedPackages", void 0), _define_property$1(this, "completedPackages", void 0), _define_property$1(this, "checkpointPath", void 0), this.failedPackages = failedPackages, this.completedPackages = completedPackages, this.checkpointPath = checkpointPath;
+        this.name = 'TreeExecutionError';
+    }
+}
+/**
+ * Error for validation failures (pre-flight checks)
+ */ class ValidationError extends KodrdrivError {
+    constructor(message, context, validationErrors = [], validationWarnings = []){
+        super(message, {
+            ...context,
+            operation: 'validation'
+        }, false), _define_property$1(this, "validationErrors", void 0), _define_property$1(this, "validationWarnings", void 0), this.validationErrors = validationErrors, this.validationWarnings = validationWarnings;
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * Error for workspace structure issues
+ */ class WorkspaceError extends KodrdrivError {
+    constructor(message, context, expectedStructure){
+        super(message, {
+            ...context,
+            operation: 'workspace'
+        }, false), _define_property$1(this, "expectedStructure", void 0), this.expectedStructure = expectedStructure;
+        this.name = 'WorkspaceError';
+    }
+}
+/**
+ * Format error for MCP tool responses
+ */ function formatErrorForMCP(error) {
+    // Handle TreeExecutionError
+    if (error instanceof TreeExecutionError) {
+        const recovery = [];
+        if (error.failedPackages.length > 0) {
+            recovery.push(`Fix the issue in: ${error.failedPackages.join(', ')}`);
+        }
+        if (error.checkpointPath) {
+            recovery.push(`Then resume with: kodrdriv tree_publish --continue`);
+            recovery.push(`Or via MCP: kodrdriv_tree_publish({directory: "...", continue: true})`);
+        }
+        return {
+            message: error.message,
+            context: {
+                ...error.context,
+                failedPackages: error.failedPackages,
+                completedPackages: error.completedPackages,
+                checkpointPath: error.checkpointPath,
+                recoverable: error.recoverable
+            },
+            recovery: recovery.length > 0 ? recovery : undefined
+        };
+    }
+    // Handle ValidationError
+    if (error instanceof ValidationError) {
+        const recovery = [];
+        if (error.validationErrors.length > 0) {
+            recovery.push('Fix the following validation errors:');
+            error.validationErrors.forEach((err, idx)=>{
+                recovery.push(`  ${idx + 1}. ${err.check}: ${err.message}`);
+                if (err.files && err.files.length > 0) {
+                    recovery.push(`     Files: ${err.files.join(', ')}`);
+                }
+            });
+        }
+        return {
+            message: error.message,
+            context: {
+                ...error.context,
+                validationErrors: error.validationErrors,
+                validationWarnings: error.validationWarnings,
+                recoverable: error.recoverable
+            },
+            recovery: recovery.length > 0 ? recovery : undefined
+        };
+    }
+    // Handle PublishError
+    if (error instanceof PublishError) {
+        const recovery = [];
+        if (error.context.phase) {
+            recovery.push(`Failed during: ${error.context.phase}`);
+        }
+        if (error.context.files && error.context.files.length > 0) {
+            recovery.push(`Check these files: ${error.context.files.join(', ')}`);
+        }
+        if (error.context.command) {
+            recovery.push(`Failed command: ${error.context.command}`);
+            if (error.context.exitCode) {
+                recovery.push(`Exit code: ${error.context.exitCode}`);
+            }
+        }
+        return {
+            message: error.message,
+            context: {
+                ...error.context,
+                recoverable: error.recoverable
+            },
+            recovery: recovery.length > 0 ? recovery : undefined
+        };
+    }
+    // Handle WorkspaceError
+    if (error instanceof WorkspaceError) {
+        const recovery = [];
+        if (error.expectedStructure) {
+            recovery.push(`Expected structure: ${error.expectedStructure}`);
+        }
+        if (error.context.files && error.context.files.length > 0) {
+            recovery.push(`Missing or invalid files: ${error.context.files.join(', ')}`);
+        }
+        return {
+            message: error.message,
+            context: {
+                ...error.context,
+                expectedStructure: error.expectedStructure,
+                recoverable: error.recoverable
+            },
+            recovery: recovery.length > 0 ? recovery : undefined
+        };
+    }
+    // Handle generic KodrdrivError
+    if (error instanceof KodrdrivError) {
+        return {
+            message: error.message,
+            context: {
+                ...error.context,
+                recoverable: error.recoverable
+            }
+        };
+    }
+    // Handle generic Error
+    return {
+        message: error.message || 'Unknown error occurred',
+        context: {
+            name: error.name,
+            stack: error.stack
+        }
+    };
+}
+/**
+ * Extract error details from command execution errors
+ */ function extractCommandErrorDetails(error) {
+    const context = {};
+    // Extract stdout/stderr from various error formats
+    if (error.stdout) {
+        context.stdout = typeof error.stdout === 'string' ? error.stdout : String(error.stdout);
+    }
+    if (error.stderr) {
+        context.stderr = typeof error.stderr === 'string' ? error.stderr : String(error.stderr);
+    }
+    // Extract exit code
+    if (error.code !== undefined) {
+        context.exitCode = error.code;
+    } else if (error.exitCode !== undefined) {
+        context.exitCode = error.exitCode;
+    }
+    // Extract command if available
+    if (error.cmd) {
+        context.command = error.cmd;
+    } else if (error.command) {
+        context.command = error.command;
+    }
+    return context;
+}
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class TransactionLog {
+    /**
+     * Record an operation with its rollback function
+     */ async record(type, details, rollback) {
+        this.operations.push({
+            type,
+            timestamp: new Date(),
+            details,
+            rollback
+        });
+        this.logger.debug(`TRANSACTION_RECORDED: ${type} | Details: ${JSON.stringify(details)}`);
+    }
+    /**
+     * Roll back all operations in reverse order
+     */ async rollbackAll() {
+        this.logger.info('TRANSACTION_ROLLBACK_STARTING: Rolling back operations | Count: ' + this.operations.length);
+        const errors = [];
+        // Rollback in reverse order (LIFO)
+        for(let i = this.operations.length - 1; i >= 0; i--){
+            const op = this.operations[i];
+            try {
+                this.logger.info(`TRANSACTION_ROLLBACK: Rolling back ${op.type} | Timestamp: ${op.timestamp.toISOString()}`);
+                await op.rollback();
+                this.logger.info(`TRANSACTION_ROLLBACK_SUCCESS: ${op.type} rolled back successfully`);
+            } catch (error) {
+                this.logger.error(`TRANSACTION_ROLLBACK_FAILED: Failed to rollback ${op.type} | Error: ${error.message}`);
+                errors.push(error);
+            // Continue rolling back other operations even if one fails
+            }
+        }
+        if (errors.length > 0) {
+            this.logger.error(`TRANSACTION_ROLLBACK_PARTIAL: ${errors.length} rollback operation(s) failed`);
+            throw new Error(`Rollback completed with ${errors.length} error(s). See logs for details.`);
+        }
+        this.logger.info('TRANSACTION_ROLLBACK_COMPLETE: All operations rolled back successfully');
+        this.operations = [];
+    }
+    /**
+     * Clear the transaction log without rolling back
+     */ clear() {
+        this.operations = [];
+        this.logger.debug('TRANSACTION_LOG_CLEARED: Transaction log cleared');
+    }
+    /**
+     * Get the number of recorded operations
+     */ get count() {
+        return this.operations.length;
+    }
+    /**
+     * Get all operations
+     */ getOperations() {
+        return [
+            ...this.operations
+        ];
+    }
+    /**
+     * Check if there are any recorded operations
+     */ hasOperations() {
+        return this.operations.length > 0;
+    }
+    constructor(){
+        _define_property(this, "operations", []);
+        _define_property(this, "logger", getLogger());
+    }
+}
+/**
+ * Create a no-op rollback function for operations that can't be rolled back
+ */ function noopRollback() {
+    return Promise.resolve();
+}
+/**
+ * Helper to create a file restore rollback
+ */ function createFileRestoreRollback(filePath, originalContent) {
+    return async ()=>{
+        const { createStorage } = await import('@eldrforge/shared');
+        const storage = createStorage();
+        await storage.writeFile(filePath, originalContent, 'utf-8');
+    };
+}
+/**
+ * Helper to create a git command rollback
+ */ function createGitRollback(command) {
+    return async ()=>{
+        const { run } = await import('@eldrforge/git-tools');
+        await run(command);
+    };
+}
+
+export { ALLOWED_COMMANDS, COMMAND_AUDIO_COMMIT, COMMAND_AUDIO_REVIEW, COMMAND_CHECK_CONFIG, COMMAND_CLEAN, COMMAND_COMMIT, COMMAND_DEVELOPMENT, COMMAND_INIT_CONFIG, COMMAND_LINK, COMMAND_PRECOMMIT, COMMAND_PUBLISH, COMMAND_RELEASE, COMMAND_REVIEW, COMMAND_SELECT_AUDIO, COMMAND_TREE, COMMAND_UNLINK, COMMAND_UPDATES, COMMAND_VERSIONS, CommandConfigSchema, ConfigSchema, DATE_FORMAT_DAY, DATE_FORMAT_HOURS, DATE_FORMAT_MILLISECONDS, DATE_FORMAT_MINUTES, DATE_FORMAT_MONTH, DATE_FORMAT_MONTH_DAY, DATE_FORMAT_SECONDS, DATE_FORMAT_SHORT_TIMESTAMP, DATE_FORMAT_YEAR, DATE_FORMAT_YEAR_MONTH, DATE_FORMAT_YEAR_MONTH_DAY, DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES, DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS, DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS_MILLISECONDS, DATE_FORMAT_YEAR_MONTH_DAY_SLASH, DEFAULT_ADD, DEFAULT_AMEND_MODE, DEFAULT_BINARY_TO_TEXT_ENCODING, DEFAULT_CACHED, DEFAULT_CHARACTER_ENCODING, DEFAULT_COMMAND, DEFAULT_CONFIG_DIR, DEFAULT_CONTEXT_DIRECTORIES, DEFAULT_DEBUG, DEFAULT_DIFF, DEFAULT_DIRECTORY_PREFIX, DEFAULT_DRY_RUN, DEFAULT_EXCLUDED_PATTERNS, DEFAULT_FROM_COMMIT_ALIAS, DEFAULT_GIT_COMMAND_MAX_BUFFER, DEFAULT_IGNORE_PATTERNS, DEFAULT_INSTRUCTIONS_COMMIT_FILE, DEFAULT_INSTRUCTIONS_DIR, DEFAULT_INSTRUCTIONS_MAP, DEFAULT_INSTRUCTIONS_RELEASE_FILE, DEFAULT_INSTRUCTIONS_REVIEW_FILE, DEFAULT_INTERACTIVE_MODE, DEFAULT_LOG, DEFAULT_MAX_DIFF_BYTES, DEFAULT_MERGE_METHOD, DEFAULT_MESSAGE_LIMIT, DEFAULT_MODEL, DEFAULT_MODEL_STRONG, DEFAULT_OPENAI_MAX_OUTPUT_TOKENS, DEFAULT_OPENAI_REASONING, DEFAULT_OUTPUT_DIRECTORY, DEFAULT_OVERRIDES, DEFAULT_PATH_SEPARATOR, DEFAULT_PERSONA_DIR, DEFAULT_PERSONA_MAP, DEFAULT_PERSONA_RELEASER_FILE, DEFAULT_PERSONA_YOU_FILE, DEFAULT_PREFERENCES_DIRECTORY, DEFAULT_SENDIT_MODE, DEFAULT_TO_COMMIT_ALIAS, DEFAULT_VERBOSE, diff as Diff, FileLock, files as Files, INTERNAL_DATETIME_FORMAT, INTERNAL_DEFAULT_OUTPUT_FILE, KODRDRIV_DEFAULTS, KodrdrivError, log as Log, PROGRAM_NAME, ProgressTracker, PublishError, RepositoryFileLockManager, RepositoryMutexManager, SecureConfigSchema, TransactionLog, TreeExecutionError, VERSION, ValidationError, WorkspaceError, areInSameRepository, calculateBranchDependentVersion, checkIfTagExists, confirmVersionInteractively, createErrorResult, createFileRestoreRollback, createGitRollback, createLoggerAdapter, createStorageAdapter, createSuccessResult, destroyGitMutexManager, executeWithErrorHandling, extractCommandErrorDetails, filterContent, findDevelopmentBranch, formatErrorForMCP, getDryRunLogger, getExpectedVersionPattern, getGitMutexManager, getGitRepositoryRoot, getLogger, getNpmPublishedVersion, getOutputPath, getTagInfo, getTimestampedArchivedAudioFilename, getTimestampedArchivedTranscriptFilename, getTimestampedAudioFilename, getTimestampedCommitFilename, getTimestampedFilename, getTimestampedReleaseNotesFilename, getTimestampedRequestFilename, getTimestampedResponseFilename, getTimestampedReviewFilename, getTimestampedReviewNotesFilename, getTimestampedTranscriptFilename, getVersionFromBranch, handleCommandError, haveSamePrereleaseTag, improveContentWithLLM, isDevelopmentVersion, isInGitRepository, isReleaseVersion, isStopContextEnabled, isVersionPublishedOnNpm, noopRollback, runGitWithLock, sanitizeDirection, setLogLevel, toAIConfig, validateReleaseSummary, validateTranscriptionResult, validateVersionForBranch };
 //# sourceMappingURL=index.js.map