github

type App struct {
	// Issuer is the App's client ID (preferred) or its numeric App ID as a string.
	// It becomes the "iss" claim of the signed assertion.
	Issuer string

	// InstallationID identifies the installation whose token the App mints. An App
	// with no installation has no repository access.
	InstallationID int64

	// PrivateKey signs the assertion. It is the App's sole credential and grants
	// everything its installations do; store it in the vault, not on disk.
	PrivateKey *rsa.PrivateKey
}

type ChangedFile struct {
	Filename  string `json:"filename"`
	Status    string `json:"status"`
	Additions int    `json:"additions"`
	Deletions int    `json:"deletions"`
	Patch     string `json:"patch"`

	// PatchTruncated reports that Patch was shortened to fit the configured cap.
	PatchTruncated bool `json:"patch_truncated,omitempty"`
}

type Config struct {
	// App identifies the GitHub App and the installation the Set acts as. Set exactly
	// one of App and Token.
	//
	// The App path gives the reviewer an identity of its own, distinct from whoever
	// authored the pull request, which is what a formal approval requires.
	App App

	// Token authenticates as whoever issued it: a workflow's ambient GITHUB_TOKEN, or
	// a personal access token. Set exactly one of App and Token.
	//
	// A review posted with a workflow's GITHUB_TOKEN is authored by
	// github-actions[bot], and a repository refuses an approving review from that
	// identity unless an owner has enabled "Allow GitHub Actions to create and approve
	// pull requests", which is off by default. So this path can comment and request
	// changes anywhere, and can approve only where that setting was deliberately
	// turned on.
	Token secret.Text

	// Owner and Repo bound the Set to a single repository. Every tool call operates
	// on this repository; the model cannot redirect a review at another one because
	// the coordinates are not part of any tool's input schema.
	Owner string
	Repo  string

	// Number is the pull request the reviewer was invoked for. Like Owner and Repo it
	// binds the whole review: no tool takes a pull-request number from the model, so
	// the diff a review reads cannot steer a comment or a verdict onto a different pull
	// request by naming its number. A review whose own diff mentions "#123" still writes
	// only to the pull request it was launched against. Must be positive.
	Number int

	// SelfLogin is the reviewer's own login, such as "my-reviewer[bot]". When a pull
	// request's author matches it, an APPROVE verdict is refused. Empty disables the
	// check, which is only correct in tests.
	SelfLogin string

	// AllowApprove permits the APPROVE verdict. It is off by default on purpose, and
	// a host should set it only from committed repository configuration, never from
	// a value a pull-request comment can reach.
	AllowApprove bool

	// MaxFiles caps how many changed files a fetch returns, and MaxPatchBytes caps
	// each file's patch, so a large pull request cannot flood the model's context.
	// Zero selects the defaults.
	MaxFiles      int
	MaxPatchBytes int

	// MaxChangedLines is the review budget: a pull request whose additions plus
	// deletions exceed it is refused rather than reviewed, because a runaway diff
	// costs real money and yields a worse review. Zero selects the default. Negative
	// disables the budget, which is what an explicit "review it anyway" invocation
	// passes.
	//
	// The count is GitHub's own total for the whole pull request, so a diff cannot
	// slip under the budget by being truncated on the way in.
	MaxChangedLines int

	// ReviewOversize permits reviewing a pull request that exceeds MaxChangedLines.
	// It exists for the explicit, human-initiated "yes, review the big one" path. It
	// does not permit approving one: see ErrIncompleteDiff.
	ReviewOversize bool

	// HTTPClient issues the API requests. Nil selects a netguard-backed client with a
	// public-only egress policy, which refuses connections to private, loopback, and
	// cloud-metadata addresses after DNS resolution.
	HTTPClient *http.Client

	// APIBase overrides the REST API root. Empty selects DefaultAPIBase. Tests point
	// it at an httptest server; a GitHub Enterprise host points it at its own API.
	APIBase string

	// Clock supplies the current time for App token minting and expiry. Nil selects
	// clock.System.
	Clock clock.Clock
}

type Finding struct {
	// Path and Line locate the finding on the right-hand side of the diff.
	Path string `json:"path"`
	Line int    `json:"line"`

	// Rule names the check that produced the finding. It participates in the
	// comment's identity, so re-running a review updates a finding in place rather
	// than posting it twice.
	Rule string `json:"rule"`

	// Summary states the defect in one sentence.
	Summary string `json:"summary"`

	// Failure is the concrete scenario the defect causes: inputs or state, and the
	// wrong output or crash that results. A finding without one is not postable,
	// because a comment that cannot name what breaks is a nitpick.
	Failure string `json:"failure"`
}

type PostedFinding struct {
	Path    string `json:"path"`
	Line    int    `json:"line"`
	Rule    string `json:"rule"`
	Summary string `json:"summary,omitempty"`
	Failure string `json:"failure,omitempty"`
}

type PullRequest struct {
	Number      int    `json:"number"`
	Title       string `json:"title"`
	Body        string `json:"body"`
	State       string `json:"state"`
	Draft       bool   `json:"draft"`
	HeadSHA     string `json:"-"`
	AuthorLogin string `json:"-"`

	// ChangedFiles, Additions, and Deletions are the authoritative totals for the
	// pull request, reported by GitHub on the pull request itself.
	ChangedFiles int `json:"changed_files"`
	Additions    int `json:"additions"`
	Deletions    int `json:"deletions"`

	Head struct {
		SHA string `json:"sha"`
	} `json:"head"`
	User struct {
		Login string `json:"login"`
	} `json:"user"`
}

type ReviewComment struct {
	ID   int64  `json:"id"`
	Path string `json:"path"`
	Line int    `json:"line"`
	Body string `json:"body"`

	// HTMLURL addresses the comment on the pull request, so a verdict can point at a
	// finding instead of repeating it.
	HTMLURL string `json:"html_url"`

	// User is who wrote the comment. A marker in a body proves nothing about that: it
	// is plain text anyone can copy.
	User struct {
		Login string `json:"login"`
	} `json:"user"`
}

type ReviewThread struct {
	// ID is the GraphQL node id, which is what resolveReviewThread takes. It is not
	// the REST comment id.
	ID string

	// Resolved reports whether the thread is already closed.
	Resolved bool

	// Outdated reports GitHub's own judgement that the diff hunk this thread is
	// anchored to no longer matches the head of the pull request.
	Outdated bool

	// Marker keys the thread to the finding that opened it, taken from the body of
	// its first comment. A thread a human opened carries none.
	Marker string

	// Author is the login that opened the thread.
	Author string

	// Participants counts the distinct logins that have commented. More than one means
	// somebody replied.
	Participants int

	// CanResolve reports whether the authenticated identity may close this thread.
	// Resolving a conversation needs write access to the repository, which a reviewer
	// holding only pull_requests:write does not have. A reviewer that can never push is
	// therefore a reviewer that can never resolve, and must retract its finding another
	// way. GitHub answers this per thread, so the capability is read rather than guessed.
	CanResolve bool

	// CommentNodeIDs are the GraphQL ids of the thread's comments, in order. They are
	// what minimizeComment takes, and minimizing is the retraction available to a
	// reviewer that may not resolve.
	CommentNodeIDs []string

	// Truncated reports that the thread carries more comments than were read. Whether
	// anybody replied is then unknown, and a reviewer that guessed would eventually
	// retract a finding somebody was still arguing with.
	Truncated bool
}

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