orch-code 0.1.1

package/internal/providers/provider.go

@@ -0,0 +1,47 @@
+package providers
+
+import "context"
+
+type Role string
+
+const (
+	RolePlanner  Role = "planner"
+	RoleCoder    Role = "coder"
+	RoleReviewer Role = "reviewer"
+)
+
+type ChatRequest struct {
+	Role            Role
+	Model           string
+	SystemPrompt    string
+	UserPrompt      string
+	MaxTokens       int
+	Temperature     float64
+	ReasoningEffort string
+}
+
+type Usage struct {
+	InputTokens  int
+	OutputTokens int
+	TotalTokens  int
+}
+
+type ChatResponse struct {
+	Text             string
+	FinishReason     string
+	Usage            Usage
+	ProviderMetadata map[string]string
+}
+
+type StreamEvent struct {
+	Type     string
+	Text     string
+	Metadata map[string]string
+}
+
+type Provider interface {
+	Name() string
+	Validate(ctx context.Context) error
+	Chat(ctx context.Context, req ChatRequest) (ChatResponse, error)
+	Stream(ctx context.Context, req ChatRequest) (<-chan StreamEvent, <-chan error)
+}

package/internal/providers/registry.go

@@ -0,0 +1,32 @@
+package providers
+
+import (
+	"fmt"
+	"strings"
+)
+
+type Registry struct {
+	providers map[string]Provider
+}
+
+func NewRegistry() *Registry {
+	return &Registry{providers: make(map[string]Provider)}
+}
+
+func (r *Registry) Register(p Provider) {
+	if r == nil || p == nil {
+		return
+	}
+	r.providers[strings.ToLower(p.Name())] = p
+}
+
+func (r *Registry) Get(name string) (Provider, error) {
+	if r == nil {
+		return nil, fmt.Errorf("provider registry is nil")
+	}
+	p, ok := r.providers[strings.ToLower(strings.TrimSpace(name))]
+	if !ok {
+		return nil, fmt.Errorf("provider not found: %s", name)
+	}
+	return p, nil
+}

package/internal/providers/registry_test.go

@@ -0,0 +1,57 @@
+package providers
+
+import (
+	"context"
+	"testing"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+)
+
+type fakeProvider struct{ name string }
+
+func (f fakeProvider) Name() string { return f.name }
+
+func (f fakeProvider) Validate(ctx context.Context) error { return nil }
+
+func (f fakeProvider) Chat(ctx context.Context, req ChatRequest) (ChatResponse, error) {
+	return ChatResponse{Text: "ok"}, nil
+}
+
+func (f fakeProvider) Stream(ctx context.Context, req ChatRequest) (<-chan StreamEvent, <-chan error) {
+	ev := make(chan StreamEvent)
+	err := make(chan error)
+	close(ev)
+	close(err)
+	return ev, err
+}
+
+func TestRegistryGetProvider(t *testing.T) {
+	reg := NewRegistry()
+	reg.Register(fakeProvider{name: "openai"})
+
+	got, err := reg.Get("openai")
+	if err != nil {
+		t.Fatalf("get provider: %v", err)
+	}
+	if got.Name() != "openai" {
+		t.Fatalf("unexpected provider: %s", got.Name())
+	}
+}
+
+func TestRouterResolveRoleModel(t *testing.T) {
+	cfg := config.DefaultConfig()
+	reg := NewRegistry()
+	reg.Register(fakeProvider{name: "openai"})
+
+	router := NewRouter(cfg, reg)
+	provider, model, err := router.Resolve(RoleCoder)
+	if err != nil {
+		t.Fatalf("resolve route: %v", err)
+	}
+	if provider.Name() != "openai" {
+		t.Fatalf("unexpected provider: %s", provider.Name())
+	}
+	if model != cfg.Provider.OpenAI.Models.Coder {
+		t.Fatalf("unexpected model: got=%s want=%s", model, cfg.Provider.OpenAI.Models.Coder)
+	}
+}

package/internal/providers/router.go

@@ -0,0 +1,52 @@
+package providers
+
+import (
+	"fmt"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+)
+
+type Router struct {
+	cfg      *config.Config
+	registry *Registry
+}
+
+func NewRouter(cfg *config.Config, registry *Registry) *Router {
+	return &Router{cfg: cfg, registry: registry}
+}
+
+func (r *Router) Resolve(role Role) (Provider, string, error) {
+	if r == nil || r.cfg == nil || r.registry == nil {
+		return nil, "", fmt.Errorf("provider router is not initialized")
+	}
+
+	providerName := r.cfg.Provider.Default
+	model := modelForRole(r.cfg, role)
+
+	provider, err := r.registry.Get(providerName)
+	if err != nil {
+		return nil, "", err
+	}
+
+	if model == "" {
+		return nil, "", fmt.Errorf("model not configured for role %s", role)
+	}
+
+	return provider, model, nil
+}
+
+func modelForRole(cfg *config.Config, role Role) string {
+	if cfg == nil {
+		return ""
+	}
+	switch role {
+	case RolePlanner:
+		return cfg.Provider.OpenAI.Models.Planner
+	case RoleCoder:
+		return cfg.Provider.OpenAI.Models.Coder
+	case RoleReviewer:
+		return cfg.Provider.OpenAI.Models.Reviewer
+	default:
+		return ""
+	}
+}

