@dcode-dev/dcode-cli 1.0.0

package/internal/config/config.go

@@ -0,0 +1,428 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+// Config represents the global configuration for dcode
+type Config struct {
+	// Auth configuration
+	Auth AuthConfig `toml:"auth"`
+
+	// Model configuration
+	Model ModelConfig `toml:"model"`
+
+	// Policy configuration
+	Policy PolicyConfig `toml:"policy"`
+
+	// Agent configuration
+	Agent AgentConfig `toml:"agent"`
+
+	// Tool configuration
+	Tool ToolConfig `toml:"tool"`
+
+	// Server configuration
+	Server ServerConfig `toml:"server"`
+
+	// Telemetry configuration
+	Telemetry TelemetryConfig `toml:"telemetry"`
+
+	// Debug mode
+	Debug bool `toml:"debug"`
+
+	mu sync.RWMutex
+}
+
+// AuthConfig holds authentication settings
+type AuthConfig struct {
+	Type     string `toml:"type"`      // "api_key", "oauth2", "adc", "vertex_ai"
+	Provider string `toml:"provider"`  // "openai", "gemini", "claude"
+	APIKey   string `toml:"api_key"`   // API key (if type is api_key)
+	Project  string `toml:"project"`   // GCP project (for vertex_ai)
+	Location string `toml:"location"`  // GCP location (for vertex_ai)
+}
+
+// ModelConfig holds model settings
+type ModelConfig struct {
+	Provider     string  `toml:"provider"`      // "openai", "gemini", "claude"
+	Model        string  `toml:"model"`         // Model name
+	Temperature  float64 `toml:"temperature"`   // 0.0 - 2.0
+	MaxTokens    int     `toml:"max_tokens"`    // Max output tokens
+	TopP         float64 `toml:"top_p"`         // Nucleus sampling
+	SystemPrompt string  `toml:"system_prompt"` // System prompt override
+}
+
+// PolicyConfig holds confirmation policy settings
+type PolicyConfig struct {
+	Mode             string   `toml:"mode"`               // "always", "auto", "risk_based"
+	AutoApproveTools []string `toml:"auto_approve_tools"` // Tools that don't need confirmation
+	AlwaysConfirm    []string `toml:"always_confirm"`     // Tools that always need confirmation
+}
+
+// AgentConfig holds agent system settings
+type AgentConfig struct {
+	DefaultAgent     string   `toml:"default_agent"`      // Default agent to use
+	EnabledAgents    []string `toml:"enabled_agents"`     // List of enabled agents
+	AgentDirectory   string   `toml:"agent_directory"`    // Custom agent directory
+	MaxTurns         int      `toml:"max_turns"`          // Max conversation turns
+	EnableSubAgents  bool     `toml:"enable_sub_agents"`  // Allow sub-agent invocation
+	RemoteAgentURLs  []string `toml:"remote_agent_urls"`  // A2A server URLs
+}
+
+// ToolConfig holds tool system settings
+type ToolConfig struct {
+	EnabledTools     []string          `toml:"enabled_tools"`      // List of enabled tools
+	ToolDirectory    string            `toml:"tool_directory"`     // Custom tool directory
+	ShellTimeout     int               `toml:"shell_timeout"`      // Shell command timeout (seconds)
+	WebSearchEnabled bool              `toml:"web_search_enabled"` // Enable web search
+	WebSearchEngine  string            `toml:"web_search_engine"`  // "tavily", "google", "bing"
+	ToolSettings     map[string]string `toml:"tool_settings"`      // Per-tool settings
+}
+
+// ServerConfig holds server settings
+type ServerConfig struct {
+	Host           string `toml:"host"`             // Server host
+	Port           int    `toml:"port"`             // Server port
+	EnableA2A      bool   `toml:"enable_a2a"`       // Enable A2A server
+	A2APort        int    `toml:"a2a_port"`         // A2A server port
+	EnableTLS      bool   `toml:"enable_tls"`       // Enable TLS
+	CertFile       string `toml:"cert_file"`        // TLS cert file
+	KeyFile        string `toml:"key_file"`         // TLS key file
+}
+
+// TelemetryConfig holds telemetry settings
+type TelemetryConfig struct {
+	Enabled         bool   `toml:"enabled"`           // Enable telemetry
+	Provider        string `toml:"provider"`          // "opentelemetry", "prometheus"
+	Endpoint        string `toml:"endpoint"`          // Telemetry endpoint
+	SampleRate      float64 `toml:"sample_rate"`      // Sampling rate (0.0 - 1.0)
+	EnableLogging   bool   `toml:"enable_logging"`    // Enable detailed logging
+	LogLevel        string `toml:"log_level"`         // "debug", "info", "warn", "error"
+}
+
+var (
+	globalConfig     *Config
+	globalConfigOnce sync.Once
+)
+
+// DefaultConfig returns a config with sensible defaults
+func DefaultConfig() *Config {
+	homeDir, _ := os.UserHomeDir()
+	
+	// Detect provider from environment
+	provider := "openai"
+	model := "gpt-4o-mini"
+	
+	// Check which API keys are available
+	if os.Getenv("GEMINI_API_KEY") != "" || os.Getenv("GOOGLE_API_KEY") != "" {
+		provider = "gemini"
+		model = "gemini-2.5-flash"  // Stable fast model
+	} else if os.Getenv("ANTHROPIC_API_KEY") != "" {
+		provider = "claude"
+		model = "claude-3-5-sonnet-20241022"
+	} else if os.Getenv("OPENAI_API_KEY") != "" {
+		provider = "openai"
+		model = "gpt-4o-mini"
+	}
+	
+	return &Config{
+		Auth: AuthConfig{
+			Type:     "api_key",
+			Provider: provider,
+		},
+		Model: ModelConfig{
+			Provider:    provider,
+			Model:       model,
+			Temperature: 0.7,
+			MaxTokens:   4096,
+			TopP:        1.0,
+		},
+		Policy: PolicyConfig{
+			Mode: "always",
+			AutoApproveTools: []string{
+				"read_file",
+				"grep",
+				"glob",
+				"web_fetch",
+				"analyze",
+			},
+			AlwaysConfirm: []string{
+				"shell",
+				"edit_file",
+				"write_file",
+				"delete_file",
+			},
+		},
+		Agent: AgentConfig{
+			DefaultAgent:    "generalist",
+			EnabledAgents:   []string{"generalist", "codebase_investigator", "editor", "analyzer"},
+			AgentDirectory:  filepath.Join(homeDir, ".dcode", "agents"),
+			MaxTurns:        50,
+			EnableSubAgents: true,
+		},
+		Tool: ToolConfig{
+			EnabledTools:     []string{}, // Empty means all
+			ToolDirectory:    filepath.Join(homeDir, ".dcode", "tools"),
+			ShellTimeout:     300,
+			WebSearchEnabled: false,
+			WebSearchEngine:  "tavily",
+			ToolSettings:     make(map[string]string),
+		},
+		Server: ServerConfig{
+			Host:      "localhost",
+			Port:      8080,
+			EnableA2A: false,
+			A2APort:   41242,
+		},
+		Telemetry: TelemetryConfig{
+			Enabled:       false,
+			Provider:      "opentelemetry",
+			SampleRate:    1.0,
+			EnableLogging: true,
+			LogLevel:      "info",
+		},
+		Debug: false,
+	}
+}
+
+// GetConfigDir returns the dcode config directory
+func GetConfigDir() (string, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("failed to get home directory: %w", err)
+	}
+	
+	configDir := filepath.Join(homeDir, ".dcode")
+	
+	// Create directory if it doesn't exist
+	if err := os.MkdirAll(configDir, 0755); err != nil {
+		return "", fmt.Errorf("failed to create config directory: %w", err)
+	}
+	
+	return configDir, nil
+}
+
+// LoadConfig loads configuration from file and environment
+func LoadConfig() (*Config, error) {
+	cfg := DefaultConfig()
+	
+	// Check environment for provider override first
+	if provider := os.Getenv("AI_PROVIDER"); provider != "" {
+		cfg.Model.Provider = provider
+		cfg.Auth.Provider = provider
+	}
+	
+	// Load from settings.toml if it exists
+	configDir, err := GetConfigDir()
+	if err != nil {
+		return nil, err
+	}
+	
+	settingsPath := filepath.Join(configDir, "settings.toml")
+	if _, err := os.Stat(settingsPath); err == nil {
+		data, err := os.ReadFile(settingsPath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read settings file: %w", err)
+		}
+		
+		if err := toml.Unmarshal(data, cfg); err != nil {
+			return nil, fmt.Errorf("failed to parse settings file: %w", err)
+		}
+	}
+	
+	// Override with environment variables
+	cfg.ApplyEnvironment()
+	
+	// Auto-detect model if using default OpenAI model with non-OpenAI provider
+	if cfg.Model.Model == "gpt-4o-mini" && cfg.Model.Provider != "openai" {
+		cfg.Model.Model = GetDefaultModelForProvider(cfg.Model.Provider)
+	}
+	
+	return cfg, nil
+}
+
+// GetDefaultModelForProvider returns the default model for a given provider
+func GetDefaultModelForProvider(provider string) string {
+	switch provider {
+	case "gemini":
+		return "gemini-2.5-flash"  // Stable fast model
+	case "claude":
+		return "claude-3-5-sonnet-20241022"
+	case "openai":
+		return "gpt-4o-mini"
+	default:
+		return "gpt-4o-mini"
+	}
+}
+
+// ApplyEnvironment overrides config with environment variables
+func (c *Config) ApplyEnvironment() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	
+	// Auth
+	if val := os.Getenv("AI_PROVIDER"); val != "" {
+		c.Auth.Provider = val
+		c.Model.Provider = val
+	}
+	if val := os.Getenv("OPENAI_API_KEY"); val != "" && c.Auth.Provider == "openai" {
+		c.Auth.APIKey = val
+	}
+	if val := os.Getenv("GEMINI_API_KEY"); val != "" && c.Auth.Provider == "gemini" {
+		c.Auth.APIKey = val
+	}
+	if val := os.Getenv("ANTHROPIC_API_KEY"); val != "" && c.Auth.Provider == "claude" {
+		c.Auth.APIKey = val
+	}
+	if val := os.Getenv("GOOGLE_CLOUD_PROJECT"); val != "" {
+		c.Auth.Project = val
+	}
+	if val := os.Getenv("GOOGLE_CLOUD_LOCATION"); val != "" {
+		c.Auth.Location = val
+	}
+	
+	// Model
+	if val := os.Getenv("AI_MODEL"); val != "" {
+		c.Model.Model = val
+	}
+	
+	// Debug
+	if os.Getenv("DEBUG") == "1" || os.Getenv("DEBUG") == "true" {
+		c.Debug = true
+	}
+	
+	// Web search
+	if os.Getenv("WEB_SEARCH") == "true" {
+		c.Tool.WebSearchEnabled = true
+	}
+}
+
+// Save writes the config to settings.toml
+func (c *Config) Save() error {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	
+	configDir, err := GetConfigDir()
+	if err != nil {
+		return err
+	}
+	
+	settingsPath := filepath.Join(configDir, "settings.toml")
+	
+	data, err := toml.Marshal(c)
+	if err != nil {
+		return fmt.Errorf("failed to marshal config: %w", err)
+	}
+	
+	if err := os.WriteFile(settingsPath, data, 0644); err != nil {
+		return fmt.Errorf("failed to write settings file: %w", err)
+	}
+	
+	return nil
+}
+
+// Validate checks if the configuration is valid
+func (c *Config) Validate() error {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	
+	// Validate auth
+	if c.Auth.Type == "" {
+		return fmt.Errorf("auth.type is required")
+	}
+	if c.Auth.Provider == "" {
+		return fmt.Errorf("auth.provider is required")
+	}
+	
+	// Validate model
+	if c.Model.Provider == "" {
+		return fmt.Errorf("model.provider is required")
+	}
+	if c.Model.Model == "" {
+		return fmt.Errorf("model.model is required")
+	}
+	if c.Model.Temperature < 0 || c.Model.Temperature > 2 {
+		return fmt.Errorf("model.temperature must be between 0 and 2")
+	}
+	
+	// Validate policy
+	validModes := map[string]bool{"always": true, "auto": true, "risk_based": true}
+	if !validModes[c.Policy.Mode] {
+		return fmt.Errorf("policy.mode must be one of: always, auto, risk_based")
+	}
+	
+	return nil
+}
+
+// Global returns the global config instance
+func Global() *Config {
+	globalConfigOnce.Do(func() {
+		cfg, err := LoadConfig()
+		if err != nil {
+			// Fallback to defaults if loading fails
+			cfg = DefaultConfig()
+		}
+		globalConfig = cfg
+	})
+	return globalConfig
+}
+
+// Set updates a config value by path
+func (c *Config) Set(key string, value interface{}) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	
+	// Simple key-value setting
+	// In a real implementation, you'd parse the key path and set nested values
+	switch key {
+	case "auth.provider":
+		if v, ok := value.(string); ok {
+			c.Auth.Provider = v
+		}
+	case "model.provider":
+		if v, ok := value.(string); ok {
+			c.Model.Provider = v
+		}
+	case "model.model":
+		if v, ok := value.(string); ok {
+			c.Model.Model = v
+		}
+	case "debug":
+		if v, ok := value.(bool); ok {
+			c.Debug = v
+		}
+	default:
+		return fmt.Errorf("unknown config key: %s", key)
+	}
+	
+	return nil
+}
+
+// Get retrieves a config value by path
+func (c *Config) Get(key string) interface{} {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	
+	switch key {
+	case "auth.provider":
+		return c.Auth.Provider
+	case "model.provider":
+		return c.Model.Provider
+	case "model.model":
+		return c.Model.Model
+	case "debug":
+		return c.Debug
+	default:
+		return nil
+	}
+}
+
+// SaveConfig is a convenience function to save a config
+func SaveConfig(cfg *Config) error {
+	return cfg.Save()
+}

