core

type AutoRebaseDecision struct {
	Decision         string   `json:"decision"`          // "auto-rebase", "manual", "skip", "abort"
	Details          string   `json:"details"`           // Additional details about the decision
	ExcludedBranches []string `json:"excluded_branches"` // Branches to exclude from auto-rebase
	BackupStrategy   string   `json:"backup_strategy"`   // "always", "on-conflict", "never"
}

type AutoRebaseEngine struct {
	// contains filtered or unexported fields
}

type AutoRebaseLogger interface {
	LogStart(plan *RebasePlan, opts AutoRebaseOptions)
	LogStep(step *RebaseStep, stepNumber int, totalSteps int)
	LogStepResult(result *RebaseStepResult, stepNumber int, totalSteps int)
	LogConflict(branch string, conflicts []string)
	LogResolution(branch string, resolution string)
	LogCompletion(result *AutoRebaseResult)
	LogError(operation string, branch string, err error)
}

type AutoRebaseOptions struct {
	DryRun             bool     `json:"dry_run"`
	Interactive        bool     `json:"interactive"`
	ForceRebase        bool     `json:"force_rebase"`
	BackupBeforeRebase bool     `json:"backup_before_rebase"`
	ContinueOnError    bool     `json:"continue_on_error"`
	MaxRetries         int      `json:"max_retries"`
	ExcludedBranches   []string `json:"excluded_branches"`
	Verbose            bool     `json:"verbose"`
	Quiet              bool     `json:"quiet"`
}

type AutoRebaseRecoveryState struct {
	TotalBranches     int                             `json:"total_branches"`
	CompletedBranches int                             `json:"completed_branches"`
	FailedBranches    int                             `json:"failed_branches"`
	SkippedBranches   int                             `json:"skipped_branches"`
	CurrentBranch     string                          `json:"current_branch,omitempty"`
	BranchStates      map[string]*BranchRecoveryState `json:"branch_states"`
	BackupBranches    []string                        `json:"backup_branches"`
}

type AutoRebaseResult struct {
	Success         bool               `json:"success"`
	TotalSteps      int                `json:"total_steps"`
	CompletedSteps  int                `json:"completed_steps"`
	FailedSteps     int                `json:"failed_steps"`
	SkippedSteps    int                `json:"skipped_steps"`
	StartTime       string             `json:"start_time"`
	EndTime         string             `json:"end_time"`
	Duration        string             `json:"duration"`
	StepResults     []RebaseStepResult `json:"step_results"`
	Summary         AutoRebaseSummary  `json:"summary"`
	BackupsCreated  []string           `json:"backups_created"`
	Recommendations []string           `json:"recommendations"`
}

type AutoRebaseSummary struct {
	BranchesProcessed  int     `json:"branches_processed"`
	BranchesRebased    int     `json:"branches_rebased"`
	BranchesFailed     int     `json:"branches_failed"`
	BranchesSkipped    int     `json:"branches_skipped"`
	ConflictsResolved  int     `json:"conflicts_resolved"`
	ConflictsRemaining int     `json:"conflicts_remaining"`
	TotalCommits       int     `json:"total_commits"`
	SuccessRate        float64 `json:"success_rate"`
	OverallStatus      string  `json:"overall_status"` // "success", "partial_success", "failed"
}

type BranchDependency struct {
	Source       string            `json:"source"`       // The branch being depended on
	Dependent    string            `json:"dependent"`    // The branch that depends on source
	Relationship string            `json:"relationship"` // Type of relationship: "direct", "indirect", "environment"
	Distance     int               `json:"distance"`     // Number of hops in dependency graph
	Conflicts    []MergeConflict   `json:"conflicts"`    // Potential merge conflicts
	Metadata     map[string]string `json:"metadata"`     // Additional dependency metadata
}

type BranchInfo struct {
	Name          string `json:"name"`
	CommitHash    string `json:"commit_hash"`
	CommitDate    string `json:"commit_date"`
	Author        string `json:"author"`
	Message       string `json:"message"`
	FileCount     int    `json:"file_count"`
	Additions     int    `json:"additions"`
	Deletions     int    `json:"deletions"`
	IsEnvironment bool   `json:"is_environment"`
}

