services

type AgentAdapter interface {
	Name() string
	WatchRoot() string
	Discover(
		seen map[string]struct{},
		cached func(path string, parse func() (*models.AgentSession, error)) (*models.AgentSession, error),
	) ([]*models.AgentSession, error)
}

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

type AgentHookState struct {
	Agent          models.AgentKind
	SessionID      string
	TranscriptPath string
	CWD            string
	Model          string
	Source         string
	PID            int
	LastEventName  string
	LastEventAt    time.Time
	Ended          bool
}

type AgentProcess struct {
	PID       int
	Agent     models.AgentKind
	Source    string
	Command   string
	Args      string
	CWD       string
	OpenFiles []string
}

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

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

type AgentWatchService struct {
	Started bool
	Waiting bool
	Roots   []string
	// SpoolRoots is the subset of Roots that contain hook spool .json files.
	// .json events are only accepted from these roots; all roots accept .jsonl.
	SpoolRoots []string
	Events     chan struct{}
	Done       chan struct{}
	Paths      map[string]struct{}
	Mu         sync.Mutex
	Watcher    *fsnotify.Watcher
	// Debounce throttles how often transcript-write bursts trigger a refresh.
	// A value <= 0 disables throttling. See PlanRefresh.
	Debounce    time.Duration
	LastRefresh time.Time
	// contains filtered or unexported fields
}

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

type AvatarImage struct {
	URL string
	Key string
	PNG []byte
}

type CICheckCache interface {
	// Get retrieves cached CI checks for a branch.
	// Returns the checks, fetch time, and whether the entry exists.
	Get(branch string) ([]*models.CICheck, time.Time, bool)

	// Set stores CI checks for a branch with the current timestamp.
	Set(branch string, checks []*models.CICheck)

	// Clear removes all cached entries.
	Clear()

	// IsFresh returns true if the cache entry exists and is within the TTL.
	IsFresh(branch string, ttl time.Duration) bool
}

type CIDataService interface {
	// Sort returns a copy of checks sorted with GitHub Actions first.
	Sort(checks []*models.CICheck) []*models.CICheck

	// StatusIcon returns the appropriate icon for CI status.
	// Draft PRs show "D" instead of CI status.
	StatusIcon(status string, isDraft, useIcons bool, iconProvider CIIconProvider) string

	// ExtractRunID extracts the run ID from a GitHub Actions URL.
	// Example: https://github.com/owner/repo/actions/runs/12345678/job/98765432 -> 12345678
	ExtractRunID(link string) string

	// ExtractJobID extracts the job ID from a GitHub Actions URL.
	// Example: https://github.com/owner/repo/actions/runs/12345678/job/98765432 -> 98765432
	ExtractJobID(link string) string

	// ExtractRepo extracts the owner/repo from a GitHub URL.
	// Example: https://github.com/owner/repo/actions/runs/12345678 -> owner/repo
	ExtractRepo(link string) string
}

type CIFetchResult struct {
	Branch string
	Checks []*models.CICheck
	Err    error
}

type CIFetchService interface {
	// CreateFetchForPR creates a fetch function for PR-based CI status.
	// The returned function can be called to perform the fetch and return a result.
	CreateFetchForPR(ctx context.Context, git GitCIProvider, prNumber int, branch string) func() CIFetchResult

	// CreateFetchForCommit creates a fetch function for commit-based CI status.
	// The returned function can be called to perform the fetch and return a result.
	CreateFetchForCommit(ctx context.Context, git GitCIProvider, worktreePath, branch string) func() CIFetchResult
}

type CIIconProvider interface {
	GetCIIcon(conclusion string) string
}

type CommandExecutor interface {
	Run(cmd string, cwd string, env map[string]string) tea.Cmd
	RunWithPager(cmd string, cwd string, env map[string]string) tea.Cmd
	RunInteractive(cmd *exec.Cmd, callback tea.ExecCallback) tea.Cmd
}

type CommandPaletteUsage struct {
	ID        string `json:"id"`
	Timestamp int64  `json:"timestamp"`
	Count     int    `json:"count"`
}

type CreateFromChangesOptions struct {
	SourcePath    string
	NewBranch     string
	TargetPath    string
	CurrentBranch string
	Env           map[string]string
}

type CreateOptions struct {
	Branch     string
	TargetPath string
	BaseRef    string
	Env        map[string]string
}

type FilterService struct {
	FilterQuery         string
	StatusFilterQuery   string
	LogFilterQuery      string
	WorktreeSearchQuery string
	StatusSearchQuery   string
	LogSearchQuery      string
}

type GitCIProvider interface {
	// FetchCIStatus fetches CI status for a PR.
	FetchCIStatus(ctx context.Context, prNumber int, branch string) ([]*models.CICheck, error)

	// FetchCIStatusByCommit fetches CI status for a commit SHA.
	FetchCIStatusByCommit(ctx context.Context, sha, path string) ([]*models.CICheck, error)

	// GetHeadSHA returns the HEAD commit SHA for a worktree path.
	GetHeadSHA(ctx context.Context, path string) string

	// IsGitHub returns true if the repository is hosted on GitHub.
	IsGitHub(ctx context.Context) bool
}

type GitCommonDirResolver interface {
	RunGit(ctx context.Context, args []string, cwd string, okReturncodes []int, strip, silent bool) string
}

type GitService interface {
	RunGit(ctx context.Context, args []string, cwd string, okReturncodes []int, strip, silent bool) string
	RunCommandChecked(ctx context.Context, args []string, cwd, errorPrefix string) bool
	GetMainBranch(ctx context.Context) string
	GetMergedBranches(ctx context.Context, baseBranch string) []string
	RenameWorktree(ctx context.Context, oldPath, newPath, oldBranch, newBranch string) bool
	ExecuteCommands(ctx context.Context, cmdList []string, cwd string, env map[string]string) error
	RunGitWithCombinedOutput(ctx context.Context, args []string, cwd string, env map[string]string) ([]byte, error)
}

