feat: implement go code analysis tools #41

Author: TobiasGleiter

agents/agents.go

@@ -16,6 +16,10 @@ import (
 	"github.com/bit8bytes/gogantic/tools"
 )
 
+var (
+	ErrNoFinalAnswer = errors.New("no final answer available")
+)
+
 type llm interface {
 	Generate(ctx context.Context, messages []llms.Message) (*llms.ContentResponse, error)
 }
@@ -89,27 +93,32 @@ func (a *Agent) Plan(ctx context.Context) (*Response, error) {
 		return nil, fmt.Errorf("failed to parse agent response: %w", err)
 	}
 
+	if parsed.FinalAnswer == "" && parsed.Action == "" {
+		if err := a.addAssistantMessage(ctx, generated.Result); err != nil {
+			return nil, fmt.Errorf("failed to store assistant message: %w", err)
+		}
+		if err := a.addObservationMessage(ctx, "Your last response was incomplete: it contained neither an action nor a final answer. Please continue: either call a tool or provide your final answer."); err != nil {
+			return nil, err
+		}
+		return &Response{Thought: parsed.Thought}, nil
+	}
+
 	if err := a.addAssistantMessage(ctx, generated.Result); err != nil {
 		return nil, fmt.Errorf("failed to store assistant message: %w", err)
 	}
 
 	if parsed.FinalAnswer != "" {
 		a.finalAnswer = parsed.FinalAnswer
-		return &Response{Finish: true}, nil
-	}
-
-	if parsed.Action == "" {
-		return nil, errors.New("agent response contains neither a final answer nor an action")
+		return &Response{Thought: parsed.Thought, Finish: true}, nil
 	}
 
-	a.actions = []Action{
-		{
-			Tool:      parsed.Action,
-			ToolInput: parsed.ActionInput,
-		},
+	action := Action{
+		Tool:      parsed.Action,
+		ToolInput: parsed.ActionInput,
 	}
+	a.actions = []Action{action}
 
-	return &Response{}, nil
+	return &Response{Thought: parsed.Thought, Actions: []Action{action}}, nil
 }
 
 // Act executes the tool chosen by Plan and adds the result as an observation.