type BranchProcessor interface {
	// ProcessBranches executes the core branch processing algorithm
	// This is the main method that both rebuild and release will use
	ProcessBranches(source string, target string, branches []string, opts ProcessOptions) error

	// GetFeaturesInEnvironment returns the list of features in an environment
	GetFeaturesInEnvironment(env string) []string

	// LockTarget acquires a lock on the target branch/environment
	LockTarget(target string, opts ProcessOptions) error

	// UnlockTarget releases a lock on the target branch/environment
	UnlockTarget(target string, opts ProcessOptions) error

	// CreateTempBranch creates a temporary branch for safe operations
	CreateTempBranch(name, base string, opts ProcessOptions) (string, error)

	// CleanupTempBranch removes a temporary branch
	CleanupTempBranch(name string, opts ProcessOptions) error

	// SwapToTarget atomically swaps temp branch to become the target
	SwapToTarget(tempBranch, target string, opts ProcessOptions) error

	// ProcessBranch handles processing of a single branch
	ProcessBranch(branch, tempBranch string, opts ProcessOptions) error

	// HandleBranchFailure handles failures during branch processing
	HandleBranchFailure(branch string, err error, opts ProcessOptions) error

	// UpdateMetadata updates metadata after processing
	UpdateMetadata(source, target string, branches []string, opts ProcessOptions) error

	// ValidatePreconditions validates that processing can proceed
	ValidatePreconditions(source, target string, branches []string, opts ProcessOptions) error
}

type BranchRecoveryState struct {
	BranchName     string `json:"branch_name"`
	OriginalCommit string `json:"original_commit"`
	CurrentCommit  string `json:"current_commit"`
	Status         string `json:"status"` // "pending", "in_progress", "completed", "failed", "rolled_back"
	BackupBranch   string `json:"backup_branch,omitempty"`
	FailedStep     string `json:"failed_step,omitempty"`
	FailureReason  string `json:"failure_reason,omitempty"`
	LastError      string `json:"last_error,omitempty"`
	LastUpdate     string `json:"last_update"`
}

type BranchResult struct {
	Branch      string    // Branch name
	Success     bool      // Whether processing succeeded
	StartedAt   time.Time // When processing started
	CompletedAt time.Time // When processing completed
	Duration    time.Time // How long processing took
	Error       error     // Error if processing failed
	Conflicts   []string  // Conflicts that were encountered and resolved
	Commits     int       // Number of commits made
	Messages    []string  // Informational messages
}

type BranchValidator interface {
	ValidatePreconditions(repo *hitchgit.Repo, meta *metadata.Metadata, source, target string, branches []string) error
}

type ConflictResolutionDecision struct {
	Strategy string   `json:"strategy"` // "abort", "skip", "manual", "force"
	Details  string   `json:"details"`
	Actions  []string `json:"actions"`
}

type DefaultBranchProcessor struct {
	// contains filtered or unexported fields
}

type DefaultOperationLogger struct {
	// contains filtered or unexported fields
}

type DefaultPerformanceLogger struct {
	// contains filtered or unexported fields
}

type DependencyAnalysis struct {
	SourceBranch          string             `json:"source_branch"`
	TargetBranch          string             `json:"target_branch"`
	AnalyzedAt            string             `json:"analyzed_at"`
	DirectDependents      []BranchDependency `json:"direct_dependents"`
	IndirectDependents    []BranchDependency `json:"indirect_dependents"`
	EnvironmentDependents []BranchDependency `json:"environment_dependents"`
	TotalDependents       int                `json:"total_dependents"`
	Conflicts             []MergeConflict    `json:"conflicts"`
	Summary               DependencySummary  `json:"summary"`
}

type DependencyAnalyzer struct {
	// contains filtered or unexported fields
}

type DependencySummary struct {
	TotalBranches       int      `json:"total_branches"`
	DirectBranches      int      `json:"direct_branches"`
	IndirectBranches    int      `json:"indirect_branches"`
	EnvironmentBranches int      `json:"environment_branches"`
	HasConflicts        bool     `json:"has_conflicts"`
	ConflictCount       int      `json:"conflict_count"`
	CriticalConflicts   int      `json:"critical_conflicts"`
	RebaseRequired      bool     `json:"rebase_required"`
	RiskLevel           string   `json:"risk_level"` // "low", "medium", "high", "critical"
	Recommendations     []string `json:"recommendations"`
}

type DryRunImpact struct {
	EstimatedDuration string
	AffectedBranches  int
	RiskLevel         string // "low", "medium", "high", "critical"
}

type DryRunSafetyCheck struct {
	Status  string // "✅", "⚠️", "❌"
	Message string
}

type DryRunValidation struct {
	HasWarnings bool
	HasErrors   bool
	Warnings    []string
	Errors      []string
}

