reposync

type Action struct {
	Repo      RepoSpec
	Type      ActionType
	Strategy  Strategy
	Reason    string
	PlannedBy string
	Workspace string // workspace name for grouping display (empty = flat repositories)
}

type ActionResult struct {
	Action     Action
	Message    string
	Error      error
	PostStatus *PostSyncStatus
}

type ActionType string

type AuthConfig struct {
	// Token is used for HTTPS clone URL injection
	Token string

	// Provider is the forge provider type (github, gitlab, gitea)
	// Used to determine the correct token format for URL injection
	Provider string

	// SSHKeyPath is the path to SSH private key file (priority)
	SSHKeyPath string

	// SSHKeyContent is the SSH private key content (used if SSHKeyPath is empty)
	SSHKeyContent string

	// SSHPort is the custom SSH port (0 = default)
	SSHPort int
}

type AuthResult struct {
	// CloneURL is the modified clone URL (with token injected for HTTPS)
	CloneURL string

	// Env contains environment variables to set for git commands
	Env []string

	// TempKeyPath is the path to temporary SSH key file (if created from content)
	// Caller should display warning to user about cleanup
	TempKeyPath string

	// Warnings contains non-fatal warnings (e.g., temp file cleanup reminder)
	Warnings []string
}

type DiagnosticExecutor struct {
	Client repo.Client
	Logger repo.Logger
}

type DiagnosticOptions struct {
	// SkipFetch skips remote fetch before checking divergence.
	// This is faster but may give stale results.
	SkipFetch bool

	// FetchTimeout is max time to wait for remote fetch (per repo).
	// Default: 30s.
	FetchTimeout time.Duration

	// Parallel is number of concurrent health checks.
	// Default: 4.
	Parallel int

	// CheckWorkTree enables working tree status checks.
	// Default: true.
	CheckWorkTree bool

	// IncludeRecommendations generates actionable guidance.
	// Default: true.
	IncludeRecommendations bool

	// Progress is an optional progress callback.
	Progress DiagnosticProgress
}

type DiagnosticProgress interface {
	OnRepoStart(repo RepoSpec)
	OnRepoComplete(health RepoHealth)
}

type DivergenceType string

type ExecutionResult struct {
	Succeeded []ActionResult
	Failed    []ActionResult
	Skipped   []ActionResult
}

type Executor interface {
	Execute(ctx context.Context, plan Plan, opts RunOptions, sink ProgressSink, store StateStore) (ExecutionResult, error)
}

type FSPlanner struct{}

type FileHistoryStore struct {
	BaseDir string
}

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

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

type ForgePlannerConfig struct {
	// TargetPath is the base directory for cloning repositories
	TargetPath string

	// Organization is the org/group to sync from
	Organization string

	// IsUser indicates if Organization is actually a user (for ListUserRepos)
	IsUser bool

	// IncludeArchived includes archived repositories
	IncludeArchived bool

	// IncludeForks includes forked repositories
	IncludeForks bool

	// IncludePrivate includes private repositories
	IncludePrivate bool

	// CloneProto is the clone protocol: ssh, https
	CloneProto string

	// SSHPort is the custom SSH port (0 = default 22)
	SSHPort int

	// IncludeSubgroups includes subgroups (GitLab only)
	IncludeSubgroups bool

	// SubgroupMode is flat (dash-separated) or nested (directories)
	SubgroupMode string

	// FlatSeparator is the separator for flat mode (default: "-")
	// Examples: "-", "_", ".", "" (empty = no separator)
	// Invalid characters: / \ : * ? " < > |
	FlatSeparator string

	// Branch is the branch to checkout after clone/update (comma-separated fallback list)
	Branch string

	// Auth contains authentication settings for clone operations
	Auth AuthConfig

	// Metadata filters
	FilterLanguages     []string  // Filter by language (lowercase)
	FilterMinStars      int       // Minimum star count
	FilterMaxStars      int       // Maximum star count (0 = unlimited)
	FilterLastPushAfter time.Time // Only include repos pushed after this time

	// Name/path regex filters
	FilterIncludePatterns []string // Include repos whose name or full name matches
	FilterExcludePatterns []string // Exclude repos whose name or full name matches
}

type ForgeProvider interface {
	Name() string
	ListOrganizationRepos(ctx context.Context, org string) ([]*provider.Repository, error)
	ListUserRepos(ctx context.Context, user string) ([]*provider.Repository, error)
}

type GitExecutor struct {
	Client repo.Client
	Logger repo.Logger
}

type HealthReport struct {
	// Results contains per-repository health status.
	Results []RepoHealth

	// Summary provides counts by health status.
	Summary HealthSummary

	// TotalDuration is the total time for all checks.
	TotalDuration time.Duration

	// CheckedAt is when the health check was performed.
	CheckedAt time.Time
}

