@dcode-dev/dcode-cli 1.0.0

package/internal/tools/filesystem.go

@@ -0,0 +1,286 @@
+package tools
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// DeleteFileTool deletes a file
+type DeleteFileTool struct{}
+
+func NewDeleteFileTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "delete_file",
+		Name:        "Delete File",
+		Description: "Delete a file or directory",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "Path to file or directory to delete",
+				},
+				"recursive": map[string]interface{}{
+					"type":        "boolean",
+					"description": "Delete directory recursively",
+				},
+			},
+			"required": []string{"path"},
+		},
+		RequiresConfirmation: true,
+		RiskLevel:            "high",
+		Category:             "file",
+		Executor:             executeDeleteFile,
+	}
+}
+
+func executeDeleteFile(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	path, ok := input.Parameters["path"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "path parameter is required",
+		}, fmt.Errorf("invalid path parameter")
+	}
+	
+	recursive := false
+	if r, ok := input.Parameters["recursive"].(bool); ok {
+		recursive = r
+	}
+	
+	// Check if path exists
+	info, err := os.Stat(path)
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("path not found: %v", err),
+		}, err
+	}
+	
+	// Handle directory
+	if info.IsDir() {
+		if !recursive {
+			return &registry.ToolOutput{
+				Success: false,
+				Error:   "path is a directory, use recursive=true to delete",
+			}, fmt.Errorf("directory requires recursive flag")
+		}
+		err = os.RemoveAll(path)
+	} else {
+		err = os.Remove(path)
+	}
+	
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to delete: %v", err),
+		}, err
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    fmt.Sprintf("Deleted: %s", path),
+		Metadata: map[string]interface{}{
+			"path":      path,
+			"recursive": recursive,
+		},
+	}, nil
+}
+
+// MoveFileTool moves/renames files
+type MoveFileTool struct{}
+
+func NewMoveFileTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "move_file",
+		Name:        "Move/Rename File",
+		Description: "Move or rename a file",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"source": map[string]interface{}{
+					"type":        "string",
+					"description": "Source path",
+				},
+				"destination": map[string]interface{}{
+					"type":        "string",
+					"description": "Destination path",
+				},
+			},
+			"required": []string{"source", "destination"},
+		},
+		RequiresConfirmation: true,
+		RiskLevel:            "medium",
+		Category:             "file",
+		Executor:             executeMoveFile,
+	}
+}
+
+func executeMoveFile(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	source, ok := input.Parameters["source"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "source parameter is required",
+		}, fmt.Errorf("invalid source parameter")
+	}
+	
+	dest, ok := input.Parameters["destination"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "destination parameter is required",
+		}, fmt.Errorf("invalid destination parameter")
+	}
+	
+	err := os.Rename(source, dest)
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to move: %v", err),
+		}, err
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    fmt.Sprintf("Moved %s to %s", source, dest),
+		Metadata: map[string]interface{}{
+			"source":      source,
+			"destination": dest,
+		},
+	}, nil
+}
+
+// CreateDirectoryTool creates directories
+type CreateDirectoryTool struct{}
+
+func NewCreateDirectoryTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "create_directory",
+		Name:        "Create Directory",
+		Description: "Create a directory",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "Directory path to create",
+				},
+				"parents": map[string]interface{}{
+					"type":        "boolean",
+					"description": "Create parent directories",
+				},
+			},
+			"required": []string{"path"},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "file",
+		Executor:             executeCreateDirectory,
+	}
+}
+
+func executeCreateDirectory(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	path, ok := input.Parameters["path"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "path parameter is required",
+		}, fmt.Errorf("invalid path parameter")
+	}
+	
+	parents := true
+	if p, ok := input.Parameters["parents"].(bool); ok {
+		parents = p
+	}
+	
+	var err error
+	if parents {
+		err = os.MkdirAll(path, 0755)
+	} else {
+		err = os.Mkdir(path, 0755)
+	}
+	
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to create directory: %v", err),
+		}, err
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    fmt.Sprintf("Created directory: %s", path),
+		Metadata: map[string]interface{}{
+			"path":    path,
+			"parents": parents,
+		},
+	}, nil
+}
+
+// GlobTool finds files by pattern
+type GlobTool struct{}
+
+func NewGlobTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "glob",
+		Name:        "Glob Pattern Match",
+		Description: "Find files matching a pattern",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"pattern": map[string]interface{}{
+					"type":        "string",
+					"description": "Glob pattern (e.g., '**/*.go')",
+				},
+				"base_path": map[string]interface{}{
+					"type":        "string",
+					"description": "Base path to search from",
+				},
+			},
+			"required": []string{"pattern"},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "file",
+		Executor:             executeGlob,
+	}
+}
+
+func executeGlob(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")
+	}
+	
+	basePath := "."
+	if p, ok := input.Parameters["base_path"].(string); ok {
+		basePath = p
+	}
+	
+	// Use filepath.Glob with full pattern
+	fullPattern := filepath.Join(basePath, pattern)
+	matches, err := filepath.Glob(fullPattern)
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("glob failed: %v", err),
+		}, err
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    matches,
+		Metadata: map[string]interface{}{
+			"pattern":   pattern,
+			"base_path": basePath,
+			"count":     len(matches),
+		},
+	}, nil
+}

package/internal/tools/git.go

