* First commit

pkg/tools/base.go

@@ -0,0 +1,21 @@
+package tools
+
+import "context"
+
+type Tool interface {
+	Name() string
+	Description() string
+	Parameters() map[string]interface{}
+	Execute(ctx context.Context, args map[string]interface{}) (string, error)
+}
+
+func ToolToSchema(tool Tool) map[string]interface{} {
+	return map[string]interface{}{
+		"type": "function",
+		"function": map[string]interface{}{
+			"name":        tool.Name(),
+			"description": tool.Description(),
+			"parameters":  tool.Parameters(),
+		},
+	}
+}

pkg/tools/edit.go

@@ -0,0 +1,148 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type EditFileTool struct{}
+
+func NewEditFileTool() *EditFileTool {
+	return &EditFileTool{}
+}
+
+func (t *EditFileTool) Name() string {
+	return "edit_file"
+}
+
+func (t *EditFileTool) Description() string {
+	return "Edit a file by replacing old_text with new_text. The old_text must exist exactly in the file."
+}
+
+func (t *EditFileTool) Parameters() map[string]interface{} {
+	return map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"path": map[string]interface{}{
+				"type":        "string",
+				"description": "The file path to edit",
+			},
+			"old_text": map[string]interface{}{
+				"type":        "string",
+				"description": "The exact text to find and replace",
+			},
+			"new_text": map[string]interface{}{
+				"type":        "string",
+				"description": "The text to replace with",
+			},
+		},
+		"required": []string{"path", "old_text", "new_text"},
+	}
+}
+
+func (t *EditFileTool) Execute(ctx context.Context, args map[string]interface{}) (string, error) {
+	path, ok := args["path"].(string)
+	if !ok {
+		return "", fmt.Errorf("path is required")
+	}
+
+	oldText, ok := args["old_text"].(string)
+	if !ok {
+		return "", fmt.Errorf("old_text is required")
+	}
+
+	newText, ok := args["new_text"].(string)
+	if !ok {
+		return "", fmt.Errorf("new_text is required")
+	}
+
+	filePath := filepath.Clean(path)
+
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		return "", fmt.Errorf("file not found: %s", path)
+	}
+
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		return "", fmt.Errorf("failed to read file: %w", err)
+	}
+
+	contentStr := string(content)
+
+	if !strings.Contains(contentStr, oldText) {
+		return "", fmt.Errorf("old_text not found in file. Make sure it matches exactly")
+	}
+
+	count := strings.Count(contentStr, oldText)
+	if count > 1 {
+		return "", fmt.Errorf("old_text appears %d times. Please provide more context to make it unique", count)
+	}
+
+	newContent := strings.Replace(contentStr, oldText, newText, 1)
+
+	if err := os.WriteFile(filePath, []byte(newContent), 0644); err != nil {
+		return "", fmt.Errorf("failed to write file: %w", err)
+	}
+
+	return fmt.Sprintf("Successfully edited %s", path), nil
+}
+
+type AppendFileTool struct{}
+
+func NewAppendFileTool() *AppendFileTool {
+	return &AppendFileTool{}
+}
+
+func (t *AppendFileTool) Name() string {
+	return "append_file"
+}
+
+func (t *AppendFileTool) Description() string {
+	return "Append content to the end of a file"
+}
+
+func (t *AppendFileTool) Parameters() map[string]interface{} {
+	return map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"path": map[string]interface{}{
+				"type":        "string",
+				"description": "The file path to append to",
+			},
+			"content": map[string]interface{}{
+				"type":        "string",
+				"description": "The content to append",
+			},
+		},
+		"required": []string{"path", "content"},
+	}
+}
+
+func (t *AppendFileTool) Execute(ctx context.Context, args map[string]interface{}) (string, error) {
+	path, ok := args["path"].(string)
+	if !ok {
+		return "", fmt.Errorf("path is required")
+	}
+
+	content, ok := args["content"].(string)
+	if !ok {
+		return "", fmt.Errorf("content is required")
+	}
+
+	filePath := filepath.Clean(path)
+
+	f, err := os.OpenFile(filePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return "", fmt.Errorf("failed to open file: %w", err)
+	}
+	defer f.Close()
+
+	if _, err := f.WriteString(content); err != nil {
+		return "", fmt.Errorf("failed to append to file: %w", err)
+	}
+
+	return fmt.Sprintf("Successfully appended to %s", path), nil
+}

