@dcode-dev/dcode-cli 1.0.0

package/cmd/context.go

@@ -0,0 +1,111 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/ddhanush1/dcode/internal/context"
+	"github.com/spf13/cobra"
+)
+
+var (
+	contextListAll bool
+	contextAdd     []string
+	contextRemove  []string
+)
+
+var contextCmd = &cobra.Command{
+	Use:   "context",
+	Short: "Manage context for AI operations",
+	Long: `Smart context management for better AI understanding
+
+The context system helps DCode understand your codebase by:
+  • Auto-detecting relevant files
+  • Tracking dependencies and imports
+  • Building a knowledge graph
+  • Remembering conversation history
+
+Subcommands:
+  analyze   - Analyze project and build context
+  list      - List current context files
+  clear     - Clear context cache
+`,
+}
+
+var contextAnalyzeCmd = &cobra.Command{
+	Use:   "analyze",
+	Short: "Analyze project and build context",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		wd, _ := os.Getwd()
+		
+		fmt.Println("\033[1;36m🔍 Analyzing project...\033[0m\n")
+
+		builder := context.NewBuilder(wd)
+		projectCtx, err := builder.Build()
+		if err != nil {
+			return fmt.Errorf("failed to analyze: %w", err)
+		}
+
+		// Print detailed summary
+		fmt.Println(projectCtx.Summary)
+		
+		fmt.Println("\n\033[90m💡 Use 'dcode agent' to interact with this project\033[0m")
+		
+		return nil
+	},
+}
+
+var contextListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List current context files",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		wd, _ := os.Getwd()
+		
+		builder := context.NewBuilder(wd)
+		projectCtx, err := builder.Build()
+		if err != nil {
+			return fmt.Errorf("failed to analyze: %w", err)
+		}
+
+		files := projectCtx.RelevantFiles
+
+		if len(files) == 0 {
+			fmt.Println("\033[90mNo files in context\033[0m")
+			return nil
+		}
+
+		fmt.Printf("\033[1;36mContext files (%d):\033[0m\n\n", len(files))
+		for i, f := range files {
+			if contextListAll || i < 20 {
+				fmt.Printf("  %3d. %.1f%%  %s\n", i+1, f.Relevance*100, f.RelPath)
+			}
+		}
+		
+		if !contextListAll && len(files) > 20 {
+			fmt.Printf("\n\033[90m... and %d more (use --all to show all)\033[0m\n", len(files)-20)
+		}
+
+		return nil
+	},
+}
+
+var contextClearCmd = &cobra.Command{
+	Use:   "clear",
+	Short: "Clear context cache",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		// For now, this is a no-op since we don't persist context yet
+		// In future: clear cache, embeddings, etc.
+		fmt.Println("\033[32m✓ Context cleared\033[0m")
+		return nil
+	},
+}
+
+func init() {
+	contextListCmd.Flags().BoolVarP(&contextListAll, "all", "a", false, "Show all files")
+	
+	contextCmd.AddCommand(contextAnalyzeCmd)
+	contextCmd.AddCommand(contextListCmd)
+	contextCmd.AddCommand(contextClearCmd)
+	
+	rootCmd.AddCommand(contextCmd)
+}

package/cmd/edit.go

