Feat/refactor tools system

cmd/picoclaw/internal/gateway/helpers.go

@@ -24,6 +24,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/providers"
 	"github.com/sipeed/picoclaw/pkg/state"
 	"github.com/sipeed/picoclaw/pkg/tools"
+	cron_tool "github.com/sipeed/picoclaw/pkg/tools/cron"
 	"github.com/sipeed/picoclaw/pkg/voice"
 )
 
@@ -232,14 +233,15 @@ func setupCronTool(
 	cronService := cron.NewCronService(cronStorePath, nil)
 
 	// Create and register CronTool
-	cronTool := tools.NewCronTool(cronService, agentLoop, msgBus, workspace, restrict, execTimeout, cfg)
-	agentLoop.RegisterTool(cronTool)
-
-	// Set the onJob handler
-	cronService.SetOnJob(func(job *cron.CronJob) (string, error) {
-		result := cronTool.ExecuteJob(context.Background(), job)
-		return result, nil
-	})
-
+	if cfg.Tools.Cron.Enabled {
+		cronTool := cron_tool.NewCronTool(cronService, agentLoop, msgBus, workspace, restrict, execTimeout, cfg)
+		agentLoop.RegisterTool(cronTool)
+
+		// Set the onJob handler
+		cronService.SetOnJob(func(job *cron.CronJob) (string, error) {
+			result := cronTool.ExecuteJob(context.Background(), job)
+			return result, nil
+		})
+	}
 	return cronService
 }

pkg/agent/instance.go