package/internal/providers/state.go

@@ -0,0 +1,114 @@
+package providers
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/auth"
+	"github.com/furkanbeydemir/orch/internal/config"
+)
+
+type OpenAIState struct {
+	Enabled   bool
+	Connected bool
+	Mode      string
+	Source    string
+	Reason    string
+}
+
+type ProviderState struct {
+	All       []string
+	Default   map[string]string
+	Connected []string
+	OpenAI    OpenAIState
+}
+
+func ReadState(repoRoot string) (ProviderState, error) {
+	cfg, err := config.Load(repoRoot)
+	if err != nil {
+		return ProviderState{}, fmt.Errorf("failed to load config: %w", err)
+	}
+
+	state := ProviderState{
+		All:       []string{},
+		Default:   map[string]string{},
+		Connected: []string{},
+		OpenAI: OpenAIState{
+			Enabled: cfg.Provider.Flags.OpenAIEnabled,
+			Mode:    strings.ToLower(strings.TrimSpace(cfg.Provider.OpenAI.AuthMode)),
+		},
+	}
+
+	if state.OpenAI.Mode == "" {
+		state.OpenAI.Mode = "api_key"
+	}
+
+	if cfg.Provider.Flags.OpenAIEnabled {
+		state.All = append(state.All, "openai")
+		state.Default["openai"] = strings.TrimSpace(cfg.Provider.OpenAI.Models.Coder)
+	}
+
+	if !cfg.Provider.Flags.OpenAIEnabled {
+		state.OpenAI.Reason = "provider disabled"
+		return state, nil
+	}
+
+	var connected bool
+	var source string
+
+	switch state.OpenAI.Mode {
+	case "api_key":
+		if strings.TrimSpace(os.Getenv(cfg.Provider.OpenAI.APIKeyEnv)) != "" {
+			connected = true
+			source = "env"
+		} else {
+			cred, credErr := auth.Get(repoRoot, "openai")
+			if credErr == nil && cred != nil && strings.TrimSpace(strings.ToLower(cred.Type)) == "api" && strings.TrimSpace(cred.Key) != "" {
+				connected = true
+				source = "local"
+			}
+		}
+		if !connected {
+			state.OpenAI.Reason = fmt.Sprintf("missing API key (%s or local auth)", cfg.Provider.OpenAI.APIKeyEnv)
+		}
+	case "account":
+		if strings.TrimSpace(os.Getenv(cfg.Provider.OpenAI.AccountTokenEnv)) != "" {
+			connected = true
+			source = "env"
+		} else {
+			cred, credErr := auth.Get(repoRoot, "openai")
+			if credErr == nil && cred != nil && strings.TrimSpace(strings.ToLower(cred.Type)) == "oauth" && strings.TrimSpace(cred.AccessToken) != "" {
+				expired := !cred.ExpiresAt.IsZero() && time.Now().UTC().After(cred.ExpiresAt)
+				if expired && strings.TrimSpace(cred.RefreshToken) == "" {
+					connected = false
+					state.OpenAI.Reason = "stored oauth token expired and missing refresh token"
+				} else {
+					connected = true
+					source = "local"
+				}
+			}
+		}
+		if !connected {
+			if state.OpenAI.Reason == "" {
+				state.OpenAI.Reason = fmt.Sprintf("missing account token (%s or local auth)", cfg.Provider.OpenAI.AccountTokenEnv)
+			}
+		}
+	default:
+		state.OpenAI.Reason = fmt.Sprintf("invalid auth mode (%s)", state.OpenAI.Mode)
+	}
+
+	state.OpenAI.Connected = connected
+	state.OpenAI.Source = source
+	if connected {
+		state.Connected = append(state.Connected, "openai")
+		state.OpenAI.Reason = ""
+	}
+
+	sort.Strings(state.All)
+	sort.Strings(state.Connected)
+
+	return state, nil
+}

package/internal/providers/state_test.go

