app: basic server and client (honganh1206#79)

* app: lifecycle management and store

* remove lifecycle struct

* Add app binary for future use

* Add server, remove store

* Add basic server and client

* Switch to union for blocks and unified message

* Remove app/, update block structs

* Fix marshal unmarshal blocks

* Fix UT, update README

Author: honganh1206

Makefile

@@ -2,6 +2,8 @@ run/new:
 	go run ./main.go
 run/latest:
 	go run ./main.go -n=false
+serve:
+	go run ./main.go serve
 list/models:
 	go run ./main.go list
 list/conversations:

README.md

@@ -2,17 +2,26 @@
 
 Simple CLI-based AI coding agent
 
+![Clue](./assets/clue.png)
+
 If this proves to be helpful to anyone, consider it my thanks to the open-source community :)
 
 (Important) Read through this wonderful article on [how to build an agent by Thorsten Ball](https://ampcode.com/how-to-build-an-agent) and follow along if possible
 
 ## Installation
 
 1. Add Anthropic API key as an environment variable with `export ANTHROPIC_API_KEY="your-api-key-here"`
-2. Run the installation script for the latest version:
+2. Run the installation script for the latest version (Linux only at the moment):
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/honganh1206/clue/main/scripts/install.sh | sudo -E bash
 ```
 
+## Development
+
+```bash
+make serve # Run the server
+make # Run the agent
+```
+
 [References](./docs/References.md)

agent/agent.go

@@ -1,83 +1,35 @@
 package agent
 
 import (
-	"bufio"
 	"context"
-	"database/sql"
 	"encoding/json"
 	"fmt"
-	"log"
-	"os"
 	"strings"
 
-	"github.com/honganh1206/clue/conversation"
+	"github.com/honganh1206/clue/api"
 	"github.com/honganh1206/clue/inference"
-	"github.com/honganh1206/clue/prompts"
+	"github.com/honganh1206/clue/message"
+	"github.com/honganh1206/clue/server/data/conversation"
 	"github.com/honganh1206/clue/tools"
-	_ "github.com/mattn/go-sqlite3"
 )
 
-func Gen(conversationID string, modelConfig inference.ModelConfig, db *sql.DB) error {
-	model, err := inference.Init(modelConfig)
-	if err != nil {
-		log.Fatalf("Failed to initialize model: %s", err.Error())
-	}
-
-	scanner := bufio.NewScanner(os.Stdin)
-	getUserMsg := func() (string, bool) {
-		if !scanner.Scan() {
-			return "", false
-		}
-		return scanner.Text(), true
-	}
-
-	toolDefs := []tools.ToolDefinition{tools.ReadFileDefinition, tools.ListFilesDefinition, tools.EditFileDefinition}
-
-	var a *Agent
-	var conv *conversation.Conversation
-
-	if conversationID != "" {
-		conv, err = conversation.Load(conversationID, db)
-		if err != nil {
-			return err
-		}
-	} else {
-		conv, err = conversation.New()
-		if err != nil {
-			return err
-		}
-	}
-	a = New(model, getUserMsg, conv, toolDefs, prompts.ClaudeSystemPrompt(), db)
-
-	// In production, use Background() as the final root context()
-	// For dev env, TODO for temporary scaffolding
-	err = a.run(context.TODO())
-
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
 type Agent struct {
 	model          inference.Model
 	getUserMessage func() (string, bool)
 	tools          []tools.ToolDefinition
 	promptPath     string
 	conversation   *conversation.Conversation
-	// FIXME: CRUD operations should be on its own, not a field in Agent
-	db *sql.DB
+	client         *api.Client
 }
 
-func New(model inference.Model, getUserMsg func() (string, bool), conversation *conversation.Conversation, tools []tools.ToolDefinition, promptPath string, db *sql.DB) *Agent {
+func New(model inference.Model, getUserMsg func() (string, bool), conversation *conversation.Conversation, tools []tools.ToolDefinition, promptPath string, client *api.Client) *Agent {
 	return &Agent{
 		model:          model,
 		getUserMessage: getUserMsg,
 		tools:          tools,
 		promptPath:     promptPath,
 		conversation:   conversation,
-		db:             db,
+		client:         client,
 	}
 }
 
@@ -100,7 +52,7 @@ func getModelColor(modelName string) string {
 	}
 }
 
-func (a *Agent) run(ctx context.Context) error {
+func (a *Agent) Run(ctx context.Context) error {
 	modelName := a.model.Name()
 	colorCode := getModelColor(modelName)
 	resetCode := "\u001b[0m"
@@ -111,40 +63,35 @@ func (a *Agent) run(ctx context.Context) error {
 
 	for {
 		if readUserInput {
-
 			fmt.Print("\u001b[94m>\u001b[0m ")
 			userInput, ok := a.getUserMessage()
 			if !ok {
 				break
 			}
 
-			userMsg := conversation.MessageRequest{
-				MessageParam: conversation.MessageParam{
-					Role:    conversation.UserRole,
-					Content: []conversation.ContentBlock{conversation.NewTextContentBlock(userInput)},
-				},
+			userMsg := &message.Message{
+				Role:    message.UserRole,
+				Content: []message.ContentBlockUnion{message.NewTextContentBlock(userInput)},
 			}
-			a.conversation.Append(userMsg.MessageParam)
+
+			a.conversation.Append(userMsg)
 			a.saveConversation()
 		}
 
-		// TODO: Update with something interactive
-		// fmt.Printf("\u001b[93m%s\u001b[0m: ", modelName)
-
-		agentMsg, err := a.model.RunInference(ctx, a.conversation.Messages, a.tools)
+		agentMsg, err := a.model.CompleteStream(ctx, a.conversation.Messages, a.tools)
 		if err != nil {
 			return err
 		}
 
-		a.conversation.Append(agentMsg.MessageParam)
+		a.conversation.Append(agentMsg)
 		a.saveConversation()
 
-		toolResults := []conversation.ContentBlock{}
+		toolResults := []message.ContentBlockUnion{}
 
-		for _, content := range agentMsg.Content {
-			switch c := content.(type) {
-			case conversation.ToolUseContentBlock:
-				result := a.executeTool(c.ID, c.Name, c.Input)
+		for _, c := range agentMsg.Content {
+			switch c.Type {
+			case message.ToolUseType:
+				result := a.executeTool(c.OfToolUseBlock.ID, c.OfToolUseBlock.Name, c.OfToolUseBlock.Input)
 				toolResults = append(toolResults, result)
 			}
 		}
@@ -156,24 +103,21 @@ func (a *Agent) run(ctx context.Context) error {
 
 		readUserInput = false
 
-		toolResultMsg := conversation.MessageRequest{
-			MessageParam: conversation.MessageParam{
-				Role:    conversation.UserRole,
-				Content: toolResults,
-			},
+		toolResultMsg := &message.Message{
+			Role:    message.UserRole,
+			Content: toolResults,
 		}
 
-		a.conversation.Append(toolResultMsg.MessageParam)
+		a.conversation.Append(toolResultMsg)
 		a.saveConversation()
 	}
 
 	return nil
 }
 
-func (a *Agent) executeTool(id, name string, input json.RawMessage) conversation.ContentBlock {
+func (a *Agent) executeTool(id, name string, input json.RawMessage) message.ContentBlockUnion {
 	var toolDef tools.ToolDefinition
 	var found bool
-
 	for _, tool := range a.tools {
 		if tool.Name == name {
 			toolDef = tool
@@ -185,29 +129,29 @@ func (a *Agent) executeTool(id, name string, input json.RawMessage) conversation
 	if !found {
 		// TODO: Return proper error type
 		errorMsg := "tool not found"
-		return conversation.NewToolResultContentBlock(id, errorMsg, true)
+		return message.NewToolResultContentBlock(id, errorMsg, true)
 	}
 
 	fmt.Printf("\u001b[92mtool\u001b[0m: %s(%s)\n", name, input)
+	println()
 
 	response, err := toolDef.Function(input)
 
 	if err != nil {
-		return conversation.NewToolResultContentBlock(id, err.Error(), true)
+		return message.NewToolResultContentBlock(id, err.Error(), true)
 	}
 
-	return conversation.NewToolResultContentBlock(id, response, true)
+	return message.NewToolResultContentBlock(id, response, false)
 }
 
 func (a *Agent) saveConversation() error {
-	// FIXME: Very drafty. Consider moving the db field out of Agent struct?
-	err := a.conversation.SaveTo(a.db)
-	if err != nil {
-		// 4. Log any errors from history.Save to os.Stderr and return the error.
-		fmt.Fprintf(os.Stderr, "Warning: could not save conversation to DB: %v\n", err)
-		return err
+	if len(a.conversation.Messages) > 0 {
+		err := a.client.SaveConversation(a.conversation)
+		if err != nil {
+			fmt.Printf("DEBUG: Failed conversation details - ConversationID: %s\n", a.conversation.ID)
+			return err
+		}
 	}
 
 	return nil
-
 }

api/client.go

@@ -0,0 +1,139 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/honganh1206/clue/message"
+	"github.com/honganh1206/clue/server/data/conversation"
+)
+
+type Client struct {
+	baseURL    string
+	httpClient *http.Client
+}
+
+func NewClient(baseURL string) *Client {
+	if baseURL == "" {
+		baseURL = "http://localhost:11435"
+	}
+	return &Client{
+		baseURL:    baseURL,
+		httpClient: &http.Client{},
+	}
+}
+
+func (c *Client) CreateConversation() (*conversation.Conversation, error) {
+	resp, err := c.httpClient.Post(c.baseURL+"/conversations", "application/json", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create conversation: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("server error: %s", string(body))
+	}
+
+	var result map[string]string
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	// TODO: Use NewConversation method?
+	return &conversation.Conversation{
+		ID:       result["id"],
+		Messages: make([]*message.Message, 0),
+	}, nil
+}
+
+func (c *Client) ListConversations() ([]conversation.ConversationMetadata, error) {
+	resp, err := c.httpClient.Get(c.baseURL + "/conversations")
+	if err != nil {
+		return nil, fmt.Errorf("failed to list conversations: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("server error: %s", string(body))
+	}
+
+	var conversations []conversation.ConversationMetadata
+	if err := json.NewDecoder(resp.Body).Decode(&conversations); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return conversations, nil
+}
+
+func (c *Client) GetConversation(id string) (*conversation.Conversation, error) {
+	resp, err := c.httpClient.Get(c.baseURL + "/conversations/" + id)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get conversation: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusNotFound {
+		return nil, conversation.ErrConversationNotFound
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("server error: %s", string(body))
+	}
+
+	var conv conversation.Conversation
+	if err := json.NewDecoder(resp.Body).Decode(&conv); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return &conv, nil
+}
+
+func (c *Client) SaveConversation(conv *conversation.Conversation) error {
+	jsonData, err := json.Marshal(conv)
+	if err != nil {
+		return fmt.Errorf("failed to marshal conversation: %w", err)
+	}
+
+	url := fmt.Sprintf("%s/conversations/%s", c.baseURL, conv.ID)
+	req, err := http.NewRequest(http.MethodPut, url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to save conversation: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusNotFound {
+		return conversation.ErrConversationNotFound
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("server error: %s", string(body))
+	}
+
+	return nil
+}
+
+func (c *Client) GetLatestConversationID() (string, error) {
+	conversations, err := c.ListConversations()
+	if err != nil {
+		return "", err
+	}
+
+	if len(conversations) == 0 {
+		return "", conversation.ErrConversationNotFound
+	}
+
+	return conversations[0].ID, nil
+}