@@ -148,7 +157,7 @@ func (a *Agent) clearActions() {
 // Only call this after Plan returns Finish=true.
 func (a *Agent) Answer() (string, error) {
 	if a.finalAnswer == "" {
-		return "", errors.New("no final answer available")
+		return "", ErrNoFinalAnswer
 	}
 	return a.finalAnswer, nil
 }

agents/react.go

@@ -3,6 +3,7 @@ package agents
 import (
 	"context"
 	"fmt"
+	"os"
 	"strings"
 
 	"github.com/bit8bytes/gogantic/inputs/roles"
@@ -35,13 +36,17 @@ func buildReActPrompt(tools map[string]Tool, jsonInstructions string) []llms.Mes
 		fmt.Fprintf(&toolDescriptions, "- %s: %s\n", t.Name(), t.Description())
 	}
 
+	wd, _ := os.Getwd()
+
 	return []llms.Message{
 		{
 			Role: roles.System,
 			Content: fmt.Sprintf(`
 You are an helpful agent. Answer questions using the available tools.
 Do not estimate or predict values. Use only values returned by tools.
 
+Working directory: %s
+
 Available tools:
 %s
 %s
@@ -54,7 +59,7 @@ Respond with a JSON object on each turn with these fields:
 
 When you have enough information to answer, set "action" and "action_input" to "" and put a detailed answer based on your observations — MUST be non-empty when done; be thorough and include all relevant findings.
 
-Think step by step. Do not hallucinate.`, toolDescriptions.String(), jsonInstructions),
+Think step by step. Do not hallucinate.`, wd, toolDescriptions.String(), jsonInstructions),
 		},
 	}
 }

agents/types.go

@@ -17,5 +17,6 @@ type Action struct {
 // Response indicates whether the agent loop should continue or finish.
 type Response struct {
 	Actions []Action
+	Thought string
 	Finish  bool
 }

examples/agents/ollama/main.go examples/agents/main.goexamples/agents/ollama/main.go renamed to examples/agents/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"database/sql"
+	"errors"
 	"fmt"
 	"time"
 
@@ -59,24 +60,20 @@ func main() {
 
 	// These tools are specifically designed for Golang.
 	tools := []agents.Tool{
-		tools.ListGoPackages{},
-		tools.ParseGoFile{},
-		tools.FindIdent{},
+		tools.ListDeclarations{},
 		tools.FindCalls{},
-		tools.FindImporters{},
-		tools.FindImplementors{},
+		tools.FindUsages{},
+		tools.GetFunctionSignature{},
+		tools.GetStructFields{},
+		tools.RunGoVet{},
 	}
 
 	agent, err := agents.NewReAct(ctx, model, tools, storage)
 	if err != nil {
 		panic(err)
 	}
 
-	task := `
-		Analyze the current Go code base and evaluate its maintainability. Produce a short report.`
-	// task := `
-	// 	Find all types in this codebase that implement the parser interface.
-	// 	For each type, show which package and file it is defined in.`
+	task := `Where is the NewReAct function called?`
 	if err := agent.Task(ctx, task); err != nil {
 		panic(err)
 	}
@@ -87,8 +84,9 @@ func main() {
 	}
 
 	finalAnswer, err := agent.Answer()
-	if err != nil {
-		panic(err)
+	if errors.Is(err, agents.ErrNoFinalAnswer) {
+		fmt.Println("No final answer found")
+		return
 	}
 	fmt.Println(finalAnswer)
 }

examples/outputs/jsonout/main.go

@@ -47,6 +47,15 @@ RUN:
 				return fmt.Errorf("planning failed: %w", err)
 			}
 
+			if r.printMessages {
+				if response.Thought != "" {
+					fmt.Printf("%sTHOUGHT:%s %s\n", cyan, reset, response.Thought)
+				}
+				for _, a := range response.Actions {
+					fmt.Printf("%sACTION:%s  %s(%s)\n", blue, reset, a.Tool, a.ToolInput)
+				}
+			}
+
 			if response.Finish {
 				return nil
 			}

runner/runner.go

@@ -1,4 +1,3 @@
-// NOTE: This file was generated by AI and needs to be evaluated and refactored before production use.
 package tools
 
 import (
@@ -10,6 +9,47 @@ import (
 	"strings"
 )
 
+func docString(cg *ast.CommentGroup) string {
+	if cg == nil {
+		return ""
+	}
+	return strings.TrimSpace(cg.Text())
+}
+
+func exprString(e ast.Expr) string {
+	switch t := e.(type) {
+	case *ast.Ident:
+		return t.Name
+	case *ast.StarExpr:
+		return "*" + exprString(t.X)
+	case *ast.SelectorExpr:
+		return exprString(t.X) + "." + t.Sel.Name
+	case *ast.ArrayType:
+		return "[]" + exprString(t.Elt)
+	case *ast.MapType:
+		return "map[" + exprString(t.Key) + "]" + exprString(t.Value)
+	case *ast.InterfaceType:
+		return "interface{}"
+	case *ast.StructType:
+		return "struct{}"
+	case *ast.Ellipsis:
+		return "..." + exprString(t.Elt)
+	default:
+		return "..."
+	}
+}
+
+func recvTypeName(e ast.Expr) string {
+	switch t := e.(type) {
+	case *ast.Ident:
+		return t.Name
+	case *ast.StarExpr:
+		return recvTypeName(t.X)
+	default:
+		return ""
+	}
+}
+
 func walkGoFiles(dir string, fset *token.FileSet) ([]*ast.File, error) {
 	var files []*ast.File
 	err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {

tools/ast.go

@@ -1,11 +1,11 @@
-// NOTE: This file was generated by AI and needs to be evaluated and refactored before production use.
 package tools
 
 import (
 	"context"
 	"fmt"
 	"go/ast"
 	"go/token"
+	"path/filepath"
 	"strings"
 )
 
@@ -16,7 +16,8 @@ func (t FindCalls) Name() string { return "FindCalls" }
 func (t FindCalls) Description() string {
 	return `Find all call sites of a function by name in a Go codebase.
 Matches both direct calls (f()) and method calls (obj.f()).
-Input: two lines — directory path, then function name (e.g. 'Println').`
+Input: two lines — absolute filesystem path to a directory containing .go files, then function name.
+Use the working directory from the system prompt as the starting path.`
 }
 
 func (t FindCalls) Execute(ctx context.Context, input Input) (Output, error) {
@@ -41,7 +42,8 @@ func (t FindCalls) Execute(ctx context.Context, input Input) (Output, error) {
 			}
 			if callFuncName(call.Fun) == funcName {
 				pos := fset.Position(call.Pos())
-				fmt.Fprintf(&b, "%s:%d\n", pos.Filename, pos.Line)
+				rel, _ := filepath.Rel(dir, pos.Filename)
+				fmt.Fprintf(&b, "%s:%d\n", rel, pos.Line)
 				found++
 			}
 			return true