@@ -0,0 +1,64 @@
+package providers
+
+import (
+	"testing"
+
+	"github.com/furkanbeydemir/orch/internal/auth"
+	"github.com/furkanbeydemir/orch/internal/config"
+)
+
+func TestReadStateDisconnectedWithoutCredentials(t *testing.T) {
+	repoRoot := t.TempDir()
+	cfg := config.DefaultConfig()
+	cfg.Provider.Default = "openai"
+	cfg.Provider.OpenAI.AuthMode = "api_key"
+	if err := config.Save(repoRoot, cfg); err != nil {
+		t.Fatalf("save config: %v", err)
+	}
+
+	t.Setenv(cfg.Provider.OpenAI.APIKeyEnv, "")
+
+	state, err := ReadState(repoRoot)
+	if err != nil {
+		t.Fatalf("read state: %v", err)
+	}
+	if len(state.All) != 1 || state.All[0] != "openai" {
+		t.Fatalf("unexpected all providers: %+v", state.All)
+	}
+	if state.OpenAI.Connected {
+		t.Fatalf("expected disconnected openai state")
+	}
+	if len(state.Connected) != 0 {
+		t.Fatalf("expected no connected providers, got: %+v", state.Connected)
+	}
+}
+
+func TestReadStateConnectedWithStoredAPIKey(t *testing.T) {
+	repoRoot := t.TempDir()
+	cfg := config.DefaultConfig()
+	cfg.Provider.Default = "openai"
+	cfg.Provider.OpenAI.AuthMode = "api_key"
+	if err := config.Save(repoRoot, cfg); err != nil {
+		t.Fatalf("save config: %v", err)
+	}
+
+	if err := auth.Set(repoRoot, "openai", auth.Credential{Type: "api", Key: "sk-test"}); err != nil {
+		t.Fatalf("save auth: %v", err)
+	}
+
+	t.Setenv(cfg.Provider.OpenAI.APIKeyEnv, "")
+
+	state, err := ReadState(repoRoot)
+	if err != nil {
+		t.Fatalf("read state: %v", err)
+	}
+	if !state.OpenAI.Connected {
+		t.Fatalf("expected connected openai state")
+	}
+	if state.OpenAI.Source != "local" {
+		t.Fatalf("expected local source, got: %s", state.OpenAI.Source)
+	}
+	if len(state.Connected) != 1 || state.Connected[0] != "openai" {
+		t.Fatalf("unexpected connected providers: %+v", state.Connected)
+	}
+}

package/internal/repo/analyzer.go