@@ -0,0 +1,116 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/ddhanush1/dcode/internal/agent"
+	"github.com/ddhanush1/dcode/internal/fsutil"
+	"github.com/spf13/cobra"
+)
+
+var (
+	editFile     string
+	editPrompt   string
+	aiProvider   string
+	aiModel      string
+	useWebSearch bool
+	dryRun       bool
+)
+
+var editCmd = &cobra.Command{
+	Use:   "edit",
+	Short: "Edit code using AI",
+	Long: `Edit code intelligently using AI providers (OpenAI, Gemini, Claude).
+
+Examples:
+  dcode edit --file main.go --prompt "Add error handling" --provider openai --model gpt-4
+  dcode edit --file app.py --prompt "Optimize this function" --provider gemini
+  dcode edit --file api.js --prompt "Add validation" --provider claude --search`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if strings.TrimSpace(editFile) == "" {
+			return fmt.Errorf("--file is required")
+		}
+
+		// Allow overriding provider/model via flags.
+		if aiProvider != "" {
+			_ = os.Setenv("AI_PROVIDER", aiProvider)
+		}
+		if aiModel != "" {
+			_ = os.Setenv("AI_MODEL", aiModel)
+		}
+
+		content, err := fsutil.ReadFile(editFile)
+		if err != nil {
+			return err
+		}
+
+		ag, err := agent.New()
+		if err != nil {
+			return err
+		}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+
+		resp, err := ag.Edit(ctx, agent.EditRequest{
+			Prompt:    editPrompt,
+			Files:     []agent.FileInput{{Path: filepath.ToSlash(editFile), Content: content}},
+			WebSearch: agent.WebSearchRequest{Enabled: useWebSearch},
+		})
+		if err != nil {
+			return err
+		}
+
+		if len(resp.Edits) == 0 {
+			fmt.Println("No edits returned.")
+			return nil
+		}
+
+		for _, e := range resp.Edits {
+			if filepath.Clean(e.Path) != filepath.Clean(filepath.ToSlash(editFile)) && filepath.Clean(e.Path) != filepath.Clean(editFile) {
+				fmt.Printf("Skipping unexpected edit path: %s\n", e.Path)
+				continue
+			}
+			if e.NewContent == content {
+				fmt.Println("No changes needed.")
+				continue
+			}
+
+			if dryRun {
+				fmt.Printf("--- %s (dry-run, not written) ---\n", editFile)
+				fmt.Println(e.NewContent)
+				continue
+			}
+
+			perm := fsutil.FilePermOrDefault(editFile, 0o644)
+			if err := fsutil.WriteFileAtomic(editFile, []byte(e.NewContent), perm); err != nil {
+				return err
+			}
+			fmt.Printf("Updated %s\n", editFile)
+		}
+
+		if strings.TrimSpace(resp.Explanation) != "" {
+			fmt.Println("\nExplanation:")
+			fmt.Println(resp.Explanation)
+		}
+
+		return nil
+	},
+}
+
+func init() {
+	editCmd.Flags().StringVarP(&editFile, "file", "f", "", "File to edit")
+	editCmd.Flags().StringVarP(&editPrompt, "prompt", "p", "", "Editing instructions (required)")
+	editCmd.Flags().StringVar(&aiProvider, "provider", "", "AI provider: openai, gemini, claude (default from .env)")
+	editCmd.Flags().StringVar(&aiModel, "model", "", "Model name (default from .env)")
+	editCmd.Flags().BoolVar(&useWebSearch, "search", false, "Enable web search for context")
+	editCmd.Flags().BoolVar(&dryRun, "dry-run", false, "Print new content but do not write")
+
+	editCmd.MarkFlagRequired("prompt")
+	rootCmd.AddCommand(editCmd)
+}

package/cmd/env.go

@@ -0,0 +1,10 @@
+package cmd
+
+import "os"
+
+func getEnv(key, fallback string) string {
+	if value := os.Getenv(key); value != "" {
+		return value
+	}
+	return fallback
+}

package/cmd/fix.go