@@ -0,0 +1,355 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"time"
+
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// GitStatusTool shows git repository status
+type GitStatusTool struct{}
+
+func NewGitStatusTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "git_status",
+		Name:        "Git Status",
+		Description: "Show git repository status",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "Path to git repository (default: current directory)",
+				},
+			},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "git",
+		Executor:             executeGitStatus,
+	}
+}
+
+func executeGitStatus(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	path := "."
+	if p, ok := input.Parameters["path"].(string); ok {
+		path = p
+	}
+	
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	
+	cmd := exec.CommandContext(ctx, "git", "-C", path, "status", "--short")
+	output, err := cmd.CombinedOutput()
+	
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("git status failed: %v", err),
+		}, nil
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    string(output),
+		Metadata: map[string]interface{}{
+			"path": path,
+		},
+	}, nil
+}
+
+// GitDiffTool shows git diff
+type GitDiffTool struct{}
+
+func NewGitDiffTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "git_diff",
+		Name:        "Git Diff",
+		Description: "Show git diff",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "Path to git repository",
+				},
+				"cached": map[string]interface{}{
+					"type":        "boolean",
+					"description": "Show staged changes",
+				},
+			},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "git",
+		Executor:             executeGitDiff,
+	}
+}
+
+func executeGitDiff(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	path := "."
+	if p, ok := input.Parameters["path"].(string); ok {
+		path = p
+	}
+	
+	cached := false
+	if c, ok := input.Parameters["cached"].(bool); ok {
+		cached = c
+	}
+	
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	
+	args := []string{"-C", path, "diff"}
+	if cached {
+		args = append(args, "--cached")
+	}
+	
+	cmd := exec.CommandContext(ctx, "git", args...)
+	output, err := cmd.CombinedOutput()
+	
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("git diff failed: %v", err),
+		}, nil
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    string(output),
+		Metadata: map[string]interface{}{
+			"path":   path,
+			"cached": cached,
+		},
+	}, nil
+}
+
+// GitCommitTool commits changes
+type GitCommitTool struct{}
+
+func NewGitCommitTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "git_commit",
+		Name:        "Git Commit",
+		Description: "Commit changes to git",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"message": map[string]interface{}{
+					"type":        "string",
+					"description": "Commit message",
+				},
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "Path to git repository",
+				},
+			},
+			"required": []string{"message"},
+		},
+		RequiresConfirmation: true,
+		RiskLevel:            "high",
+		Category:             "git",
+		Executor:             executeGitCommit,
+	}
+}
+
+func executeGitCommit(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")
+	}
+	
+	path := "."
+	if p, ok := input.Parameters["path"].(string); ok {
+		path = p
+	}
+	
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	
+	cmd := exec.CommandContext(ctx, "git", "-C", path, "commit", "-m", message)
+	output, err := cmd.CombinedOutput()
+	
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Data:    string(output),
+			Error:   fmt.Sprintf("git commit failed: %v", err),
+		}, nil
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    string(output),
+		Metadata: map[string]interface{}{
+			"path":    path,
+			"message": message,
+		},
+	}, nil
+}
+
+// GitLogTool shows commit history
+type GitLogTool struct{}
+
+func NewGitLogTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "git_log",
+		Name:        "Git Log",
+		Description: "Show git commit history",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "Path to git repository",
+				},
+				"limit": map[string]interface{}{
+					"type":        "number",
+					"description": "Number of commits to show",
+				},
+			},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "git",
+		Executor:             executeGitLog,
+	}
+}
+
+func executeGitLog(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	path := "."
+	if p, ok := input.Parameters["path"].(string); ok {
+		path = p
+	}
+	
+	limit := 10
+	if l, ok := input.Parameters["limit"].(float64); ok {
+		limit = int(l)
+	}
+	
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	
+	cmd := exec.CommandContext(ctx, "git", "-C", path, "log", 
+		fmt.Sprintf("-%d", limit), "--oneline", "--decorate")
+	output, err := cmd.CombinedOutput()
+	
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("git log failed: %v", err),
+		}, nil
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    string(output),
+		Metadata: map[string]interface{}{
+			"path":  path,
+			"limit": limit,
+		},
+	}, nil
+}
+
+// GitBranchTool manages branches
+type GitBranchTool struct{}
+
+func NewGitBranchTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "git_branch",
+		Name:        "Git Branch",
+		Description: "List or switch git branches",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "Path to git repository",
+				},
+				"action": map[string]interface{}{
+					"type":        "string",
+					"description": "Action: list, switch, create",
+				},
+				"branch": map[string]interface{}{
+					"type":        "string",
+					"description": "Branch name (for switch/create)",
+				},
+			},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "git",
+		Executor:             executeGitBranch,
+	}
+}
+
+func executeGitBranch(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	path := "."
+	if p, ok := input.Parameters["path"].(string); ok {
+		path = p
+	}
+	
+	action := "list"
+	if a, ok := input.Parameters["action"].(string); ok {
+		action = a
+	}
+	
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	
+	var cmd *exec.Cmd
+	
+	switch action {
+	case "list":
+		cmd = exec.CommandContext(ctx, "git", "-C", path, "branch", "-a")
+	case "switch":
+		branch, ok := input.Parameters["branch"].(string)
+		if !ok {
+			return &registry.ToolOutput{
+				Success: false,
+				Error:   "branch parameter required for switch action",
+			}, nil
+		}
+		cmd = exec.CommandContext(ctx, "git", "-C", path, "checkout", branch)
+	case "create":
+		branch, ok := input.Parameters["branch"].(string)
+		if !ok {
+			return &registry.ToolOutput{
+				Success: false,
+				Error:   "branch parameter required for create action",
+			}, nil
+		}
+		cmd = exec.CommandContext(ctx, "git", "-C", path, "checkout", "-b", branch)
+	default:
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "invalid action: " + action,
+		}, nil
+	}
+	
+	output, err := cmd.CombinedOutput()
+	
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Data:    string(output),
+			Error:   fmt.Sprintf("git branch failed: %v", err),
+		}, nil
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    string(output),
+		Metadata: map[string]interface{}{
+			"path":   path,
+			"action": action,
+		},
+	}, nil
+}