orch-code 0.1.1

package/cmd/doctor.go

@@ -0,0 +1,149 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/auth"
+	"github.com/furkanbeydemir/orch/internal/config"
+	"github.com/furkanbeydemir/orch/internal/providers/openai"
+	"github.com/spf13/cobra"
+)
+
+var doctorCmd = &cobra.Command{
+	Use:   "doctor",
+	Short: "Validate Orch runtime readiness",
+	RunE:  runDoctor,
+}
+
+func init() {
+	rootCmd.AddCommand(doctorCmd)
+}
+
+func runDoctor(cmd *cobra.Command, args []string) error {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	cfg, err := config.Load(cwd)
+	if err != nil {
+		return fmt.Errorf("failed to load configuration: %w", err)
+	}
+
+	type check struct {
+		name   string
+		ok     bool
+		detail string
+	}
+
+	checks := make([]check, 0)
+
+	defaultProvider := strings.TrimSpace(cfg.Provider.Default)
+	checks = append(checks, check{
+		name:   "provider.default",
+		ok:     defaultProvider == "openai",
+		detail: fmt.Sprintf("value=%q", defaultProvider),
+	})
+
+	checks = append(checks, check{
+		name:   "provider.flags.openaiEnabled",
+		ok:     cfg.Provider.Flags.OpenAIEnabled,
+		detail: fmt.Sprintf("value=%t", cfg.Provider.Flags.OpenAIEnabled),
+	})
+
+	authMode := strings.ToLower(strings.TrimSpace(cfg.Provider.OpenAI.AuthMode))
+	if authMode == "" {
+		authMode = "api_key"
+	}
+	checks = append(checks, check{name: "openai.auth_mode", ok: authMode == "api_key" || authMode == "account", detail: authMode})
+
+	key := strings.TrimSpace(os.Getenv(cfg.Provider.OpenAI.APIKeyEnv))
+	accountToken := strings.TrimSpace(os.Getenv(cfg.Provider.OpenAI.AccountTokenEnv))
+
+	storedCred, credErr := auth.Get(cwd, "openai")
+	storedAPIKey := credErr == nil && storedCred != nil && storedCred.Type == "api" && strings.TrimSpace(storedCred.Key) != ""
+	storedAccount := credErr == nil && storedCred != nil && storedCred.Type == "oauth" && strings.TrimSpace(storedCred.AccessToken) != ""
+	storedRefresh := credErr == nil && storedCred != nil && storedCred.Type == "oauth" && strings.TrimSpace(storedCred.RefreshToken) != ""
+	if credErr != nil {
+		checks = append(checks, check{name: "openai.stored_credential", ok: false, detail: credErr.Error()})
+	}
+
+	checks = append(checks, check{
+		name:   "openai.api_key",
+		ok:     key != "" || storedAPIKey || authMode == "account",
+		detail: fmt.Sprintf("env=%s", cfg.Provider.OpenAI.APIKeyEnv),
+	})
+
+	checks = append(checks, check{
+		name:   "openai.account_token",
+		ok:     accountToken != "" || storedAccount || authMode == "api_key",
+		detail: fmt.Sprintf("env=%s stored=%t refresh=%t", cfg.Provider.OpenAI.AccountTokenEnv, storedAccount, storedRefresh),
+	})
+
+	checks = append(checks, check{
+		name: "openai.account_refresh",
+		ok:   authMode != "account" || accountToken != "" || !storedAccount || storedRefresh || (storedCred != nil && storedCred.ExpiresAt.IsZero()) || time.Now().UTC().Before(storedCred.ExpiresAt),
+		detail: fmt.Sprintf("required_when_expired=%t", authMode == "account" && accountToken == ""),
+	})
+
+	checks = append(checks, check{name: "openai.model.planner", ok: strings.TrimSpace(cfg.Provider.OpenAI.Models.Planner) != "", detail: cfg.Provider.OpenAI.Models.Planner})
+	checks = append(checks, check{name: "openai.model.coder", ok: strings.TrimSpace(cfg.Provider.OpenAI.Models.Coder) != "", detail: cfg.Provider.OpenAI.Models.Coder})
+	checks = append(checks, check{name: "openai.model.reviewer", ok: strings.TrimSpace(cfg.Provider.OpenAI.Models.Reviewer) != "", detail: cfg.Provider.OpenAI.Models.Reviewer})
+
+	if cfg.Provider.Flags.OpenAIEnabled && defaultProvider == "openai" {
+		client := openai.New(cfg.Provider.OpenAI)
+		client.SetTokenResolver(func(ctx context.Context) (string, error) {
+			_ = ctx
+			if authMode == "api_key" {
+				if storedCred != nil && strings.TrimSpace(storedCred.Key) != "" {
+					return strings.TrimSpace(storedCred.Key), nil
+				}
+				return "", nil
+			}
+			resolved, resolveErr := auth.ResolveAccountAccessToken(cwd, "openai")
+			if resolveErr != nil {
+				return "", resolveErr
+			}
+			return resolved, nil
+		})
+
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		validateErr := client.Validate(ctx)
+		checks = append(checks, check{
+			name:   "openai.auth",
+			ok:     validateErr == nil,
+			detail: errDetail(validateErr, "ok"),
+		})
+	}
+
+	failed := 0
+	fmt.Println("Orch Doctor")
+	fmt.Println("-----------")
+	for _, c := range checks {
+		status := "PASS"
+		if !c.ok {
+			status = "FAIL"
+			failed++
+		}
+		fmt.Printf("%-6s %-32s %s\n", status, c.name, c.detail)
+	}
+
+	if failed > 0 {
+		return fmt.Errorf("doctor failed: %d checks failed", failed)
+	}
+
+	fmt.Println("All checks passed.")
+	return nil
+}
+
+func errDetail(err error, fallback string) string {
+	if err == nil {
+		return fallback
+	}
+	return err.Error()
+}

