dimitar
aee63bf321
Add the AI layer that turns scan results into suggested next actions. Provider model (internal/ai): - Provider interface with Name() and Suggest(ctx, ScanResult) returning []Suggestion (repo_path, action, message, command, priority 0-2) - NewProvider factory resolves the configured provider and enforces that cloud providers have their API key in the configured env var; Ollama needs no key - OpenAIProvider: Chat Completions with response_format json_object - OllamaProvider: local /api/chat with format:json for structured output - AnthropicProvider: Messages API with system prompt and key/version headers; all three fall back to provider-appropriate defaults for base_url and model - Shared client: 60s timeout, 4 MiB response cap, JSON encode/decode, HTTP error surfaces the upstream status and body Prompt design (BuildPrompt): - Renders the full repository status table (name/status/branch/ahead/ behind/changes) plus strict output rules: exact suggestion schema, allowed actions, smallest-safe-step guidance, no invented repositories, return [] when healthy Parsing (parseSuggestions): - Tolerates ```json fences and surrounding prose, clamps priorities to 0-2, caps the result, and rejects replies without a JSON array Suggestion display (presenter.Suggestions): - "AI SUGGESTIONS" table (repository/action/priority/message/command) rendered below the scan table with priority color-coded (red/yellow/ green); empty results say all repositories are healthy Guarded execution (--ai-execute, experimental): - RunConfirmed executes a suggestion's command inside its repository only after explicit per-command y/N confirmation, and only for actions on an allowlist (commit/push/pull/stash/checkout) so LLM output can never run arbitrary shell commands; cancellation aborts remaining suggestions CLI wiring: - scan: AI block after the table when --ai is set and format is not json (JSON streams stay machine-readable); failures degrade to warnings - watch: AI is queried only on the first frame and when something changed since the previous frame, to avoid hammering the provider every interval - New --ai-execute flag and provider validation in config (openai/ollama/ anthropic), included in the config dump Testing: - httptest-based provider tests verifying request shape (model, auth headers, path), response parsing, API error bodies, HTTP failures, and cancellation - Parse tests: plain/fenced/prose replies, empty arrays, garbage, truncated JSON, priority clamping - Execution tests: unsafe actions and empty commands never run, declined confirmations are skipped, confirmed commands execute in the repo dir, failing commands surface errors - Presenter suggestion table and empty-state tests Verified: go build, go vet, go test -race, gofmt clean; end-to-end smoke test against a local fake Ollama server (request shape confirmed, table + suggestions rendered) and the missing-API-key warning path.
67 lines
1.5 KiB
Go
67 lines
1.5 KiB
Go
package ai
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// parseSuggestions extracts []Suggestion from an LLM text reply, tolerating
|
|
// ```json fences and surrounding prose. Priorities are clamped to 0..2 and
|
|
// the result is capped to a sane number of items.
|
|
func parseSuggestions(reply string) ([]Suggestion, error) {
|
|
text := stripFences(strings.TrimSpace(reply))
|
|
start := strings.IndexByte(text, '[')
|
|
end := strings.LastIndexByte(text, ']')
|
|
if start == -1 || end == -1 || end <= start {
|
|
return nil, fmt.Errorf("ai: no JSON array in reply: %s", truncate(reply, 200))
|
|
}
|
|
|
|
var out []Suggestion
|
|
if err := json.Unmarshal([]byte(text[start:end+1]), &out); err != nil {
|
|
return nil, fmt.Errorf("ai: parse suggestions: %w", err)
|
|
}
|
|
if len(out) > 50 {
|
|
out = out[:50]
|
|
}
|
|
for i := range out {
|
|
if out[i].Priority < 0 {
|
|
out[i].Priority = 0
|
|
}
|
|
if out[i].Priority > 2 {
|
|
out[i].Priority = 2
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// stripFences removes ```...``` code fences so fenced JSON parses cleanly.
|
|
func stripFences(s string) string {
|
|
if !strings.Contains(s, "```") {
|
|
return s
|
|
}
|
|
lines := strings.Split(s, "\n")
|
|
out := make([]string, 0, len(lines))
|
|
inFence := false
|
|
for _, line := range lines {
|
|
if strings.HasPrefix(strings.TrimSpace(line), "```") {
|
|
inFence = !inFence
|
|
continue
|
|
}
|
|
if inFence {
|
|
out = append(out, line)
|
|
}
|
|
}
|
|
if len(out) == 0 {
|
|
return s // fences never closed; fall back to raw content
|
|
}
|
|
return strings.Join(out, "\n")
|
|
}
|
|
|
|
func truncate(s string, n int) string {
|
|
if len(s) <= n {
|
|
return s
|
|
}
|
|
return s[:n] + "..."
|
|
}
|