@dcode-dev/dcode-cli 1.0.0

package/internal/tools/memory.go

@@ -0,0 +1,269 @@
+package tools
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// Memory represents a stored memory
+type Memory struct {
+	Key       string                 `json:"key"`
+	Value     string                 `json:"value"`
+	Metadata  map[string]interface{} `json:"metadata"`
+	Timestamp time.Time              `json:"timestamp"`
+}
+
+// SaveMemoryTool saves information to memory
+type SaveMemoryTool struct{}
+
+func NewSaveMemoryTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "save_memory",
+		Name:        "Save Memory",
+		Description: "Save information to persistent memory",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"key": map[string]interface{}{
+					"type":        "string",
+					"description": "Memory key/identifier",
+				},
+				"value": map[string]interface{}{
+					"type":        "string",
+					"description": "Value to store",
+				},
+			},
+			"required": []string{"key", "value"},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "memory",
+		Executor:             executeSaveMemory,
+	}
+}
+
+func executeSaveMemory(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	key, ok := input.Parameters["key"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "key parameter is required",
+		}, fmt.Errorf("invalid key parameter")
+	}
+	
+	value, ok := input.Parameters["value"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "value parameter is required",
+		}, fmt.Errorf("invalid value parameter")
+	}
+	
+	memory := Memory{
+		Key:       key,
+		Value:     value,
+		Metadata:  make(map[string]interface{}),
+		Timestamp: time.Now(),
+	}
+	
+	// Save to file
+	memoryDir, err := getMemoryDir()
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to get memory directory: %v", err),
+		}, err
+	}
+	
+	filePath := filepath.Join(memoryDir, key+".json")
+	data, err := json.MarshalIndent(memory, "", "  ")
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to marshal memory: %v", err),
+		}, err
+	}
+	
+	if err := os.WriteFile(filePath, data, 0644); err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to write memory: %v", err),
+		}, err
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    fmt.Sprintf("Saved memory: %s", key),
+		Metadata: map[string]interface{}{
+			"key": key,
+			"path": filePath,
+		},
+	}, nil
+}
+
+// RecallMemoryTool retrieves information from memory
+type RecallMemoryTool struct{}
+
+func NewRecallMemoryTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "recall_memory",
+		Name:        "Recall Memory",
+		Description: "Retrieve information from persistent memory",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"key": map[string]interface{}{
+					"type":        "string",
+					"description": "Memory key to retrieve",
+				},
+			},
+			"required": []string{"key"},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "memory",
+		Executor:             executeRecallMemory,
+	}
+}
+
+func executeRecallMemory(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	key, ok := input.Parameters["key"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "key parameter is required",
+		}, fmt.Errorf("invalid key parameter")
+	}
+	
+	memoryDir, err := getMemoryDir()
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to get memory directory: %v", err),
+		}, err
+	}
+	
+	filePath := filepath.Join(memoryDir, key+".json")
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("memory not found: %s", key),
+		}, err
+	}
+	
+	var memory Memory
+	if err := json.Unmarshal(data, &memory); err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to parse memory: %v", err),
+		}, err
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    memory.Value,
+		Metadata: map[string]interface{}{
+			"key":       memory.Key,
+			"timestamp": memory.Timestamp,
+		},
+	}, nil
+}
+
+// ListMemoriesTool lists all stored memories
+type ListMemoriesTool struct{}
+
+func NewListMemoriesTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "list_memories",
+		Name:        "List Memories",
+		Description: "List all stored memories",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "memory",
+		Executor:             executeListMemories,
+	}
+}
+
+func executeListMemories(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	memoryDir, err := getMemoryDir()
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to get memory directory: %v", err),
+		}, err
+	}
+	
+	entries, err := os.ReadDir(memoryDir)
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: true,
+			Data:    []string{},
+			Metadata: map[string]interface{}{
+				"count": 0,
+			},
+		}, nil
+	}
+	
+	memories := make([]map[string]interface{}, 0)
+	for _, entry := range entries {
+		if entry.IsDir() || filepath.Ext(entry.Name()) != ".json" {
+			continue
+		}
+		
+		filePath := filepath.Join(memoryDir, entry.Name())
+		
+		data, err := os.ReadFile(filePath)
+		if err != nil {
+			continue
+		}
+		
+		var memory Memory
+		if err := json.Unmarshal(data, &memory); err != nil {
+			continue
+		}
+		
+		memories = append(memories, map[string]interface{}{
+			"key":       memory.Key,
+			"timestamp": memory.Timestamp,
+			"preview":   truncate(memory.Value, 50),
+		})
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    memories,
+		Metadata: map[string]interface{}{
+			"count": len(memories),
+		},
+	}, nil
+}
+
+func getMemoryDir() (string, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+	
+	memoryDir := filepath.Join(homeDir, ".dcode", "memory")
+	if err := os.MkdirAll(memoryDir, 0755); err != nil {
+		return "", err
+	}
+	
+	return memoryDir, nil
+}
+
+func truncate(s string, maxLen int) string {
+	if len(s) <= maxLen {
+		return s
+	}
+	return s[:maxLen] + "..."
+}