type ErrorAnalysis struct {
	CanRecover      bool
	CanRetry        bool
	MaxRetries      int
	RetryDelay      time.Duration
	Severity        string
	Category        errors.ErrorCategory
	Message         string
	UserAction      string
	Recommendations []string
}

type ErrorRecoveryManager struct {
	// contains filtered or unexported fields
}

type ErrorType string

type GlobalRepositoryLock struct {
	// contains filtered or unexported fields
}

type HitchError struct {
	Code        string            `json:"code"`        // Error code for programmatic handling
	Type        ErrorType         `json:"type"`        // Error category
	Message     string            `json:"message"`     // Human-readable message
	Context     map[string]string `json:"context"`     // Additional context
	Suggestions []string          `json:"suggestions"` // Recovery suggestions
	Timestamp   time.Time         `json:"timestamp"`   // When error occurred
	Retryable   bool              `json:"retryable"`   // Whether operation can be retried
	Cause       error             `json:"-"`           // Underlying error (not serialized)
}

type InteractivePromptSystem struct {
	// contains filtered or unexported fields
}

type LockInfo struct {
	ID        string     `json:"id"`
	Target    LockTarget `json:"target"`
	LockedBy  string     `json:"locked_by"`
	LockedAt  time.Time  `json:"locked_at"`
	Reason    string     `json:"reason,omitempty"`
	ExpiresAt time.Time  `json:"expires_at,omitempty"`
	IsStale   bool       `json:"is_stale"`
}

type LockLogger interface {
	LogAcquisition(req LockRequest, result *LockResult)
	LogRelease(target LockTarget, user string, err error)
	LogStaleDetected(target LockTarget, lockInfo *LockInfo)
	LogRecovery(target LockTarget, recovered bool)
}

type LockManager struct {
	// contains filtered or unexported fields
}

type LockManagerStatus struct {
	Enabled          bool                `json:"enabled"`
	TotalLocks       int                 `json:"total_locks"`
	EnvironmentLocks map[string]LockInfo `json:"environment_locks"`
	BranchLocks      map[string]LockInfo `json:"branch_locks"`
}

type LockOperationResult struct {
	Operation  string `json:"operation"` // "acquire", "release"
	Target     string `json:"target"`
	TargetType string `json:"target_type"` // "branch", "environment"
	Success    bool   `json:"success"`
	Error      string `json:"error,omitempty"`
	Timestamp  string `json:"timestamp"`
	Duration   string `json:"duration"`
}

type LockRequest struct {
	Target   LockTarget
	User     string
	Reason   string
	Timeout  time.Duration
	Force    bool
	LockType string // "exclusive" | "shared" (future extension)
}

type LockResult struct {
	Success       bool
	Message       string
	LockAcquired  bool
	WasStale      bool
	RecoveredFrom []string
	LockInfo      *LockInfo
}

type LockTarget struct {
	Type     string // "environment" | "branch"
	Name     string // "qa", "dev", "main", etc.
	FullName string // Full name for logging (e.g., "environment qa", "branch main")
}

type LogLevel int

type Logger interface {
	Trace(message string, args ...interface{})
	Debug(message string, args ...interface{})
	Info(message string, args ...interface{})
	Warn(message string, args ...interface{})
	Error(message string, args ...interface{})
	Fatal(message string, args ...interface{})

	WithError(err error) Logger
	WithContext(key, value string) Logger
	WithFields(fields map[string]interface{}) Logger

	SetOutput(w io.Writer) Logger
	SetLevel(level LogLevel) Logger
}

type LoggingConfig struct {
	Level           LogLevel
	Quiet           bool
	Verbose         bool
	NoColor         bool
	LogFile         string
	EnableCaller    bool
	EnableTimestamp bool
	EnableSystemLog bool
}

type MergeConflict struct {
	Type        string   `json:"type"`        // "file", "directory", "content"
	Path        string   `json:"path"`        // File/directory path
	Description string   `json:"description"` // Human-readable description
	Severity    string   `json:"severity"`    // "low", "medium", "high", "critical"
	Solutions   []string `json:"solutions"`   // Suggested resolutions
}

type OperationLogger interface {
	LogOperationStart(operation, target string, fields map[string]interface{})
	LogOperationSuccess(operation, target string, duration time.Duration, fields map[string]interface{})
	LogOperationFailure(operation, target string, err error, duration time.Duration, fields map[string]interface{})
	LogOperationProgress(operation, target string, progress int, message string)
}

type PerformanceLogger interface {
	LogPerformanceMetric(operation string, metric string, value interface{}, unit string)
	LogSlowOperation(operation string, duration time.Duration, threshold time.Duration)
	LogMemoryUsage(operation string, allocated, total uint64)
}