@@ -0,0 +1,188 @@
+// - Primary programming language
+// - File inventory
+package repo
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+type Analyzer struct {
+	rootPath string
+}
+
+func NewAnalyzer(rootPath string) *Analyzer {
+	return &Analyzer{
+		rootPath: rootPath,
+	}
+}
+
+func (a *Analyzer) Analyze() (*models.RepoMap, error) {
+	repoMap := &models.RepoMap{
+		RootPath: a.rootPath,
+		Files:    make([]models.FileInfo, 0),
+	}
+
+	err := filepath.Walk(a.rootPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+		}
+
+		// Skip hidden directories and .orch.
+		if info.IsDir() {
+			name := info.Name()
+			if strings.HasPrefix(name, ".") || name == "node_modules" || name == "vendor" {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		// Resolve relative path.
+		relPath, err := filepath.Rel(a.rootPath, path)
+		if err != nil {
+			return nil
+		}
+
+		fileInfo := models.FileInfo{
+			Path:     relPath,
+			Language: detectLanguage(path),
+			Size:     info.Size(),
+		}
+
+		repoMap.Files = append(repoMap.Files, fileInfo)
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("repository scan failed: %w", err)
+	}
+
+	repoMap.Language = a.detectMainLanguage(repoMap.Files)
+	repoMap.PackageManager = a.detectPackageManager()
+	repoMap.TestFramework = a.detectTestFramework()
+
+	// Persist repo map.
+	if err := a.saveRepoMap(repoMap); err != nil {
+		return nil, err
+	}
+
+	return repoMap, nil
+}
+
+func detectLanguage(path string) string {
+	ext := strings.ToLower(filepath.Ext(path))
+	languages := map[string]string{
+		".go":    "go",
+		".js":    "javascript",
+		".ts":    "typescript",
+		".py":    "python",
+		".rs":    "rust",
+		".java":  "java",
+		".rb":    "ruby",
+		".cpp":   "cpp",
+		".c":     "c",
+		".cs":    "csharp",
+		".php":   "php",
+		".swift": "swift",
+		".kt":    "kotlin",
+		".md":    "markdown",
+		".json":  "json",
+		".yaml":  "yaml",
+		".yml":   "yaml",
+		".toml":  "toml",
+		".xml":   "xml",
+		".html":  "html",
+		".css":   "css",
+		".sql":   "sql",
+		".sh":    "shell",
+	}
+
+	if lang, ok := languages[ext]; ok {
+		return lang
+	}
+	return "unknown"
+}
+
+// detectMainLanguage infers the primary language from the file inventory.
+func (a *Analyzer) detectMainLanguage(files []models.FileInfo) string {
+	counts := make(map[string]int)
+	for _, f := range files {
+		if f.Language != "unknown" && f.Language != "markdown" && f.Language != "json" && f.Language != "yaml" {
+			counts[f.Language]++
+		}
+	}
+
+	maxLang := "unknown"
+	maxCount := 0
+	for lang, count := range counts {
+		if count > maxCount {
+			maxLang = lang
+			maxCount = count
+		}
+	}
+
+	return maxLang
+}
+
+func (a *Analyzer) detectPackageManager() string {
+	indicators := map[string]string{
+		"go.mod":           "go modules",
+		"package.json":     "npm",
+		"requirements.txt": "pip",
+		"Cargo.toml":       "cargo",
+		"pom.xml":          "maven",
+		"build.gradle":     "gradle",
+		"Gemfile":          "bundler",
+		"composer.json":    "composer",
+	}
+
+	for file, manager := range indicators {
+		if _, err := os.Stat(filepath.Join(a.rootPath, file)); err == nil {
+			return manager
+		}
+	}
+
+	return "unknown"
+}
+
+func (a *Analyzer) detectTestFramework() string {
+	indicators := map[string]string{
+		"go.mod":         "go test",
+		"jest.config.js": "jest",
+		"jest.config.ts": "jest",
+		"pytest.ini":     "pytest",
+		"setup.cfg":      "pytest",
+		".rspec":         "rspec",
+	}
+
+	for file, framework := range indicators {
+		if _, err := os.Stat(filepath.Join(a.rootPath, file)); err == nil {
+			return framework
+		}
+	}
+
+	return "unknown"
+}
+
+func (a *Analyzer) saveRepoMap(repoMap *models.RepoMap) error {
+	orchDir := filepath.Join(a.rootPath, ".orch")
+	if err := os.MkdirAll(orchDir, 0o755); err != nil {
+		return fmt.Errorf("failed to create .orch directory: %w", err)
+	}
+
+	data, err := json.MarshalIndent(repoMap, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to serialize repo map: %w", err)
+	}
+
+	mapPath := filepath.Join(orchDir, "repo-map.json")
+	if err := os.WriteFile(mapPath, data, 0o644); err != nil {
+		return fmt.Errorf("failed to write repo map file: %w", err)
+	}
+
+	return nil
+}

package/internal/repo/context.go

@@ -0,0 +1,83 @@
+// Package repo - Context Builder implementasyonu.
+//
+// Girdi:
+//   - Planner hints (opsiyonel)
+package repo
+
+import (
+	"path/filepath"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+type ContextBuilder struct {
+	rootPath string
+}
+
+func NewContextBuilder(rootPath string) *ContextBuilder {
+	return &ContextBuilder{
+		rootPath: rootPath,
+	}
+}
+
+func (cb *ContextBuilder) Build(task *models.Task, repoMap *models.RepoMap, plan *models.Plan) *models.ContextResult {
+	result := &models.ContextResult{
+		SelectedFiles:   make([]string, 0),
+		RelatedTests:    make([]string, 0),
+		RelevantConfigs: make([]string, 0),
+	}
+
+	if plan != nil {
+		result.SelectedFiles = append(result.SelectedFiles, plan.FilesToModify...)
+		result.SelectedFiles = append(result.SelectedFiles, plan.FilesToInspect...)
+	}
+
+	for _, file := range repoMap.Files {
+		if isTestFile(file.Path) {
+			result.RelatedTests = append(result.RelatedTests, file.Path)
+		} else if isConfigFile(file.Path) {
+			result.RelevantConfigs = append(result.RelevantConfigs, file.Path)
+		}
+	}
+
+	return result
+}
+
+func isTestFile(path string) bool {
+	base := strings.ToLower(filepath.Base(path))
+	patterns := []string{
+		"_test.go",
+		".test.js", ".test.ts",
+		".spec.js", ".spec.ts",
+		"test_", "_test.py",
+	}
+
+	for _, pattern := range patterns {
+		if strings.Contains(base, pattern) {
+			return true
+		}
+	}
+
+	dir := strings.ToLower(filepath.Dir(path))
+	return strings.Contains(dir, "test") || strings.Contains(dir, "__tests__")
+}
+
+func isConfigFile(path string) bool {
+	base := strings.ToLower(filepath.Base(path))
+	configs := []string{
+		"config", "conf", ".env", ".rc",
+		"tsconfig", "jest.config", "webpack",
+		"package.json", "go.mod", "cargo.toml",
+		"dockerfile", "docker-compose", "makefile",
+	}
+
+	for _, cfg := range configs {
+		if strings.Contains(base, cfg) {
+			return true
+		}
+	}
+
+	ext := strings.ToLower(filepath.Ext(path))
+	return ext == ".yaml" || ext == ".yml" || ext == ".toml" || ext == ".ini"
+}