pkg/tools/filesystem.go

@@ -0,0 +1,141 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+type ReadFileTool struct{}
+
+func (t *ReadFileTool) Name() string {
+	return "read_file"
+}
+
+func (t *ReadFileTool) Description() string {
+	return "Read the contents of a file"
+}
+
+func (t *ReadFileTool) Parameters() map[string]interface{} {
+	return map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"path": map[string]interface{}{
+				"type":        "string",
+				"description": "Path to the file to read",
+			},
+		},
+		"required": []string{"path"},
+	}
+}
+
+func (t *ReadFileTool) Execute(ctx context.Context, args map[string]interface{}) (string, error) {
+	path, ok := args["path"].(string)
+	if !ok {
+		return "", fmt.Errorf("path is required")
+	}
+
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return "", fmt.Errorf("failed to read file: %w", err)
+	}
+
+	return string(content), nil
+}
+
+type WriteFileTool struct{}
+
+func (t *WriteFileTool) Name() string {
+	return "write_file"
+}
+
+func (t *WriteFileTool) Description() string {
+	return "Write content to a file"
+}
+
+func (t *WriteFileTool) Parameters() map[string]interface{} {
+	return map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"path": map[string]interface{}{
+				"type":        "string",
+				"description": "Path to the file to write",
+			},
+			"content": map[string]interface{}{
+				"type":        "string",
+				"description": "Content to write to the file",
+			},
+		},
+		"required": []string{"path", "content"},
+	}
+}
+
+func (t *WriteFileTool) Execute(ctx context.Context, args map[string]interface{}) (string, error) {
+	path, ok := args["path"].(string)
+	if !ok {
+		return "", fmt.Errorf("path is required")
+	}
+
+	content, ok := args["content"].(string)
+	if !ok {
+		return "", fmt.Errorf("content is required")
+	}
+
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return "", fmt.Errorf("failed to create directory: %w", err)
+	}
+
+	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+		return "", fmt.Errorf("failed to write file: %w", err)
+	}
+
+	return "File written successfully", nil
+}
+
+type ListDirTool struct{}
+
+func (t *ListDirTool) Name() string {
+	return "list_dir"
+}
+
+func (t *ListDirTool) Description() string {
+	return "List files and directories in a path"
+}
+
+func (t *ListDirTool) Parameters() map[string]interface{} {
+	return map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"path": map[string]interface{}{
+				"type":        "string",
+				"description": "Path to list",
+			},
+		},
+		"required": []string{"path"},
+	}
+}
+
+func (t *ListDirTool) Execute(ctx context.Context, args map[string]interface{}) (string, error) {
+	path, ok := args["path"].(string)
+	if !ok {
+		path = "."
+	}
+
+	entries, err := os.ReadDir(path)
+	if err != nil {
+		return "", fmt.Errorf("failed to read directory: %w", err)
+	}
+
+	result := ""
+	for _, entry := range entries {
+		if entry.IsDir() {
+			result += "DIR:  " + entry.Name() + "\n"
+		} else {
+			result += "FILE: " + entry.Name() + "\n"
+		}
+	}
+
+	return result, nil
+}

pkg/tools/message.go

