llm

type AnthropicClient ¶ added in v0.4.0

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

AnthropicClient is a hand-written net/http client for the Anthropic Messages API (POST {base}/v1/messages). It reuses the package-level retry/backoff loop and error classification shared with the OpenAI-compatible Client: 429 and 5xx (incl. Anthropic's 529 "overloaded") are retryable, other 4xx are fatal.

func NewAnthropicClient(cfg ClientConfig) (*AnthropicClient, error)

func (c *AnthropicClient) Complete(ctx context.Context, req Request) (Response, error)

func (c *AnthropicClient) CompleteRaw(ctx context.Context, req Request) (string, error)

type AzureConfig ¶

type AzureConfig struct {
	Endpoint   string
	Deployment string
	APIVersion string
}

AzureConfig holds the Azure OpenAI-specific endpoint coordinates, required only when provider == "azure_openai".

type ChangelogItem ¶ added in v0.4.0

type ChangelogItem struct {
	Subject string   `json:"subject"`
	Hashes  []string `json:"hashes"`
}

ChangelogItem is one AI-rewritten changelog line: prose subject plus the short hash(es) of the commit(s) it covers — the model may merge closely related commits into a single entry.

type ChangelogPayload ¶ added in v0.4.0

type ChangelogPayload struct {
	// Categories maps Keep a Changelog category names to entries. The prompt
	// tells the model to include only non-empty categories.
	Categories map[string][]ChangelogItem `json:"categories"`
	// Breaking lists breaking changes; may be empty or omitted.
	Breaking []ChangelogItem `json:"breaking"`
}

ChangelogPayload is the structured changelog the model emits inside its trailing ```changelog fenced block — the changelog analogue of the review ```risk contract (ParseRisk).

func ParseChangelogResponse(content string) (payload ChangelogPayload, ok bool)

type Client ¶

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

Client is a hand-written net/http client for an OpenAI-compatible chat/completions endpoint. It supports three providers — openai, ollama and azure_openai — that differ only in endpoint URL and auth header; the request and response JSON shape is identical across all three, so there is a single wire format. Requests are retried with exponential backoff + jitter on retryable failures (429/5xx/network), bounded by maxRetries; fatal failures (400/401/403/404) fail immediately.

func NewClient(cfg ClientConfig) (*Client, error)

func (c *Client) Complete(ctx context.Context, req Request) (Response, error)

func (c *Client) CompleteRaw(ctx context.Context, req Request) (string, error)

func (c *Client) Stream(ctx context.Context, req Request, w io.Writer) (Response, error)

type ClientConfig ¶

type ClientConfig struct {
	Provider   string
	BaseURL    string
	APIKey     string
	Timeout    time.Duration
	MaxRetries int
	Azure      AzureConfig
}

ClientConfig configures a Client. It mirrors the config.LLMConfig fields the network path needs, without importing internal/config (avoids a cycle and keeps llm reusable).

type Estimate ¶

type Estimate struct {
	Model        string
	InputTokens  int
	OutputTokens int // the configured max_tokens ceiling
	Pricing      Pricing
	CostUSD      float64
}

Estimate is the result of a cost estimation for one review request.

func EstimateCost(promptText string, maxOutputTokens int, pricing Pricing) Estimate

func (e Estimate) String() string

type GeminiClient ¶ added in v0.4.0

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

GeminiClient is a hand-written net/http client for the Google AI Studio generateContent endpoint (POST {base}/models/{model}:generateContent?key=…). It reuses the package-level retry/backoff loop and error classification shared with the other providers (429/5xx retryable, other 4xx fatal).

Because the API key rides in the URL query string, every error path that could echo a URL (transport errors wrap *url.Error, which stringifies the full URL) is redacted before surfacing — the key must never appear in error messages or logs.

func NewGeminiClient(cfg ClientConfig) (*GeminiClient, error)

func (c *GeminiClient) Complete(ctx context.Context, req Request) (Response, error)

func (c *GeminiClient) CompleteRaw(ctx context.Context, req Request) (string, error)

type Offline ¶

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

Offline is a deterministic, network-free Provider used when no API key is configured. Given the same commits and diff it always produces the same Markdown review — no time-based randomness, no external calls — so tests stay stable.

It is a genuinely useful fallback (not a "no key" stub): it summarizes commit subjects, lists changed files grouped by status, and reports rough size stats. It always carries a structured risk score (low|medium|high) computed by the shared deterministic heuristic (§7.3) — there is no model to ask.

func NewOffline(commits []gitlog.Commit, diff string) *Offline

func (o *Offline) Complete(ctx context.Context, _ Request) (Response, error)

type Pricing ¶

type Pricing struct {
	InputPer1M  float64
	OutputPer1M float64
}

Pricing is the per-1M-token price of a model, in USD.

func LookupPricing(model string) (Pricing, bool)

type Provider ¶

type Provider interface {
	Complete(ctx context.Context, req Request) (Response, error)
}

Provider produces a completion for a Request. Implemented by both the network Client and the deterministic Offline provider.

type RawCompleter ¶ added in v0.4.0

type RawCompleter interface {
	CompleteRaw(ctx context.Context, req Request) (string, error)
}

RawCompleter is an optional capability for providers that can return the assistant text verbatim, without the review risk-block parsing that Complete performs. It mirrors Streamer: an optional capability probed via a type assertion (provider.(llm.RawCompleter)), not part of the base Provider interface. changelog --ai uses it because ParseRisk over a ```changelog payload would log a spurious "risk block missing" warning and compute a meaningless heuristic. The Offline provider deliberately does NOT implement it — changelog falls back to the deterministic path before provider selection.

type Request ¶

type Request struct {
	// System is the system prompt (role=system); may be empty.
	System string
	// User is the user prompt (role=user).
	User string
	// Model, MaxTokens and Temperature come from config; the offline provider
	// ignores them.
	Model       string
	MaxTokens   int
	Temperature float64

	// Commits and Diff are pass-through context (not sent over the wire) so the
	// risk heuristic (§7.3) can be computed inside the provider without
	// re-deriving structure from the prompt text: the offline provider always
	// uses them, and the network Client uses them as a fallback when the
	// model's risk block is missing or invalid.
	Commits []gitlog.Commit
	Diff    string
}

Request is a provider-agnostic completion request.

type Response ¶

type Response struct {
	// Content is the assistant message text (Markdown for review), with any
	// trailing risk block already stripped (§7.2).
	Content string
	// Risk is always populated: the model supplies it, or the heuristic
	// fallback does (§7.2, §7.3). Consumers never need to handle an empty risk.
	Risk Risk
}

Response is a provider-agnostic completion response.

type Risk ¶

type Risk struct {
	Level     string
	Summary   string
	Heuristic bool
}

Risk is the structured risk score attached to a review (§7). Level is one of "low", "medium", "high"; Summary is a one-sentence explanation. Heuristic is true when the score was computed by the deterministic fallback (offline mode, or the model omitted a valid risk block) rather than parsed from the model's own fenced risk block.

func HeuristicRisk(commits []gitlog.Commit, diff string) Risk

func ParseRisk(content string) (stripped string, risk Risk, ok bool)

type StatusError ¶

type StatusError struct {
	StatusCode int
	Retryable  bool
	Provider   string
	Message    string
}

StatusError is a typed HTTP error carrying the status code and whether the request is worth retrying. It is used with errors.As so retry classification never relies on string matching.

func (e *StatusError) Error() string

type Streamer ¶ added in v0.3.0

type Streamer interface {
	Stream(ctx context.Context, req Request, w io.Writer) (Response, error)
}

Streamer is an optional interface for providers that support token-by-token SSE streaming. Client implements it; Offline does not.