review

type Finding ¶

type Finding struct {
	File             string
	Line             int
	Severity         Severity
	Title            string
	Evidence         string
	SuggestedComment string
	FixHint          string
	Confidence       float64
	Model            string
	State            FindingState
}

Finding is a validated review candidate ready for the TUI. Model and State are runtime metadata not present in the model's raw output.

type FindingCandidate ¶

type FindingCandidate struct {
	File             string  `json:"file"`
	Line             int     `json:"line"`
	Severity         string  `json:"severity"`
	Title            string  `json:"title"`
	Evidence         string  `json:"evidence"`
	SuggestedComment string  `json:"suggested_comment"`
	FixHint          string  `json:"fix_hint"`
	Confidence       float64 `json:"confidence"`
}

FindingCandidate is the transport-layer shape of a finding returned by a model CLI. Severity is kept as a string here; Validate converts it to a typed Severity.

Field ordering and JSON tags mirror docs/review-finding-schema.md exactly so the same struct can be used for both encoding the schema example in the prompt and decoding the model's reply.

type FindingState ¶

type FindingState int

FindingState is the TUI workflow state for a finding. Initial state on every fresh validation is StatePending; the TUI mutates state in M4.

const (
	StatePending FindingState = iota
	StateApproved
	StateDismissed
)

type Host ¶

type Host string

Host names the review target's hosting service.

const (
	HostGitHub Host = "github.com"
	HostGitLab Host = "gitlab.com"
)

type IssueContext ¶ added in v0.2.0

type IssueContext struct {
	Number int
	Title  string
	Body   string
	URL    string
}

IssueContext is one same-host issue a PR/MR closes. Body may be "" when the issue exists but its body could not be fetched.

type LinkedIssueFetcher ¶ added in v0.2.0

type LinkedIssueFetcher interface {
	FetchLinkedIssues(ctx context.Context, target ReviewTarget) (issues []IssueContext, notes []string, err error)
}

LinkedIssueFetcher is implemented by providers that can resolve the same-host issues a PR/MR formally closes. It is an OPTIONAL capability: the app type-asserts a provider to it and skips acceptance-criteria enrichment when the assertion fails.

Return contract:

• issues: successfully resolved acceptance criteria (may be empty).
• notes: non-fatal, human-readable diagnostics (an issue was dropped, a count cap was hit) — surfaced in the run summary, never swallowed.
• err: TOTAL failure only (the closing-refs query itself failed); the caller surfaces it as one note and proceeds with no criteria.

type ModelReviewResult ¶

type ModelReviewResult struct {
	Model     string
	Findings  []FindingCandidate
	RawOutput string
}

ModelReviewResult is what a model adapter returns after invocation. RawOutput preserves the model's stdout so the TUI's debug surface can show it when validation rejects everything.

type Quarantined ¶

type Quarantined struct {
	Candidate FindingCandidate
	Reason    string
}

Quarantined holds a finding that failed validation, with the reason preserved so the TUI's debug surface can explain why.

type ReviewInput ¶

type ReviewInput struct {
	Target      ReviewTarget
	Title       string
	Author      string
	Description string // PR/MR body, verbatim (may be ""); populated by Fetch
	// AcceptanceCriteria holds the same-host issues this PR/MR formally
	// closes, resolved via LinkedIssueFetcher. Empty is the normal "no
	// linked issues" state, not an error.
	AcceptanceCriteria []IssueContext
	Files              []*diff.DiffFile
	RawDiff            string
}

ReviewInput is the normalized input the review core consumes. Provider adapters produce this shape regardless of which CLI fetched the diff.

func (in *ReviewInput) CapContext() []string

type ReviewTarget ¶

type ReviewTarget struct {
	Host     Host
	URL      string
	Owner    string
	Repo     string
	Number   int
	HeadRef  string
	HeadSHA  string
	BaseRef  string
	BaseSHA  string
	StartSHA string
}

ReviewTarget identifies the PR/MR being reviewed.

HeadSHA is the commit OID at the time the diff was fetched. GitLab uses it directly as the posting anchor (position.head_sha). GitHub's thread mutation cannot carry a commit OID — threads implicitly anchor to the PR's current head — so there HeadSHA serves as a drift guard: posting refuses when the head has moved since fetch, instead of silently re-anchoring comments to lines the review never saw (diffsmith-cgq).

BaseSHA and StartSHA are the GitLab diff-refs required to post inline review threads (positioned at file:line in the diff view). GitHub uses HeadSHA alone; for GitLab we need all three. Empty for GitHub targets.

func (t ReviewTarget) Hostname() string

type Severity ¶

type Severity int

Severity enumerates the four severity buckets v1 supports.

const (
	SeverityHigh Severity = iota
	SeverityMedium
	SeverityLow
	SeveritySuggestion
)

func ParseSeverity(s string) (Severity, error)

func (s Severity) String() string