type PostReleaseValidator struct {
	// contains filtered or unexported fields
}

type PreReleaseValidator struct {
	// contains filtered or unexported fields
}

type ProcessOptions struct {
	// Core operation identification
	OperationType string // "rebuild" | "release" | future operations
	Source        string // Source branch/environment name
	Target        string // Target branch/environment name
	SourceType    string // "hitched_branch" | "feature_branch" | "base_branch"

	// Operation configuration
	DryRun           bool // Simulate without making changes
	Force            bool // Force operation even if locked/in use
	Interactive      bool // Prompt for user decisions during conflicts
	Resume           bool // Resume a previously failed operation
	UpdateDependents bool // Update dependent branches after operation

	// Locking configuration
	LockTimeout time.Duration // How long to wait for locks
	LockReason  string        // Reason for locking
	UserEmail   string        // User email for lock attribution
	UserName    string        // User name for lock attribution

	// Branch processing options
	AutoRebase     bool // Automatically rebase dependent branches
	BackupBranches bool // Create backups before modifying branches
	ContinueOnFail bool // Continue processing other branches if one fails

	// Output and logging
	Verbose     bool // Show detailed processing information
	Quiet       bool // Suppress non-error output
	ColorOutput bool // Use colored output

	// Metadata options
	UpdateMetadata bool   // Update metadata after processing
	CommitMessage  string // Custom commit message for metadata updates

	// Validation options
	SkipValidation bool // Skip pre-flight validation
	StrictMode     bool // Fail on any warnings
}

type ProcessingResult struct {
	// Success information
	Success     bool      // Whether operation succeeded
	CompletedAt time.Time // When operation completed
	Duration    time.Time // Total duration taken

	// Branch processing results
	ProcessedBranches  []string                // Successfully processed
	FailedBranches     []string                // Failed to process
	ConflictedBranches []string                // Had conflicts
	BranchResults      map[string]BranchResult // Detailed results per branch

	// Changes made
	TempBranchCreated string   // Temporary branch that was created
	ChangesCommitted  int      // Number of commits made
	ConflictsResolved int      // Number of conflicts resolved
	BranchesRebased   []string // Branches that were rebased

	// Metadata updates
	MetadataUpdated   bool   // Whether metadata was updated
	MetadataCommitSHA string // SHA of metadata commit
	ReleaseID         string // ID of release (for release operations)

	// Lock information
	LockAcquired bool      // Whether a lock was acquired
	LockReleased bool      // Whether lock was properly released
	LockDuration time.Time // How long lock was held

	// Error information
	Errors            []error  // All errors encountered
	LastError         error    // Last error
	RecoveryAvailable bool     // Whether recovery is possible
	RecoveryActions   []string // Recovery actions available

	// Additional information
	Messages        []string // Informational messages
	Warnings        []string // Warning messages
	DryRun          bool     // Whether this was a dry run
	ResumeAvailable bool     // Whether operation can be resumed
}

type ProcessingState struct {
	// Identification
	OperationID   string    // Unique identifier for this operation
	OperationType string    // Type of operation (rebuild, release, etc.)
	Source        string    // Source branch/environment
	Target        string    // Target branch/environment
	StartTime     time.Time // When the operation started

	// Branch information
	Branches           []string // Branches being processed
	ProcessedBranches  []string // Successfully processed branches
	FailedBranches     []string // Failed to process
	ConflictedBranches []string // Had conflicts during processing

	// Temporary branch management
	TempBranch     string // Current temporary branch name
	OriginalBranch string // Branch we started on
	BaseBranch     string // Base branch for operations

	// Locking state
	TargetLocked   bool      // Whether target is currently locked
	LockAcquiredAt time.Time // When lock was acquired
	LockExpiresAt  time.Time // When lock expires

	// User information
	UserEmail string // User email
	UserName  string // User name

	// Progress tracking
	CurrentStep        string    // Current step description
	ProgressPercent    int       // Progress percentage (0-100)
	EstimatedRemaining time.Time // Estimated time remaining

	// Error handling
	LastError  error // Last error encountered
	RetryCount int   // Number of retries attempted
	MaxRetries int   // Maximum allowed retries

	// Results
	Success           bool      // Whether operation succeeded
	CompletionTime    time.Time // When operation completed
	Duration          time.Time // Total duration
	ChangesCommitted  int       // Number of changes committed
	ConflictsResolved int       // Number of conflicts resolved
}