@@ -0,0 +1,145 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/ddhanush1/dcode/internal/agent"
+	"github.com/ddhanush1/dcode/internal/fsutil"
+	"github.com/spf13/cobra"
+)
+
+var (
+	fixFile    string
+	fixPrompt  string
+	fixCommand string
+	fixDryRun  bool
+)
+
+var fixCmd = &cobra.Command{
+	Use:   "fix",
+	Short: "Find and fix errors",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if strings.TrimSpace(fixFile) == "" {
+			return fmt.Errorf("--file is required")
+		}
+
+		content, err := fsutil.ReadFile(fixFile)
+		if err != nil {
+			return err
+		}
+
+		// Allow overriding provider/model via flags inherited from edit if set.
+		if aiProvider != "" {
+			_ = os.Setenv("AI_PROVIDER", aiProvider)
+		}
+		if aiModel != "" {
+			_ = os.Setenv("AI_MODEL", aiModel)
+		}
+
+		var testOutput string
+		if strings.TrimSpace(fixCommand) != "" {
+			out, err := runShellCommand(fixCommand)
+			testOutput = out
+			if err != nil {
+				// keep output; model can still try to fix
+				fmt.Printf("Command failed (continuing): %v\n", err)
+			}
+		} else {
+			// If this looks like a Go workspace, run tests by default.
+			if _, err := os.Stat("go.mod"); err == nil {
+				out, err := runShellCommand("go test ./...")
+				testOutput = out
+				if err != nil {
+					fmt.Printf("go test failed (continuing): %v\n", err)
+				}
+			}
+		}
+
+		ag, err := agent.New()
+		if err != nil {
+			return err
+		}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 8*time.Minute)
+		defer cancel()
+
+		resp, err := ag.Fix(ctx, agent.FixRequest{
+			Prompt:     fixPrompt,
+			Files:      []agent.FileInput{{Path: filepath.ToSlash(fixFile), Content: content}},
+			TestOutput: testOutput,
+		})
+		if err != nil {
+			return err
+		}
+
+		for _, e := range resp.Edits {
+			if filepath.Clean(e.Path) != filepath.Clean(filepath.ToSlash(fixFile)) && filepath.Clean(e.Path) != filepath.Clean(fixFile) {
+				fmt.Printf("Skipping unexpected edit path: %s\n", e.Path)
+				continue
+			}
+			if e.NewContent == content {
+				fmt.Println("No changes needed.")
+				continue
+			}
+
+			if fixDryRun {
+				fmt.Printf("--- %s (dry-run, not written) ---\n", fixFile)
+				fmt.Println(e.NewContent)
+				continue
+			}
+
+			perm := fsutil.FilePermOrDefault(fixFile, 0o644)
+			if err := fsutil.WriteFileAtomic(fixFile, []byte(e.NewContent), perm); err != nil {
+				return err
+			}
+			fmt.Printf("Updated %s\n", fixFile)
+		}
+
+		if strings.TrimSpace(resp.Explanation) != "" {
+			fmt.Println("\nExplanation:")
+			fmt.Println(resp.Explanation)
+		}
+
+		return nil
+	},
+}
+
+func runShellCommand(command string) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+
+	// Use `bash -lc` when available (WSL/Linux/mac). On Windows, users can pass a single command supported by their shell.
+	var cmd *exec.Cmd
+	if _, err := exec.LookPath("bash"); err == nil {
+		cmd = exec.CommandContext(ctx, "bash", "-lc", command)
+	} else {
+		parts := strings.Fields(command)
+		if len(parts) == 0 {
+			return "", fmt.Errorf("empty command")
+		}
+		cmd = exec.CommandContext(ctx, parts[0], parts[1:]...)
+	}
+
+	var buf bytes.Buffer
+	cmd.Stdout = &buf
+	cmd.Stderr = &buf
+	cmd.Dir = "."
+	cmd.Env = os.Environ()
+	err := cmd.Run()
+	return buf.String(), err
+}
+
+func init() {
+	fixCmd.Flags().StringVarP(&fixFile, "file", "f", "", "File to fix (required)")
+	fixCmd.Flags().StringVarP(&fixPrompt, "prompt", "p", "", "Optional extra instructions")
+	fixCmd.Flags().StringVar(&fixCommand, "command", "", "Command to run for error output (default: go test ./... if go.mod exists)")
+	fixCmd.Flags().BoolVar(&fixDryRun, "dry-run", false, "Print new content but do not write")
+	rootCmd.AddCommand(fixCmd)
+}

package/cmd/gemini.go

