@dcode-dev/dcode-cli 1.0.0

package/cmd/agent_v2.go

@@ -0,0 +1,448 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/ddhanush1/dcode/internal/agents"
+	"github.com/ddhanush1/dcode/internal/ai"
+	"github.com/ddhanush1/dcode/internal/auth"
+	"github.com/ddhanush1/dcode/internal/config"
+	"github.com/ddhanush1/dcode/internal/registry"
+	"github.com/ddhanush1/dcode/internal/scheduler"
+	"github.com/ddhanush1/dcode/internal/tools"
+	"github.com/peterh/liner"
+	"github.com/spf13/cobra"
+)
+
+var agentV2Cmd = &cobra.Command{
+	Use:   "agent-v2",
+	Short: "Start the new agent system (v2 architecture)",
+	Long:  `Interactive AI agent using the new architecture with agent registry and tool system`,
+	RunE:  runAgentV2,
+}
+
+func init() {
+	rootCmd.AddCommand(agentV2Cmd)
+	
+	// Add flags to both root and agent-v2 commands
+	for _, cmd := range []*cobra.Command{rootCmd, agentV2Cmd} {
+		cmd.Flags().String("agent", "generalist", "Agent to use (generalist, codebase_investigator)")
+		cmd.Flags().String("provider", "", "AI provider (openai, gemini, claude)")
+		cmd.Flags().String("model", "", "AI model to use")
+	}
+}
+
+func runAgentV2(cmd *cobra.Command, args []string) error {
+	// Load config
+	cfg, err := config.LoadConfig()
+	if err != nil {
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+	
+	// Override with flags
+	if provider, _ := cmd.Flags().GetString("provider"); provider != "" {
+		cfg.Model.Provider = provider
+		cfg.Auth.Provider = provider
+	}
+	if model, _ := cmd.Flags().GetString("model"); model != "" {
+		cfg.Model.Model = model
+	}
+	
+	// Interactive provider selection if not set
+	if cfg.Model.Provider == "" {
+		fmt.Println("🤖 Welcome to DCode!")
+		fmt.Println("\nSelect your AI provider:")
+		fmt.Println("  1. Gemini (Google)")
+		fmt.Println("  2. OpenAI (ChatGPT)")
+		fmt.Println("  3. GitHub Copilot")
+		fmt.Println("  4. Claude (Anthropic)")
+		fmt.Print("\nEnter choice (1-4): ")
+		
+		var choice int
+		fmt.Scanf("%d", &choice)
+		
+		providers := map[int]string{
+			1: "gemini",
+			2: "openai",
+			3: "copilot",
+			4: "claude",
+		}
+		
+		if provider, ok := providers[choice]; ok {
+			cfg.Model.Provider = provider
+			cfg.Auth.Provider = provider
+			
+			// Set default models
+			switch provider {
+			case "gemini":
+				cfg.Model.Model = "gemini-2.0-flash-exp"
+			case "openai":
+				cfg.Model.Model = "gpt-4"
+			case "copilot":
+				cfg.Model.Model = "gpt-4"
+			case "claude":
+				cfg.Model.Model = "claude-3-5-sonnet-20241022"
+			}
+			
+			config.SaveConfig(cfg)
+			fmt.Printf("\n✅ Set provider to: %s\n\n", provider)
+		} else {
+			return fmt.Errorf("invalid choice. Use: dcode --provider gemini|openai|copilot|claude")
+		}
+	}
+	
+	// Create authenticator
+	authFactory := auth.NewFactory(auth.GetDefaultStore())
+	authenticator, err := authFactory.CreateFromConfig(cfg)
+	if err != nil {
+		fmt.Printf("⚠️  Warning: Auth setup failed: %v\n", err)
+		fmt.Println("Falling back to environment variables...")
+	}
+	
+	// Get API key
+	var apiKey string
+	if authenticator != nil {
+		ctx := context.Background()
+		apiKey, err = authenticator.GetToken(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get API key: %w", err)
+		}
+	} else {
+		// Fallback to env
+		switch cfg.Model.Provider {
+		case "openai":
+			apiKey = os.Getenv("OPENAI_API_KEY")
+		case "gemini":
+			apiKey = os.Getenv("GEMINI_API_KEY")
+			if apiKey == "" {
+				apiKey = os.Getenv("GOOGLE_API_KEY")
+			}
+		case "github":
+			apiKey = os.Getenv("GITHUB_TOKEN")
+		case "claude":
+			apiKey = os.Getenv("ANTHROPIC_API_KEY")
+		case "copilot":
+			apiKey = os.Getenv("COPILOT_TOKEN")
+			if apiKey == "" {
+				// Try to get token from Copilot CLI config
+				apiKey = ai.GetCopilotToken()
+			}
+		}
+		
+		if apiKey == "" {
+			return fmt.Errorf("API key not found for provider: %s", cfg.Model.Provider)
+		}
+	}
+	
+	// Create AI client
+	aiClient := &ai.Client{
+		Provider: ai.Provider(cfg.Model.Provider),
+		Model:    cfg.Model.Model,
+		APIKey:   apiKey,
+	}
+	
+	// Create registries
+	agentRegistry := registry.NewAgentRegistry()
+	toolRegistry := registry.NewToolRegistry()
+	
+	// Register tools
+	if err := tools.RegisterBuiltinTools(toolRegistry); err != nil {
+		return fmt.Errorf("failed to register tools: %w", err)
+	}
+	
+	// Register agents
+	if err := agents.RegisterAllAgents(agentRegistry, cfg, aiClient); err != nil {
+		return fmt.Errorf("failed to register agents: %w", err)
+	}
+	
+	// Create policy
+	policyFile, err := config.LoadPolicyFile()
+	if err != nil {
+		return fmt.Errorf("failed to load policy: %w", err)
+	}
+	
+	// Create scheduler
+	sched := scheduler.NewScheduler(toolRegistry, policyFile)
+	
+	// Create agent manager
+	agentManager := agents.NewAgentManager(agentRegistry, toolRegistry)
+	
+	// Switch to requested agent
+	agentID, _ := cmd.Flags().GetString("agent")
+	if err := agentManager.SwitchAgent(agentID); err != nil {
+		return err
+	}
+	
+	currentAgent, _ := agentManager.GetCurrentAgent()
+	
+	// Simple welcome message (like gemini-cli)
+	fmt.Println()
+	fmt.Printf("╭─ DCode v2.0 ─ %s ─ %d tools\n", cfg.Model.Model, len(toolRegistry.List()))
+	fmt.Println("╰─ Type your message or /help for commands")
+	fmt.Println()
+	
+	// Start REPL
+	line := liner.NewLiner()
+	defer line.Close()
+	
+	line.SetCtrlCAborts(true)
+	
+	// Load history
+	historyFile := os.ExpandEnv("$HOME/.dcode_history")
+	if f, err := os.Open(historyFile); err == nil {
+		line.ReadHistory(f)
+		f.Close()
+	}
+	
+	ctx := context.Background()
+	
+	for {
+		// Simple prompt like gemini-cli
+		prompt := "╰─ "
+		input, err := line.Prompt(prompt)
+		if err != nil {
+			break
+		}
+		
+		input = strings.TrimSpace(input)
+		if input == "" {
+			continue
+		}
+		
+		line.AppendHistory(input)
+		
+		// Handle commands
+		if strings.HasPrefix(input, "/") {
+			if handled, shouldContinue := handleCommand(input, agentManager, toolRegistry, agentRegistry, line, historyFile); !shouldContinue {
+				break
+			} else if handled {
+				currentAgent, _ = agentManager.GetCurrentAgent()
+				continue
+			}
+		}
+		
+		// Get current working directory
+		cwd, err := os.Getwd()
+		if err != nil {
+			cwd = "unknown"
+		}
+		
+		// Execute agent with streaming and working directory context
+		agentInput := &registry.AgentInput{
+			Query:        input,
+			Parameters:   make(map[string]interface{}),
+			History:      agentManager.GetHistory(currentAgent.ID),
+			Tools:        currentAgent.Tools,
+			ToolRegistry: toolRegistry,
+			SystemPrompt: currentAgent.SystemPrompt + fmt.Sprintf("\n\nCURRENT WORKING DIRECTORY: %s\nIMPORTANT: When creating files, use relative paths from the current working directory unless absolute paths are explicitly requested.", cwd),
+			Context:      make(map[string]interface{}),
+			Config:       currentAgent.Config,
+		}
+		
+		fmt.Println("\n🤔 Thinking...")
+		
+		// Try to execute with streaming if possible
+		var output *registry.AgentOutput
+		var execErr error
+		
+		// Check if we can use streaming (only for GeneralistAgent currently)
+		if genAgent, ok := currentAgent.Instance.(*agents.GeneralistAgent); ok {
+			// Stream with typewriter effect
+			fmt.Print("\n💬 ")
+			output, execErr = genAgent.ExecuteStream(agentInput, func(chunk string) {
+				for _, char := range chunk {
+					fmt.Print(string(char))
+					time.Sleep(20 * time.Millisecond) // Typewriter speed
+				}
+			})
+			fmt.Println() // Newline after streaming
+		} else {
+			// Fallback to non-streaming
+			output, execErr = agentManager.Execute(ctx, agentInput)
+			if execErr == nil && output.Message != "" {
+				fmt.Printf("\n💬 %s\n", output.Message)
+			}
+		}
+		
+		if execErr != nil {
+			fmt.Printf("\n❌ Error: %v\n\n", execErr)
+			continue
+		}
+		
+		// Execute tool calls if any and continue conversation
+		if len(output.ToolCalls) > 0 {
+			fmt.Printf("\n🔧 Executing %d tool(s)...\n", len(output.ToolCalls))
+			
+			toolResults := []string{}
+			for _, toolCall := range output.ToolCalls {
+				fmt.Printf("  • %s\n", toolCall.ToolName)
+				
+				req := &scheduler.ExecutionRequest{
+					ToolID:     toolCall.ToolName,
+					Parameters: toolCall.Parameters,
+					Context:    make(map[string]interface{}),
+				}
+				
+				confirmHandler := func(req *scheduler.ConfirmationRequest) (bool, error) {
+					// Use liner.Prompt for input (works with liner's terminal mode)
+					response, err := line.Prompt(fmt.Sprintf("⚠️  Confirm %s? (y/n): ", req.ToolName))
+					if err != nil {
+						return false, err
+					}
+					response = strings.ToLower(strings.TrimSpace(response))
+					return response == "y" || response == "yes", nil
+				}
+				
+				result, err := sched.Execute(ctx, req, confirmHandler)
+				if err != nil {
+					fmt.Printf("    ❌ Failed: %v\n", err)
+					toolResults = append(toolResults, fmt.Sprintf("Tool '%s' failed: %v", toolCall.ToolName, err))
+				} else if result.Success {
+					fmt.Printf("    ✅ Success\n")
+					// Format tool result as string
+					resultStr := fmt.Sprintf("Tool '%s' result: %v", toolCall.ToolName, result.Data)
+					toolResults = append(toolResults, resultStr)
+				} else {
+					fmt.Printf("    ⚠️  %s\n", result.Error)
+					toolResults = append(toolResults, fmt.Sprintf("Tool '%s' error: %s", toolCall.ToolName, result.Error))
+				}
+			}
+			
+			// Continue conversation with tool results
+			if len(toolResults) > 0 {
+				fmt.Println("\n🤔 Processing results...")
+				
+				// Only add model's response if it has content
+				if output.Message != "" {
+					agentManager.AddMessage(currentAgent.ID, "model", output.Message, make(map[string]interface{}))
+				}
+				
+				// Add function results as special "function" message  
+				toolResultsStr := strings.Join(toolResults, "\n\n")
+				agentManager.AddMessage(currentAgent.ID, "function", toolResultsStr, make(map[string]interface{}))
+				
+				// Get continuation from AI
+				continuationInput := &registry.AgentInput{
+					Query:        "",  // Empty query, AI should process function results
+					Parameters:   make(map[string]interface{}),
+					History:      agentManager.GetHistory(currentAgent.ID),
+					Tools:        currentAgent.Tools,
+					ToolRegistry: toolRegistry,
+					SystemPrompt: currentAgent.SystemPrompt,
+					Context:      make(map[string]interface{}),
+					Config:       currentAgent.Config,
+				}
+				
+				continuationOutput, err := agentManager.Execute(ctx, continuationInput)
+				if err != nil {
+					fmt.Printf("\n❌ Error processing results: %v\n\n", err)
+				} else {
+					fmt.Printf("\n💬 %s\n", continuationOutput.Message)
+				}
+			}
+		}
+		
+		fmt.Println()
+	}
+	
+	return nil
+}
+
+func handleCommand(input string, agentManager *agents.AgentManager, toolRegistry *registry.ToolRegistry, agentRegistry *registry.AgentRegistry, linerInst *liner.State, historyFile string) (handled bool, shouldContinue bool) {
+	parts := strings.Fields(input)
+	if len(parts) == 0 {
+		return true, true
+	}
+	
+	command := parts[0]
+	
+	switch command {
+	case "/help", "/h":
+		fmt.Println("\nAvailable Commands:")
+		fmt.Println("  /help, /h       - Show this help")
+		fmt.Println("  /agent          - List and switch agents")
+		fmt.Println("  /tools          - List available tools")
+		fmt.Println("  /auth           - Show authentication status")
+		fmt.Println("  /clear          - Clear conversation history")
+		fmt.Println("  /exit, /quit    - Exit the agent")
+		fmt.Println()
+		return true, true
+		
+	case "/agent", "/agents":
+		if len(parts) > 1 {
+			// Switch agent
+			agentID := parts[1]
+			if err := agentManager.SwitchAgent(agentID); err != nil {
+				fmt.Printf("❌ Error: %v\n", err)
+			} else {
+				agent, _ := agentManager.GetCurrentAgent()
+				fmt.Printf("✅ Switched to: %s\n", agent.Name)
+			}
+		} else {
+			// List agents
+			agents := agentRegistry.List()
+			fmt.Println("\nAvailable Agents:")
+			for _, agent := range agents {
+				fmt.Printf("  • %s - %s\n", agent.ID, agent.Description)
+			}
+			fmt.Println("\nUse '/agent <id>' to switch")
+			fmt.Println()
+		}
+		return true, true
+		
+	case "/tools":
+		tools := toolRegistry.List()
+		fmt.Println("\nAvailable Tools:")
+		for _, tool := range tools {
+			fmt.Printf("  • %s (%s) - %s\n", tool.Name, tool.RiskLevel, tool.Description)
+		}
+		fmt.Println()
+		return true, true
+		
+	case "/clear":
+		agent, _ := agentManager.GetCurrentAgent()
+		agentManager.ClearHistory(agent.ID)
+		fmt.Println("✅ Conversation history cleared")
+		return true, true
+		
+	case "/auth":
+		// Show auth status
+		cfg, err := config.LoadConfig()
+		if err != nil {
+			fmt.Printf("❌ Error loading config: %v\n", err)
+			return true, true
+		}
+		
+		fmt.Println("\n🔐 Authentication Status:")
+		fmt.Printf("  Provider: %s\n", cfg.Auth.Provider)
+		fmt.Printf("  Auth Type: %s\n", cfg.Auth.Type)
+		
+		if cfg.Auth.APIKey != "" {
+			fmt.Printf("  Status: ✅ Authenticated (API Key)\n")
+			keyLen := len(cfg.Auth.APIKey)
+			if keyLen > 12 {
+				fmt.Printf("  Key: %s...%s\n", cfg.Auth.APIKey[:8], cfg.Auth.APIKey[keyLen-4:])
+			}
+		} else {
+			fmt.Printf("  Status: ❌ Not authenticated\n")
+			fmt.Println("\n  Run: ./dcode auth login --type api_key")
+		}
+		fmt.Println()
+		return true, true
+		
+	case "/exit", "/quit", "/q":
+		if f, err := os.Create(historyFile); err == nil {
+			linerInst.WriteHistory(f)
+			f.Close()
+		}
+		fmt.Println("\n👋 Goodbye!")
+		return true, false
+		
+	default:
+		return false, true
+	}
+}

package/cmd/analyze.go

@@ -0,0 +1,97 @@
+package cmd
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+var analyzeCmd = &cobra.Command{
+Use:   "analyze [path]",
+Short: "Analyze project structure",
+RunE: func(cmd *cobra.Command, args []string) error {
+path := "."
+if len(args) > 0 {
+path = args[0]
+}
+		fmt.Printf("Analyzing: %s\n\n", path)
+
+		var total int
+		byExt := map[string]int{}
+		markers := map[string]bool{}
+		ignoreDirs := map[string]bool{".git": true, "node_modules": true, ".next": true, "dist": true, "build": true, ".venv": true}
+
+		err := filepath.WalkDir(path, func(p string, d fs.DirEntry, err error) error {
+			if err != nil {
+				return err
+			}
+			name := d.Name()
+			if d.IsDir() {
+				if ignoreDirs[name] {
+					return filepath.SkipDir
+				}
+				return nil
+			}
+			total++
+			ext := strings.ToLower(filepath.Ext(name))
+			if ext == "" {
+				ext = "(noext)"
+			}
+			byExt[ext]++
+			base := strings.ToLower(name)
+			switch base {
+			case "go.mod", "package.json", "pyproject.toml", "requirements.txt", "pom.xml", "build.gradle", "cargo.toml":
+				markers[base] = true
+			}
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Files: %d\n", total)
+		if len(markers) > 0 {
+			fmt.Println("Detected:")
+			keys := make([]string, 0, len(markers))
+			for k := range markers {
+				keys = append(keys, k)
+			}
+			sort.Strings(keys)
+			for _, k := range keys {
+				fmt.Printf("  - %s\n", k)
+			}
+			fmt.Println()
+		}
+
+		type kv struct {
+			k string
+			v int
+		}
+		items := make([]kv, 0, len(byExt))
+		for k, v := range byExt {
+			items = append(items, kv{k: k, v: v})
+		}
+		sort.Slice(items, func(i, j int) bool { return items[i].v > items[j].v })
+
+		fmt.Println("Top file types:")
+		for i := 0; i < len(items) && i < 10; i++ {
+			fmt.Printf("  %6d  %s\n", items[i].v, items[i].k)
+		}
+		fmt.Println()
+
+		if _, err := os.Stat(filepath.Join(path, "README.md")); err == nil {
+			fmt.Println("Tip: run `dcode edit --file README.md --prompt \"...\"` to update docs.")
+		}
+		fmt.Println("Analysis complete.")
+		return nil
+},
+}
+
+func init() {
+rootCmd.AddCommand(analyzeCmd)
+}