config validation

.opencode.json

@@ -1,4 +1,5 @@
 {
+  "$schema": "./opencode-schema.json",
   "lsp": {
     "gopls": {
       "command": "gopls"

cmd/schema/README.md

@@ -0,0 +1,64 @@
+# OpenCode Configuration Schema Generator
+
+This tool generates a JSON Schema for the OpenCode configuration file. The schema can be used to validate configuration files and provide autocompletion in editors that support JSON Schema.
+
+## Usage
+
+```bash
+go run cmd/schema/main.go > opencode-schema.json
+```
+
+This will generate a JSON Schema file that can be used to validate configuration files.
+
+## Schema Features
+
+The generated schema includes:
+
+- All configuration options with descriptions
+- Default values where applicable
+- Validation for enum values (e.g., model IDs, provider types)
+- Required fields
+- Type checking
+
+## Using the Schema
+
+You can use the generated schema in several ways:
+
+1. **Editor Integration**: Many editors (VS Code, JetBrains IDEs, etc.) support JSON Schema for validation and autocompletion. You can configure your editor to use the generated schema for `.opencode.json` files.
+
+2. **Validation Tools**: You can use tools like [jsonschema](https://github.com/Julian/jsonschema) to validate your configuration files against the schema.
+
+3. **Documentation**: The schema serves as documentation for the configuration options.
+
+## Example Configuration
+
+Here's an example configuration that conforms to the schema:
+
+```json
+{
+  "data": {
+    "directory": ".opencode"
+  },
+  "debug": false,
+  "providers": {
+    "anthropic": {
+      "apiKey": "your-api-key"
+    }
+  },
+  "agents": {
+    "coder": {
+      "model": "claude-3.7-sonnet",
+      "maxTokens": 5000,
+      "reasoningEffort": "medium"
+    },
+    "task": {
+      "model": "claude-3.7-sonnet",
+      "maxTokens": 5000
+    },
+    "title": {
+      "model": "claude-3.7-sonnet",
+      "maxTokens": 80
+    }
+  }
+}
+```

cmd/schema/main.go

@@ -0,0 +1,262 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/kujtimiihoxha/opencode/internal/config"
+	"github.com/kujtimiihoxha/opencode/internal/llm/models"
+)
+
+// JSONSchemaType represents a JSON Schema type
+type JSONSchemaType struct {
+	Type                 string           `json:"type,omitempty"`
+	Description          string           `json:"description,omitempty"`
+	Properties           map[string]any   `json:"properties,omitempty"`
+	Required             []string         `json:"required,omitempty"`
+	AdditionalProperties any              `json:"additionalProperties,omitempty"`
+	Enum                 []any            `json:"enum,omitempty"`
+	Items                map[string]any   `json:"items,omitempty"`
+	OneOf                []map[string]any `json:"oneOf,omitempty"`
+	AnyOf                []map[string]any `json:"anyOf,omitempty"`
+	Default              any              `json:"default,omitempty"`
+}
+
+func main() {
+	schema := generateSchema()
+
+	// Pretty print the schema
+	encoder := json.NewEncoder(os.Stdout)
+	encoder.SetIndent("", "  ")
+	if err := encoder.Encode(schema); err != nil {
+		fmt.Fprintf(os.Stderr, "Error encoding schema: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+func generateSchema() map[string]any {
+	schema := map[string]any{
+		"$schema":     "http://json-schema.org/draft-07/schema#",
+		"title":       "OpenCode Configuration",
+		"description": "Configuration schema for the OpenCode application",
+		"type":        "object",
+		"properties":  map[string]any{},
+	}
+
+	// Add Data configuration
+	schema["properties"].(map[string]any)["data"] = map[string]any{
+		"type":        "object",
+		"description": "Storage configuration",
+		"properties": map[string]any{
+			"directory": map[string]any{
+				"type":        "string",
+				"description": "Directory where application data is stored",
+				"default":     ".opencode",
+			},
+		},
+		"required": []string{"directory"},
+	}
+
+	// Add working directory
+	schema["properties"].(map[string]any)["wd"] = map[string]any{
+		"type":        "string",
+		"description": "Working directory for the application",
+	}
+
+	// Add debug flags
+	schema["properties"].(map[string]any)["debug"] = map[string]any{
+		"type":        "boolean",
+		"description": "Enable debug mode",
+		"default":     false,
+	}
+
+	schema["properties"].(map[string]any)["debugLSP"] = map[string]any{
+		"type":        "boolean",
+		"description": "Enable LSP debug mode",
+		"default":     false,
+	}
+
+	// Add MCP servers
+	schema["properties"].(map[string]any)["mcpServers"] = map[string]any{
+		"type":        "object",
+		"description": "Model Control Protocol server configurations",
+		"additionalProperties": map[string]any{
+			"type":        "object",
+			"description": "MCP server configuration",
+			"properties": map[string]any{
+				"command": map[string]any{
+					"type":        "string",
+					"description": "Command to execute for the MCP server",
+				},
+				"env": map[string]any{
+					"type":        "array",
+					"description": "Environment variables for the MCP server",
+					"items": map[string]any{
+						"type": "string",
+					},
+				},
+				"args": map[string]any{
+					"type":        "array",
+					"description": "Command arguments for the MCP server",
+					"items": map[string]any{
+						"type": "string",
+					},
+				},
+				"type": map[string]any{
+					"type":        "string",
+					"description": "Type of MCP server",
+					"enum":        []string{"stdio", "sse"},
+					"default":     "stdio",
+				},
+				"url": map[string]any{
+					"type":        "string",
+					"description": "URL for SSE type MCP servers",
+				},
+				"headers": map[string]any{
+					"type":        "object",
+					"description": "HTTP headers for SSE type MCP servers",
+					"additionalProperties": map[string]any{
+						"type": "string",
+					},
+				},
+			},
+			"required": []string{"command"},
+		},
+	}
+
+	// Add providers
+	providerSchema := map[string]any{
+		"type":        "object",
+		"description": "LLM provider configurations",
+		"additionalProperties": map[string]any{
+			"type":        "object",
+			"description": "Provider configuration",
+			"properties": map[string]any{
+				"apiKey": map[string]any{
+					"type":        "string",
+					"description": "API key for the provider",
+				},
+				"disabled": map[string]any{
+					"type":        "boolean",
+					"description": "Whether the provider is disabled",
+					"default":     false,
+				},
+			},
+		},
+	}
+
+	// Add known providers
+	knownProviders := []string{
+		string(models.ProviderAnthropic),
+		string(models.ProviderOpenAI),
+		string(models.ProviderGemini),
+		string(models.ProviderGROQ),
+		string(models.ProviderBedrock),
+	}
+
+	providerSchema["additionalProperties"].(map[string]any)["properties"].(map[string]any)["provider"] = map[string]any{
+		"type":        "string",
+		"description": "Provider type",
+		"enum":        knownProviders,
+	}
+
+	schema["properties"].(map[string]any)["providers"] = providerSchema
+
+	// Add agents
+	agentSchema := map[string]any{
+		"type":        "object",
+		"description": "Agent configurations",
+		"additionalProperties": map[string]any{
+			"type":        "object",
+			"description": "Agent configuration",
+			"properties": map[string]any{
+				"model": map[string]any{
+					"type":        "string",
+					"description": "Model ID for the agent",
+				},
+				"maxTokens": map[string]any{
+					"type":        "integer",
+					"description": "Maximum tokens for the agent",
+					"minimum":     1,
+				},
+				"reasoningEffort": map[string]any{
+					"type":        "string",
+					"description": "Reasoning effort for models that support it (OpenAI, Anthropic)",
+					"enum":        []string{"low", "medium", "high"},
+				},
+			},
+			"required": []string{"model"},
+		},
+	}
+
+	// Add model enum
+	modelEnum := []string{}
+	for modelID := range models.SupportedModels {
+		modelEnum = append(modelEnum, string(modelID))
+	}
+	agentSchema["additionalProperties"].(map[string]any)["properties"].(map[string]any)["model"].(map[string]any)["enum"] = modelEnum
+
+	// Add specific agent properties
+	agentProperties := map[string]any{}
+	knownAgents := []string{
+		string(config.AgentCoder),
+		string(config.AgentTask),
+		string(config.AgentTitle),
+	}
+
+	for _, agentName := range knownAgents {
+		agentProperties[agentName] = map[string]any{
+			"$ref": "#/definitions/agent",
+		}
+	}
+
+	// Create a combined schema that allows both specific agents and additional ones
+	combinedAgentSchema := map[string]any{
+		"type":                 "object",
+		"description":          "Agent configurations",
+		"properties":           agentProperties,
+		"additionalProperties": agentSchema["additionalProperties"],
+	}
+
+	schema["properties"].(map[string]any)["agents"] = combinedAgentSchema
+	schema["definitions"] = map[string]any{
+		"agent": agentSchema["additionalProperties"],
+	}
+
+	// Add LSP configuration
+	schema["properties"].(map[string]any)["lsp"] = map[string]any{
+		"type":        "object",
+		"description": "Language Server Protocol configurations",
+		"additionalProperties": map[string]any{
+			"type":        "object",
+			"description": "LSP configuration for a language",
+			"properties": map[string]any{
+				"disabled": map[string]any{
+					"type":        "boolean",
+					"description": "Whether the LSP is disabled",
+					"default":     false,
+				},
+				"command": map[string]any{
+					"type":        "string",
+					"description": "Command to execute for the LSP server",
+				},
+				"args": map[string]any{
+					"type":        "array",
+					"description": "Command arguments for the LSP server",
+					"items": map[string]any{
+						"type": "string",
+					},
+				},
+				"options": map[string]any{
+					"type":        "object",
+					"description": "Additional options for the LSP server",
+				},
+			},
+			"required": []string{"command"},
+		},
+	}
+
+	return schema
+}
+

internal/config/config.go

@@ -120,13 +120,11 @@ func Load(workingDir string, debug bool) (*Config, error) {
 	}
 
 	applyDefaultValues()
-
 	defaultLevel := slog.LevelInfo
 	if cfg.Debug {
 		defaultLevel = slog.LevelDebug
 	}
-	// if we are in debug mode make the writer a file
-	if cfg.Debug {
+	if os.Getenv("OPENCODE_DEV_DEBUG") == "true" {
 		loggingFile := fmt.Sprintf("%s/%s", cfg.Data.Directory, "debug.log")
 
 		// if file does not exist create it
@@ -156,6 +154,11 @@ func Load(workingDir string, debug bool) (*Config, error) {
 		slog.SetDefault(logger)
 	}
 
+	// Validate configuration
+	if err := Validate(); err != nil {
+		return cfg, fmt.Errorf("config validation failed: %w", err)
+	}
+
 	if cfg.Agents == nil {
 		cfg.Agents = make(map[AgentName]Agent)
 	}
@@ -302,6 +305,273 @@ func applyDefaultValues() {
 	}
 }
 
+// Validate checks if the configuration is valid and applies defaults where needed.
+// It validates model IDs and providers, ensuring they are supported.
+func Validate() error {
+	if cfg == nil {
+		return fmt.Errorf("config not loaded")
+	}
+
+	// Validate agent models
+	for name, agent := range cfg.Agents {
+		// Check if model exists
+		model, modelExists := models.SupportedModels[agent.Model]
+		if !modelExists {
+			logging.Warn("unsupported model configured, reverting to default",
+				"agent", name,
+				"configured_model", agent.Model)
+
+			// Set default model based on available providers
+			if setDefaultModelForAgent(name) {
+				logging.Info("set default model for agent", "agent", name, "model", cfg.Agents[name].Model)
+			} else {
+				return fmt.Errorf("no valid provider available for agent %s", name)
+			}
+			continue
+		}
+
+		// Check if provider for the model is configured
+		provider := model.Provider
+		providerCfg, providerExists := cfg.Providers[provider]
+
+		if !providerExists {
+			// Provider not configured, check if we have environment variables
+			apiKey := getProviderAPIKey(provider)
+			if apiKey == "" {
+				logging.Warn("provider not configured for model, reverting to default",
+					"agent", name,
+					"model", agent.Model,
+					"provider", provider)
+
+				// Set default model based on available providers
+				if setDefaultModelForAgent(name) {
+					logging.Info("set default model for agent", "agent", name, "model", cfg.Agents[name].Model)
+				} else {
+					return fmt.Errorf("no valid provider available for agent %s", name)
+				}
+			} else {
+				// Add provider with API key from environment
+				cfg.Providers[provider] = Provider{
+					APIKey: apiKey,
+				}
+				logging.Info("added provider from environment", "provider", provider)
+			}
+		} else if providerCfg.Disabled || providerCfg.APIKey == "" {
+			// Provider is disabled or has no API key
+			logging.Warn("provider is disabled or has no API key, reverting to default",
+				"agent", name,
+				"model", agent.Model,
+				"provider", provider)
+
+			// Set default model based on available providers
+			if setDefaultModelForAgent(name) {
+				logging.Info("set default model for agent", "agent", name, "model", cfg.Agents[name].Model)
+			} else {
+				return fmt.Errorf("no valid provider available for agent %s", name)
+			}
+		}
+
+		// Validate max tokens
+		if agent.MaxTokens <= 0 {
+			logging.Warn("invalid max tokens, setting to default",
+				"agent", name,
+				"model", agent.Model,
+				"max_tokens", agent.MaxTokens)
+
+			// Update the agent with default max tokens
+			updatedAgent := cfg.Agents[name]
+			if model.DefaultMaxTokens > 0 {
+				updatedAgent.MaxTokens = model.DefaultMaxTokens
+			} else {
+				updatedAgent.MaxTokens = 4096 // Fallback default
+			}
+			cfg.Agents[name] = updatedAgent
+		} else if model.ContextWindow > 0 && agent.MaxTokens > model.ContextWindow/2 {
+			// Ensure max tokens doesn't exceed half the context window (reasonable limit)
+			logging.Warn("max tokens exceeds half the context window, adjusting",
+				"agent", name,
+				"model", agent.Model,
+				"max_tokens", agent.MaxTokens,
+				"context_window", model.ContextWindow)
+
+			// Update the agent with adjusted max tokens
+			updatedAgent := cfg.Agents[name]
+			updatedAgent.MaxTokens = model.ContextWindow / 2
+			cfg.Agents[name] = updatedAgent
+		}
+
+		// Validate reasoning effort for models that support reasoning
+		if model.CanReason && provider == models.ProviderOpenAI {
+			if agent.ReasoningEffort == "" {
+				// Set default reasoning effort for models that support it
+				logging.Info("setting default reasoning effort for model that supports reasoning",
+					"agent", name,
+					"model", agent.Model)
+
+				// Update the agent with default reasoning effort
+				updatedAgent := cfg.Agents[name]
+				updatedAgent.ReasoningEffort = "medium"
+				cfg.Agents[name] = updatedAgent
+			} else {
+				// Check if reasoning effort is valid (low, medium, high)
+				effort := strings.ToLower(agent.ReasoningEffort)
+				if effort != "low" && effort != "medium" && effort != "high" {
+					logging.Warn("invalid reasoning effort, setting to medium",
+						"agent", name,
+						"model", agent.Model,
+						"reasoning_effort", agent.ReasoningEffort)
+
+					// Update the agent with valid reasoning effort
+					updatedAgent := cfg.Agents[name]
+					updatedAgent.ReasoningEffort = "medium"
+					cfg.Agents[name] = updatedAgent
+				}
+			}
+		} else if !model.CanReason && agent.ReasoningEffort != "" {
+			// Model doesn't support reasoning but reasoning effort is set
+			logging.Warn("model doesn't support reasoning but reasoning effort is set, ignoring",
+				"agent", name,
+				"model", agent.Model,
+				"reasoning_effort", agent.ReasoningEffort)
+
+			// Update the agent to remove reasoning effort
+			updatedAgent := cfg.Agents[name]
+			updatedAgent.ReasoningEffort = ""
+			cfg.Agents[name] = updatedAgent
+		}
+	}
+
+	// Validate providers
+	for provider, providerCfg := range cfg.Providers {
+		if providerCfg.APIKey == "" && !providerCfg.Disabled {
+			logging.Warn("provider has no API key, marking as disabled", "provider", provider)
+			providerCfg.Disabled = true
+			cfg.Providers[provider] = providerCfg
+		}
+	}
+
+	// Validate LSP configurations
+	for language, lspConfig := range cfg.LSP {
+		if lspConfig.Command == "" && !lspConfig.Disabled {
+			logging.Warn("LSP configuration has no command, marking as disabled", "language", language)
+			lspConfig.Disabled = true
+			cfg.LSP[language] = lspConfig
+		}
+	}
+
+	return nil
+}
+
+// getProviderAPIKey gets the API key for a provider from environment variables
+func getProviderAPIKey(provider models.ModelProvider) string {
+	switch provider {
+	case models.ProviderAnthropic:
+		return os.Getenv("ANTHROPIC_API_KEY")
+	case models.ProviderOpenAI:
+		return os.Getenv("OPENAI_API_KEY")
+	case models.ProviderGemini:
+		return os.Getenv("GEMINI_API_KEY")
+	case models.ProviderGROQ:
+		return os.Getenv("GROQ_API_KEY")
+	case models.ProviderBedrock:
+		if hasAWSCredentials() {
+			return "aws-credentials-available"
+		}
+	}
+	return ""
+}
+
+// setDefaultModelForAgent sets a default model for an agent based on available providers
+func setDefaultModelForAgent(agent AgentName) bool {
+	// Check providers in order of preference
+	if apiKey := os.Getenv("ANTHROPIC_API_KEY"); apiKey != "" {
+		maxTokens := int64(5000)
+		if agent == AgentTitle {
+			maxTokens = 80
+		}
+		cfg.Agents[agent] = Agent{
+			Model:     models.Claude37Sonnet,
+			MaxTokens: maxTokens,
+		}
+		return true
+	}
+
+	if apiKey := os.Getenv("OPENAI_API_KEY"); apiKey != "" {
+		var model models.ModelID
+		maxTokens := int64(5000)
+		reasoningEffort := ""
+
+		switch agent {
+		case AgentTitle:
+			model = models.GPT41Mini
+			maxTokens = 80
+		case AgentTask:
+			model = models.GPT41Mini
+		default:
+			model = models.GPT41
+		}
+
+		// Check if model supports reasoning
+		if modelInfo, ok := models.SupportedModels[model]; ok && modelInfo.CanReason {
+			reasoningEffort = "medium"
+		}
+
+		cfg.Agents[agent] = Agent{
+			Model:           model,
+			MaxTokens:       maxTokens,
+			ReasoningEffort: reasoningEffort,
+		}
+		return true
+	}
+
+	if apiKey := os.Getenv("GEMINI_API_KEY"); apiKey != "" {
+		var model models.ModelID
+		maxTokens := int64(5000)
+
+		if agent == AgentTitle {
+			model = models.Gemini25Flash
+			maxTokens = 80
+		} else {
+			model = models.Gemini25
+		}
+
+		cfg.Agents[agent] = Agent{
+			Model:     model,
+			MaxTokens: maxTokens,
+		}
+		return true
+	}
+
+	if apiKey := os.Getenv("GROQ_API_KEY"); apiKey != "" {
+		maxTokens := int64(5000)
+		if agent == AgentTitle {
+			maxTokens = 80
+		}
+
+		cfg.Agents[agent] = Agent{
+			Model:     models.QWENQwq,
+			MaxTokens: maxTokens,
+		}
+		return true
+	}
+
+	if hasAWSCredentials() {
+		maxTokens := int64(5000)
+		if agent == AgentTitle {
+			maxTokens = 80
+		}
+
+		cfg.Agents[agent] = Agent{
+			Model:           models.BedrockClaude37Sonnet,
+			MaxTokens:       maxTokens,
+			ReasoningEffort: "medium", // Claude models support reasoning
+		}
+		return true
+	}
+
+	return false
+}
+
 // Get returns the current configuration.
 // It's safe to call this function multiple times.
 func Get() *Config {

internal/llm/agent/agent.go

@@ -471,7 +471,7 @@ func createAgentProvider(agentName config.AgentName) (provider.Provider, error)
 				provider.WithReasoningEffort(agentConfig.ReasoningEffort),
 			),
 		)
-	} else if model.Provider == models.ProviderAnthropic && model.CanReason {
+	} else if model.Provider == models.ProviderAnthropic && model.CanReason && agentName == config.AgentCoder {
 		opts = append(
 			opts,
 			provider.WithAnthropicOptions(

internal/llm/tools/edit.go

@@ -196,11 +196,16 @@ func (e *editTool) createNewFile(ctx context.Context, filePath, content string)
 		content,
 		filePath,
 	)
+	rootDir := config.WorkingDirectory()
+	permissionPath := filepath.Dir(filePath)
+	if strings.HasPrefix(filePath, rootDir) {
+		permissionPath = rootDir
+	}
 	p := e.permissions.Request(
 		permission.CreatePermissionRequest{
-			Path:        filepath.Dir(filePath),
+			Path:        permissionPath,
 			ToolName:    EditToolName,
-			Action:      "create",
+			Action:      "write",
 			Description: fmt.Sprintf("Create file %s", filePath),
 			Params: EditPermissionsParams{
 				FilePath: filePath,
@@ -301,11 +306,16 @@ func (e *editTool) deleteContent(ctx context.Context, filePath, oldString string
 		filePath,
 	)
 
+	rootDir := config.WorkingDirectory()
+	permissionPath := filepath.Dir(filePath)
+	if strings.HasPrefix(filePath, rootDir) {
+		permissionPath = rootDir
+	}
 	p := e.permissions.Request(
 		permission.CreatePermissionRequest{
-			Path:        filepath.Dir(filePath),
+			Path:        permissionPath,
 			ToolName:    EditToolName,
-			Action:      "delete",
+			Action:      "write",
 			Description: fmt.Sprintf("Delete content from file %s", filePath),
 			Params: EditPermissionsParams{
 				FilePath: filePath,
@@ -415,11 +425,16 @@ func (e *editTool) replaceContent(ctx context.Context, filePath, oldString, newS
 		newContent,
 		filePath,
 	)
+	rootDir := config.WorkingDirectory()
+	permissionPath := filepath.Dir(filePath)
+	if strings.HasPrefix(filePath, rootDir) {
+		permissionPath = rootDir
+	}
 	p := e.permissions.Request(
 		permission.CreatePermissionRequest{
-			Path:        filepath.Dir(filePath),
+			Path:        permissionPath,
 			ToolName:    EditToolName,
-			Action:      "replace",
+			Action:      "write",
 			Description: fmt.Sprintf("Replace content in file %s", filePath),
 			Params: EditPermissionsParams{
 				FilePath: filePath,

internal/llm/tools/write.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"github.com/kujtimiihoxha/opencode/internal/config"
@@ -159,11 +160,17 @@ func (w *writeTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error
 		params.Content,
 		filePath,
 	)
+
+	rootDir := config.WorkingDirectory()
+	permissionPath := filepath.Dir(filePath)
+	if strings.HasPrefix(filePath, rootDir) {
+		permissionPath = rootDir
+	}
 	p := w.permissions.Request(
 		permission.CreatePermissionRequest{
-			Path:        filePath,
+			Path:        permissionPath,
 			ToolName:    WriteToolName,
-			Action:      "create",
+			Action:      "write",
 			Description: fmt.Sprintf("Create file %s", filePath),
 			Params: WritePermissionsParams{
 				FilePath: filePath,

internal/permission/permission.go

@@ -2,10 +2,12 @@ package permission
 
 import (
 	"errors"
+	"path/filepath"
 	"sync"
 	"time"
 
 	"github.com/google/uuid"
+	"github.com/kujtimiihoxha/opencode/internal/config"
 	"github.com/kujtimiihoxha/opencode/internal/pubsub"
 )
 
@@ -67,9 +69,13 @@ func (s *permissionService) Deny(permission PermissionRequest) {
 }
 
 func (s *permissionService) Request(opts CreatePermissionRequest) bool {
+	dir := filepath.Dir(opts.Path)
+	if dir == "." {
+		dir = config.WorkingDirectory()
+	}
 	permission := PermissionRequest{
 		ID:          uuid.New().String(),
-		Path:        opts.Path,
+		Path:        dir,
 		ToolName:    opts.ToolName,
 		Description: opts.Description,
 		Action:      opts.Action,
@@ -77,7 +83,7 @@ func (s *permissionService) Request(opts CreatePermissionRequest) bool {
 	}
 
 	for _, p := range s.sessionPermissions {
-		if p.ToolName == permission.ToolName && p.Action == permission.Action {
+		if p.ToolName == permission.ToolName && p.Action == permission.Action && p.SessionID == permission.SessionID && p.Path == permission.Path {
 			return true
 		}
 	}

internal/tui/tui.go

@@ -57,8 +57,8 @@ var returnKey = key.NewBinding(
 )
 
 var logsKeyReturnKey = key.NewBinding(
-	key.WithKeys("backspace"),
-	key.WithHelp("backspace", "go back"),
+	key.WithKeys("backspace", "q"),
+	key.WithHelp("backspace/q", "go back"),
 )
 
 type appModel struct {

internal/version/version.go

@@ -5,7 +5,7 @@ import "runtime/debug"
 // Build-time parameters set via -ldflags
 var Version = "unknown"
 
-// A user may install pug using `go install github.com/leg100/pug@latest`
+// A user may install pug using `go install github.com/kujtimiihoxha/opencode@latest`.
 // without -ldflags, in which case the version above is unset. As a workaround
 // we use the embedded build version that *is* set when using `go install` (and
 // is only set for `go install` and not for `go build`).

opencode-schema.json

@@ -0,0 +1,269 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "agent": {
+      "description": "Agent configuration",
+      "properties": {
+        "maxTokens": {
+          "description": "Maximum tokens for the agent",
+          "minimum": 1,
+          "type": "integer"
+        },
+        "model": {
+          "description": "Model ID for the agent",
+          "enum": [
+            "gemini-2.0-flash",
+            "bedrock.claude-3.7-sonnet",
+            "claude-3-opus",
+            "claude-3.5-sonnet",
+            "gpt-4o-mini",
+            "o1",
+            "o3-mini",
+            "o1-pro",
+            "o4-mini",
+            "claude-3-haiku",
+            "gpt-4o",
+            "o3",
+            "gpt-4.1-mini",
+            "gpt-4.5-preview",
+            "gemini-2.5-flash",
+            "claude-3.5-haiku",
+            "gpt-4.1",
+            "gemini-2.0-flash-lite",
+            "claude-3.7-sonnet",
+            "o1-mini",
+            "gpt-4.1-nano",
+            "gemini-2.5"
+          ],
+          "type": "string"
+        },
+        "reasoningEffort": {
+          "description": "Reasoning effort for models that support it (OpenAI, Anthropic)",
+          "enum": [
+            "low",
+            "medium",
+            "high"
+          ],
+          "type": "string"
+        }
+      },
+      "required": [
+        "model"
+      ],
+      "type": "object"
+    }
+  },
+  "description": "Configuration schema for the OpenCode application",
+  "properties": {
+    "agents": {
+      "additionalProperties": {
+        "description": "Agent configuration",
+        "properties": {
+          "maxTokens": {
+            "description": "Maximum tokens for the agent",
+            "minimum": 1,
+            "type": "integer"
+          },
+          "model": {
+            "description": "Model ID for the agent",
+            "enum": [
+              "gemini-2.0-flash",
+              "bedrock.claude-3.7-sonnet",
+              "claude-3-opus",
+              "claude-3.5-sonnet",
+              "gpt-4o-mini",
+              "o1",
+              "o3-mini",
+              "o1-pro",
+              "o4-mini",
+              "claude-3-haiku",
+              "gpt-4o",
+              "o3",
+              "gpt-4.1-mini",
+              "gpt-4.5-preview",
+              "gemini-2.5-flash",
+              "claude-3.5-haiku",
+              "gpt-4.1",
+              "gemini-2.0-flash-lite",
+              "claude-3.7-sonnet",
+              "o1-mini",
+              "gpt-4.1-nano",
+              "gemini-2.5"
+            ],
+            "type": "string"
+          },
+          "reasoningEffort": {
+            "description": "Reasoning effort for models that support it (OpenAI, Anthropic)",
+            "enum": [
+              "low",
+              "medium",
+              "high"
+            ],
+            "type": "string"
+          }
+        },
+        "required": [
+          "model"
+        ],
+        "type": "object"
+      },
+      "description": "Agent configurations",
+      "properties": {
+        "coder": {
+          "$ref": "#/definitions/agent"
+        },
+        "task": {
+          "$ref": "#/definitions/agent"
+        },
+        "title": {
+          "$ref": "#/definitions/agent"
+        }
+      },
+      "type": "object"
+    },
+    "data": {
+      "description": "Storage configuration",
+      "properties": {
+        "directory": {
+          "default": ".opencode",
+          "description": "Directory where application data is stored",
+          "type": "string"
+        }
+      },
+      "required": [
+        "directory"
+      ],
+      "type": "object"
+    },
+    "debug": {
+      "default": false,
+      "description": "Enable debug mode",
+      "type": "boolean"
+    },
+    "debugLSP": {
+      "default": false,
+      "description": "Enable LSP debug mode",
+      "type": "boolean"
+    },
+    "lsp": {
+      "additionalProperties": {
+        "description": "LSP configuration for a language",
+        "properties": {
+          "args": {
+            "description": "Command arguments for the LSP server",
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "command": {
+            "description": "Command to execute for the LSP server",
+            "type": "string"
+          },
+          "disabled": {
+            "default": false,
+            "description": "Whether the LSP is disabled",
+            "type": "boolean"
+          },
+          "options": {
+            "description": "Additional options for the LSP server",
+            "type": "object"
+          }
+        },
+        "required": [
+          "command"
+        ],
+        "type": "object"
+      },
+      "description": "Language Server Protocol configurations",
+      "type": "object"
+    },
+    "mcpServers": {
+      "additionalProperties": {
+        "description": "MCP server configuration",
+        "properties": {
+          "args": {
+            "description": "Command arguments for the MCP server",
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "command": {
+            "description": "Command to execute for the MCP server",
+            "type": "string"
+          },
+          "env": {
+            "description": "Environment variables for the MCP server",
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "headers": {
+            "additionalProperties": {
+              "type": "string"
+            },
+            "description": "HTTP headers for SSE type MCP servers",
+            "type": "object"
+          },
+          "type": {
+            "default": "stdio",
+            "description": "Type of MCP server",
+            "enum": [
+              "stdio",
+              "sse"
+            ],
+            "type": "string"
+          },
+          "url": {
+            "description": "URL for SSE type MCP servers",
+            "type": "string"
+          }
+        },
+        "required": [
+          "command"
+        ],
+        "type": "object"
+      },
+      "description": "Model Control Protocol server configurations",
+      "type": "object"
+    },
+    "providers": {
+      "additionalProperties": {
+        "description": "Provider configuration",
+        "properties": {
+          "apiKey": {
+            "description": "API key for the provider",
+            "type": "string"
+          },
+          "disabled": {
+            "default": false,
+            "description": "Whether the provider is disabled",
+            "type": "boolean"
+          },
+          "provider": {
+            "description": "Provider type",
+            "enum": [
+              "anthropic",
+              "openai",
+              "gemini",
+              "groq",
+              "bedrock"
+            ],
+            "type": "string"
+          }
+        },
+        "type": "object"
+      },
+      "description": "LLM provider configurations",
+      "type": "object"
+    },
+    "wd": {
+      "description": "Working directory for the application",
+      "type": "string"
+    }
+  },
+  "title": "OpenCode Configuration",
+  "type": "object"
+}