@dcode-dev/dcode-cli 1.0.0

package/cmd/auth.go

@@ -0,0 +1,338 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/ddhanush1/dcode/internal/auth"
+	"github.com/ddhanush1/dcode/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var authCmd = &cobra.Command{
+	Use:   "auth",
+	Short: "Authentication management",
+	Long:  `Manage authentication credentials for various AI providers`,
+}
+
+var loginCmd = &cobra.Command{
+	Use:   "login",
+	Short: "Login to an AI provider",
+	Long:  `Authenticate with an AI provider using OAuth2 flow`,
+	RunE:  runLogin,
+}
+
+var logoutCmd = &cobra.Command{
+	Use:   "logout",
+	Short: "Logout from an AI provider",
+	Long:  `Remove stored credentials for an AI provider`,
+	RunE:  runLogout,
+}
+
+var statusCmd = &cobra.Command{
+	Use:   "status",
+	Short: "Show authentication status",
+	Long:  `Display current authentication status for all providers`,
+	RunE:  runStatus,
+}
+
+func init() {
+	rootCmd.AddCommand(authCmd)
+	authCmd.AddCommand(loginCmd)
+	authCmd.AddCommand(logoutCmd)
+	authCmd.AddCommand(statusCmd)
+	
+	loginCmd.Flags().String("provider", "gemini", "AI provider (openai, gemini, claude)")
+	loginCmd.Flags().String("type", "oauth2", "Auth type (oauth2, adc, api_key)")
+	
+	logoutCmd.Flags().String("provider", "", "AI provider to logout from (default: all)")
+}
+
+func runLogin(cmd *cobra.Command, args []string) error {
+	provider, _ := cmd.Flags().GetString("provider")
+	authType, _ := cmd.Flags().GetString("type")
+	
+	fmt.Printf("🔐 Logging in to %s using %s...\n\n", provider, authType)
+	
+	store := auth.GetDefaultStore()
+	
+	cfg, err := config.LoadConfig()
+	if err != nil {
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+	
+	// Override with flags
+	cfg.Auth.Provider = provider
+	cfg.Auth.Type = authType
+	
+	ctx := context.Background()
+	
+	switch auth.AuthType(authType) {
+	case auth.AuthTypeOAuth2:
+		return runOAuth2Login(ctx, provider, store)
+		
+	case auth.AuthTypeADC:
+		return runADCLogin(ctx, provider)
+		
+	case auth.AuthTypeAPIKey:
+		return runAPIKeyLogin(provider, store)
+		
+	default:
+		return fmt.Errorf("unsupported auth type: %s", authType)
+	}
+}
+
+func runOAuth2Login(ctx context.Context, provider string, store auth.CredentialStore) error {
+	clientID := os.Getenv("GOOGLE_CLIENT_ID")
+	clientSecret := os.Getenv("GOOGLE_CLIENT_SECRET")
+	
+	if clientID == "" || clientSecret == "" {
+		fmt.Println("❌ OAuth2 requires GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET environment variables")
+		fmt.Println("\nTo set up OAuth2:")
+		fmt.Println("1. Go to https://console.cloud.google.com/apis/credentials")
+		fmt.Println("2. Create OAuth 2.0 Client ID")
+		fmt.Println("3. Set redirect URI to: http://localhost:8085/callback")
+		fmt.Println("4. Export credentials:")
+		fmt.Println("   export GOOGLE_CLIENT_ID=your-client-id")
+		fmt.Println("   export GOOGLE_CLIENT_SECRET=your-client-secret")
+		return fmt.Errorf("OAuth2 credentials not configured")
+	}
+	
+	scopes := []string{
+		"https://www.googleapis.com/auth/userinfo.email",
+		"https://www.googleapis.com/auth/cloud-platform",
+		"https://www.googleapis.com/auth/generative-language",
+	}
+	
+	authenticator := auth.NewOAuth2Auth(provider, clientID, clientSecret, scopes, store)
+	
+	// Start auth flow
+	authURL, err := authenticator.StartAuthFlow(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to start auth flow: %w", err)
+	}
+	
+	fmt.Println("📱 Opening browser for authentication...")
+	fmt.Printf("\nIf browser doesn't open, visit:\n%s\n\n", authURL)
+	
+	// TODO: Implement OAuth callback server
+	fmt.Println("⚠️  OAuth2 callback server not yet implemented")
+	fmt.Println("For now, use API key authentication with: dcode auth login --type api_key")
+	
+	return nil
+}
+
+func runADCLogin(ctx context.Context, provider string) error {
+	fmt.Println("🔍 Checking for Application Default Credentials...")
+	
+	if !auth.IsADCAvailable(ctx) {
+		fmt.Println("❌ ADC not available")
+		fmt.Println("\nTo set up ADC:")
+		fmt.Println("1. Install gcloud CLI: https://cloud.google.com/sdk/docs/install")
+		fmt.Println("2. Run: gcloud auth application-default login")
+		return fmt.Errorf("ADC not configured")
+	}
+	
+	authenticator := auth.NewADCAuth(provider, []string{"https://www.googleapis.com/auth/cloud-platform"})
+	
+	if err := authenticator.Validate(ctx); err != nil {
+		return fmt.Errorf("ADC validation failed: %w", err)
+	}
+	
+	fmt.Println("✅ ADC authentication successful!")
+	fmt.Printf("Provider: %s\n", provider)
+	
+	return nil
+}
+
+func runAPIKeyLogin(provider string, store auth.CredentialStore) error {
+	var envVar string
+	switch provider {
+	case "openai":
+		envVar = "OPENAI_API_KEY"
+	case "gemini":
+		envVar = "GEMINI_API_KEY or GOOGLE_API_KEY"
+	case "claude", "anthropic":
+		envVar = "ANTHROPIC_API_KEY"
+	default:
+		return fmt.Errorf("unknown provider: %s", provider)
+	}
+	
+	fmt.Printf("🔑 API Key authentication for %s\n", provider)
+	fmt.Printf("Set environment variable: %s\n\n", envVar)
+	
+	apiKey := os.Getenv(envVar)
+	if apiKey == "" && provider == "gemini" {
+		apiKey = os.Getenv("GOOGLE_API_KEY")
+	}
+	
+	if apiKey == "" {
+		fmt.Println("❌ API key not found in environment")
+		fmt.Printf("\nTo set up API key:\n")
+		fmt.Printf("export %s=your-api-key\n", envVar)
+		return fmt.Errorf("API key not configured")
+	}
+	
+	// Store credentials
+	creds := &auth.Credentials{
+		Type:     auth.AuthTypeAPIKey,
+		Provider: provider,
+		Token:    apiKey,
+		Metadata: make(map[string]string),
+	}
+	
+	if err := store.Save(provider, creds); err != nil {
+		fmt.Printf("⚠️  Failed to store credentials: %v\n", err)
+		fmt.Println("Credentials are still available from environment variable")
+	}
+	
+	fmt.Println("✅ API key authentication successful!")
+	fmt.Printf("Provider: %s\n", provider)
+	
+	return nil
+}
+
+func runLogout(cmd *cobra.Command, args []string) error {
+	provider, _ := cmd.Flags().GetString("provider")
+	
+	store := auth.GetDefaultStore()
+	
+	if provider == "" {
+		// Logout from all providers
+		providers, err := store.List()
+		if err != nil {
+			return fmt.Errorf("failed to list providers: %w", err)
+		}
+		
+		if len(providers) == 0 {
+			fmt.Println("No stored credentials found")
+			return nil
+		}
+		
+		fmt.Printf("Logging out from %d provider(s)...\n", len(providers))
+		for _, p := range providers {
+			if err := store.Delete(p); err != nil {
+				fmt.Printf("⚠️  Failed to remove %s: %v\n", p, err)
+			} else {
+				fmt.Printf("✅ Removed credentials for %s\n", p)
+			}
+		}
+	} else {
+		// Logout from specific provider
+		if err := store.Delete(provider); err != nil {
+			return fmt.Errorf("failed to remove credentials: %w", err)
+		}
+		fmt.Printf("✅ Logged out from %s\n", provider)
+	}
+	
+	return nil
+}
+
+func runStatus(cmd *cobra.Command, args []string) error {
+	fmt.Println("🔐 Authentication Status\n")
+	
+	cfg, err := config.LoadConfig()
+	if err != nil {
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+	
+	factory := auth.NewFactory(auth.GetDefaultStore())
+	ctx := context.Background()
+	
+	// Check configured provider
+	fmt.Printf("Configured Provider: %s\n", cfg.Auth.Provider)
+	fmt.Printf("Auth Type: %s\n\n", cfg.Auth.Type)
+	
+	// Check stored credentials
+	store := auth.GetDefaultStore()
+	providers, err := store.List()
+	if err != nil {
+		fmt.Printf("⚠️  Failed to list stored credentials: %v\n", err)
+	} else if len(providers) > 0 {
+		fmt.Println("Stored Credentials:")
+		for _, provider := range providers {
+			authenticator, err := factory.CreateFromProvider(provider)
+			if err != nil {
+				fmt.Printf("  • %s: ❌ Invalid\n", provider)
+				continue
+			}
+			
+			info, err := getTokenInfo(ctx, authenticator)
+			if err != nil {
+				fmt.Printf("  • %s: ❌ Error: %v\n", provider, err)
+				continue
+			}
+			
+			status := "✅ Valid"
+			if !info.Valid {
+				status = "❌ Invalid"
+			} else if !info.ExpiresAt.IsZero() && info.ExpiresAt.Before(time.Now()) {
+				status = "⚠️  Expired"
+			}
+			
+			fmt.Printf("  • %s: %s", provider, status)
+			if !info.ExpiresAt.IsZero() {
+				fmt.Printf(" (expires in %s)", time.Until(info.ExpiresAt).Round(time.Minute))
+			}
+			fmt.Println()
+		}
+		fmt.Println()
+	}
+	
+	// Check environment variables
+	fmt.Println("Environment Variables:")
+	checkEnvVar("OPENAI_API_KEY")
+	checkEnvVar("GEMINI_API_KEY")
+	checkEnvVar("GOOGLE_API_KEY")
+	checkEnvVar("ANTHROPIC_API_KEY")
+	fmt.Println()
+	
+	// Check ADC
+	fmt.Print("Application Default Credentials (ADC): ")
+	if auth.IsADCAvailable(ctx) {
+		fmt.Println("✅ Available")
+	} else {
+		fmt.Println("❌ Not available")
+	}
+	
+	return nil
+}
+
+func checkEnvVar(name string) {
+	value := os.Getenv(name)
+	if value != "" {
+		masked := value[:minInt(8, len(value))] + "..."
+		fmt.Printf("  • %s: ✅ Set (%s)\n", name, masked)
+	} else {
+		fmt.Printf("  • %s: ❌ Not set\n", name)
+	}
+}
+
+func getTokenInfo(ctx context.Context, authenticator auth.Authenticator) (*auth.TokenInfo, error) {
+	// Try type assertion for method that returns TokenInfo
+	switch a := authenticator.(type) {
+	case *auth.APIKeyAuth:
+		return a.GetTokenInfo(ctx)
+	case *auth.OAuth2Auth:
+		return a.GetTokenInfo(ctx)
+	case *auth.ADCAuth:
+		return a.GetTokenInfo(ctx)
+	case *auth.VertexAIAuth:
+		return a.GetTokenInfo(ctx)
+	default:
+		// Fallback: just validate
+		if err := authenticator.Validate(ctx); err != nil {
+			return &auth.TokenInfo{Valid: false}, nil
+		}
+		return &auth.TokenInfo{Valid: true, Provider: authenticator.GetProvider()}, nil
+	}
+}
+
+func minInt(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

package/cmd/compose.go

@@ -0,0 +1,284 @@
+package cmd
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/ddhanush1/dcode/internal/agent"
+	"github.com/ddhanush1/dcode/internal/diffutil"
+	"github.com/ddhanush1/dcode/internal/fsutil"
+	"github.com/spf13/cobra"
+)
+
+var (
+	composeFiles    []string
+	composeAuto     bool
+	composeModel    string
+	composeProvider string
+	composeWeb      bool
+)
+
+var composeCmd = &cobra.Command{
+	Use:   "compose [prompt]",
+	Short: "Cursor-like composer for multi-file edits",
+	Long: `Composer Mode - Multi-file AI-powered code generation and editing
+
+Like Cursor Composer, this mode allows you to:
+  • Generate multiple files at once
+  • Edit across multiple files simultaneously
+  • Create entire features or components
+  • Refactor with context awareness
+
+Examples:
+  dcode compose "Create a REST API with user CRUD operations"
+  dcode compose "Add authentication to the project"
+  dcode compose --files "*.go" "Add logging to all functions"
+  dcode compose --auto "Refactor database layer to use repository pattern"
+
+The composer will:
+  1. Analyze your request and codebase
+  2. Determine which files need changes
+  3. Generate or edit multiple files
+  4. Show you a preview of all changes
+  5. Apply changes after confirmation (or --auto)
+`,
+	RunE: runCompose,
+}
+
+func runCompose(cmd *cobra.Command, args []string) error {
+	if len(args) == 0 {
+		return fmt.Errorf("prompt required")
+	}
+
+	prompt := strings.Join(args, " ")
+
+	if composeProvider != "" {
+		_ = os.Setenv("AI_PROVIDER", composeProvider)
+	}
+	if composeModel != "" {
+		_ = os.Setenv("AI_MODEL", composeModel)
+	}
+
+	ag, err := agent.New()
+	if err != nil {
+		return err
+	}
+
+	wd, _ := os.Getwd()
+	
+	fmt.Println("\033[1;35m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m")
+	fmt.Println("\033[1;36m🎼 DCode Composer Mode\033[0m")
+	fmt.Printf("\033[90mWorking directory: %s\033[0m\n", wd)
+	fmt.Println("\033[1;35m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m")
+	fmt.Println()
+
+	// Gather context files
+	contextFiles, err := gatherContextFiles(wd, composeFiles)
+	if err != nil {
+		return fmt.Errorf("gathering context: %w", err)
+	}
+
+	if len(contextFiles) > 0 {
+		fmt.Printf("\033[90m📁 Context files (%d):\033[0m\n", len(contextFiles))
+		for _, f := range contextFiles {
+			fmt.Printf("  • %s\n", f.Path)
+		}
+		fmt.Println()
+	}
+
+	// Build prompt with context
+	fullPrompt := buildComposePrompt(prompt, contextFiles)
+
+	fmt.Println("\033[1;33m🤔 Analyzing request...\033[0m")
+	fmt.Println()
+
+	// Use the agent's edit capability for multi-file operations
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
+	defer cancel()
+
+	resp, err := ag.Edit(ctx, agent.EditRequest{
+		Prompt:    fullPrompt,
+		Files:     contextFiles,
+		WebSearch: agent.WebSearchRequest{Enabled: composeWeb},
+	})
+	if err != nil {
+		return fmt.Errorf("composer failed: %w", err)
+	}
+
+	if len(resp.Edits) == 0 {
+		fmt.Println("\033[33m⚠ No changes generated\033[0m")
+		return nil
+	}
+
+	// Display results
+	fmt.Println("\033[1;32m✨ Generated changes:\033[0m")
+	fmt.Println()
+
+	for i, edit := range resp.Edits {
+		fmt.Printf("\033[1;36m%d. %s\033[0m\n", i+1, edit.Path)
+		
+		// Check if file exists
+		existingContent := ""
+		fullPath := filepath.Join(wd, edit.Path)
+		if _, err := os.Stat(fullPath); err == nil {
+			existingContent, _ = fsutil.ReadFile(fullPath)
+		}
+
+		if existingContent == "" {
+			fmt.Println("\033[90m  (new file)\033[0m")
+			// Show preview of new file (first 10 lines)
+			lines := strings.Split(edit.NewContent, "\n")
+			preview := strings.Join(lines[:min(10, len(lines))], "\n")
+			fmt.Println("\033[90m" + preview + "\033[0m")
+			if len(lines) > 10 {
+				fmt.Printf("\033[90m  ... (%d more lines)\033[0m\n", len(lines)-10)
+			}
+		} else {
+			// Show diff
+			diff := diffutil.Unified("a/"+edit.Path, "b/"+edit.Path, existingContent, edit.NewContent)
+			fmt.Println(diff)
+		}
+		fmt.Println()
+	}
+
+	if resp.Explanation != "" {
+		fmt.Println("\033[1;34m💡 Explanation:\033[0m")
+		fmt.Println(resp.Explanation)
+		fmt.Println()
+	}
+
+	// Auto-apply or ask for confirmation
+	apply := composeAuto
+	if !apply {
+		fmt.Print("\033[1;33m📝 Apply these changes? [y/N] \033[0m")
+		reader := bufio.NewReader(os.Stdin)
+		line, _ := reader.ReadString('\n')
+		apply = strings.TrimSpace(strings.ToLower(line)) == "y" || strings.TrimSpace(strings.ToLower(line)) == "yes"
+	}
+
+	if !apply {
+		fmt.Println("\033[90m✗ Changes not applied\033[0m")
+		return nil
+	}
+
+	// Apply changes
+	fmt.Println("\033[1;32m✓ Applying changes...\033[0m")
+	for _, edit := range resp.Edits {
+		fullPath := filepath.Join(wd, edit.Path)
+		
+		// Ensure directory exists
+		dir := filepath.Dir(fullPath)
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			return fmt.Errorf("creating directory %s: %w", dir, err)
+		}
+
+		// Write file
+		perm := fsutil.FilePermOrDefault(fullPath, 0o644)
+		if err := fsutil.WriteFileAtomic(fullPath, []byte(edit.NewContent), perm); err != nil {
+			return fmt.Errorf("writing %s: %w", fullPath, err)
+		}
+		
+		fmt.Printf("  \033[32m✓\033[0m %s\n", edit.Path)
+	}
+
+	fmt.Println()
+	fmt.Println("\033[1;32m🎉 All changes applied successfully!\033[0m")
+
+	return nil
+}
+
+func gatherContextFiles(wd string, patterns []string) ([]agent.FileInput, error) {
+	if len(patterns) == 0 {
+		// Auto-detect relevant files based on common patterns
+		patterns = []string{"*.go", "*.ts", "*.tsx", "*.js", "*.jsx", "*.py", "*.java", "*.rs"}
+	}
+
+	var files []agent.FileInput
+	seen := make(map[string]bool)
+
+	for _, pattern := range patterns {
+		matches, err := filepath.Glob(filepath.Join(wd, pattern))
+		if err != nil {
+			continue
+		}
+
+		for _, match := range matches {
+			relPath, _ := filepath.Rel(wd, match)
+			if seen[relPath] {
+				continue
+			}
+			seen[relPath] = true
+
+			// Skip large files and binaries
+			info, err := os.Stat(match)
+			if err != nil || info.IsDir() || info.Size() > 100*1024 {
+				continue
+			}
+
+			content, err := fsutil.ReadFile(match)
+			if err != nil {
+				continue
+			}
+
+			files = append(files, agent.FileInput{
+				Path:    filepath.ToSlash(relPath),
+				Content: content,
+			})
+
+			// Limit context size
+			if len(files) >= 20 {
+				break
+			}
+		}
+	}
+
+	return files, nil
+}
+
+func buildComposePrompt(userPrompt string, contextFiles []agent.FileInput) string {
+	var sb strings.Builder
+	
+	sb.WriteString("You are a Cursor-like AI composer assistant. ")
+	sb.WriteString("Generate or edit multiple files as needed to fulfill the user's request.\n\n")
+	
+	sb.WriteString("User Request:\n")
+	sb.WriteString(userPrompt)
+	sb.WriteString("\n\n")
+	
+	if len(contextFiles) > 0 {
+		sb.WriteString("Existing Codebase Context:\n")
+		sb.WriteString("Analyze these files to understand the project structure, patterns, and style.\n")
+		sb.WriteString("Maintain consistency with existing code.\n\n")
+	}
+
+	sb.WriteString("Instructions:\n")
+	sb.WriteString("1. Create new files or edit existing ones as needed\n")
+	sb.WriteString("2. Follow best practices and existing code patterns\n")
+	sb.WriteString("3. Add comments where helpful\n")
+	sb.WriteString("4. Ensure code is production-ready\n")
+	sb.WriteString("5. Generate complete, runnable code\n")
+
+	return sb.String()
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func init() {
+	composeCmd.Flags().StringSliceVarP(&composeFiles, "files", "f", nil, "File patterns for context (e.g., *.go, src/*.ts)")
+	composeCmd.Flags().BoolVarP(&composeAuto, "auto", "a", false, "Auto-apply changes without confirmation")
+	composeCmd.Flags().StringVar(&composeModel, "model", "", "AI model to use")
+	composeCmd.Flags().StringVar(&composeProvider, "provider", "", "AI provider (openai, claude, gemini)")
+	composeCmd.Flags().BoolVar(&composeWeb, "web", false, "Enable web search for additional context")
+	
+	rootCmd.AddCommand(composeCmd)
+}