@@ -0,0 +1,20 @@
+package cmd
+
+import (
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var geminiCmd = &cobra.Command{
+	Use:   "gemini",
+	Short: "Start agent with Google Gemini (shortcut)",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		_ = os.Setenv("AI_PROVIDER", "gemini")
+		return agentV2Cmd.RunE(cmd, args)
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(geminiCmd)
+}

package/cmd/generate.go

@@ -0,0 +1,47 @@
+package cmd
+
+import (
+"fmt"
+"github.com/spf13/cobra"
+)
+
+var generateCmd = &cobra.Command{
+Use:   "generate",
+Short: "Generate code using AI",
+Long: `Generate code from natural language descriptions using AI.
+
+Examples:
+  dcode generate --prompt "REST API with authentication" --language go --provider openai
+  dcode generate --prompt "Binary search algorithm" --language python --provider gemini
+  dcode generate --prompt "React component for login form" --language typescript --provider claude`,
+RunE: func(cmd *cobra.Command, args []string) error {
+genPrompt, _ := cmd.Flags().GetString("prompt")
+genLang, _ := cmd.Flags().GetString("language")
+provider, _ := cmd.Flags().GetString("provider")
+model, _ := cmd.Flags().GetString("model")
+
+if provider == "" {
+provider = getEnv("AI_PROVIDER", "openai")
+}
+if model == "" {
+model = getEnv("AI_MODEL", "gpt-4")
+}
+
+fmt.Printf(" Using %s (%s)\n", provider, model)
+fmt.Printf(" Generating %s code...\n", genLang)
+fmt.Printf(" Prompt: %s\n\n", genPrompt)
+
+fmt.Println("Generated code will appear here...")
+return nil
+},
+}
+
+func init() {
+generateCmd.Flags().StringP("prompt", "p", "", "Description of code to generate (required)")
+generateCmd.Flags().StringP("language", "l", "go", "Programming language")
+generateCmd.Flags().String("provider", "", "AI provider: openai, gemini, claude")
+generateCmd.Flags().String("model", "", "Model name")
+
+generateCmd.MarkFlagRequired("prompt")
+rootCmd.AddCommand(generateCmd)
+}

package/cmd/interactive.go

@@ -0,0 +1,33 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/ddhanush1/dcode/internal/prompt"
+	"github.com/spf13/cobra"
+)
+
+var interactiveCmd = &cobra.Command{
+	Use:   "interactive",
+	Short: "Start interactive mode with slash command suggestions",
+	Long: `Start an interactive session with a prompt that shows command suggestions
+when you type /. Use arrow keys to navigate, Tab or Enter to select.
+
+Features:
+  • Type / to see all available commands
+  • Autocomplete filters as you type
+  • Use ↑↓ arrow keys to navigate suggestions
+  • Press Tab or Enter to select a command
+  • Type regular prompts without / for normal input`,
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Println("Starting interactive mode...")
+		fmt.Println()
+		if err := prompt.StartInteractive(); err != nil {
+			fmt.Printf("Error: %v\n", err)
+		}
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(interactiveCmd)
+}

package/cmd/mcp.go

