267 lines
6.7 KiB
Go
267 lines
6.7 KiB
Go
package agent
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/openai/openai-go"
|
|
oaioption "github.com/openai/openai-go/option"
|
|
|
|
"llm-agent/prd"
|
|
)
|
|
|
|
const (
|
|
baseURL = "http://127.0.0.1:12434/v1"
|
|
maxRetries = 3
|
|
maxTurns = 10
|
|
)
|
|
|
|
var systemPrompt = `Du bist ein Coding-Agent und programmierst Go.
|
|
Erledige deine Aufgabe mit folgenden Tools:
|
|
TOOL:READ_FILE:pfad
|
|
TOOL:WRITE_FILE:pfad:<<<inhalt>>>
|
|
TOOL:LIST_FILES:pfad
|
|
|
|
REGELN:
|
|
- Nutze relative Pfade
|
|
- Kein Markdown in Dateiinhalten
|
|
- Wenn Task erledigt: schreibe nur TASK_COMPLETE`
|
|
|
|
type AgentLoop struct {
|
|
client *openai.Client
|
|
model string
|
|
workDir string
|
|
prdFile string
|
|
log *Logger
|
|
}
|
|
|
|
func NewAgentLoop(model, workDir, prdFile string, verbose bool) *AgentLoop {
|
|
client := openai.NewClient(
|
|
oaioption.WithBaseURL(baseURL),
|
|
oaioption.WithAPIKey("ollama"),
|
|
)
|
|
return &AgentLoop{
|
|
client: &client,
|
|
model: model,
|
|
workDir: workDir,
|
|
prdFile: prdFile,
|
|
log: NewLogger(verbose),
|
|
}
|
|
}
|
|
|
|
func (a *AgentLoop) Run() error {
|
|
tasks, err := prd.ParseTasks(a.prdFile)
|
|
if err != nil {
|
|
return fmt.Errorf("PRD lesen fehlgeschlagen: %w", err)
|
|
}
|
|
|
|
pending := 0
|
|
for _, t := range tasks {
|
|
if !t.Completed {
|
|
pending++
|
|
}
|
|
}
|
|
a.log.Info("📋 %d Tasks gefunden, %d offen", len(tasks), pending)
|
|
|
|
for _, task := range tasks {
|
|
if task.Completed {
|
|
a.log.Info("✅ Überspringe (bereits erledigt): %s", task.Title)
|
|
continue
|
|
}
|
|
|
|
a.log.TaskStart(task.Title)
|
|
|
|
success := false
|
|
for attempt := 1; attempt <= maxRetries; attempt++ {
|
|
if attempt > 1 {
|
|
a.log.Info("🔁 Retry %d/%d...", attempt, maxRetries)
|
|
time.Sleep(time.Duration(attempt) * 2 * time.Second)
|
|
}
|
|
|
|
if err := a.runTask(task); err == nil {
|
|
success = true
|
|
break
|
|
} else {
|
|
a.log.Info("⚠️ Fehler: %v", err)
|
|
}
|
|
}
|
|
|
|
if success {
|
|
prd.MarkTaskComplete(a.prdFile, task.Title)
|
|
a.log.TaskDone(task.Title)
|
|
} else {
|
|
a.log.TaskFailed(task.Title, maxRetries)
|
|
}
|
|
}
|
|
|
|
a.log.Info("\n🎉 Alle Tasks abgearbeitet!")
|
|
return nil
|
|
}
|
|
|
|
func (a *AgentLoop) runTask(task prd.Task) error {
|
|
// Frischer Kontext pro Task
|
|
messages := []openai.ChatCompletionMessageParamUnion{
|
|
openai.SystemMessage(systemPrompt),
|
|
openai.UserMessage(fmt.Sprintf(
|
|
"Task: %s\nArbeitsverzeichnis: %s",
|
|
task.Title,
|
|
a.workDir,
|
|
)),
|
|
}
|
|
|
|
a.log.ChatMessage("system", systemPrompt)
|
|
a.log.ChatMessage("user", fmt.Sprintf(
|
|
"Task: %s\nArbeitsverzeichnis: %s",
|
|
task.Title,
|
|
a.workDir,
|
|
))
|
|
|
|
for turn := 0; turn < maxTurns; turn++ {
|
|
a.log.Turn(turn + 1)
|
|
|
|
// Token-Schätzung für Debugging
|
|
totalChars := 0
|
|
for _, m := range messages {
|
|
totalChars += len(fmt.Sprintf("%v", m))
|
|
}
|
|
start := time.Now()
|
|
a.log.Debug("MODEL REQUEST: model=%s ~%d Zeichen\n%s", a.model, totalChars, formatMessages(messages))
|
|
resp, err := a.client.Chat.Completions.New(
|
|
context.Background(),
|
|
openai.ChatCompletionNewParams{
|
|
Model: a.model,
|
|
Messages: messages,
|
|
},
|
|
)
|
|
elapsed := time.Since(start)
|
|
if resp != nil && len(resp.Choices) > 0 {
|
|
a.log.Debug("MODEL RESPONSE\n%s", formatResponse(resp, elapsed))
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("API-Fehler (~%d Zeichen im Kontext): %w", totalChars, err)
|
|
}
|
|
|
|
response := resp.Choices[0].Message.Content
|
|
a.log.ChatMessage("assistant", response)
|
|
messages = append(messages, openai.AssistantMessage(response))
|
|
|
|
// Completion Detection
|
|
if isTaskComplete(response) {
|
|
if turn == 0 {
|
|
// LLM hat sofort TASK_COMPLETE ohne Tool-Call → nichts wurde getan
|
|
nudge := "Du hast die Datei noch nicht erstellt! Nutze zuerst WRITE_FILE, dann schreibe TASK_COMPLETE."
|
|
a.log.ChatMessage("user", nudge)
|
|
messages = append(messages, openai.UserMessage(nudge))
|
|
continue // nächster Turn
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Tool Execution
|
|
toolOutput, hadTools := ExecuteTools(response, a.workDir)
|
|
if hadTools {
|
|
a.log.ChatMessage("tool", toolOutput)
|
|
messages = append(messages, openai.UserMessage(toolOutput))
|
|
continue
|
|
}
|
|
|
|
// Kein Tool, kein TASK_COMPLETE → anstupsen
|
|
nudge := "Fahre fort. Wenn der Task erledigt ist, schreibe TASK_COMPLETE."
|
|
a.log.ChatMessage("user", nudge)
|
|
messages = append(messages, openai.UserMessage(nudge))
|
|
}
|
|
|
|
return fmt.Errorf("maximale Turns (%d) erreicht ohne TASK_COMPLETE", maxTurns)
|
|
}
|
|
|
|
// isTaskComplete erkennt TASK_COMPLETE auch bei häufigen LLM-Tippfehlern
|
|
func isTaskComplete(response string) bool {
|
|
if strings.Contains(response, "TASK_COMPLETE") {
|
|
return true
|
|
}
|
|
typos := []string{
|
|
"TUTK_COMPLETE",
|
|
"TASK_COMPLET",
|
|
"TASK_COMPLETED",
|
|
"TASK_COMPETE",
|
|
"TAKS_COMPLETE",
|
|
}
|
|
upper := strings.ToUpper(response)
|
|
for _, t := range typos {
|
|
if strings.Contains(upper, t) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// formatMessages gibt die Chat-History lesbar aus
|
|
func formatMessages(messages []openai.ChatCompletionMessageParamUnion) string {
|
|
var sb strings.Builder
|
|
for i, m := range messages {
|
|
var role, content string
|
|
|
|
switch {
|
|
case m.OfSystem != nil:
|
|
role = "system"
|
|
if len(m.OfSystem.Content.OfString.Value) > 0 {
|
|
content = m.OfSystem.Content.OfString.Value
|
|
}
|
|
case m.OfUser != nil:
|
|
role = "user"
|
|
if len(m.OfUser.Content.OfString.Value) > 0 {
|
|
content = m.OfUser.Content.OfString.Value
|
|
}
|
|
case m.OfAssistant != nil:
|
|
role = "assistant"
|
|
if len(m.OfAssistant.Content.OfString.Value) > 0 {
|
|
content = m.OfAssistant.Content.OfString.Value
|
|
}
|
|
default:
|
|
role = "unknown"
|
|
content = fmt.Sprintf("%+v", m)
|
|
}
|
|
|
|
// Inhalt auf 120 Zeichen kürzen für Übersicht
|
|
preview := content
|
|
if len(preview) > 120 {
|
|
preview = preview[:120] + "..."
|
|
}
|
|
// Zeilenumbrüche für einzeilige Darstellung ersetzen
|
|
preview = strings.ReplaceAll(preview, "\n", "↵")
|
|
|
|
sb.WriteString(fmt.Sprintf(" [%d] %-10s : %s\n", i, role, preview))
|
|
}
|
|
return sb.String()
|
|
}
|
|
|
|
func formatResponse(resp *openai.ChatCompletion, elapsed time.Duration) string {
|
|
var sb strings.Builder
|
|
|
|
sb.WriteString(fmt.Sprintf(" ID : %s\n", resp.ID))
|
|
sb.WriteString(fmt.Sprintf(" Modell : %s\n", resp.Model))
|
|
sb.WriteString(fmt.Sprintf(" Elapsed : %s\n", elapsed.Round(time.Millisecond)))
|
|
sb.WriteString(fmt.Sprintf(" Finish-Reason : %s\n", resp.Choices[0].FinishReason))
|
|
sb.WriteString(fmt.Sprintf(" Tokens : prompt=%d completion=%d total=%d\n",
|
|
resp.Usage.PromptTokens,
|
|
resp.Usage.CompletionTokens,
|
|
resp.Usage.TotalTokens,
|
|
))
|
|
|
|
// Tokens/Sekunde aus den Timing-Daten (Ollama-spezifisch)
|
|
if timings, ok := resp.JSON.ExtraFields["timings"]; ok {
|
|
sb.WriteString(fmt.Sprintf(" Timings : %s\n", timings.Raw()))
|
|
}
|
|
|
|
sb.WriteString(fmt.Sprintf(" Content :\n"))
|
|
// Inhalt eingerückt und vollständig ausgeben
|
|
content := resp.Choices[0].Message.Content
|
|
for _, line := range strings.Split(content, "\n") {
|
|
sb.WriteString(fmt.Sprintf(" %s\n", line))
|
|
}
|
|
|
|
return sb.String()
|
|
}
|