type GitWatchService struct {
	Started     bool
	Waiting     bool
	CommonDir   string
	Roots       []string
	Events      chan struct{}
	Done        chan struct{}
	Paths       map[string]struct{}
	Mu          sync.Mutex
	Watcher     *fsnotify.Watcher
	LastRefresh time.Time
	// contains filtered or unexported fields
}

type HistoryService interface {
	LoadCommands(repoKey string) []string
	SaveCommands(repoKey string, cmds []string)
	AddCommand(repoKey string, cmd string)
	LoadAccessHistory(repoKey string) map[string]int64
	SaveAccessHistory(repoKey string, history map[string]int64)
	RecordAccess(repoKey string, path string)
	LoadPaletteHistory(repoKey string) []CommandPaletteUsage
	SavePaletteHistory(repoKey string, commands []CommandPaletteUsage)
	AddPaletteUsage(repoKey string, id string)
}

type LazyWorktreeContext struct {
	Type          string
	Number        string
	Template      string
	SuggestedName string
	Title         string
	URL           string
	Description   string
}

type PRReviewerCache interface {
	// Get returns the cached summary for a key, if a lookup has succeeded.
	Get(key string) (*models.PRReviewerSummary, bool)

	// ShouldFetch reports whether a fresh lookup is warranted: no successful
	// result within ttl, no failure within retryBackoff, and nothing in flight.
	ShouldFetch(key string, ttl, retryBackoff time.Duration) bool

	// MarkFetching claims a key for one lookup, returning false when another
	// lookup already holds it.
	MarkFetching(key string) (ReviewerToken, bool)

	// Complete finishes the lookup a token was issued for, releasing the claim
	// and recording the outcome. It does nothing when the token no longer owns
	// the key, or when the cache has been invalidated since the token was
	// issued.
	Complete(token ReviewerToken, summary *models.PRReviewerSummary, err error)

	// Invalidate makes every entry due for a fresh lookup and drops the results
	// of anything still in flight. Summaries already fetched are kept, so a
	// refresh that fails still has last known good reviewers to show.
	Invalidate()
}

type Pager interface {
	Show(content string, env []string, cwd string) tea.Cmd
	ShowFileDiff(sf models.StatusFile, wt *models.WorktreeInfo) tea.Cmd
	ShowCommitDiff(sha string, wt *models.WorktreeInfo) tea.Cmd
}

type PruneCandidate struct {
	Worktree *models.WorktreeInfo // nil for branch-only candidates
	Branch   string               // branch name (always set)
	Source   string               // "pr", "git", or "both"
}

type RefreshPlan struct {
	// Now requests an immediate (leading-edge) refresh.
	Now bool
	// TrailingIn, when > 0, requests a single trailing-edge refresh scheduled
	// this far in the future so the final write of a burst still renders without
	// waiting for the periodic auto-refresh.
	TrailingIn time.Duration
}

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

type SessionRegistryStore interface {
	Load() (map[string]*models.AgentSession, error)
	Save(sessions []*models.AgentSession) error
}

type StatusFile = models.StatusFile

type StatusService struct {
	Tree          *StatusTreeNode
	TreeFlat      []*StatusTreeNode
	CollapsedDirs map[string]bool
	Index         int
}

type StatusTreeNode struct {
	Path        string            // Full path (e.g., "internal/app" or "internal/app/app.go")
	File        *StatusFile       // nil for directories
	Children    []*StatusTreeNode // nil for files
	Compression int               // Number of compressed path segments (e.g., "a/b" = 1)
	Depth       int               // Cached depth for rendering
}

type WorktreeNoteScriptInput struct {
	Content     string
	Type        string
	Number      int
	Title       string
	URL         string
	Description string
}

type WorktreeService interface {
	// Create creates a new worktree.
	Create(ctx context.Context, opts CreateOptions) error

	// CreateFromChanges moves changes from an existing worktree to a new one.
	CreateFromChanges(ctx context.Context, opts CreateFromChangesOptions) error

	// Delete removes a worktree and optionally its branch.
	Delete(ctx context.Context, path, branch string, deleteBranch bool) error

	// Rename moves a worktree and conditionally renames its branch.
	Rename(ctx context.Context, oldPath, newPath, oldBranch, newBranch string) error

	// Push pushes a worktree's branch to its upstream.
	Push(ctx context.Context, wt *models.WorktreeInfo, args []string, env map[string]string) (string, error)

	// Sync synchronizes a worktree's branch with its upstream (pull + push).
	Sync(ctx context.Context, wt *models.WorktreeInfo, pullArgs, pushArgs []string, env map[string]string) (string, error)

	// UpdateFromBase updates a branch from its PR base branch.
	UpdateFromBase(ctx context.Context, wt *models.WorktreeInfo, mergeMethod string, env map[string]string) (string, error)

	// Absorb merges or rebases a worktree into the main branch.
	Absorb(ctx context.Context, wt *models.WorktreeInfo, mainWorktree *models.WorktreeInfo, mergeMethod string) error

	// GetPruneCandidates identifies worktrees and stale branches that have been merged and are candidates for pruning.
	GetPruneCandidates(ctx context.Context, worktrees []*models.WorktreeInfo, includeStaleBranches bool) ([]PruneCandidate, error)

	// ExecuteCommands runs a list of shell commands in the specified directory.
	ExecuteCommands(ctx context.Context, commands []string, cwd string, env map[string]string) error
}