package/cmd/explain.go

@@ -0,0 +1,192 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+	"github.com/spf13/cobra"
+)
+
+var explainCmd = &cobra.Command{
+	Use:   "explain [run-id]",
+	Short: "Explain why a run passed, failed, or was downgraded",
+	Long:  `Shows the structured reasoning artifacts for a run, including plan, validation, test, review, and confidence signals.`,
+	Args:  cobra.MaximumNArgs(1),
+	RunE:  runExplain,
+}
+
+func init() {
+	rootCmd.AddCommand(explainCmd)
+}
+
+func runExplain(cmd *cobra.Command, args []string) error {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	ctx, err := loadSessionContext(cwd)
+	if err != nil {
+		return err
+	}
+	defer ctx.Store.Close()
+
+	var state *models.RunState
+	if len(args) == 0 {
+		state, err = ctx.Store.GetLatestRunStateBySession(ctx.Session.ID)
+		if err != nil {
+			return fmt.Errorf("failed to load latest run state: %w", err)
+		}
+	} else {
+		state, err = ctx.Store.GetRunState(ctx.ProjectID, args[0])
+		if err != nil {
+			return fmt.Errorf("failed to load run state %s: %w", args[0], err)
+		}
+	}
+
+	printExplain(state)
+	return nil
+}
+
+func printExplain(state *models.RunState) {
+	if state == nil {
+		fmt.Println("No run state available.")
+		return
+	}
+
+	fmt.Println("═══════════════════════════════════════")
+	fmt.Println("🔎 RUN EXPLANATION")
+	fmt.Println("═══════════════════════════════════════")
+	fmt.Printf("Run ID: %s\n", state.ID)
+	fmt.Printf("Status: %s\n", state.Status)
+	fmt.Printf("Task: %s\n", state.Task.Description)
+	if state.Error != "" {
+		fmt.Printf("Error: %s\n", state.Error)
+	}
+
+	if state.TaskBrief != nil {
+		fmt.Println("\n🧭 Task Brief")
+		fmt.Printf("  Type: %s\n", state.TaskBrief.TaskType)
+		fmt.Printf("  Risk: %s\n", state.TaskBrief.RiskLevel)
+		fmt.Printf("  Goal: %s\n", state.TaskBrief.NormalizedGoal)
+	}
+
+	if state.Plan != nil {
+		fmt.Println("\n📋 Plan")
+		if state.Plan.Summary != "" {
+			fmt.Printf("  Summary: %s\n", state.Plan.Summary)
+		}
+		if len(state.Plan.FilesToModify) > 0 {
+			fmt.Printf("  Files To Modify: %s\n", strings.Join(state.Plan.FilesToModify, ", "))
+		}
+		if len(state.Plan.AcceptanceCriteria) > 0 {
+			fmt.Println("  Acceptance Criteria:")
+			for _, criterion := range state.Plan.AcceptanceCriteria {
+				fmt.Printf("    - %s\n", criterion.Description)
+			}
+		}
+	}
+
+	if state.ExecutionContract != nil {
+		fmt.Println("\n🧩 Execution Contract")
+		if len(state.ExecutionContract.AllowedFiles) > 0 {
+			fmt.Printf("  Allowed Files: %s\n", strings.Join(state.ExecutionContract.AllowedFiles, ", "))
+		}
+		if len(state.ExecutionContract.RequiredEdits) > 0 {
+			fmt.Printf("  Required Edits: %s\n", strings.Join(state.ExecutionContract.RequiredEdits, " | "))
+		}
+		fmt.Printf("  Patch Budget: max_files=%d max_changed_lines=%d\n", state.ExecutionContract.PatchBudget.MaxFiles, state.ExecutionContract.PatchBudget.MaxChangedLines)
+	}
+
+	if len(state.ValidationResults) > 0 {
+		fmt.Println("\n🛡️ Validation + Review/Test Gates")
+		results := append([]models.ValidationResult(nil), state.ValidationResults...)
+		sort.SliceStable(results, func(i, j int) bool {
+			if results[i].Stage == results[j].Stage {
+				return results[i].Name < results[j].Name
+			}
+			return results[i].Stage < results[j].Stage
+		})
+		for _, result := range results {
+			fmt.Printf("  - [%s] %s = %s (%s)\n", result.Stage, result.Name, result.Status, result.Summary)
+		}
+	}
+
+	if len(state.TestFailures) > 0 {
+		fmt.Println("\n🧪 Test Failure Classification")
+		for _, failure := range state.TestFailures {
+			line := fmt.Sprintf("  - %s: %s", failure.Code, failure.Summary)
+			if failure.Flaky {
+				line += " [flaky-suspected]"
+			}
+			fmt.Println(line)
+		}
+	} else if strings.TrimSpace(state.TestResults) != "" {
+		fmt.Println("\n🧪 Test Output")
+		fmt.Printf("  %s\n", strings.ReplaceAll(strings.TrimSpace(state.TestResults), "\n", "\n  "))
+	}
+
+	if state.ReviewScorecard != nil {
+		fmt.Println("\n🧠 Review Scorecard")
+		fmt.Printf("  Requirement Coverage: %d\n", state.ReviewScorecard.RequirementCoverage)
+		fmt.Printf("  Scope Control: %d\n", state.ReviewScorecard.ScopeControl)
+		fmt.Printf("  Regression Risk: %d\n", state.ReviewScorecard.RegressionRisk)
+		fmt.Printf("  Readability: %d\n", state.ReviewScorecard.Readability)
+		fmt.Printf("  Maintainability: %d\n", state.ReviewScorecard.Maintainability)
+		fmt.Printf("  Test Adequacy: %d\n", state.ReviewScorecard.TestAdequacy)
+		fmt.Printf("  Decision: %s\n", state.ReviewScorecard.Decision)
+		if len(state.ReviewScorecard.Findings) > 0 {
+			fmt.Println("  Findings:")
+			for _, finding := range state.ReviewScorecard.Findings {
+				fmt.Printf("    - %s\n", finding)
+			}
+		}
+	}
+
+	if state.Confidence != nil {
+		fmt.Println("\n🎯 Confidence")
+		fmt.Printf("  Score: %.2f\n", state.Confidence.Score)
+		fmt.Printf("  Band: %s\n", state.Confidence.Band)
+		if len(state.Confidence.Reasons) > 0 {
+			fmt.Println("  Reasons:")
+			for _, reason := range state.Confidence.Reasons {
+				fmt.Printf("    - %s\n", reason)
+			}
+		}
+		if len(state.Confidence.Warnings) > 0 {
+			fmt.Println("  Warnings:")
+			for _, warning := range state.Confidence.Warnings {
+				fmt.Printf("    - %s\n", warning)
+			}
+		}
+	}
+
+	if state.Review != nil {
+		fmt.Println("\n💬 Final Review")
+		fmt.Printf("  Decision: %s\n", state.Review.Decision)
+		for _, comment := range state.Review.Comments {
+			fmt.Printf("  - %s\n", comment)
+		}
+		if len(state.Review.Suggestions) > 0 {
+			fmt.Println("  Suggestions:")
+			for _, suggestion := range state.Review.Suggestions {
+				fmt.Printf("    - %s\n", suggestion)
+			}
+		}
+	}
+
+	if state.RetryDirective != nil {
+		fmt.Println("\n🔁 Last Retry Directive")
+		fmt.Printf("  Stage: %s\n", state.RetryDirective.Stage)
+		fmt.Printf("  Attempt: %d\n", state.RetryDirective.Attempt)
+		if len(state.RetryDirective.Reasons) > 0 {
+			fmt.Printf("  Reasons: %s\n", strings.Join(state.RetryDirective.Reasons, " | "))
+		}
+		if len(state.RetryDirective.Instructions) > 0 {
+			fmt.Printf("  Instructions: %s\n", strings.Join(state.RetryDirective.Instructions, " | "))
+		}
+	}
+}