package/internal/config/policy.go

@@ -0,0 +1,251 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+// PolicyFile represents the policy.toml configuration
+type PolicyFile struct {
+	// Confirmation mode: "always", "auto", "risk_based"
+	Mode string `toml:"mode"`
+	
+	// Tools that don't require confirmation
+	AutoApprove AutoApprovePolicy `toml:"auto_approve"`
+	
+	// Tools that always require confirmation
+	AlwaysConfirm AlwaysConfirmPolicy `toml:"always_confirm"`
+	
+	// Risk-based policy settings
+	RiskBased RiskBasedPolicy `toml:"risk_based"`
+}
+
+// AutoApprovePolicy defines tools that auto-approve
+type AutoApprovePolicy struct {
+	Enabled bool     `toml:"enabled"`
+	Tools   []string `toml:"tools"`
+}
+
+// AlwaysConfirmPolicy defines tools that always confirm
+type AlwaysConfirmPolicy struct {
+	Enabled bool     `toml:"enabled"`
+	Tools   []string `toml:"tools"`
+}
+
+// RiskBasedPolicy defines risk-based confirmation rules
+type RiskBasedPolicy struct {
+	Enabled               bool     `toml:"enabled"`
+	LowRiskTools          []string `toml:"low_risk_tools"`
+	MediumRiskTools       []string `toml:"medium_risk_tools"`
+	HighRiskTools         []string `toml:"high_risk_tools"`
+	AutoApproveLowRisk    bool     `toml:"auto_approve_low_risk"`
+	AutoApproveMediumRisk bool     `toml:"auto_approve_medium_risk"`
+}
+
+// DefaultPolicyFile returns a policy file with sensible defaults
+func DefaultPolicyFile() *PolicyFile {
+	return &PolicyFile{
+		Mode: "always",
+		AutoApprove: AutoApprovePolicy{
+			Enabled: true,
+			Tools: []string{
+				"read_file",
+				"grep",
+				"glob",
+				"ls",
+				"web_fetch",
+				"analyze",
+				"get_project_context",
+			},
+		},
+		AlwaysConfirm: AlwaysConfirmPolicy{
+			Enabled: true,
+			Tools: []string{
+				"shell",
+				"edit_file",
+				"write_file",
+				"delete_file",
+				"git_commit",
+				"git_push",
+			},
+		},
+		RiskBased: RiskBasedPolicy{
+			Enabled: false,
+			LowRiskTools: []string{
+				"read_file",
+				"grep",
+				"glob",
+				"ls",
+				"web_fetch",
+				"web_search",
+				"analyze",
+			},
+			MediumRiskTools: []string{
+				"edit_file",
+				"write_file",
+				"shell",
+			},
+			HighRiskTools: []string{
+				"delete_file",
+				"git_push",
+				"git_force_push",
+			},
+			AutoApproveLowRisk:    true,
+			AutoApproveMediumRisk: false,
+		},
+	}
+}
+
+// LoadPolicyFile loads the policy.toml file
+func LoadPolicyFile() (*PolicyFile, error) {
+	configDir, err := GetConfigDir()
+	if err != nil {
+		return nil, err
+	}
+	
+	policyPath := filepath.Join(configDir, "policy.toml")
+	
+	// If file doesn't exist, create it with defaults
+	if _, err := os.Stat(policyPath); os.IsNotExist(err) {
+		policy := DefaultPolicyFile()
+		if err := policy.Save(); err != nil {
+			return nil, err
+		}
+		return policy, nil
+	}
+	
+	// Read and parse existing file
+	data, err := os.ReadFile(policyPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read policy file: %w", err)
+	}
+	
+	policy := &PolicyFile{}
+	if err := toml.Unmarshal(data, policy); err != nil {
+		return nil, fmt.Errorf("failed to parse policy file: %w", err)
+	}
+	
+	return policy, nil
+}
+
+// Save writes the policy to policy.toml
+func (p *PolicyFile) Save() error {
+	configDir, err := GetConfigDir()
+	if err != nil {
+		return err
+	}
+	
+	policyPath := filepath.Join(configDir, "policy.toml")
+	
+	data, err := toml.Marshal(p)
+	if err != nil {
+		return fmt.Errorf("failed to marshal policy: %w", err)
+	}
+	
+	if err := os.WriteFile(policyPath, data, 0644); err != nil {
+		return fmt.Errorf("failed to write policy file: %w", err)
+	}
+	
+	return nil
+}
+
+// ShouldAutoApprove checks if a tool should be auto-approved
+func (p *PolicyFile) ShouldAutoApprove(toolName string) bool {
+	switch p.Mode {
+	case "auto":
+		// In auto mode, check if tool is in auto-approve list
+		if p.AutoApprove.Enabled {
+			for _, tool := range p.AutoApprove.Tools {
+				if tool == toolName {
+					return true
+				}
+			}
+		}
+		return false
+		
+	case "always":
+		// In always mode, never auto-approve unless explicitly listed
+		if p.AutoApprove.Enabled {
+			for _, tool := range p.AutoApprove.Tools {
+				if tool == toolName {
+					return true
+				}
+			}
+		}
+		return false
+		
+	case "risk_based":
+		// In risk-based mode, check risk level
+		if !p.RiskBased.Enabled {
+			return false
+		}
+		
+		// Check if low risk and auto-approve is enabled
+		if p.RiskBased.AutoApproveLowRisk {
+			for _, tool := range p.RiskBased.LowRiskTools {
+				if tool == toolName {
+					return true
+				}
+			}
+		}
+		
+		// Check if medium risk and auto-approve is enabled
+		if p.RiskBased.AutoApproveMediumRisk {
+			for _, tool := range p.RiskBased.MediumRiskTools {
+				if tool == toolName {
+					return true
+				}
+			}
+		}
+		
+		return false
+		
+	default:
+		return false
+	}
+}
+
+// ShouldAlwaysConfirm checks if a tool should always require confirmation
+func (p *PolicyFile) ShouldAlwaysConfirm(toolName string) bool {
+	if !p.AlwaysConfirm.Enabled {
+		return false
+	}
+	
+	for _, tool := range p.AlwaysConfirm.Tools {
+		if tool == toolName {
+			return true
+		}
+	}
+	
+	return false
+}
+
+// GetRiskLevel returns the risk level for a tool
+func (p *PolicyFile) GetRiskLevel(toolName string) string {
+	if !p.RiskBased.Enabled {
+		return "unknown"
+	}
+	
+	for _, tool := range p.RiskBased.LowRiskTools {
+		if tool == toolName {
+			return "low"
+		}
+	}
+	
+	for _, tool := range p.RiskBased.MediumRiskTools {
+		if tool == toolName {
+			return "medium"
+		}
+	}
+	
+	for _, tool := range p.RiskBased.HighRiskTools {
+		if tool == toolName {
+			return "high"
+		}
+	}
+	
+	return "unknown"
+}