Initial commit
diff --git a/loop/agent.go b/loop/agent.go
new file mode 100644
index 0000000..ce362e6
--- /dev/null
+++ b/loop/agent.go
@@ -0,0 +1,1124 @@
+package loop
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "log/slog"
+ "net/http"
+ "os"
+ "os/exec"
+ "runtime/debug"
+ "slices"
+ "strings"
+ "sync"
+ "time"
+
+ "sketch.dev/ant"
+ "sketch.dev/claudetool"
+)
+
+const (
+ userCancelMessage = "user requested agent to stop handling responses"
+)
+
+type CodingAgent interface {
+ // Init initializes an agent inside a docker container.
+ Init(AgentInit) error
+
+ // Ready returns a channel closed after Init successfully called.
+ Ready() <-chan struct{}
+
+ // URL reports the HTTP URL of this agent.
+ URL() string
+
+ // UserMessage enqueues a message to the agent and returns immediately.
+ UserMessage(ctx context.Context, msg string)
+
+ // WaitForMessage blocks until the agent has a response to give.
+ // Use AgentMessage.EndOfTurn to help determine if you want to
+ // drain the agent.
+ WaitForMessage(ctx context.Context) AgentMessage
+
+ // Loop begins the agent loop returns only when ctx is cancelled.
+ Loop(ctx context.Context)
+
+ CancelInnerLoop(cause error)
+
+ CancelToolUse(toolUseID string, cause error) error
+
+ // Returns a subset of the agent's message history.
+ Messages(start int, end int) []AgentMessage
+
+ // Returns the current number of messages in the history
+ MessageCount() int
+
+ TotalUsage() ant.CumulativeUsage
+ OriginalBudget() ant.Budget
+
+ // WaitForMessageCount returns when the agent has at more than clientMessageCount messages or the context is done.
+ WaitForMessageCount(ctx context.Context, greaterThan int)
+
+ WorkingDir() string
+
+ // Diff returns a unified diff of changes made since the agent was instantiated.
+ // If commit is non-nil, it shows the diff for just that specific commit.
+ Diff(commit *string) (string, error)
+
+ // InitialCommit returns the Git commit hash that was saved when the agent was instantiated.
+ InitialCommit() string
+
+ // Title returns the current title of the conversation.
+ Title() string
+
+ // OS returns the operating system of the client.
+ OS() string
+}
+
+type CodingAgentMessageType string
+
+const (
+ UserMessageType CodingAgentMessageType = "user"
+ AgentMessageType CodingAgentMessageType = "agent"
+ ErrorMessageType CodingAgentMessageType = "error"
+ BudgetMessageType CodingAgentMessageType = "budget" // dedicated for "out of budget" errors
+ ToolUseMessageType CodingAgentMessageType = "tool"
+ CommitMessageType CodingAgentMessageType = "commit" // for displaying git commits
+ AutoMessageType CodingAgentMessageType = "auto" // for automated notifications like autoformatting
+
+ cancelToolUseMessage = "Stop responding to my previous message. Wait for me to ask you something else before attempting to use any more tools."
+)
+
+type AgentMessage struct {
+ Type CodingAgentMessageType `json:"type"`
+ // EndOfTurn indicates that the AI is done working and is ready for the next user input.
+ EndOfTurn bool `json:"end_of_turn"`
+
+ Content string `json:"content"`
+ ToolName string `json:"tool_name,omitempty"`
+ ToolInput string `json:"input,omitempty"`
+ ToolResult string `json:"tool_result,omitempty"`
+ ToolError bool `json:"tool_error,omitempty"`
+ ToolCallId string `json:"tool_call_id,omitempty"`
+
+ // ToolCalls is a list of all tool calls requested in this message (name and input pairs)
+ ToolCalls []ToolCall `json:"tool_calls,omitempty"`
+
+ // Commits is a list of git commits for a commit message
+ Commits []*GitCommit `json:"commits,omitempty"`
+
+ Timestamp time.Time `json:"timestamp"`
+ ConversationID string `json:"conversation_id"`
+ ParentConversationID *string `json:"parent_conversation_id,omitempty"`
+ Usage *ant.Usage `json:"usage,omitempty"`
+
+ // Message timing information
+ StartTime *time.Time `json:"start_time,omitempty"`
+ EndTime *time.Time `json:"end_time,omitempty"`
+ Elapsed *time.Duration `json:"elapsed,omitempty"`
+
+ // Turn duration - the time taken for a complete agent turn
+ TurnDuration *time.Duration `json:"turnDuration,omitempty"`
+
+ Idx int `json:"idx"`
+}
+
+// GitCommit represents a single git commit for a commit message
+type GitCommit struct {
+ Hash string `json:"hash"` // Full commit hash
+ Subject string `json:"subject"` // Commit subject line
+ Body string `json:"body"` // Full commit message body
+ PushedBranch string `json:"pushed_branch,omitempty"` // If set, this commit was pushed to this branch
+}
+
+// ToolCall represents a single tool call within an agent message
+type ToolCall struct {
+ Name string `json:"name"`
+ Input string `json:"input"`
+ ToolCallId string `json:"tool_call_id"`
+}
+
+func (a *AgentMessage) Attr() slog.Attr {
+ var attrs []any = []any{
+ slog.String("type", string(a.Type)),
+ }
+ if a.EndOfTurn {
+ attrs = append(attrs, slog.Bool("end_of_turn", a.EndOfTurn))
+ }
+ if a.Content != "" {
+ attrs = append(attrs, slog.String("content", a.Content))
+ }
+ if a.ToolName != "" {
+ attrs = append(attrs, slog.String("tool_name", a.ToolName))
+ }
+ if a.ToolInput != "" {
+ attrs = append(attrs, slog.String("tool_input", a.ToolInput))
+ }
+ if a.Elapsed != nil {
+ attrs = append(attrs, slog.Int64("elapsed", a.Elapsed.Nanoseconds()))
+ }
+ if a.TurnDuration != nil {
+ attrs = append(attrs, slog.Int64("turnDuration", a.TurnDuration.Nanoseconds()))
+ }
+ if a.ToolResult != "" {
+ attrs = append(attrs, slog.String("tool_result", a.ToolResult))
+ }
+ if a.ToolError {
+ attrs = append(attrs, slog.Bool("tool_error", a.ToolError))
+ }
+ if len(a.ToolCalls) > 0 {
+ toolCallAttrs := make([]any, 0, len(a.ToolCalls))
+ for i, tc := range a.ToolCalls {
+ toolCallAttrs = append(toolCallAttrs, slog.Group(
+ fmt.Sprintf("tool_call_%d", i),
+ slog.String("name", tc.Name),
+ slog.String("input", tc.Input),
+ ))
+ }
+ attrs = append(attrs, slog.Group("tool_calls", toolCallAttrs...))
+ }
+ if a.ConversationID != "" {
+ attrs = append(attrs, slog.String("convo_id", a.ConversationID))
+ }
+ if a.ParentConversationID != nil {
+ attrs = append(attrs, slog.String("parent_convo_id", *a.ParentConversationID))
+ }
+ if a.Usage != nil && !a.Usage.IsZero() {
+ attrs = append(attrs, a.Usage.Attr())
+ }
+ // TODO: timestamp, convo ids, idx?
+ return slog.Group("agent_message", attrs...)
+}
+
+func errorMessage(err error) AgentMessage {
+ // It's somewhat unknowable whether error messages are "end of turn" or not, but it seems like the best approach.
+ if os.Getenv(("DEBUG")) == "1" {
+ return AgentMessage{Type: ErrorMessageType, Content: err.Error() + " Stacktrace: " + string(debug.Stack()), EndOfTurn: true}
+ }
+
+ return AgentMessage{Type: ErrorMessageType, Content: err.Error(), EndOfTurn: true}
+}
+
+func budgetMessage(err error) AgentMessage {
+ return AgentMessage{Type: BudgetMessageType, Content: err.Error(), EndOfTurn: true}
+}
+
+// ConvoInterface defines the interface for conversation interactions
+type ConvoInterface interface {
+ CumulativeUsage() ant.CumulativeUsage
+ ResetBudget(ant.Budget)
+ OverBudget() error
+ SendMessage(message ant.Message) (*ant.MessageResponse, error)
+ SendUserTextMessage(s string, otherContents ...ant.Content) (*ant.MessageResponse, error)
+ ToolResultContents(ctx context.Context, resp *ant.MessageResponse) ([]ant.Content, error)
+ ToolResultCancelContents(resp *ant.MessageResponse) ([]ant.Content, error)
+ CancelToolUse(toolUseID string, cause error) error
+}
+
+type Agent struct {
+ convo ConvoInterface
+ config AgentConfig // config for this agent
+ workingDir string
+ repoRoot string // workingDir may be a subdir of repoRoot
+ url string
+ lastHEAD string // hash of the last HEAD that was pushed to the host (only when under docker)
+ initialCommit string // hash of the Git HEAD when the agent was instantiated or Init()
+ gitRemoteAddr string // HTTP URL of the host git repo (only when under docker)
+ ready chan struct{} // closed when the agent is initialized (only when under docker)
+ startedAt time.Time
+ originalBudget ant.Budget
+ title string
+ codereview *claudetool.CodeReviewer
+
+ // Time when the current turn started (reset at the beginning of InnerLoop)
+ startOfTurn time.Time
+
+ // Inbox - for messages from the user to the agent.
+ // sent on by UserMessage
+ // . e.g. when user types into the chat textarea
+ // read from by GatherMessages
+ inbox chan string
+
+ // Outbox
+ // sent on by pushToOutbox
+ // via OnToolResult and OnResponse callbacks
+ // read from by WaitForMessage
+ // called by termui inside its repl loop.
+ outbox chan AgentMessage
+
+ // protects cancelInnerLoop
+ cancelInnerLoopMu sync.Mutex
+ // cancels potentially long-running tool_use calls or chains of them
+ cancelInnerLoop context.CancelCauseFunc
+
+ // protects following
+ mu sync.Mutex
+
+ // Stores all messages for this agent
+ history []AgentMessage
+
+ listeners []chan struct{}
+
+ // Track git commits we've already seen (by hash)
+ seenCommits map[string]bool
+}
+
+func (a *Agent) URL() string { return a.url }
+
+// Title returns the current title of the conversation.
+// If no title has been set, returns an empty string.
+func (a *Agent) Title() string {
+ a.mu.Lock()
+ defer a.mu.Unlock()
+ return a.title
+}
+
+// OS returns the operating system of the client.
+func (a *Agent) OS() string {
+ return a.config.ClientGOOS
+}
+
+// SetTitle sets the title of the conversation.
+func (a *Agent) SetTitle(title string) {
+ a.mu.Lock()
+ defer a.mu.Unlock()
+ a.title = title
+ // Notify all listeners that the state has changed
+ for _, ch := range a.listeners {
+ close(ch)
+ }
+ a.listeners = a.listeners[:0]
+}
+
+// OnToolResult implements ant.Listener.
+func (a *Agent) OnToolResult(ctx context.Context, convo *ant.Convo, toolName string, toolInput json.RawMessage, content ant.Content, result *string, err error) {
+ m := AgentMessage{
+ Type: ToolUseMessageType,
+ Content: content.Text,
+ ToolResult: content.ToolResult,
+ ToolError: content.ToolError,
+ ToolName: toolName,
+ ToolInput: string(toolInput),
+ ToolCallId: content.ToolUseID,
+ StartTime: content.StartTime,
+ EndTime: content.EndTime,
+ }
+
+ // Calculate the elapsed time if both start and end times are set
+ if content.StartTime != nil && content.EndTime != nil {
+ elapsed := content.EndTime.Sub(*content.StartTime)
+ m.Elapsed = &elapsed
+ }
+
+ m.ConversationID = convo.ID
+ if convo.Parent != nil {
+ m.ParentConversationID = &convo.Parent.ID
+ }
+ a.pushToOutbox(ctx, m)
+}
+
+// OnRequest implements ant.Listener.
+func (a *Agent) OnRequest(ctx context.Context, convo *ant.Convo, msg *ant.Message) {
+ // No-op.
+ // We already get tool results from the above. We send user messages to the outbox in the agent loop.
+}
+
+// OnResponse implements ant.Listener. Responses contain messages from the LLM
+// that need to be displayed (as well as tool calls that we send along when
+// they're done). (It would be reasonable to also mention tool calls when they're
+// started, but we don't do that yet.)
+func (a *Agent) OnResponse(ctx context.Context, convo *ant.Convo, resp *ant.MessageResponse) {
+ endOfTurn := false
+ if resp.StopReason != ant.StopReasonToolUse {
+ endOfTurn = true
+ }
+ m := AgentMessage{
+ Type: AgentMessageType,
+ Content: collectTextContent(resp),
+ EndOfTurn: endOfTurn,
+ Usage: &resp.Usage,
+ StartTime: resp.StartTime,
+ EndTime: resp.EndTime,
+ }
+
+ // Extract any tool calls from the response
+ if resp.StopReason == ant.StopReasonToolUse {
+ var toolCalls []ToolCall
+ for _, part := range resp.Content {
+ if part.Type == "tool_use" {
+ toolCalls = append(toolCalls, ToolCall{
+ Name: part.ToolName,
+ Input: string(part.ToolInput),
+ ToolCallId: part.ID,
+ })
+ }
+ }
+ m.ToolCalls = toolCalls
+ }
+
+ // Calculate the elapsed time if both start and end times are set
+ if resp.StartTime != nil && resp.EndTime != nil {
+ elapsed := resp.EndTime.Sub(*resp.StartTime)
+ m.Elapsed = &elapsed
+ }
+
+ m.ConversationID = convo.ID
+ if convo.Parent != nil {
+ m.ParentConversationID = &convo.Parent.ID
+ }
+ a.pushToOutbox(ctx, m)
+}
+
+// WorkingDir implements CodingAgent.
+func (a *Agent) WorkingDir() string {
+ return a.workingDir
+}
+
+// MessageCount implements CodingAgent.
+func (a *Agent) MessageCount() int {
+ a.mu.Lock()
+ defer a.mu.Unlock()
+ return len(a.history)
+}
+
+// Messages implements CodingAgent.
+func (a *Agent) Messages(start int, end int) []AgentMessage {
+ a.mu.Lock()
+ defer a.mu.Unlock()
+ return slices.Clone(a.history[start:end])
+}
+
+func (a *Agent) OriginalBudget() ant.Budget {
+ return a.originalBudget
+}
+
+// AgentConfig contains configuration for creating a new Agent.
+type AgentConfig struct {
+ Context context.Context
+ AntURL string
+ APIKey string
+ HTTPC *http.Client
+ Budget ant.Budget
+ GitUsername string
+ GitEmail string
+ SessionID string
+ ClientGOOS string
+ ClientGOARCH string
+ UseAnthropicEdit bool
+}
+
+// NewAgent creates a new Agent.
+// It is not usable until Init() is called.
+func NewAgent(config AgentConfig) *Agent {
+ agent := &Agent{
+ config: config,
+ ready: make(chan struct{}),
+ inbox: make(chan string, 100),
+ outbox: make(chan AgentMessage, 100),
+ startedAt: time.Now(),
+ originalBudget: config.Budget,
+ seenCommits: make(map[string]bool),
+ }
+ return agent
+}
+
+type AgentInit struct {
+ WorkingDir string
+ NoGit bool // only for testing
+
+ InDocker bool
+ Commit string
+ GitRemoteAddr string
+ HostAddr string
+}
+
+func (a *Agent) Init(ini AgentInit) error {
+ ctx := a.config.Context
+ if ini.InDocker {
+ cmd := exec.CommandContext(ctx, "git", "stash")
+ cmd.Dir = ini.WorkingDir
+ if out, err := cmd.CombinedOutput(); err != nil {
+ return fmt.Errorf("git stash: %s: %v", out, err)
+ }
+ cmd = exec.CommandContext(ctx, "git", "fetch", ini.GitRemoteAddr)
+ cmd.Dir = ini.WorkingDir
+ if out, err := cmd.CombinedOutput(); err != nil {
+ return fmt.Errorf("git fetch: %s: %w", out, err)
+ }
+ cmd = exec.CommandContext(ctx, "git", "checkout", "-f", ini.Commit)
+ cmd.Dir = ini.WorkingDir
+ if out, err := cmd.CombinedOutput(); err != nil {
+ return fmt.Errorf("git checkout %s: %s: %w", ini.Commit, out, err)
+ }
+ a.lastHEAD = ini.Commit
+ a.gitRemoteAddr = ini.GitRemoteAddr
+ a.initialCommit = ini.Commit
+ if ini.HostAddr != "" {
+ a.url = "http://" + ini.HostAddr
+ }
+ }
+ a.workingDir = ini.WorkingDir
+
+ if !ini.NoGit {
+ repoRoot, err := repoRoot(ctx, a.workingDir)
+ if err != nil {
+ return fmt.Errorf("repoRoot: %w", err)
+ }
+ a.repoRoot = repoRoot
+
+ commitHash, err := resolveRef(ctx, a.repoRoot, "HEAD")
+ if err != nil {
+ return fmt.Errorf("resolveRef: %w", err)
+ }
+ a.initialCommit = commitHash
+
+ codereview, err := claudetool.NewCodeReviewer(ctx, a.repoRoot, a.initialCommit)
+ if err != nil {
+ return fmt.Errorf("Agent.Init: claudetool.NewCodeReviewer: %w", err)
+ }
+ a.codereview = codereview
+ }
+ a.lastHEAD = a.initialCommit
+ a.convo = a.initConvo()
+ close(a.ready)
+ return nil
+}
+
+// initConvo initializes the conversation.
+// It must not be called until all agent fields are initialized,
+// particularly workingDir and git.
+func (a *Agent) initConvo() *ant.Convo {
+ ctx := a.config.Context
+ convo := ant.NewConvo(ctx, a.config.APIKey)
+ if a.config.HTTPC != nil {
+ convo.HTTPC = a.config.HTTPC
+ }
+ if a.config.AntURL != "" {
+ convo.URL = a.config.AntURL
+ }
+ convo.PromptCaching = true
+ convo.Budget = a.config.Budget
+
+ var editPrompt string
+ if a.config.UseAnthropicEdit {
+ editPrompt = "Then use the str_replace_editor tool to make those edits. For short complete file replacements, you may use the bash tool with cat and heredoc stdin."
+ } else {
+ editPrompt = "Then use the patch tool to make those edits. Combine all edits to any given file into a single patch tool call."
+ }
+
+ convo.SystemPrompt = fmt.Sprintf(`
+You are an expert coding assistant and architect, with a specialty in Go.
+You are assisting the user to achieve their goals.
+
+Start by asking concise clarifying questions as needed.
+Once the intent is clear, work autonomously.
+
+Call the title tool early in the conversation to provide a brief summary of
+what the chat is about.
+
+Break down the overall goal into a series of smaller steps.
+(The first step is often: "Make a plan.")
+Then execute each step using tools.
+Update the plan if you have encountered problems or learned new information.
+
+When in doubt about a step, follow this broad workflow:
+
+- Think about how the current step fits into the overall plan.
+- Do research. Good tool choices: bash, think, keyword_search
+- Make edits.
+- Repeat.
+
+To make edits reliably and efficiently, first think about the intent of the edit,
+and what set of patches will achieve that intent.
+%s
+
+For renames or refactors, consider invoking gopls (via bash).
+
+The done tool provides a checklist of items you MUST verify and
+review before declaring that you are done. Before executing
+the done tool, run all the tools the done tool checklist asks
+for, including creating a git commit. Do not forget to run tests.
+
+<platform>
+%s/%s
+</platform>
+<pwd>
+%v
+</pwd>
+<git_root>
+%v
+</git_root>
+`, editPrompt, a.config.ClientGOOS, a.config.ClientGOARCH, a.workingDir, a.repoRoot)
+
+ // Register all tools with the conversation
+ // When adding, removing, or modifying tools here, double-check that the termui tool display
+ // template in termui/termui.go has pretty-printing support for all tools.
+ convo.Tools = []*ant.Tool{
+ claudetool.Bash, claudetool.Keyword,
+ claudetool.Think, a.titleTool(), makeDoneTool(a.codereview, a.config.GitUsername, a.config.GitEmail),
+ a.codereview.Tool(),
+ }
+ if a.config.UseAnthropicEdit {
+ convo.Tools = append(convo.Tools, claudetool.AnthropicEditTool)
+ } else {
+ convo.Tools = append(convo.Tools, claudetool.Patch)
+ }
+ convo.Listener = a
+ return convo
+}
+
+func (a *Agent) titleTool() *ant.Tool {
+ // titleTool creates the title tool that sets the conversation title.
+ title := &ant.Tool{
+ Name: "title",
+ Description: `Use this tool early in the conversation, BEFORE MAKING ANY GIT COMMITS, to summarize what the chat is about briefly.`,
+ InputSchema: json.RawMessage(`{
+ "type": "object",
+ "properties": {
+ "title": {
+ "type": "string",
+ "description": "A brief title summarizing what this chat is about"
+ }
+ },
+ "required": ["title"]
+}`),
+ Run: func(ctx context.Context, input json.RawMessage) (string, error) {
+ var params struct {
+ Title string `json:"title"`
+ }
+ if err := json.Unmarshal(input, ¶ms); err != nil {
+ return "", err
+ }
+ a.SetTitle(params.Title)
+ return fmt.Sprintf("Title set to: %s", params.Title), nil
+ },
+ }
+ return title
+}
+
+func (a *Agent) Ready() <-chan struct{} {
+ return a.ready
+}
+
+func (a *Agent) UserMessage(ctx context.Context, msg string) {
+ a.pushToOutbox(ctx, AgentMessage{Type: UserMessageType, Content: msg})
+ a.inbox <- msg
+}
+
+func (a *Agent) WaitForMessage(ctx context.Context) AgentMessage {
+ // TODO: Should this drain any outbox messages in case there are multiple?
+ select {
+ case msg := <-a.outbox:
+ return msg
+ case <-ctx.Done():
+ return errorMessage(ctx.Err())
+ }
+}
+
+func (a *Agent) CancelToolUse(toolUseID string, cause error) error {
+ return a.convo.CancelToolUse(toolUseID, cause)
+}
+
+func (a *Agent) CancelInnerLoop(cause error) {
+ a.cancelInnerLoopMu.Lock()
+ defer a.cancelInnerLoopMu.Unlock()
+ if a.cancelInnerLoop != nil {
+ a.cancelInnerLoop(cause)
+ }
+}
+
+func (a *Agent) Loop(ctxOuter context.Context) {
+ for {
+ select {
+ case <-ctxOuter.Done():
+ return
+ default:
+ ctxInner, cancel := context.WithCancelCause(ctxOuter)
+ a.cancelInnerLoopMu.Lock()
+ // Set .cancelInnerLoop so the user can cancel whatever is happening
+ // inside InnerLoop(ctxInner) without canceling this outer Loop execution.
+ // This CancelInnerLoop func is intended be called from other goroutines,
+ // hence the mutex.
+ a.cancelInnerLoop = cancel
+ a.cancelInnerLoopMu.Unlock()
+ a.InnerLoop(ctxInner)
+ cancel(nil)
+ }
+ }
+}
+
+func (a *Agent) pushToOutbox(ctx context.Context, m AgentMessage) {
+ if m.Timestamp.IsZero() {
+ m.Timestamp = time.Now()
+ }
+
+ // If this is an end-of-turn message, calculate the turn duration and add it to the message
+ if m.EndOfTurn && m.Type == AgentMessageType {
+ turnDuration := time.Since(a.startOfTurn)
+ m.TurnDuration = &turnDuration
+ slog.InfoContext(ctx, "Turn completed", "turnDuration", turnDuration)
+ }
+
+ slog.InfoContext(ctx, "agent message", m.Attr())
+
+ a.mu.Lock()
+ defer a.mu.Unlock()
+ m.Idx = len(a.history)
+ a.history = append(a.history, m)
+ a.outbox <- m
+
+ // Notify all listeners:
+ for _, ch := range a.listeners {
+ close(ch)
+ }
+ a.listeners = a.listeners[:0]
+}
+
+func (a *Agent) GatherMessages(ctx context.Context, block bool) ([]ant.Content, error) {
+ var m []ant.Content
+ if block {
+ select {
+ case <-ctx.Done():
+ return m, ctx.Err()
+ case msg := <-a.inbox:
+ m = append(m, ant.Content{Type: "text", Text: msg})
+ }
+ }
+ for {
+ select {
+ case msg := <-a.inbox:
+ m = append(m, ant.Content{Type: "text", Text: msg})
+ default:
+ return m, nil
+ }
+ }
+}
+
+func (a *Agent) InnerLoop(ctx context.Context) {
+ // Reset the start of turn time
+ a.startOfTurn = time.Now()
+
+ // Wait for at least one message from the user.
+ msgs, err := a.GatherMessages(ctx, true)
+ if err != nil { // e.g. the context was canceled while blocking in GatherMessages
+ return
+ }
+ // We do this as we go, but let's also do it at the end of the turn
+ defer func() {
+ if _, err := a.handleGitCommits(ctx); err != nil {
+ // Just log the error, don't stop execution
+ slog.WarnContext(ctx, "Failed to check for new git commits", "error", err)
+ }
+ }()
+
+ userMessage := ant.Message{
+ Role: "user",
+ Content: msgs,
+ }
+ // convo.SendMessage does the actual network call to send this to anthropic. This blocks until the response is ready.
+ // TODO: pass ctx to SendMessage, and figure out how to square that ctx with convo's own .Ctx. Who owns the scope of this call?
+ resp, err := a.convo.SendMessage(userMessage)
+ if err != nil {
+ a.pushToOutbox(ctx, errorMessage(err))
+ return
+ }
+ for {
+ // TODO: here and below where we check the budget,
+ // we should review the UX: is it clear what happened?
+ // is it clear how to resume?
+ // should we let the user set a new budget?
+ if err := a.overBudget(ctx); err != nil {
+ return
+ }
+ if resp.StopReason != ant.StopReasonToolUse {
+ break
+ }
+ var results []ant.Content
+ cancelled := false
+ select {
+ case <-ctx.Done():
+ // Don't actually run any of the tools, but rather build a response
+ // for each tool_use message letting the LLM know that user canceled it.
+ results, err = a.convo.ToolResultCancelContents(resp)
+ if err != nil {
+ a.pushToOutbox(ctx, errorMessage(err))
+ }
+ cancelled = true
+ default:
+ ctx = claudetool.WithWorkingDir(ctx, a.workingDir)
+ // fall-through, when the user has not canceled the inner loop:
+ results, err = a.convo.ToolResultContents(ctx, resp)
+ if ctx.Err() != nil { // e.g. the user canceled the operation
+ cancelled = true
+ } else if err != nil {
+ a.pushToOutbox(ctx, errorMessage(err))
+ }
+ }
+
+ // Check for git commits. Currently we do this here, after we collect
+ // tool results, since that's when we know commits could have happened.
+ // We could instead do this when the turn ends, but I think it makes sense
+ // to do this as we go.
+ newCommits, err := a.handleGitCommits(ctx)
+ if err != nil {
+ // Just log the error, don't stop execution
+ slog.WarnContext(ctx, "Failed to check for new git commits", "error", err)
+ }
+ var autoqualityMessages []string
+ if len(newCommits) == 1 {
+ formatted := a.codereview.Autoformat(ctx)
+ if len(formatted) > 0 {
+ msg := fmt.Sprintf(`
+I ran autoformatters and they updated these files:
+
+%s
+
+Please amend your latest git commit with these changes and then continue with what you were doing.`,
+ strings.Join(formatted, "\n"),
+ )[1:]
+ a.pushToOutbox(ctx, AgentMessage{
+ Type: AutoMessageType,
+ Content: msg,
+ Timestamp: time.Now(),
+ })
+ autoqualityMessages = append(autoqualityMessages, msg)
+ }
+ }
+
+ if err := a.overBudget(ctx); err != nil {
+ return
+ }
+
+ // Include, along with the tool results (which must go first for whatever reason),
+ // any messages that the user has sent along while the tool_use was executing concurrently.
+ msgs, err = a.GatherMessages(ctx, false)
+ if err != nil {
+ return
+ }
+ // Inject any auto-generated messages from quality checks.
+ for _, msg := range autoqualityMessages {
+ msgs = append(msgs, ant.Content{Type: "text", Text: msg})
+ }
+ if cancelled {
+ msgs = append(msgs, ant.Content{Type: "text", Text: cancelToolUseMessage})
+ // EndOfTurn is false here so that the client of this agent keeps processing
+ // messages from WaitForMessage() and gets the response from the LLM (usually
+ // something like "okay, I'll wait further instructions", but the user should
+ // be made aware of it regardless).
+ a.pushToOutbox(ctx, AgentMessage{Type: ErrorMessageType, Content: userCancelMessage, EndOfTurn: false})
+ } else if err := a.convo.OverBudget(); err != nil {
+ budgetMsg := "We've exceeded our budget. Please ask the user to confirm before continuing by ending the turn."
+ msgs = append(msgs, ant.Content{Type: "text", Text: budgetMsg})
+ a.pushToOutbox(ctx, budgetMessage(fmt.Errorf("warning: %w (ask to keep trying, if you'd like)", err)))
+ }
+ results = append(results, msgs...)
+ resp, err = a.convo.SendMessage(ant.Message{
+ Role: "user",
+ Content: results,
+ })
+ if err != nil {
+ a.pushToOutbox(ctx, errorMessage(fmt.Errorf("error: failed to continue conversation: %s", err.Error())))
+ break
+ }
+ if cancelled {
+ return
+ }
+ }
+}
+
+func (a *Agent) overBudget(ctx context.Context) error {
+ if err := a.convo.OverBudget(); err != nil {
+ m := budgetMessage(err)
+ m.Content = m.Content + "\n\nBudget reset."
+ a.pushToOutbox(ctx, budgetMessage(err))
+ a.convo.ResetBudget(a.originalBudget)
+ return err
+ }
+ return nil
+}
+
+func collectTextContent(msg *ant.MessageResponse) string {
+ // Collect all text content
+ var allText strings.Builder
+ for _, content := range msg.Content {
+ if content.Type == "text" && content.Text != "" {
+ if allText.Len() > 0 {
+ allText.WriteString("\n\n")
+ }
+ allText.WriteString(content.Text)
+ }
+ }
+ return allText.String()
+}
+
+func (a *Agent) TotalUsage() ant.CumulativeUsage {
+ a.mu.Lock()
+ defer a.mu.Unlock()
+ return a.convo.CumulativeUsage()
+}
+
+// WaitForMessageCount returns when the agent has at more than clientMessageCount messages or the context is done.
+func (a *Agent) WaitForMessageCount(ctx context.Context, greaterThan int) {
+ for a.MessageCount() <= greaterThan {
+ a.mu.Lock()
+ ch := make(chan struct{})
+ // Deletion happens when we notify.
+ a.listeners = append(a.listeners, ch)
+ a.mu.Unlock()
+
+ select {
+ case <-ctx.Done():
+ return
+ case <-ch:
+ continue
+ }
+ }
+}
+
+// Diff returns a unified diff of changes made since the agent was instantiated.
+func (a *Agent) Diff(commit *string) (string, error) {
+ if a.initialCommit == "" {
+ return "", fmt.Errorf("no initial commit reference available")
+ }
+
+ // Find the repository root
+ ctx := context.Background()
+
+ // If a specific commit hash is provided, show just that commit's changes
+ if commit != nil && *commit != "" {
+ // Validate that the commit looks like a valid git SHA
+ if !isValidGitSHA(*commit) {
+ return "", fmt.Errorf("invalid git commit SHA format: %s", *commit)
+ }
+
+ // Get the diff for just this commit
+ cmd := exec.CommandContext(ctx, "git", "show", "--unified=10", *commit)
+ cmd.Dir = a.repoRoot
+ output, err := cmd.CombinedOutput()
+ if err != nil {
+ return "", fmt.Errorf("failed to get diff for commit %s: %w - %s", *commit, err, string(output))
+ }
+ return string(output), nil
+ }
+
+ // Otherwise, get the diff between the initial commit and the current state using exec.Command
+ cmd := exec.CommandContext(ctx, "git", "diff", "--unified=10", a.initialCommit)
+ cmd.Dir = a.repoRoot
+ output, err := cmd.CombinedOutput()
+ if err != nil {
+ return "", fmt.Errorf("failed to get diff: %w - %s", err, string(output))
+ }
+
+ return string(output), nil
+}
+
+// InitialCommit returns the Git commit hash that was saved when the agent was instantiated.
+func (a *Agent) InitialCommit() string {
+ return a.initialCommit
+}
+
+// handleGitCommits() highlights new commits to the user. When running
+// under docker, new HEADs are pushed to a branch according to the title.
+func (a *Agent) handleGitCommits(ctx context.Context) ([]*GitCommit, error) {
+ if a.repoRoot == "" {
+ return nil, nil
+ }
+
+ head, err := resolveRef(ctx, a.repoRoot, "HEAD")
+ if err != nil {
+ return nil, err
+ }
+ if head == a.lastHEAD {
+ return nil, nil // nothing to do
+ }
+ defer func() {
+ a.lastHEAD = head
+ }()
+
+ // Get new commits. Because it's possible that the agent does rebases, fixups, and
+ // so forth, we use, as our fixed point, the "initialCommit", and we limit ourselves
+ // to the last 100 commits.
+ var commits []*GitCommit
+
+ // Get commits since the initial commit
+ // Format: <hash>\0<subject>\0<body>\0
+ // This uses NULL bytes as separators to avoid issues with newlines in commit messages
+ // Limit to 100 commits to avoid overwhelming the user
+ cmd := exec.CommandContext(ctx, "git", "log", "-n", "100", "--pretty=format:%H%x00%s%x00%b%x00", "^"+a.initialCommit, head)
+ cmd.Dir = a.repoRoot
+ output, err := cmd.Output()
+ if err != nil {
+ return nil, fmt.Errorf("failed to get git log: %w", err)
+ }
+
+ // Parse git log output and filter out already seen commits
+ parsedCommits := parseGitLog(string(output))
+
+ var headCommit *GitCommit
+
+ // Filter out commits we've already seen
+ for _, commit := range parsedCommits {
+ if commit.Hash == head {
+ headCommit = &commit
+ }
+
+ // Skip if we've seen this commit before. If our head has changed, always include that.
+ if a.seenCommits[commit.Hash] && commit.Hash != head {
+ continue
+ }
+
+ // Mark this commit as seen
+ a.seenCommits[commit.Hash] = true
+
+ // Add to our list of new commits
+ commits = append(commits, &commit)
+ }
+
+ if a.gitRemoteAddr != "" {
+ if headCommit == nil {
+ // I think this can only happen if we have a bug or if there's a race.
+ headCommit = &GitCommit{}
+ headCommit.Hash = head
+ headCommit.Subject = "unknown"
+ commits = append(commits, headCommit)
+ }
+
+ cleanTitle := titleToBranch(a.title)
+ if cleanTitle == "" {
+ cleanTitle = a.config.SessionID
+ }
+ branch := "sketch/" + cleanTitle
+
+ // TODO: I don't love the force push here. We could see if the push is a fast-forward, and,
+ // if it's not, we could make a backup with a unique name (perhaps append a timestamp) and
+ // then use push with lease to replace.
+ cmd = exec.Command("git", "push", "--force", a.gitRemoteAddr, "HEAD:refs/heads/"+branch)
+ cmd.Dir = a.workingDir
+ if out, err := cmd.CombinedOutput(); err != nil {
+ a.pushToOutbox(ctx, errorMessage(fmt.Errorf("git push to host: %s: %v", out, err)))
+ } else {
+ headCommit.PushedBranch = branch
+ }
+ }
+
+ // If we found new commits, create a message
+ if len(commits) > 0 {
+ msg := AgentMessage{
+ Type: CommitMessageType,
+ Timestamp: time.Now(),
+ Commits: commits,
+ }
+ a.pushToOutbox(ctx, msg)
+ }
+ return commits, nil
+}
+
+func titleToBranch(s string) string {
+ // Convert to lowercase
+ s = strings.ToLower(s)
+
+ // Replace spaces with hyphens
+ s = strings.ReplaceAll(s, " ", "-")
+
+ // Remove any character that isn't a-z or hyphen
+ var result strings.Builder
+ for _, r := range s {
+ if (r >= 'a' && r <= 'z') || r == '-' {
+ result.WriteRune(r)
+ }
+ }
+ return result.String()
+}
+
+// parseGitLog parses the output of git log with format '%H%x00%s%x00%b%x00'
+// and returns an array of GitCommit structs.
+func parseGitLog(output string) []GitCommit {
+ var commits []GitCommit
+
+ // No output means no commits
+ if len(output) == 0 {
+ return commits
+ }
+
+ // Split by NULL byte
+ parts := strings.Split(output, "\x00")
+
+ // Process in triplets (hash, subject, body)
+ for i := 0; i < len(parts); i++ {
+ // Skip empty parts
+ if parts[i] == "" {
+ continue
+ }
+
+ // This should be a hash
+ hash := strings.TrimSpace(parts[i])
+
+ // Make sure we have at least a subject part available
+ if i+1 >= len(parts) {
+ break // No more parts available
+ }
+
+ // Get the subject
+ subject := strings.TrimSpace(parts[i+1])
+
+ // Get the body if available
+ body := ""
+ if i+2 < len(parts) {
+ body = strings.TrimSpace(parts[i+2])
+ }
+
+ // Skip to the next triplet
+ i += 2
+
+ commits = append(commits, GitCommit{
+ Hash: hash,
+ Subject: subject,
+ Body: body,
+ })
+ }
+
+ return commits
+}
+
+func repoRoot(ctx context.Context, dir string) (string, error) {
+ cmd := exec.CommandContext(ctx, "git", "rev-parse", "--show-toplevel")
+ stderr := new(strings.Builder)
+ cmd.Stderr = stderr
+ cmd.Dir = dir
+ out, err := cmd.Output()
+ if err != nil {
+ return "", fmt.Errorf("git rev-parse failed: %w\n%s", err, stderr)
+ }
+ return strings.TrimSpace(string(out)), nil
+}
+
+func resolveRef(ctx context.Context, dir, refName string) (string, error) {
+ cmd := exec.CommandContext(ctx, "git", "rev-parse", refName)
+ stderr := new(strings.Builder)
+ cmd.Stderr = stderr
+ cmd.Dir = dir
+ out, err := cmd.Output()
+ if err != nil {
+ return "", fmt.Errorf("git rev-parse failed: %w\n%s", err, stderr)
+ }
+ // TODO: validate that out is valid hex
+ return strings.TrimSpace(string(out)), nil
+}
+
+// isValidGitSHA validates if a string looks like a valid git SHA hash.
+// Git SHAs are hexadecimal strings of at least 4 characters but typically 7, 8, or 40 characters.
+func isValidGitSHA(sha string) bool {
+ // Git SHA must be a hexadecimal string with at least 4 characters
+ if len(sha) < 4 || len(sha) > 40 {
+ return false
+ }
+
+ // Check if the string only contains hexadecimal characters
+ for _, char := range sha {
+ if !(char >= '0' && char <= '9') && !(char >= 'a' && char <= 'f') && !(char >= 'A' && char <= 'F') {
+ return false
+ }
+ }
+
+ return true
+}