uiserver

type ChatQueue interface {
	Ask(ctx context.Context, ask chat.Ask) (jobs.ChatQueued, error)
	Conversations(ctx context.Context, clone string, pr int) ([]store.Conversation, error)
}

type DecisionModel struct {
	Backend string `json:"effective_backend"`
	// Undetermined is a backend whose checks did not answer in time.
	Undetermined bool   `json:"backend_undetermined"`
	Model        string `json:"effective_model"`
	Ignored      bool   `json:"model_ignored"`
}

type DiscoveryCache interface {
	Cached(context.Context, github.Repository) (discovery.Snapshot, error)
	PollNow(context.Context, github.Repository) (discovery.Snapshot, error)
}

type FactsSource interface {
	// Facts answers the pull request's facts at head, the head the page
	// shows, building them when they are due.
	Facts(ctx context.Context, clone repos.Clone, number int, head string) ([]byte, error)
	// Cached is the facts last built for the pull request and the head they
	// describe, nil when none; it never reads GitHub.
	Cached(clone repos.Clone, number int) ([]byte, string)
}

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

type GitHubConnection struct {
	State    string             `json:"state"`
	Host     string             `json:"host"`
	Login    string             `json:"login,omitempty"`
	Source   string             `json:"source,omitempty"`
	Override bool               `json:"override"`
	Saved    bool               `json:"saved"`
	Pending  *githubauth.Device `json:"pending,omitempty"`
	Error    string             `json:"error,omitempty"`
	Message  string             `json:"message,omitempty"`
}

type IndexWatch struct {
	// Fingerprint digests what the index is built from that other processes
	// change. It must be cheap: it runs every tick.
	Fingerprint func(context.Context) string
	// Invalidate drops the cached index; it is called when Fingerprint moves.
	Invalidate func()
	// Fresh reports the version of the cached index while it is still valid.
	Fresh func() (uint64, bool)
	// Snapshot returns the index and its version, building it if needed. It
	// must read local state only and honor cancellation.
	Snapshot func(context.Context) (any, uint64, error)
}

type LinkedSessions = func(ctx context.Context, repository string, number int) ([]locallink.Session, time.Time, error)

type LocalAPI struct {
	Registry         *repos.Registry
	Config           config.Config
	PRs, Index, Jobs http.Handler
	Background       http.Handler
	GitHubAuth       http.Handler
	// Automatic serves /api/automatic: the automatic generation preferences
	// and per-repository status.
	Automatic http.Handler
	// Live serves /api/live-sessions: the agent sessions in progress, and
	// /api/live-sessions/{agent}/{id}/transcript: one of their transcripts.
	Live http.Handler
	// AgentRequests serves /api/agent-requests and /api/agent-messages: the
	// permission requests and questions agents wait on the app to answer, and
	// the messages queued for running sessions (internal/agentrequests).
	AgentRequests http.Handler
	// Clones serves /api/clones/found: the local clones found without asking.
	Clones http.Handler
	// Merge serves /api/prs/merge-options and /api/prs/merge: merging a pull
	// request from the app.
	Merge http.Handler
	// Review serves /api/prs/review: submitting a pull request review with
	// inline comments from the app.
	Review http.Handler
	// Chat serves /api/prs/chat: asking the agent that wrote a review about
	// the pull request, and the conversations so far (ChatHandler).
	Chat http.Handler
	// Update serves /api/prs/update-branch and /api/prs/rerun-checks, with
	// their -options reads: updating a pull request's branch and re-running its
	// failed workflow runs. With merging, submitting a review and a
	// fix's push, they are the GitHub writes the app makes.
	Update http.Handler
	// Groups serves /api/groups: review groups and their combined reviews
	// (internal/reviewgroups).
	Groups http.Handler
	// Inboxes serves /api/inboxes: the saved filters listed under Inbox in
	// the app. Without it the route reports the capability unavailable.
	Inboxes http.Handler
	// UIState keeps inbox bookkeeping and review drafts across browser origins.
	UIState http.Handler
	// GitHubRepositories serves the account's repositories for picking
	// (/api/github/repositories) and cloning one
	// (/api/repositories/{owner}/{name}/clone and clone-target).
	GitHubRepositories http.Handler
	// PlanUsage serves /api/plan-usage: what remains of the Claude and Codex
	// plans.
	PlanUsage http.Handler
	// Analytics serves /api/analytics: what the agents did, cost and
	// delivered (internal/analytics).
	Analytics http.Handler
	// CurrentName lets POST /api/repos register a folder whose remote uses
	// an earlier name of the repository (repos.Registry.HandlerWith).
	CurrentName repos.CurrentName
	Changed     func()
	// Timeline serves /api/timeline/: the features and decisions of the
	// local decision log (internal/decisionlog).
	Timeline http.Handler
	// Sessions are the session stores a pull request page's linked sessions
	// are read from; the zero value reads this computer's default stores.
	Sessions sessions.Options
	// Facts builds what GET /api/facts answers: a pull request's facts for
	// its page while it has no saved review (internal/facts). Without it the
	// route reports the capability unavailable.
	Facts FactsSource
	// Decisions builds the handler of /api/decisions, the decisions captured
	// from agent sessions (internal/decisionlog), given the sessions a pull
	// request's saved review links, as its PR page lists them.
	Decisions func(LinkedSessions) http.Handler
	// DecisionModel resolves the decision model capture uses with the given
	// preferences, for GET and PUT /api/settings/decisions; nil reports none.
	DecisionModel func(context.Context, repos.Preferences) DecisionModel
	// DecisionsChanged, when set, is called after a change to what decision
	// capture does: its settings or a repository's. The daemon publishes the
	// app's decisions event with it.
	DecisionsChanged func()
	// ConcurrencyChanged, when set, applies a new job concurrency
	// (repos.Preferences.JobConcurrency) to the running queue.
	ConcurrencyChanged func(int)
	// Log receives what the API logs; nil is slog.Default.
	Log *slog.Logger
	// Diagnostics builds the report served at /api/diagnostics; nil serves the
	// capability fields with a null report. It must honour its context.
	Diagnostics func(context.Context) doctor.Report
	// HookTrust checks Codex session reporting without running a conversation.
	HookTrust func(context.Context) agentplugins.HookTrust
	// DiagnosticsTimeout bounds one shared run; zero means
	// defaultDiagnosticsTimeout.
	DiagnosticsTimeout time.Duration
	// Version is this baum's version, named in the "Report a problem" link
	// that /api/diagnostics returns.
	Version string
	// contains filtered or unexported fields
}