@@ -0,0 +1,87 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+)
+
+type SendCallback func(channel, chatID, content string) error
+
+type MessageTool struct {
+	sendCallback   SendCallback
+	defaultChannel string
+	defaultChatID  string
+}
+
+func NewMessageTool() *MessageTool {
+	return &MessageTool{}
+}
+
+func (t *MessageTool) Name() string {
+	return "message"
+}
+
+func (t *MessageTool) Description() string {
+	return "Send a message to user on a chat channel. Use this when you want to communicate something."
+}
+
+func (t *MessageTool) Parameters() map[string]interface{} {
+	return map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"content": map[string]interface{}{
+				"type":        "string",
+				"description": "The message content to send",
+			},
+			"channel": map[string]interface{}{
+				"type":        "string",
+				"description": "Optional: target channel (telegram, whatsapp, etc.)",
+			},
+			"chat_id": map[string]interface{}{
+				"type":        "string",
+				"description": "Optional: target chat/user ID",
+			},
+		},
+		"required": []string{"content"},
+	}
+}
+
+func (t *MessageTool) SetContext(channel, chatID string) {
+	t.defaultChannel = channel
+	t.defaultChatID = chatID
+}
+
+func (t *MessageTool) SetSendCallback(callback SendCallback) {
+	t.sendCallback = callback
+}
+
+func (t *MessageTool) Execute(ctx context.Context, args map[string]interface{}) (string, error) {
+	content, ok := args["content"].(string)
+	if !ok {
+		return "", fmt.Errorf("content is required")
+	}
+
+	channel, _ := args["channel"].(string)
+	chatID, _ := args["chat_id"].(string)
+
+	if channel == "" {
+		channel = t.defaultChannel
+	}
+	if chatID == "" {
+		chatID = t.defaultChatID
+	}
+
+	if channel == "" || chatID == "" {
+		return "Error: No target channel/chat specified", nil
+	}
+
+	if t.sendCallback == nil {
+		return "Error: Message sending not configured", nil
+	}
+
+	if err := t.sendCallback(channel, chatID, content); err != nil {
+		return fmt.Sprintf("Error sending message: %v", err), nil
+	}
+
+	return fmt.Sprintf("Message sent to %s:%s", channel, chatID), nil
+}

pkg/tools/registry.go

@@ -0,0 +1,50 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+	"sync"
+)
+
+type ToolRegistry struct {
+	tools map[string]Tool
+	mu    sync.RWMutex
+}
+
+func NewToolRegistry() *ToolRegistry {
+	return &ToolRegistry{
+		tools: make(map[string]Tool),
+	}
+}
+
+func (r *ToolRegistry) Register(tool Tool) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.tools[tool.Name()] = tool
+}
+
+func (r *ToolRegistry) Get(name string) (Tool, bool) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	tool, ok := r.tools[name]
+	return tool, ok
+}
+
+func (r *ToolRegistry) Execute(ctx context.Context, name string, args map[string]interface{}) (string, error) {
+	tool, ok := r.Get(name)
+	if !ok {
+		return "", fmt.Errorf("tool '%s' not found", name)
+	}
+	return tool.Execute(ctx, args)
+}
+
+func (r *ToolRegistry) GetDefinitions() []map[string]interface{} {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	definitions := make([]map[string]interface{}, 0, len(r.tools))
+	for _, tool := range r.tools {
+		definitions = append(definitions, ToolToSchema(tool))
+	}
+	return definitions
+}

pkg/tools/shell.go