type PromptFormatter interface {
	FormatDependencySummary(analysis *DependencyAnalysis) string
	FormatRebasePrompt(options []string) string
	FormatConflictPrompt(conflicts []string) string
	FormatDecision(decision string, details string) string
}

type PromptLogger interface {
	LogPrompt(question string)
	LogResponse(response string)
	LogDecision(decision string, details string)
}

type RebasePlan struct {
	SourceBranch string       `json:"source_branch"`
	TargetBranch string       `json:"target_branch"`
	CreatedAt    string       `json:"created_at"`
	Steps        []RebaseStep `json:"steps"`
	Summary      string       `json:"summary"`
}

type RebaseStep struct {
	Branch       string          `json:"branch"`
	Order        int             `json:"order"`
	Priority     string          `json:"priority"`     // "high", "medium", "low"
	Dependencies []string        `json:"dependencies"` // Branches this depends on
	Conflicts    []MergeConflict `json:"conflicts"`
	Description  string          `json:"description"`
}

type RebaseStepResult struct {
	Step          RebaseStep `json:"step"`
	Success       bool       `json:"success"`
	StartTime     string     `json:"start_time"`
	EndTime       string     `json:"end_time"`
	Duration      string     `json:"duration"`
	Error         string     `json:"error,omitempty"`
	Conflicts     []string   `json:"conflicts,omitempty"`
	BackupCreated string     `json:"backup_created,omitempty"`
	Actions       []string   `json:"actions"`
	Status        string     `json:"status"` // "pending", "in_progress", "completed", "failed", "skipped"
}

type RecoveryOptions struct {
	ForceResume        bool `json:"force_resume"`
	ForceRollback      bool `json:"force_rollback"`
	SkipFailedSteps    bool `json:"skip_failed_steps"`
	CleanupOnFailure   bool `json:"cleanup_on_failure"`
	CleanupArtifacts   bool `json:"cleanup_artifacts"`
	CreateBackup       bool `json:"create_backup"`
	CreateBackups      bool `json:"create_backups"`
	RollbackDependents bool `json:"rollback_dependents"`
	Verbose            bool `json:"verbose"`
	Quiet              bool `json:"quiet"`
	DryRun             bool `json:"dry_run"`
}

type RecoveryPersistence struct {
	// contains filtered or unexported fields
}

type RecoveryResult struct {
	Success            bool            `json:"success"`
	ResumedFrom        string          `json:"resumed_from"`
	CompletedSteps     []string        `json:"completed_steps"`
	FailedSteps        []string        `json:"failed_steps"`
	RolledBackBranches []string        `json:"rolled_back_branches"`
	CleanedUpBranches  []string        `json:"cleaned_up_branches"`
	Duration           string          `json:"duration"`
	Issues             []ReleaseIssue  `json:"issues"`
	Recommendations    []string        `json:"recommendations"`
	Summary            RecoverySummary `json:"summary"`
}

type RecoveryStrategy struct {
	Category       errors.ErrorCategory
	CanRetry       bool
	MaxRetries     int
	RetryDelay     time.Duration
	UserAction     string
	AutoRecovery   bool
	RecoveryAction func(error) error
}

type RecoverySummary struct {
	TotalSteps         int     `json:"total_steps"`
	CompletedSteps     int     `json:"completed_steps"`
	FailedSteps        int     `json:"failed_steps"`
	SkippedSteps       int     `json:"skipped_steps"`
	RolledBackBranches int     `json:"rolled_back_branches"`
	CleanedUpBranches  int     `json:"cleaned_up_branches"`
	SuccessRate        float64 `json:"success_rate"`
	OverallStatus      string  `json:"overall_status"`
}

type ReleaseBranchInfo struct {
	Source     BranchInfo   `json:"source"`
	Target     BranchInfo   `json:"target"`
	Dependents []BranchInfo `json:"dependents"`
	TempBranch BranchInfo   `json:"temp_branch,omitempty"`
}

type ReleaseConfiguration struct {
	AutoRebase       bool     `json:"auto_rebase"`
	Interactive      bool     `json:"interactive"`
	DryRun           bool     `json:"dry_run"`
	Force            bool     `json:"force"`
	BackupEnabled    bool     `json:"backup_enabled"`
	BackupStrategy   string   `json:"backup_strategy"` // "always", "on-conflict", "never"
	ExcludedBranches []string `json:"excluded_branches"`
	LockTimeout      int      `json:"lock_timeout_minutes"`
	MaxRetries       int      `json:"max_retries"`
}