package/cmd/explain_test.go

@@ -0,0 +1,62 @@
+package cmd
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+func TestPrintExplainIncludesConfidenceAndReview(t *testing.T) {
+	state := &models.RunState{
+		ID:        "run-explain-1",
+		Task:      models.Task{ID: "task-1", Description: "demo", CreatedAt: time.Now()},
+		Status:    models.StatusCompleted,
+		StartedAt: time.Now(),
+		Review:    &models.ReviewResult{Decision: models.ReviewAccept, Comments: []string{"looks good"}},
+		Confidence: &models.ConfidenceReport{
+			Score:   0.91,
+			Band:    "high",
+			Reasons: []string{"tests and review aligned"},
+		},
+	}
+
+	output := captureStdout(t, func() {
+		printExplain(state)
+	})
+
+	if !strings.Contains(output, "RUN EXPLANATION") {
+		t.Fatalf("expected explanation header, got: %s", output)
+	}
+	if !strings.Contains(output, "Score: 0.91") {
+		t.Fatalf("expected confidence score in output, got: %s", output)
+	}
+	if !strings.Contains(output, "Decision: accept") {
+		t.Fatalf("expected review decision in output, got: %s", output)
+	}
+}
+
+func captureStdout(t *testing.T, fn func()) string {
+	t.Helper()
+	original := os.Stdout
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatalf("pipe: %v", err)
+	}
+	os.Stdout = w
+	defer func() { os.Stdout = original }()
+
+	fn()
+
+	_ = w.Close()
+	var buf bytes.Buffer
+	if _, err := io.Copy(&buf, r); err != nil {
+		t.Fatalf("copy stdout: %v", err)
+	}
+	_ = r.Close()
+	return buf.String()
+}