@@ -0,0 +1,202 @@
+package tools
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+)
+
+type ExecTool struct {
+	workingDir          string
+	timeout             time.Duration
+	denyPatterns        []*regexp.Regexp
+	allowPatterns       []*regexp.Regexp
+	restrictToWorkspace bool
+}
+
+func NewExecTool(workingDir string) *ExecTool {
+	denyPatterns := []*regexp.Regexp{
+		regexp.MustCompile(`\brm\s+-[rf]{1,2}\b`),
+		regexp.MustCompile(`\bdel\s+/[fq]\b`),
+		regexp.MustCompile(`\brmdir\s+/s\b`),
+		regexp.MustCompile(`\b(format|mkfs|diskpart)\b`),
+		regexp.MustCompile(`\bdd\s+if=`),
+		regexp.MustCompile(`>\s*/dev/sd`),
+		regexp.MustCompile(`\b(shutdown|reboot|poweroff)\b`),
+		regexp.MustCompile(`:\(\)\s*\{.*\};\s*:`),
+	}
+
+	return &ExecTool{
+		workingDir:          workingDir,
+		timeout:             60 * time.Second,
+		denyPatterns:        denyPatterns,
+		allowPatterns:       nil,
+		restrictToWorkspace: false,
+	}
+}
+
+func (t *ExecTool) Name() string {
+	return "exec"
+}
+
+func (t *ExecTool) Description() string {
+	return "Execute a shell command and return its output. Use with caution."
+}
+
+func (t *ExecTool) Parameters() map[string]interface{} {
+	return map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"command": map[string]interface{}{
+				"type":        "string",
+				"description": "The shell command to execute",
+			},
+			"working_dir": map[string]interface{}{
+				"type":        "string",
+				"description": "Optional working directory for the command",
+			},
+		},
+		"required": []string{"command"},
+	}
+}
+
+func (t *ExecTool) Execute(ctx context.Context, args map[string]interface{}) (string, error) {
+	command, ok := args["command"].(string)
+	if !ok {
+		return "", fmt.Errorf("command is required")
+	}
+
+	cwd := t.workingDir
+	if wd, ok := args["working_dir"].(string); ok && wd != "" {
+		cwd = wd
+	}
+
+	if cwd == "" {
+		wd, err := os.Getwd()
+		if err == nil {
+			cwd = wd
+		}
+	}
+
+	if guardError := t.guardCommand(command, cwd); guardError != "" {
+		return fmt.Sprintf("Error: %s", guardError), nil
+	}
+
+	cmdCtx, cancel := context.WithTimeout(ctx, t.timeout)
+	defer cancel()
+
+	cmd := exec.CommandContext(cmdCtx, "sh", "-c", command)
+	if cwd != "" {
+		cmd.Dir = cwd
+	}
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	err := cmd.Run()
+	output := stdout.String()
+	if stderr.Len() > 0 {
+		output += "\nSTDERR:\n" + stderr.String()
+	}
+
+	if err != nil {
+		if cmdCtx.Err() == context.DeadlineExceeded {
+			return fmt.Sprintf("Error: Command timed out after %v", t.timeout), nil
+		}
+		output += fmt.Sprintf("\nExit code: %v", err)
+	}
+
+	if output == "" {
+		output = "(no output)"
+	}
+
+	maxLen := 10000
+	if len(output) > maxLen {
+		output = output[:maxLen] + fmt.Sprintf("\n... (truncated, %d more chars)", len(output)-maxLen)
+	}
+
+	return output, nil
+}
+
+func (t *ExecTool) guardCommand(command, cwd string) string {
+	cmd := strings.TrimSpace(command)
+	lower := strings.ToLower(cmd)
+
+	for _, pattern := range t.denyPatterns {
+		if pattern.MatchString(lower) {
+			return "Command blocked by safety guard (dangerous pattern detected)"
+		}
+	}
+
+	if len(t.allowPatterns) > 0 {
+		allowed := false
+		for _, pattern := range t.allowPatterns {
+			if pattern.MatchString(lower) {
+				allowed = true
+				break
+			}
+		}
+		if !allowed {
+			return "Command blocked by safety guard (not in allowlist)"
+		}
+	}
+
+	if t.restrictToWorkspace {
+		if strings.Contains(cmd, "..\\") || strings.Contains(cmd, "../") {
+			return "Command blocked by safety guard (path traversal detected)"
+		}
+
+		cwdPath, err := filepath.Abs(cwd)
+		if err != nil {
+			return ""
+		}
+
+		pathPattern := regexp.MustCompile(`[A-Za-z]:\\[^\\\"']+|/[^\s\"']+`)
+		matches := pathPattern.FindAllString(cmd, -1)
+
+		for _, raw := range matches {
+			p, err := filepath.Abs(raw)
+			if err != nil {
+				continue
+			}
+
+			rel, err := filepath.Rel(cwdPath, p)
+			if err != nil {
+				continue
+			}
+
+			if strings.HasPrefix(rel, "..") {
+				return "Command blocked by safety guard (path outside working dir)"
+			}
+		}
+	}
+
+	return ""
+}
+
+func (t *ExecTool) SetTimeout(timeout time.Duration) {
+	t.timeout = timeout
+}
+
+func (t *ExecTool) SetRestrictToWorkspace(restrict bool) {
+	t.restrictToWorkspace = restrict
+}
+
+func (t *ExecTool) SetAllowPatterns(patterns []string) error {
+	t.allowPatterns = make([]*regexp.Regexp, 0, len(patterns))
+	for _, p := range patterns {
+		re, err := regexp.Compile(p)
+		if err != nil {
+			return fmt.Errorf("invalid allow pattern %q: %w", p, err)
+		}
+		t.allowPatterns = append(t.allowPatterns, re)
+	}
+	return nil
+}