package/internal/tools/registry.go

@@ -0,0 +1,49 @@
+package tools
+
+import (
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// RegisterBuiltinTools registers all built-in tools
+func RegisterBuiltinTools(toolRegistry *registry.ToolRegistry) error {
+	tools := []*registry.ToolDefinition{
+		// File operations
+		NewReadFileTool(),
+		NewWriteFileTool(),
+		NewListFilesTool(),
+		NewDeleteFileTool(),
+		NewMoveFileTool(),
+		NewCreateDirectoryTool(),
+		
+		// Shell
+		NewShellTool(),
+		
+		// Search & patterns
+		NewGrepTool(),
+		NewGlobTool(),
+		
+		// Git operations
+		NewGitStatusTool(),
+		NewGitDiffTool(),
+		NewGitLogTool(),
+		NewGitCommitTool(),
+		NewGitBranchTool(),
+		
+		// Interactive
+		NewAskUserTool(),
+		NewConfirmTool(),
+		
+		// Memory
+		NewSaveMemoryTool(),
+		NewRecallMemoryTool(),
+		NewListMemoriesTool(),
+	}
+	
+	for _, tool := range tools {
+		if err := toolRegistry.Register(tool); err != nil {
+			return err
+		}
+	}
+	
+	return nil
+}

package/internal/tools/search.go

@@ -0,0 +1,230 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"strings"
+	"time"
+
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// GrepTool searches for patterns in files
+type GrepTool struct{}
+
+func NewGrepTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "grep",
+		Name:        "Grep Search",
+		Description: "Search for patterns in files using grep",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"pattern": map[string]interface{}{
+					"type":        "string",
+					"description": "Search pattern",
+				},
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "Path to search in",
+				},
+				"recursive": map[string]interface{}{
+					"type":        "boolean",
+					"description": "Search recursively",
+				},
+				"ignore_case": map[string]interface{}{
+					"type":        "boolean",
+					"description": "Ignore case",
+				},
+			},
+			"required": []string{"pattern"},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "search",
+		Executor:             executeGrep,
+	}
+}
+
+func executeGrep(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	pattern, ok := input.Parameters["pattern"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "pattern parameter is required",
+		}, fmt.Errorf("invalid pattern parameter")
+	}
+	
+	path := "."
+	if p, ok := input.Parameters["path"].(string); ok {
+		path = p
+	}
+	
+	recursive := true
+	if r, ok := input.Parameters["recursive"].(bool); ok {
+		recursive = r
+	}
+	
+	ignoreCase := false
+	if i, ok := input.Parameters["ignore_case"].(bool); ok {
+		ignoreCase = i
+	}
+	
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	
+	args := []string{}
+	if ignoreCase {
+		args = append(args, "-i")
+	}
+	if recursive {
+		args = append(args, "-r")
+	}
+	args = append(args, "-n", pattern, path)
+	
+	cmd := exec.CommandContext(ctx, "grep", args...)
+	output, err := cmd.CombinedOutput()
+	
+	// grep returns exit code 1 if no matches, which is not an error
+	if err != nil && len(output) == 0 {
+		return &registry.ToolOutput{
+			Success: true,
+			Data:    "No matches found",
+			Metadata: map[string]interface{}{
+				"pattern": pattern,
+				"path":    path,
+				"matches": 0,
+			},
+		}, nil
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    string(output),
+		Metadata: map[string]interface{}{
+			"pattern": pattern,
+			"path":    path,
+			"matches": strings.Count(string(output), "\n"),
+		},
+	}, nil
+}
+
+// AskUserTool prompts the user for input
+type AskUserTool struct{}
+
+func NewAskUserTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "ask_user",
+		Name:        "Ask User",
+		Description: "Ask the user a question and get their response",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"question": map[string]interface{}{
+					"type":        "string",
+					"description": "Question to ask the user",
+				},
+				"default": map[string]interface{}{
+					"type":        "string",
+					"description": "Default answer",
+				},
+			},
+			"required": []string{"question"},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "interactive",
+		Executor:             executeAskUser,
+	}
+}
+
+func executeAskUser(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	question, ok := input.Parameters["question"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "question parameter is required",
+		}, fmt.Errorf("invalid question parameter")
+	}
+	
+	defaultAnswer := ""
+	if d, ok := input.Parameters["default"].(string); ok {
+		defaultAnswer = d
+	}
+	
+	// Print question
+	if defaultAnswer != "" {
+		fmt.Printf("%s [%s]: ", question, defaultAnswer)
+	} else {
+		fmt.Printf("%s: ", question)
+	}
+	
+	// Read answer
+	var answer string
+	fmt.Scanln(&answer)
+	
+	if answer == "" {
+		answer = defaultAnswer
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    answer,
+		Metadata: map[string]interface{}{
+			"question": question,
+			"answer":   answer,
+		},
+	}, nil
+}
+
+// ConfirmTool asks for yes/no confirmation
+type ConfirmTool struct{}
+
+func NewConfirmTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "confirm",
+		Name:        "Confirm",
+		Description: "Ask for yes/no confirmation",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"message": map[string]interface{}{
+					"type":        "string",
+					"description": "Confirmation message",
+				},
+			},
+			"required": []string{"message"},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "interactive",
+		Executor:             executeConfirm,
+	}
+}
+
+func executeConfirm(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	message, ok := input.Parameters["message"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "message parameter is required",
+		}, fmt.Errorf("invalid message parameter")
+	}
+	
+	fmt.Printf("%s (y/n): ", message)
+	
+	var answer string
+	fmt.Scanln(&answer)
+	
+	confirmed := strings.ToLower(answer) == "y" || strings.ToLower(answer) == "yes"
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    confirmed,
+		Metadata: map[string]interface{}{
+			"message":   message,
+			"confirmed": confirmed,
+		},
+	}, nil
+}