@@ -47,13 +47,7 @@ func NewAgentInstance(
 	fallbacks := resolveAgentFallbacks(agentCfg, defaults)
 
 	restrict := defaults.RestrictToWorkspace
-	toolsRegistry := tools.NewToolRegistry()
-	toolsRegistry.Register(tools.NewReadFileTool(workspace, restrict))
-	toolsRegistry.Register(tools.NewWriteFileTool(workspace, restrict))
-	toolsRegistry.Register(tools.NewListDirTool(workspace, restrict))
-	toolsRegistry.Register(tools.NewExecToolWithConfig(workspace, restrict, cfg))
-	toolsRegistry.Register(tools.NewEditFileTool(workspace, restrict))
-	toolsRegistry.Register(tools.NewAppendFileTool(workspace, restrict))
+	toolsRegistry := tools.NewToolRegistry(cfg, workspace, restrict)
 
 	sessionsDir := filepath.Join(workspace, "sessions")
 	sessionsManager := session.NewSessionManager(sessionsDir)

pkg/agent/loop.go

@@ -23,9 +23,10 @@ import (
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/providers"
 	"github.com/sipeed/picoclaw/pkg/routing"
-	"github.com/sipeed/picoclaw/pkg/skills"
 	"github.com/sipeed/picoclaw/pkg/state"
 	"github.com/sipeed/picoclaw/pkg/tools"
+	"github.com/sipeed/picoclaw/pkg/tools/message"
+	"github.com/sipeed/picoclaw/pkg/tools/subagent"
 	"github.com/sipeed/picoclaw/pkg/utils"
 )
 
@@ -92,63 +93,31 @@ func registerSharedTools(
 			continue
 		}
 
-		// Web tools
-		if searchTool := tools.NewWebSearchTool(tools.WebSearchToolOptions{
-			BraveAPIKey:          cfg.Tools.Web.Brave.APIKey,
-			BraveMaxResults:      cfg.Tools.Web.Brave.MaxResults,
-			BraveEnabled:         cfg.Tools.Web.Brave.Enabled,
-			TavilyAPIKey:         cfg.Tools.Web.Tavily.APIKey,
-			TavilyBaseURL:        cfg.Tools.Web.Tavily.BaseURL,
-			TavilyMaxResults:     cfg.Tools.Web.Tavily.MaxResults,
-			TavilyEnabled:        cfg.Tools.Web.Tavily.Enabled,
-			DuckDuckGoMaxResults: cfg.Tools.Web.DuckDuckGo.MaxResults,
-			DuckDuckGoEnabled:    cfg.Tools.Web.DuckDuckGo.Enabled,
-			PerplexityAPIKey:     cfg.Tools.Web.Perplexity.APIKey,
-			PerplexityMaxResults: cfg.Tools.Web.Perplexity.MaxResults,
-			PerplexityEnabled:    cfg.Tools.Web.Perplexity.Enabled,
-			Proxy:                cfg.Tools.Web.Proxy,
-		}); searchTool != nil {
-			agent.Tools.Register(searchTool)
-		}
-		agent.Tools.Register(tools.NewWebFetchToolWithProxy(50000, cfg.Tools.Web.Proxy))
-
-		// Hardware tools (I2C, SPI) - Linux only, returns error on other platforms
-		agent.Tools.Register(tools.NewI2CTool())
-		agent.Tools.Register(tools.NewSPITool())
-
 		// Message tool
-		messageTool := tools.NewMessageTool()
-		messageTool.SetSendCallback(func(channel, chatID, content string) error {
-			msgBus.PublishOutbound(bus.OutboundMessage{
-				Channel: channel,
-				ChatID:  chatID,
-				Content: content,
+		if cfg.Tools.Message.Enabled {
+			messageTool := message.NewMessageTool()
+			messageTool.SetSendCallback(func(channel, chatID, content string) error {
+				msgBus.PublishOutbound(bus.OutboundMessage{
+					Channel: channel,
+					ChatID:  chatID,
+					Content: content,
+				})
+				return nil
 			})
-			return nil
-		})
-		agent.Tools.Register(messageTool)
-
-		// Skill discovery and installation tools
-		registryMgr := skills.NewRegistryManagerFromConfig(skills.RegistryConfig{
-			MaxConcurrentSearches: cfg.Tools.Skills.MaxConcurrentSearches,
-			ClawHub:               skills.ClawHubConfig(cfg.Tools.Skills.Registries.ClawHub),
-		})
-		searchCache := skills.NewSearchCache(
-			cfg.Tools.Skills.SearchCache.MaxSize,
-			time.Duration(cfg.Tools.Skills.SearchCache.TTLSeconds)*time.Second,
-		)
-		agent.Tools.Register(tools.NewFindSkillsTool(registryMgr, searchCache))
-		agent.Tools.Register(tools.NewInstallSkillTool(registryMgr, agent.Workspace))
+			agent.Tools.Register(messageTool)
+		}
 
 		// Spawn tool with allowlist checker
-		subagentManager := tools.NewSubagentManager(provider, agent.Model, agent.Workspace, msgBus)
-		subagentManager.SetLLMOptions(agent.MaxTokens, agent.Temperature)
-		spawnTool := tools.NewSpawnTool(subagentManager)
-		currentAgentID := agentID
-		spawnTool.SetAllowlistChecker(func(targetAgentID string) bool {
-			return registry.CanSpawnSubagent(currentAgentID, targetAgentID)
-		})
-		agent.Tools.Register(spawnTool)
+		if cfg.Tools.Spawn.Enabled {
+			subagentManager := subagent.NewSubagentManager(provider, agent.Model, agent.Workspace, msgBus)
+			subagentManager.SetLLMOptions(agent.MaxTokens, agent.Temperature)
+			spawnTool := subagent.NewSpawnTool(subagentManager)
+			currentAgentID := agentID
+			spawnTool.SetAllowlistChecker(func(targetAgentID string) bool {
+				return registry.CanSpawnSubagent(currentAgentID, targetAgentID)
+			})
+			agent.Tools.Register(spawnTool)
+		}
 	}
 }
 
@@ -178,7 +147,7 @@ func (al *AgentLoop) Run(ctx context.Context) error {
 				defaultAgent := al.registry.GetDefaultAgent()
 				if defaultAgent != nil {
 					if tool, ok := defaultAgent.Tools.Get("message"); ok {
-						if mt, ok := tool.(*tools.MessageTool); ok {
+						if mt, ok := tool.(*message.MessageTool); ok {
 							alreadySent = mt.HasSentInRound()
 						}
 					}

pkg/config/config.go

@@ -452,6 +452,7 @@ type PerplexityConfig struct {
 }
 
 type WebToolsConfig struct {
+	Enabled    bool             `json:"enabled"    env:"PICOCLAW_TOOLS_WEB_ENABLED"`
 	Brave      BraveConfig      `json:"brave"`
 	Tavily     TavilyConfig     `json:"tavily"`
 	DuckDuckGo DuckDuckGoConfig `json:"duckduckgo"`
@@ -461,19 +462,53 @@ type WebToolsConfig struct {
 	Proxy string `json:"proxy,omitempty" env:"PICOCLAW_TOOLS_WEB_PROXY"`
 }
 
-type CronToolsConfig struct {
-	ExecTimeoutMinutes int `json:"exec_timeout_minutes" env:"PICOCLAW_TOOLS_CRON_EXEC_TIMEOUT_MINUTES"` // 0 means no timeout
+type CronToolConfig struct {
+	Enabled            bool `json:"enabled"              env:"PICOCLAW_TOOLS_CRON_ENABLED"`
+	ExecTimeoutMinutes int  `json:"exec_timeout_minutes" env:"PICOCLAW_TOOLS_CRON_EXEC_TIMEOUT_MINUTES"` // 0 means no timeout
+}
+
+type ToolConfig struct {
+	Enabled bool `json:"enabled" env:"PICOCLAW_TOOLS_ENABLED"` // Default env var, can be overridden per tool
 }
 
 type ExecConfig struct {
+	Enabled            bool     `json:"enabled"              env:"PICOCLAW_TOOLS_EXEC_ENABLED"`
 	EnableDenyPatterns bool     `json:"enable_deny_patterns" env:"PICOCLAW_TOOLS_EXEC_ENABLE_DENY_PATTERNS"`
 	CustomDenyPatterns []string `json:"custom_deny_patterns" env:"PICOCLAW_TOOLS_EXEC_CUSTOM_DENY_PATTERNS"`
 }
 
 type ToolsConfig struct {
-	Web    WebToolsConfig    `json:"web"`
-	Cron   CronToolsConfig   `json:"cron"`
-	Exec   ExecConfig        `json:"exec"`
+	// Web tools
+	Web WebToolsConfig `json:"web"`
+
+	// Cron tools
+	Cron CronToolConfig `json:"cron"`
+
+	// File tools
+	ReadFile   ToolConfig `json:"read_file"   env:"PICOCLAW_TOOLS_READ_FILE_ENABLED"`
+	WriteFile  ToolConfig `json:"write_file"  env:"PICOCLAW_TOOLS_WRITE_FILE_ENABLED"`
+	EditFile   ToolConfig `json:"edit_file"   env:"PICOCLAW_TOOLS_EDIT_FILE_ENABLED"`
+	AppendFile ToolConfig `json:"append_file" env:"PICOCLAW_TOOLS_APPEND_FILE_ENABLED"`
+	ListDir    ToolConfig `json:"list_dir"    env:"PICOCLAW_TOOLS_LIST_DIR_ENABLED"`
+
+	// Exec tool
+	Exec ExecConfig `json:"exec"`
+
+	// Skills tools
+	FindSkills   ToolConfig `json:"find_skills"   env:"PICOCLAW_TOOLS_FIND_SKILLS_ENABLED"`
+	InstallSkill ToolConfig `json:"install_skill" env:"PICOCLAW_TOOLS_INSTALL_SKILL_ENABLED"`
+
+	// Subagent tools
+	Spawn ToolConfig `json:"spawn" env:"PICOCLAW_TOOLS_SPAWN_ENABLED"`
+
+	// Message tool
+	Message ToolConfig `json:"message" env:"PICOCLAW_TOOLS_MESSAGE_ENABLED"`
+
+	// Hardware tools
+	I2C ToolConfig `json:"i2c" env:"PICOCLAW_TOOLS_I2C_ENABLED"`
+	SPI ToolConfig `json:"spi" env:"PICOCLAW_TOOLS_SPI_ENABLED"`
+
+	// Skills configuration (registry, cache, etc.)
 	Skills SkillsToolsConfig `json:"skills"`
 }
 

pkg/config/defaults.go

@@ -293,12 +293,53 @@ func DefaultConfig() *Config {
 					MaxResults: 5,
 				},
 			},
-			Cron: CronToolsConfig{
+			Cron: CronToolConfig{
+				Enabled:            true,
 				ExecTimeoutMinutes: 5,
 			},
+			// File tools - each individually configurable
+			ReadFile: ToolConfig{
+				Enabled: true,
+			},
+			WriteFile: ToolConfig{
+				Enabled: true,
+			},
+			EditFile: ToolConfig{
+				Enabled: false,
+			},
+			AppendFile: ToolConfig{
+				Enabled: false,
+			},
+			ListDir: ToolConfig{
+				Enabled: false,
+			},
+			// Exec tool
 			Exec: ExecConfig{
+				Enabled:            true,
 				EnableDenyPatterns: true,
 			},
+			// Skills tools
+			FindSkills: ToolConfig{
+				Enabled: true,
+			},
+			InstallSkill: ToolConfig{
+				Enabled: true,
+			},
+			// Subagent tools
+			Spawn: ToolConfig{
+				Enabled: true,
+			},
+			// Message tool
+			Message: ToolConfig{
+				Enabled: true,
+			},
+			// Hardware tools
+			I2C: ToolConfig{
+				Enabled: false,
+			},
+			SPI: ToolConfig{
+				Enabled: false,
+			},
 			Skills: SkillsToolsConfig{
 				Registries: SkillsRegistriesConfig{
 					ClawHub: ClawHubRegistryConfig{

pkg/tools/append_file/append_file.go

@@ -0,0 +1,77 @@
+package append_file
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io/fs"
+
+	"github.com/sipeed/picoclaw/pkg/tools/common"
+)
+
+type AppendFileTool struct {
+	fs common.FileSystem
+}
+
+func NewAppendFileTool(workspace string, restrict bool) *AppendFileTool {
+	var fs common.FileSystem
+	if restrict {
+		fs = &common.SandboxFs{Workspace: workspace}
+	} else {
+		fs = &common.HostFs{}
+	}
+	return &AppendFileTool{fs: fs}
+}
+
+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]any {
+	return map[string]any{
+		"type": "object",
+		"properties": map[string]any{
+			"path": map[string]any{
+				"type":        "string",
+				"description": "The file path to append to",
+			},
+			"content": map[string]any{
+				"type":        "string",
+				"description": "The content to append",
+			},
+		},
+		"required": []string{"path", "content"},
+	}
+}
+
+func (t *AppendFileTool) Execute(ctx context.Context, args map[string]any) *common.ToolResult {
+	path, ok := args["path"].(string)
+	if !ok {
+		return common.ErrorResult("path is required")
+	}
+
+	content, ok := args["content"].(string)
+	if !ok {
+		return common.ErrorResult("content is required")
+	}
+
+	if err := appendFile(t.fs, path, content); err != nil {
+		return common.ErrorResult(err.Error())
+	}
+	return common.SilentResult(fmt.Sprintf("Appended to %s", path))
+}
+
+// appendFile reads the existing content (if any) via sysFs, appends new content, and writes back.
+func appendFile(sysFs common.FileSystem, path, appendContent string) error {
+	content, err := sysFs.ReadFile(path)
+	if err != nil && !errors.Is(err, fs.ErrNotExist) {
+		return err
+	}
+
+	newContent := append(content, []byte(appendContent)...)
+	return sysFs.WriteFile(path, newContent)
+}