type LocalHandler struct {
	http.Handler
	// contains filtered or unexported fields
}

type Options struct {
	// API serves application routes after authentication and CSRF validation.
	API http.Handler
	// App serves the browser application's files (GET and HEAD outside /api/)
	// under the session namespace, after authentication, with the namespace
	// prefix stripped. Nil serves a minimal status page.
	App http.Handler
	// Sample serves the API under /s/<namespace>/sample/, the sample project
	// the tour shows when there is no local data yet; the app's files are the
	// same. Nil leaves those paths unserved.
	Sample http.Handler
}

type PullRequestMerger interface {
	MergeOptions(ctx context.Context, repository github.Repository, number int) (github.MergeOptions, error)
	MergePullRequest(ctx context.Context, repository github.Repository, number int, method, expectedHead string) error
}

type PullRequestReviewer interface {
	SubmitReview(ctx context.Context, repository github.Repository, number int, review github.ReviewSubmission) (github.ReviewResult, error)
}

type PullRequestUpdater interface {
	UpdateOptions(ctx context.Context, repository github.Repository, number int) (prupdate.UpdateOptions, error)
	UpdateBranch(ctx context.Context, repository github.Repository, number int, expectedHead string) error
	RerunOptions(ctx context.Context, repository github.Repository, number int) (prupdate.RerunOptions, error)
	RerunFailedChecks(ctx context.Context, repository github.Repository, number int, expectedHead string) (prupdate.RerunResult, error)
	ReviewThreads(ctx context.Context, repository github.Repository, number, unresolved int) (prupdate.Threads, error)
	ResolveThread(ctx context.Context, repository github.Repository, number int, id string) error
	FailingChecks(ctx context.Context, repository github.Repository, number int, head string) (prupdate.Checks, error)
	RerunJob(ctx context.Context, repository github.Repository, number int, expectedHead string, job int64) error
	AllChecks(ctx context.Context, repository github.Repository, number int, head string) (prupdate.CheckList, error)
	Conflicts(ctx context.Context, repository github.Repository, number int) (prupdate.ConflictFiles, error)
	Description(ctx context.Context, repository github.Repository, number int) (prupdate.Description, error)
}

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