prpipeline

type Action string

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

type DiscoveryResult struct {
	// Repository is the repository that was scanned
	Repository github.Repository

	// DiscoveredPRs contains newly discovered PRs
	DiscoveredPRs []github.PullRequest

	// ExistingPRs contains PRs that were already known
	ExistingPRs []github.PullRequest

	// WorkItems contains work items created during discovery
	WorkItems []WorkItem

	// Errors contains any non-fatal errors that occurred
	Errors []error

	// Duration is how long discovery took
	Duration time.Duration

	// Timestamp is when discovery completed
	Timestamp time.Time
}

type GitHubClient interface {
	// ListPRs retrieves all open pull requests for a repository
	ListPRs(ctx context.Context, repo github.Repository) ([]github.PullRequest, error)

	// GetPR retrieves a specific pull request
	GetPR(ctx context.Context, repo github.Repository, number int) (*github.PullRequest, error)

	// MergePR merges a pull request
	MergePR(ctx context.Context, repo github.Repository, number int, commitMsg string) error

	// GetPRFiles retrieves files changed in a pull request
	GetPRFiles(ctx context.Context, repo github.Repository, number int) ([]github.File, error)
}

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

type Logger interface {
	Debug(msg string, fields ...zap.Field)
	Info(msg string, fields ...zap.Field)
	Warn(msg string, fields ...zap.Field)
	Error(msg string, fields ...zap.Field)
}

type MergeResult struct {
	// PR is the pull request that was merged
	PR github.PullRequest

	// MergeCommitSHA is the SHA of the merge commit (if successful)
	MergeCommitSHA string

	// StateTransition indicates the state transition that occurred
	StateTransition *StateTransition

	// Duration is how long the merge took
	Duration time.Duration

	// Error contains any error that occurred
	Error error
}

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

type PipelineConfig struct {
	// GitHubClient provides GitHub API operations
	GitHubClient GitHubClient

	// LabelManager handles PR label lifecycle
	LabelManager labels.LabelManager

	// QualificationEngine performs PR qualification
	QualificationEngine QualificationEngine

	// Repositories is the list of repositories to monitor
	Repositories []github.Repository

	// DiscoveryInterval is how often to discover new PRs
	DiscoveryInterval time.Duration

	// MergeCommitMessage is the template for auto-merge commit messages
	MergeCommitMessage string

	// DryRun when true will log actions but not execute them
	DryRun bool

	// MaxConcurrentActions limits concurrent PR processing
	MaxConcurrentActions int

	// ProcessingTimeout is the maximum time to spend processing a single PR
	ProcessingTimeout time.Duration
}

type PipelineError struct {
	// Type indicates the type of error
	Type PipelineErrorType

	// Repository is the repository where the error occurred
	Repository github.Repository

	// PR is the pull request associated with the error (if applicable)
	PR *github.PullRequest

	// Action is the action that was being performed
	Action Action

	// Cause is the underlying error
	Cause error

	// Timestamp is when the error occurred
	Timestamp time.Time

	// Context provides additional error context
	Context map[string]interface{}
}

type PipelineErrorType string

type ProcessResult struct {
	// Success indicates whether the processing succeeded
	Success bool

	// Action is the action that was performed
	Action Action

	// PR is the pull request that was processed
	PR github.PullRequest

	// NewState is the state the PR was transitioned to (if any)
	NewState labels.State

	// Error contains any error that occurred during processing
	Error error

	// Duration is how long the processing took
	Duration time.Duration

	// NextActions contains follow-up actions that should be scheduled
	NextActions []Action

	// Metadata contains additional result information
	Metadata map[string]interface{}
}

type ProcessingStats struct {
	// ProcessedItems is the number of work items processed
	ProcessedItems int

	// SuccessfulItems is the number of successfully processed items
	SuccessfulItems int

	// FailedItems is the number of failed items
	FailedItems int

	// DiscoveredPRs is the number of PRs discovered
	DiscoveredPRs int

	// QualifiedPRs is the number of PRs that passed qualification
	QualifiedPRs int

	// MergedPRs is the number of PRs that were merged
	MergedPRs int

	// TotalDuration is the total processing time
	TotalDuration time.Duration

	// AverageProcessingTime is the average time per work item
	AverageProcessingTime time.Duration

	// Timestamp is when these stats were collected
	Timestamp time.Time
}

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

type ProcessorConfig struct {
	GitHubClient        GitHubClient
	LabelManager        labels.LabelManager
	QualificationEngine QualificationEngine
	MergeCommitMessage  string
	DryRun              bool
	ProcessingTimeout   time.Duration
}

type QualificationEngine interface {
	// Qualify performs complete PR qualification
	Qualify(ctx context.Context, pr github.PullRequest) (*qualification.QualificationResult, error)
}

type QualificationResult struct {
	// PR is the pull request that was qualified
	PR github.PullRequest

	// QualificationResult contains the detailed qualification results
	QualificationResult *qualification.QualificationResult

	// StateTransition indicates if a state transition occurred
	StateTransition *StateTransition

	// DynamicLabelsApplied contains labels that were extracted and applied
	DynamicLabelsApplied map[string]string

	// Duration is how long qualification took
	Duration time.Duration

	// Error contains any error that occurred
	Error error
}

type SchedulerStats struct {
	QueuedItems     int
	ProcessingItems int
	MaxConcurrent   int
}

type StateTransition struct {
	// FromState is the previous state
	FromState labels.State

	// ToState is the new state
	ToState labels.State

	// Reason is why the transition occurred
	Reason string

	// Timestamp is when the transition occurred
	Timestamp time.Time
}

type WorkItem struct {
	// PR is the pull request to process
	PR github.PullRequest

	// Action is the type of work to perform
	Action Action

	// Repository contains the repository information
	Repository github.Repository

	// Priority determines processing order (higher = more urgent)
	Priority int

	// CreatedAt is when this work item was created
	CreatedAt time.Time

	// Metadata contains additional context for processing
	Metadata map[string]interface{}
}

type WorkScheduler interface {
	// Schedule adds a work item to the processing queue
	Schedule(ctx context.Context, item WorkItem) error

	// ScheduleBatch adds multiple work items to the processing queue
	ScheduleBatch(ctx context.Context, items []WorkItem) error

	// GetPendingWork retrieves work items ready for processing
	GetPendingWork(ctx context.Context, limit int) ([]WorkItem, error)
}