pkg/tools/spawn.go

@@ -0,0 +1,70 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+)
+
+type SpawnTool struct {
+	manager       *SubagentManager
+	originChannel string
+	originChatID  string
+}
+
+func NewSpawnTool(manager *SubagentManager) *SpawnTool {
+	return &SpawnTool{
+		manager:       manager,
+		originChannel: "cli",
+		originChatID:  "direct",
+	}
+}
+
+func (t *SpawnTool) Name() string {
+	return "spawn"
+}
+
+func (t *SpawnTool) Description() string {
+	return "Spawn a subagent to handle a task in the background. Use this for complex or time-consuming tasks that can run independently. The subagent will complete the task and report back when done."
+}
+
+func (t *SpawnTool) Parameters() map[string]interface{} {
+	return map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"task": map[string]interface{}{
+				"type":        "string",
+				"description": "The task for subagent to complete",
+			},
+			"label": map[string]interface{}{
+				"type":        "string",
+				"description": "Optional short label for the task (for display)",
+			},
+		},
+		"required": []string{"task"},
+	}
+}
+
+func (t *SpawnTool) SetContext(channel, chatID string) {
+	t.originChannel = channel
+	t.originChatID = chatID
+}
+
+func (t *SpawnTool) Execute(ctx context.Context, args map[string]interface{}) (string, error) {
+	task, ok := args["task"].(string)
+	if !ok {
+		return "", fmt.Errorf("task is required")
+	}
+
+	label, _ := args["label"].(string)
+
+	if t.manager == nil {
+		return "Error: Subagent manager not configured", nil
+	}
+
+	result, err := t.manager.Spawn(ctx, task, label, t.originChannel, t.originChatID)
+	if err != nil {
+		return "", fmt.Errorf("failed to spawn subagent: %w", err)
+	}
+
+	return result, nil
+}

pkg/tools/subagent.go