type HealthStatus string

type HealthSummary struct {
	// Healthy is count of healthy repositories.
	Healthy int

	// Warning is count of repositories with warnings.
	Warning int

	// Error is count of repositories with errors.
	Error int

	// Unreachable is count of unreachable repositories.
	Unreachable int

	// Total is total number of repositories checked.
	Total int
}

type HistorySnapshot struct {
	Timestamp time.Time     `json:"timestamp"`
	Report    *HealthReport `json:"report"`
}

type HistoryStore interface {
	Save(ctx context.Context, report *HealthReport) error
	Load(ctx context.Context, limit int) ([]HistorySnapshot, error)
	GetTrend(ctx context.Context, repoName string) ([]RepoHealth, error)
}

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

type NetworkStatus string

type NoopExecutor struct{}

type NoopProgressSink struct{}

type Orchestrator struct {
	Planner    Planner
	Executor   Executor
	StateStore StateStore
}

type Plan struct {
	Actions []Action
}

type PlanInput struct {
	Repos []RepoSpec
}

type PlanOptions struct {
	DefaultStrategy Strategy
	CleanupOrphans  bool
	Roots           []string // optional roots to detect orphan directories
}

type PlanRequest struct {
	Input   PlanInput
	Options PlanOptions
}

type Planner interface {
	Plan(ctx context.Context, req PlanRequest) (Plan, error)
}

type PostSyncStatus struct {
	Branch       string
	AheadBy      int
	BehindBy     int
	IsDirty      bool
	HasConflicts bool

	// StatusErr records a failure to read the working tree. IsDirty and
	// HasConflicts are only meaningful when it is nil — their zero values are
	// indistinguishable from a clean, conflict-free repository, so a renderer
	// that ignores this field reports an unreadable repo as a healthy one.
	// Same reasoning as WorkTreeUnknown in diagnostic.go.
	StatusErr error
}

type ProgressSink interface {
	OnStart(action Action)
	OnProgress(action Action, message string, progress float64)
	OnComplete(result ActionResult)
}

type RepoHealth struct {
	// Repo is the repository descriptor.
	Repo RepoSpec

	// HealthStatus is the overall health classification.
	HealthStatus HealthStatus

	// NetworkStatus indicates remote connectivity.
	NetworkStatus NetworkStatus

	// DivergenceType classifies local vs remote state.
	DivergenceType DivergenceType

	// WorkTreeStatus indicates working tree state.
	WorkTreeStatus WorkTreeStatus

	// CurrentBranch is the active branch name.
	CurrentBranch string

	// UpstreamBranch is the tracked upstream branch (e.g., "origin/main").
	UpstreamBranch string

	// AheadBy is commits ahead of upstream.
	AheadBy int

	// BehindBy is commits behind upstream.
	BehindBy int

	// ModifiedFiles is count of modified files.
	ModifiedFiles int

	// UntrackedFiles is count of untracked files.
	UntrackedFiles int

	// ConflictFiles is count of files with conflicts.
	ConflictFiles int

	// Recommendation provides actionable guidance.
	Recommendation string

	// Error contains error details if health check failed.
	Error error

	// Duration is how long the health check took.
	Duration time.Duration

	// FetchDuration is how long remote fetch took (if performed).
	FetchDuration time.Duration
}

type RepoSpec struct {
	Name                 string
	Description          string // optional: human-readable description of the repository
	Provider             string
	CloneURL             string
	AdditionalRemotes    map[string]string // Additional git remotes (name: url), configured after clone
	TargetPath           string
	Branch               string // optional: branch to checkout after clone/update (empty = no checkout)
	StrictBranchCheckout bool   // if true, branch checkout failure causes action failure (default: false)
	Strategy             Strategy
	Enabled              *bool // if false, repo is excluded from sync (default: true, nil = true)
	AssumePresent        bool  // if true, planner treats repo as already present (skip clone check)

	// Auth contains authentication config for this repo's clone operation.
	// If empty, system defaults are used (git credential helper, ssh-agent).
	Auth AuthConfig
}

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

type RunOptions struct {
	Parallel   int
	MaxRetries int
	Resume     bool
	DryRun     bool
}

type RunRequest struct {
	PlanRequest PlanRequest
	RunOptions  RunOptions

	Progress ProgressSink
	State    StateStore
}

type RunState struct {
	Items []RunStateItem
}

type RunStateItem struct {
	Repo    RepoSpec
	Status  RunStatus
	Message string
}

type RunStatus string

type Runner interface {
	Run(ctx context.Context, req RunRequest) (ExecutionResult, error)
}

type StateStore interface {
	Save(ctx context.Context, state RunState) error
	Load(ctx context.Context) (RunState, error)
}

type StaticPlanner struct{}

type Strategy string

type WorkTreeStatus string