package/internal/tools/shell.go

@@ -0,0 +1,84 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"time"
+
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// ShellTool executes shell commands
+type ShellTool struct{}
+
+func NewShellTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "shell",
+		Name:        "Shell Command",
+		Description: "Execute a shell command",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"command": map[string]interface{}{
+					"type":        "string",
+					"description": "Shell command to execute",
+				},
+				"timeout": map[string]interface{}{
+					"type":        "number",
+					"description": "Timeout in seconds (default: 300)",
+				},
+			},
+			"required": []string{"command"},
+		},
+		RequiresConfirmation: true,
+		RiskLevel:            "high",
+		Category:             "shell",
+		Executor:             executeShell,
+	}
+}
+
+func executeShell(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	command, ok := input.Parameters["command"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "command parameter is required and must be a string",
+		}, fmt.Errorf("invalid command parameter")
+	}
+	
+	// Get timeout (default 300 seconds)
+	timeout := 300
+	if t, ok := input.Parameters["timeout"].(float64); ok {
+		timeout = int(t)
+	}
+	
+	// Create context with timeout
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
+	defer cancel()
+	
+	// Execute command
+	cmd := exec.CommandContext(ctx, "sh", "-c", command)
+	output, err := cmd.CombinedOutput()
+	
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Data:    string(output),
+			Error:   fmt.Sprintf("command failed: %v", err),
+			Metadata: map[string]interface{}{
+				"command":   command,
+				"exit_code": cmd.ProcessState.ExitCode(),
+			},
+		}, nil // Don't return error, just mark as failed
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    string(output),
+		Metadata: map[string]interface{}{
+			"command":   command,
+			"exit_code": 0,
+		},
+	}, nil
+}

package/internal/websearch/search.go

@@ -0,0 +1,40 @@
+package websearch
+
+import (
+	"context"
+	"os"
+	"strings"
+)
+
+type Result struct {
+	Title   string
+	URL     string
+	Snippet string
+}
+
+type Searcher interface {
+	Search(ctx context.Context, query string) ([]Result, error)
+}
+
+func NewFromEnv() Searcher {
+	provider := strings.ToLower(strings.TrimSpace(os.Getenv("WEB_SEARCH_PROVIDER")))
+	if provider == "" {
+		provider = strings.ToLower(strings.TrimSpace(os.Getenv("SEARCH_PROVIDER")))
+	}
+
+	switch provider {
+	case "", "none", "disabled":
+		return nil
+	case "tavily":
+		key := strings.TrimSpace(os.Getenv("TAVILY_API_KEY"))
+		if key == "" {
+			key = strings.TrimSpace(os.Getenv("SEARCH_API_KEY"))
+		}
+		if key == "" {
+			return nil
+		}
+		return NewTavily(key)
+	default:
+		return nil
+	}
+}