@@ -0,0 +1,111 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+)
+
+type SubagentTask struct {
+	ID            string
+	Task          string
+	Label         string
+	OriginChannel string
+	OriginChatID  string
+	Status        string
+	Result        string
+	Created       int64
+}
+
+type SubagentManager struct {
+	tasks     map[string]*SubagentTask
+	mu        sync.RWMutex
+	provider  LLMProvider
+	workspace string
+	nextID    int
+}
+
+func NewSubagentManager(provider LLMProvider, workspace string) *SubagentManager {
+	return &SubagentManager{
+		tasks:     make(map[string]*SubagentTask),
+		provider:  provider,
+		workspace: workspace,
+		nextID:    1,
+	}
+}
+
+func (sm *SubagentManager) Spawn(ctx context.Context, task, label, originChannel, originChatID string) (string, error) {
+	sm.mu.Lock()
+	defer sm.mu.Unlock()
+
+	taskID := fmt.Sprintf("subagent-%d", sm.nextID)
+	sm.nextID++
+
+	subagentTask := &SubagentTask{
+		ID:            taskID,
+		Task:          task,
+		Label:         label,
+		OriginChannel: originChannel,
+		OriginChatID:  originChatID,
+		Status:        "running",
+		Created:       time.Now().UnixMilli(),
+	}
+	sm.tasks[taskID] = subagentTask
+
+	go sm.runTask(ctx, subagentTask)
+
+	if label != "" {
+		return fmt.Sprintf("Spawned subagent '%s' for task: %s", label, task), nil
+	}
+	return fmt.Sprintf("Spawned subagent for task: %s", task), nil
+}
+
+func (sm *SubagentManager) runTask(ctx context.Context, task *SubagentTask) {
+	task.Status = "running"
+	task.Created = time.Now().UnixMilli()
+
+	messages := []Message{
+		{
+			Role:    "system",
+			Content: "You are a subagent. Complete the given task independently and report the result.",
+		},
+		{
+			Role:    "user",
+			Content: task.Task,
+		},
+	}
+
+	response, err := sm.provider.Chat(ctx, messages, nil, sm.provider.GetDefaultModel(), map[string]interface{}{
+		"max_tokens": 4096,
+	})
+
+	sm.mu.Lock()
+	defer sm.mu.Unlock()
+
+	if err != nil {
+		task.Status = "failed"
+		task.Result = fmt.Sprintf("Error: %v", err)
+	} else {
+		task.Status = "completed"
+		task.Result = response.Content
+	}
+}
+
+func (sm *SubagentManager) GetTask(taskID string) (*SubagentTask, bool) {
+	sm.mu.RLock()
+	defer sm.mu.RUnlock()
+	task, ok := sm.tasks[taskID]
+	return task, ok
+}
+
+func (sm *SubagentManager) ListTasks() []*SubagentTask {
+	sm.mu.RLock()
+	defer sm.mu.RUnlock()
+
+	tasks := make([]*SubagentTask, 0, len(sm.tasks))
+	for _, task := range sm.tasks {
+		tasks = append(tasks, task)
+	}
+	return tasks
+}

pkg/tools/types.go

@@ -0,0 +1,52 @@
+package tools
+
+import "context"
+
+type Message struct {
+	Role       string     `json:"role"`
+	Content    string     `json:"content"`
+	ToolCalls  []ToolCall `json:"tool_calls,omitempty"`
+	ToolCallID string     `json:"tool_call_id,omitempty"`
+}
+
+type ToolCall struct {
+	ID        string                 `json:"id"`
+	Type      string                 `json:"type"`
+	Function  *FunctionCall          `json:"function,omitempty"`
+	Name      string                 `json:"name,omitempty"`
+	Arguments map[string]interface{} `json:"arguments,omitempty"`
+}
+
+type FunctionCall struct {
+	Name      string `json:"name"`
+	Arguments string `json:"arguments"`
+}
+
+type LLMResponse struct {
+	Content      string     `json:"content"`
+	ToolCalls    []ToolCall `json:"tool_calls,omitempty"`
+	FinishReason string     `json:"finish_reason"`
+	Usage        *UsageInfo `json:"usage,omitempty"`
+}
+
+type UsageInfo struct {
+	PromptTokens     int `json:"prompt_tokens"`
+	CompletionTokens int `json:"completion_tokens"`
+	TotalTokens      int `json:"total_tokens"`
+}
+
+type LLMProvider interface {
+	Chat(ctx context.Context, messages []Message, tools []ToolDefinition, model string, options map[string]interface{}) (*LLMResponse, error)
+	GetDefaultModel() string
+}
+
+type ToolDefinition struct {
+	Type     string                 `json:"type"`
+	Function ToolFunctionDefinition `json:"function"`
+}
+
+type ToolFunctionDefinition struct {
+	Name        string                 `json:"name"`
+	Description string                 `json:"description"`
+	Parameters  map[string]interface{} `json:"parameters"`
+}