type ReleaseHistory struct {
	TotalReleases  int               `json:"total_releases"`
	RecentReleases []ReleaseRecord   `json:"recent_releases"`
	Statistics     ReleaseStatistics `json:"statistics"`
	LastUpdated    string            `json:"last_updated"`
}

type ReleaseIssue struct {
	ID         string `json:"id"`
	Type       string `json:"type"`     // "error", "warning", "conflict", "validation"
	Severity   string `json:"severity"` // "critical", "high", "medium", "low"
	Message    string `json:"message"`
	Branch     string `json:"branch"`
	File       string `json:"file,omitempty"`
	LineNumber int    `json:"line_number,omitempty"`
	Timestamp  string `json:"timestamp"`
	Resolved   bool   `json:"resolved"`
	Resolution string `json:"resolution,omitempty"`
}

type ReleaseMetadataLogger interface {
	LogRecordCreated(record *ReleaseRecord)
	LogRecordUpdated(record *ReleaseRecord)
	LogRecordQueried(query string, results int)
	LogBackupCreated(branch string, backup string)
	LogRollbackExecuted(rollbackID string, success bool)
}

type ReleaseMetadataManager struct {
	// contains filtered or unexported fields
}

type ReleaseRecord struct {
	ID            string               `json:"id"`
	OperationType string               `json:"operation_type"`
	SourceBranch  string               `json:"source_branch"`
	TargetBranch  string               `json:"target_branch"`
	StartTime     string               `json:"start_time"`
	EndTime       string               `json:"end_time"`
	Duration      string               `json:"duration"`
	Status        string               `json:"status"` // "in_progress", "completed", "failed", "aborted", "rolled_back"
	User          UserInfo             `json:"user"`
	Configuration ReleaseConfiguration `json:"configuration"`
	Branches      ReleaseBranchInfo    `json:"branches"`
	Metadata      map[string]string    `json:"metadata"`
	Results       ReleaseResults       `json:"results"`
	Issues        []ReleaseIssue       `json:"issues"`
	RollbackInfo  *RollbackInfo        `json:"rollback_info,omitempty"`
}

type ReleaseRecoveryLogger interface {
	LogRecoveryAttempt(releaseID string)
	LogRecoverySuccess(releaseID string)
	LogRecoveryFailure(releaseID string, err error)
	LogCleanupAttempt(releaseID string)
	LogCleanupSuccess(releaseID string)
	LogRollbackAttempt(releaseID string)
	LogRollbackSuccess(releaseID string)
	LogRollbackFailure(releaseID string, err error)
}

type ReleaseRecoveryManager struct {
	// contains filtered or unexported fields
}

type ReleaseRecoveryState struct {
	ReleaseID       string                   `json:"release_id"`
	OriginalBranch  string                   `json:"original_branch"`
	SourceBranch    string                   `json:"source_branch"`
	TargetBranch    string                   `json:"target_branch"`
	TempBranch      string                   `json:"temp_branch"`
	BackupBranches  []string                 `json:"backup_branches"`
	CurrentStep     string                   `json:"current_step"`
	CompletedSteps  []string                 `json:"completed_steps"`
	FailedStep      string                   `json:"failed_step,omitempty"`
	FailureReason   string                   `json:"failure_reason,omitempty"`
	Configuration   ReleaseConfiguration     `json:"configuration"`
	StartTime       string                   `json:"start_time"`
	LastUpdateTime  string                   `json:"last_update_time"`
	AutoRebaseState *AutoRebaseRecoveryState `json:"auto_rebase_state,omitempty"`
	Metadata        map[string]string        `json:"metadata"`
	IsResumable     bool                     `json:"is_resumable"`
	RequiresCleanup bool                     `json:"requires_cleanup"`
	CanRollback     bool                     `json:"can_rollback"`
}

type ReleaseResults struct {
	BranchesProcessed int                   `json:"branches_processed"`
	BranchesSucceeded int                   `json:"branches_succeeded"`
	BranchesFailed    int                   `json:"branches_failed"`
	AutoRebaseResult  *AutoRebaseResult     `json:"auto_rebase_result,omitempty"`
	LockOperations    []LockOperationResult `json:"lock_operations"`
	BackupBranches    []string              `json:"backup_branches"`
	CreatedTags       []string              `json:"created_tags"`
	UpdatedMetadata   map[string]string     `json:"updated_metadata"`
	Summary           ReleaseSummary        `json:"summary"`
}