package/cmd/init.go

@@ -0,0 +1,100 @@
+// Package cmd implements the init command.
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+	"github.com/furkanbeydemir/orch/internal/repo"
+	"github.com/furkanbeydemir/orch/internal/storage"
+	"github.com/spf13/cobra"
+)
+
+// initCmd represents the `orch init` command.
+var initCmd = &cobra.Command{
+	Use:   "init",
+	Short: "Analyze repository and create configuration",
+	Long:  `Analyzes repository and creates .orch/ and configuration files.`,
+	RunE:  runInit,
+}
+
+func init() {
+	rootCmd.AddCommand(initCmd)
+}
+
+func runInit(cmd *cobra.Command, args []string) error {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	return performInit(cwd, false)
+}
+
+func AutoInitIfNeeded(cwd string) error {
+	configPath := filepath.Join(cwd, config.OrchDir, config.ConfigFile)
+	if _, err := os.Stat(configPath); err == nil {
+		// Already initialized
+		return nil
+	}
+	
+	// Print a notice since it's happening automatically
+	fmt.Println("✨ First run detected. Initializing Orch automatically...")
+	return performInit(cwd, true)
+}
+
+func performInit(cwd string, quiet bool) error {
+	if !quiet {
+		fmt.Println("🔍 Analyzing repository...")
+	}
+
+	if err := config.EnsureOrchDir(cwd); err != nil {
+		return err
+	}
+
+	cfg := config.DefaultConfig()
+	if err := config.Save(cwd, cfg); err != nil {
+		return err
+	}
+	if !quiet {
+		fmt.Println("✅ .orch/config.json created")
+	}
+
+	// Repository analysis
+	analyzer := repo.NewAnalyzer(cwd)
+	repoMap, err := analyzer.Analyze()
+	if err != nil {
+		return fmt.Errorf("repository analysis failed: %w", err)
+	}
+
+	if !quiet {
+		fmt.Printf("✅ .orch/repo-map.json created (%d files scanned)\n", len(repoMap.Files))
+		fmt.Printf("📋 Language: %s | Package Manager: %s | Test: %s\n",
+			repoMap.Language, repoMap.PackageManager, repoMap.TestFramework)
+	}
+
+	store, err := storage.Open(cwd)
+	if err != nil {
+		return fmt.Errorf("failed to initialize sqlite storage: %w", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		return fmt.Errorf("failed to resolve project: %w", err)
+	}
+
+	session, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		return fmt.Errorf("failed to resolve default session: %w", err)
+	}
+
+	if !quiet {
+		fmt.Printf("✅ SQLite storage ready (.orch/orch.db), active session: %s (%s)\n", session.Name, session.ID)
+		fmt.Println("\n🎯 Orch configured successfully!")
+	}
+
+	return nil
+}