pkg/tools/web.go

@@ -0,0 +1,298 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+)
+
+const (
+	userAgent = "Mozilla/5.0 (compatible; picoclaw/1.0)"
+)
+
+type WebSearchTool struct {
+	apiKey     string
+	maxResults int
+}
+
+func NewWebSearchTool(apiKey string, maxResults int) *WebSearchTool {
+	if maxResults <= 0 || maxResults > 10 {
+		maxResults = 5
+	}
+	return &WebSearchTool{
+		apiKey:     apiKey,
+		maxResults: maxResults,
+	}
+}
+
+func (t *WebSearchTool) Name() string {
+	return "web_search"
+}
+
+func (t *WebSearchTool) Description() string {
+	return "Search the web. Returns titles, URLs, and snippets."
+}
+
+func (t *WebSearchTool) Parameters() map[string]interface{} {
+	return map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"query": map[string]interface{}{
+				"type":        "string",
+				"description": "Search query",
+			},
+			"count": map[string]interface{}{
+				"type":        "integer",
+				"description": "Number of results (1-10)",
+				"minimum":     1.0,
+				"maximum":     10.0,
+			},
+		},
+		"required": []string{"query"},
+	}
+}
+
+func (t *WebSearchTool) Execute(ctx context.Context, args map[string]interface{}) (string, error) {
+	if t.apiKey == "" {
+		return "Error: BRAVE_API_KEY not configured", nil
+	}
+
+	query, ok := args["query"].(string)
+	if !ok {
+		return "", fmt.Errorf("query is required")
+	}
+
+	count := t.maxResults
+	if c, ok := args["count"].(float64); ok {
+		if int(c) > 0 && int(c) <= 10 {
+			count = int(c)
+		}
+	}
+
+	searchURL := fmt.Sprintf("https://api.search.brave.com/res/v1/web/search?q=%s&count=%d",
+		url.QueryEscape(query), count)
+
+	req, err := http.NewRequestWithContext(ctx, "GET", searchURL, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("X-Subscription-Token", t.apiKey)
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var searchResp struct {
+		Web struct {
+			Results []struct {
+				Title       string `json:"title"`
+				URL         string `json:"url"`
+				Description string `json:"description"`
+			} `json:"results"`
+		} `json:"web"`
+	}
+
+	if err := json.Unmarshal(body, &searchResp); err != nil {
+		return "", fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	results := searchResp.Web.Results
+	if len(results) == 0 {
+		return fmt.Sprintf("No results for: %s", query), nil
+	}
+
+	var lines []string
+	lines = append(lines, fmt.Sprintf("Results for: %s", query))
+	for i, item := range results {
+		if i >= count {
+			break
+		}
+		lines = append(lines, fmt.Sprintf("%d. %s\n   %s", i+1, item.Title, item.URL))
+		if item.Description != "" {
+			lines = append(lines, fmt.Sprintf("   %s", item.Description))
+		}
+	}
+
+	return strings.Join(lines, "\n"), nil
+}
+
+type WebFetchTool struct {
+	maxChars int
+}
+
+func NewWebFetchTool(maxChars int) *WebFetchTool {
+	if maxChars <= 0 {
+		maxChars = 50000
+	}
+	return &WebFetchTool{
+		maxChars: maxChars,
+	}
+}
+
+func (t *WebFetchTool) Name() string {
+	return "web_fetch"
+}
+
+func (t *WebFetchTool) Description() string {
+	return "Fetch a URL and extract readable content (HTML to text). Use this to get weather info, news, articles, or any web content."
+}
+
+func (t *WebFetchTool) Parameters() map[string]interface{} {
+	return map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"url": map[string]interface{}{
+				"type":        "string",
+				"description": "URL to fetch",
+			},
+			"maxChars": map[string]interface{}{
+				"type":        "integer",
+				"description": "Maximum characters to extract",
+				"minimum":     100.0,
+			},
+		},
+		"required": []string{"url"},
+	}
+}
+
+func (t *WebFetchTool) Execute(ctx context.Context, args map[string]interface{}) (string, error) {
+	urlStr, ok := args["url"].(string)
+	if !ok {
+		return "", fmt.Errorf("url is required")
+	}
+
+	parsedURL, err := url.Parse(urlStr)
+	if err != nil {
+		return "", fmt.Errorf("invalid URL: %w", err)
+	}
+
+	if parsedURL.Scheme != "http" && parsedURL.Scheme != "https" {
+		return "", fmt.Errorf("only http/https URLs are allowed")
+	}
+
+	if parsedURL.Host == "" {
+		return "", fmt.Errorf("missing domain in URL")
+	}
+
+	maxChars := t.maxChars
+	if mc, ok := args["maxChars"].(float64); ok {
+		if int(mc) > 100 {
+			maxChars = int(mc)
+		}
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "GET", urlStr, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("User-Agent", userAgent)
+
+	client := &http.Client{
+		Timeout: 60 * time.Second,
+		Transport: &http.Transport{
+			MaxIdleConns:        10,
+			IdleConnTimeout:     30 * time.Second,
+			DisableCompression:  false,
+			TLSHandshakeTimeout: 15 * time.Second,
+		},
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			if len(via) >= 5 {
+				return fmt.Errorf("stopped after 5 redirects")
+			}
+			return nil
+		},
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read response: %w", err)
+	}
+
+	contentType := resp.Header.Get("Content-Type")
+
+	var text, extractor string
+
+	if strings.Contains(contentType, "application/json") {
+		var jsonData interface{}
+		if err := json.Unmarshal(body, &jsonData); err == nil {
+			formatted, _ := json.MarshalIndent(jsonData, "", "  ")
+			text = string(formatted)
+			extractor = "json"
+		} else {
+			text = string(body)
+			extractor = "raw"
+		}
+	} else if strings.Contains(contentType, "text/html") || len(body) > 0 &&
+		(strings.HasPrefix(string(body), "<!DOCTYPE") || strings.HasPrefix(strings.ToLower(string(body)), "<html")) {
+		text = t.extractText(string(body))
+		extractor = "text"
+	} else {
+		text = string(body)
+		extractor = "raw"
+	}
+
+	truncated := len(text) > maxChars
+	if truncated {
+		text = text[:maxChars]
+	}
+
+	result := map[string]interface{}{
+		"url":       urlStr,
+		"status":    resp.StatusCode,
+		"extractor": extractor,
+		"truncated": truncated,
+		"length":    len(text),
+		"text":      text,
+	}
+
+	resultJSON, _ := json.MarshalIndent(result, "", "  ")
+	return string(resultJSON), nil
+}
+
+func (t *WebFetchTool) extractText(htmlContent string) string {
+	re := regexp.MustCompile(`<script[\s\S]*?</script>`)
+	result := re.ReplaceAllLiteralString(htmlContent, "")
+	re = regexp.MustCompile(`<style[\s\S]*?</style>`)
+	result = re.ReplaceAllLiteralString(result, "")
+	re = regexp.MustCompile(`<[^>]+>`)
+	result = re.ReplaceAllLiteralString(result, "")
+
+	result = strings.TrimSpace(result)
+
+	re = regexp.MustCompile(`\s+`)
+	result = re.ReplaceAllLiteralString(result, " ")
+
+	lines := strings.Split(result, "\n")
+	var cleanLines []string
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line != "" {
+			cleanLines = append(cleanLines, line)
+		}
+	}
+
+	return strings.Join(cleanLines, "\n")
+}