type ReleaseSearchCriteria struct {
	OperationType   string   `json:"operation_type"`
	SourceBranch    string   `json:"source_branch"`
	TargetBranch    string   `json:"target_branch"`
	Status          string   `json:"status"`
	User            string   `json:"user"`
	StartTime       string   `json:"start_time"`
	EndTime         string   `json:"end_time"`
	MinDuration     string   `json:"min_duration"`
	MaxDuration     string   `json:"max_duration"`
	HasIssues       bool     `json:"has_issues"`
	HasRollback     bool     `json:"has_rollback"`
	IncludeMetadata []string `json:"include_metadata"`
	ExcludeMetadata []string `json:"exclude_metadata"`
	Limit           int      `json:"limit"`
	Offset          int      `json:"offset"`
	SortBy          string   `json:"sort_by"`
	SortOrder       string   `json:"sort_order"`
}

type ReleaseStatistics struct {
	TotalReleases      int            `json:"total_releases"`
	SuccessfulReleases int            `json:"successful_releases"`
	FailedReleases     int            `json:"failed_releases"`
	AverageDuration    string         `json:"average_duration"`
	MostCommonTarget   string         `json:"most_common_target"`
	MostCommonSource   string         `json:"most_common_source"`
	ReleasesByUser     map[string]int `json:"releases_by_user"`
	ReleasesByTarget   map[string]int `json:"releases_by_target"`
	ReleasesByMonth    map[string]int `json:"releases_by_month"`
	SuccessRate        float64        `json:"success_rate"`
}

type ReleaseSummary struct {
	TotalBranches      int     `json:"total_branches"`
	SuccessfulBranches int     `json:"successful_branches"`
	FailedBranches     int     `json:"failed_branches"`
	SkippedBranches    int     `json:"skipped_branches"`
	HasRollback        bool    `json:"has_rollback"`
	TotalCommits       int     `json:"total_commits"`
	FilesChanged       int     `json:"files_changed"`
	Additions          int     `json:"additions"`
	Deletions          int     `json:"deletions"`
	SuccessRate        float64 `json:"success_rate"`
	OverallStatus      string  `json:"overall_status"`
}

type ReleaseValidationLogger interface {
	LogValidationStart(releaseID string)
	LogValidationResult(releaseID string, result *ValidationResult)
	LogRollbackStart(releaseID string)
	LogRollbackResult(releaseID string, result *RollbackResult)
}

type ReleaseValidationManager struct {
	// contains filtered or unexported fields
}

type ReleaseValidator interface {
	Validate(source, target string, opts ValidationOptions) (*ValidationResult, error)
	GetName() string
	GetDescription() string
}

type RepositoryLock struct {
	// contains filtered or unexported fields
}

type RepositoryLockLogger interface {
	LogLockAcquired(repoPath string, waitTime time.Duration)
	LogLockReleased(repoPath string, holdTime time.Duration)
	LogLockFailed(repoPath string, err error)
	LogLockStale(repoPath string, lockAge time.Duration)
}

type RollbackInfo struct {
	RollbackID       string            `json:"rollback_id"`
	Reason           string            `json:"reason"`
	ExecutedAt       string            `json:"executed_at"`
	ExecutedBy       string            `json:"executed_by"`
	BranchesRestored []string          `json:"branches_restored"`
	TagsDeleted      []string          `json:"tags_deleted"`
	MetadataRestored map[string]string `json:"metadata_restored"`
	Success          bool              `json:"success"`
	Issues           []ReleaseIssue    `json:"issues"`
}

type RollbackItem struct {
	Type          string `json:"type"` // "branch", "tag", "metadata", "file"
	Name          string `json:"name"`
	PreviousState string `json:"previous_state"`
	NewState      string `json:"new_state"`
	Success       bool   `json:"success"`
	Error         string `json:"error,omitempty"`
}

type RollbackOptions struct {
	ForceRollback         bool   `json:"force_rollback"`
	CreateBackup          bool   `json:"create_backup"`
	RollbackDependents    bool   `json:"rollback_dependents"`
	CleanupArtifacts      bool   `json:"cleanup_artifacts"`
	Reason                string `json:"reason"`
	ConfirmBeforeRollback bool   `json:"confirm_before_rollback"`
	Verbose               bool   `json:"verbose"`
	DryRun                bool   `json:"dry_run"`
}

type RollbackResult struct {
	Success         bool              `json:"success"`
	RolledBackItems []RollbackItem    `json:"rolled_back_items"`
	FailedItems     []RollbackItem    `json:"failed_items"`
	Warnings        []ValidationIssue `json:"warnings"`
	Summary         RollbackSummary   `json:"summary"`
	Duration        string            `json:"duration"`
	Recommendations []string          `json:"recommendations"`
}