@@ -0,0 +1,196 @@
+package cmd
+
+import (
+	"fmt"
+	
+	"github.com/spf13/cobra"
+	"github.com/ddhanush1/dcode/internal/mcp"
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+var mcpCmd = &cobra.Command{
+	Use:   "mcp",
+	Short: "Manage MCP (Model Context Protocol) servers",
+	Long: `Manage MCP servers that provide additional tools, resources, and prompts.
+	
+MCP servers extend dcode's capabilities by providing:
+- External tools (file systems, APIs, databases)
+- Resources (documents, URLs, data)
+- Prompts (reusable templates)`,
+}
+
+var mcpListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all configured MCP servers",
+	Run: func(cmd *cobra.Command, args []string) {
+		// Create tool registry (needed for manager)
+		toolRegistry := registry.NewToolRegistry()
+		
+		// Create MCP manager
+		manager := mcp.NewMCPManager(toolRegistry)
+		
+		// List servers
+		servers := manager.ListServers()
+		
+		if len(servers) == 0 {
+			fmt.Println("No MCP servers configured.")
+			fmt.Println("\nAdd a server with: dcode mcp add <url>")
+			return
+		}
+		
+		fmt.Println("╔════════════════════════════════════════════════════════════╗")
+		fmt.Println("║                    MCP Servers                            ║")
+		fmt.Println("╚════════════════════════════════════════════════════════════╝")
+		fmt.Println()
+		
+		for _, server := range servers {
+			status := "❌ Disabled"
+			if server.Enabled {
+				status = "✅ Enabled"
+			}
+			
+			fmt.Printf("📡 %s (%s)\n", server.Name, server.ID)
+			fmt.Printf("   URL: %s\n", server.URL)
+			fmt.Printf("   Status: %s\n", status)
+			fmt.Println()
+		}
+		
+		fmt.Printf("Total: %d server(s)\n", len(servers))
+	},
+}
+
+var mcpAddCmd = &cobra.Command{
+	Use:   "add <url>",
+	Short: "Add a new MCP server",
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		url := args[0]
+		name, _ := cmd.Flags().GetString("name")
+		id, _ := cmd.Flags().GetString("id")
+		
+		// Generate ID if not provided
+		if id == "" {
+			id = fmt.Sprintf("mcp_%d", len(args))
+		}
+		
+		// Use URL as name if not provided
+		if name == "" {
+			name = url
+		}
+		
+		// Create tool registry
+		toolRegistry := registry.NewToolRegistry()
+		
+		// Create MCP manager
+		manager := mcp.NewMCPManager(toolRegistry)
+		
+		// Add server
+		server := &mcp.MCPServer{
+			ID:      id,
+			Name:    name,
+			URL:     url,
+			Enabled: true,
+		}
+		
+		if err := manager.AddServer(server); err != nil {
+			fmt.Printf("❌ Failed to add server: %v\n", err)
+			return
+		}
+		
+		fmt.Printf("✅ Added MCP server: %s\n", name)
+		fmt.Printf("   ID: %s\n", id)
+		fmt.Printf("   URL: %s\n", url)
+		fmt.Println("\nDiscovering tools...")
+		
+		// Enable and discover tools
+		if err := manager.EnableServer(id); err != nil {
+			fmt.Printf("⚠️  Warning: failed to discover tools: %v\n", err)
+		} else {
+			fmt.Println("✅ Tools discovered and registered")
+		}
+	},
+}
+
+var mcpRemoveCmd = &cobra.Command{
+	Use:   "remove <id>",
+	Short: "Remove an MCP server",
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		id := args[0]
+		
+		// Create tool registry
+		toolRegistry := registry.NewToolRegistry()
+		
+		// Create MCP manager
+		manager := mcp.NewMCPManager(toolRegistry)
+		
+		// Remove server
+		if err := manager.RemoveServer(id); err != nil {
+			fmt.Printf("❌ Failed to remove server: %v\n", err)
+			return
+		}
+		
+		fmt.Printf("✅ Removed MCP server: %s\n", id)
+	},
+}
+
+var mcpEnableCmd = &cobra.Command{
+	Use:   "enable <id>",
+	Short: "Enable an MCP server",
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		id := args[0]
+		
+		// Create tool registry
+		toolRegistry := registry.NewToolRegistry()
+		
+		// Create MCP manager
+		manager := mcp.NewMCPManager(toolRegistry)
+		
+		// Enable server
+		if err := manager.EnableServer(id); err != nil {
+			fmt.Printf("❌ Failed to enable server: %v\n", err)
+			return
+		}
+		
+		fmt.Printf("✅ Enabled MCP server: %s\n", id)
+	},
+}
+
+var mcpDisableCmd = &cobra.Command{
+	Use:   "disable <id>",
+	Short: "Disable an MCP server",
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		id := args[0]
+		
+		// Create tool registry
+		toolRegistry := registry.NewToolRegistry()
+		
+		// Create MCP manager
+		manager := mcp.NewMCPManager(toolRegistry)
+		
+		// Disable server
+		if err := manager.DisableServer(id); err != nil {
+			fmt.Printf("❌ Failed to disable server: %v\n", err)
+			return
+		}
+		
+		fmt.Printf("✅ Disabled MCP server: %s\n", id)
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(mcpCmd)
+	
+	// Add subcommands
+	mcpCmd.AddCommand(mcpListCmd)
+	mcpCmd.AddCommand(mcpAddCmd)
+	mcpCmd.AddCommand(mcpRemoveCmd)
+	mcpCmd.AddCommand(mcpEnableCmd)
+	mcpCmd.AddCommand(mcpDisableCmd)
+	
+	// Add flags
+	mcpAddCmd.Flags().String("name", "", "Server name")
+	mcpAddCmd.Flags().String("id", "", "Server ID (auto-generated if not provided)")
+}

package/cmd/patch.go

@@ -0,0 +1,19 @@
+package cmd
+
+import (
+"fmt"
+"github.com/spf13/cobra"
+)
+
+var patchCmd = &cobra.Command{
+Use:   "patch",
+Short: "Generate or apply patches",
+RunE: func(cmd *cobra.Command, args []string) error {
+fmt.Println("Patch operations - coming soon!")
+return nil
+},
+}
+
+func init() {
+rootCmd.AddCommand(patchCmd)
+}