type RollbackSummary struct {
	TotalItems    int     `json:"total_items"`
	SuccessItems  int     `json:"success_items"`
	FailedItems   int     `json:"failed_items"`
	SuccessRate   float64 `json:"success_rate"`
	OverallStatus string  `json:"overall_status"`
}

type TempBranchConfig struct {
	// Naming configuration
	Prefix        string // Default: "hitch"
	OperationType string // e.g., "rebuild", "release"
	TargetBranch  string // e.g., "qa", "main"
	UniqueSuffix  string // Optional unique suffix

	// Safety configuration
	BackupBeforeDelete bool     // Create backup before deleting temp branches
	SafetyChecks       bool     // Enable comprehensive safety checks
	ImportantBranches  []string // Branches that should never be auto-deleted

	// Cleanup configuration
	AutoCleanup     bool          // Automatically cleanup after operation
	CleanupDelay    time.Duration // Delay before cleanup (for debugging)
	RetainOnFailure bool          // Keep temp branches if operation fails

	// Logging configuration
	Verbose    bool // Show detailed temp branch operations
	SilentMode bool // Suppress all temp branch output
}

type TempBranchInfo struct {
	Name          string    // Full branch name
	Prefix        string    // e.g., "hitch-rebuild"
	OperationType string    // e.g., "rebuild"
	TargetBranch  string    // e.g., "qa", "main"
	CreatedAt     time.Time // When the branch was created
	CreatedBy     string    // User who created it
	BaseBranch    string    // Branch it was created from
	IsActive      bool      // Whether this is the currently active temp branch
	HasChanges    bool      // Whether the branch has uncommitted changes
}

type TempBranchLogger interface {
	LogCreate(info *TempBranchInfo)
	LogCleanup(branchName string)
	LogError(operation string, branchName string, err error)
	LogWarning(message string)
}

type TempBranchManager struct {
	// contains filtered or unexported fields
}

type UserInfo struct {
	Name      string `json:"name"`
	Email     string `json:"email"`
	IPAddress string `json:"ip_address,omitempty"`
}

type ValidationIssue struct {
	Type        string `json:"type"`     // "error", "warning", "info"
	Severity    string `json:"severity"` // "low", "medium", "high", "critical"
	Category    string `json:"category"` // "dependency", "conflict", "permission", "quality", "security"
	Title       string `json:"title"`
	Description string `json:"description"`
	File        string `json:"file,omitempty"`
	LineNumber  int    `json:"line_number,omitempty"`
	Suggestion  string `json:"suggestion,omitempty"`
	CheckName   string `json:"check_name"`
}

type ValidationOptions struct {
	PreReleaseOnly      bool     `json:"pre_release_only"`
	PostReleaseOnly     bool     `json:"post_release_only"`
	SkipDependencyCheck bool     `json:"skip_dependency_check"`
	SkipConflictCheck   bool     `json:"skip_conflict_check"`
	SkipPermissionCheck bool     `json:"skip_permission_check"`
	RequiredChecks      []string `json:"required_checks"`
	ForbiddenPatterns   []string `json:"forbidden_patterns"`
	MaxCommitCount      int      `json:"max_commit_count"`
	MaxFileChanges      int      `json:"max_file_changes"`
	RequireTestCoverage bool     `json:"require_test_coverage"`
	Verbose             bool     `json:"verbose"`
}

type ValidationResult struct {
	IsValid         bool              `json:"is_valid"`
	CanProceed      bool              `json:"can_proceed"`
	Warnings        []ValidationIssue `json:"warnings"`
	Errors          []ValidationIssue `json:"errors"`
	CriticalIssues  []ValidationIssue `json:"critical_issues"`
	Summary         ValidationSummary `json:"summary"`
	Recommendations []string          `json:"recommendations"`
	EstimatedRisk   string            `json:"estimated_risk"` // "low", "medium", "high", "critical"
	ValidationTime  string            `json:"validation_time"`
	Duration        string            `json:"duration"`
}

type ValidationSummary struct {
	TotalChecks   int     `json:"total_checks"`
	PassedChecks  int     `json:"passed_checks"`
	FailedChecks  int     `json:"failed_checks"`
	WarningChecks int     `json:"warning_checks"`
	SkippedChecks int     `json:"skipped_checks"`
	SuccessRate   float64 `json:"success_rate"`
	RiskScore     float64 `json:"risk_score"`
	OverallStatus string  `json:"overall_status"` // "pass", "warning", "fail", "critical"
}