orch-code 0.1.1

package/cmd/session_list_current_test.go

@@ -0,0 +1,87 @@
+package cmd
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/furkanbeydemir/orch/internal/storage"
+)
+
+func TestSessionListJSONOutput(t *testing.T) {
+	repoRoot := t.TempDir()
+	t.Chdir(repoRoot)
+
+	store, err := storage.Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open storage: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("project: %v", err)
+	}
+	if _, err := store.EnsureDefaultSession(projectID); err != nil {
+		t.Fatalf("default session: %v", err)
+	}
+
+	sessionListJSON = true
+	t.Cleanup(func() { sessionListJSON = false })
+
+	output := captureStdout(t, func() {
+		if err := runSessionList(nil, nil); err != nil {
+			t.Fatalf("run session list: %v", err)
+		}
+	})
+
+	var payload []map[string]any
+	if err := json.Unmarshal([]byte(output), &payload); err != nil {
+		t.Fatalf("invalid json output: %v\noutput=%s", err, output)
+	}
+	if len(payload) == 0 {
+		t.Fatalf("expected at least one session")
+	}
+	if payload[0]["name"] == "" {
+		t.Fatalf("expected name in first session payload")
+	}
+}
+
+func TestSessionCurrentJSONOutput(t *testing.T) {
+	repoRoot := t.TempDir()
+	t.Chdir(repoRoot)
+
+	store, err := storage.Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open storage: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("project: %v", err)
+	}
+	sess, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("default session: %v", err)
+	}
+
+	sessionCurrentJSON = true
+	t.Cleanup(func() { sessionCurrentJSON = false })
+
+	output := captureStdout(t, func() {
+		if err := runSessionCurrent(nil, nil); err != nil {
+			t.Fatalf("run session current: %v", err)
+		}
+	})
+
+	var payload map[string]any
+	if err := json.Unmarshal([]byte(output), &payload); err != nil {
+		t.Fatalf("invalid json output: %v\noutput=%s", err, output)
+	}
+	if payload["id"] != sess.ID {
+		t.Fatalf("expected id %s, got %v", sess.ID, payload["id"])
+	}
+	if payload["is_active"] != true {
+		t.Fatalf("expected is_active=true, got %v", payload["is_active"])
+	}
+}

package/cmd/session_messages_test.go

@@ -0,0 +1,163 @@
+package cmd
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/furkanbeydemir/orch/internal/session"
+	"github.com/furkanbeydemir/orch/internal/storage"
+)
+
+func TestSessionMessagesCommand(t *testing.T) {
+	repoRoot := t.TempDir()
+	t.Chdir(repoRoot)
+
+	store, err := storage.Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open storage: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("project: %v", err)
+	}
+	sess, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("default session: %v", err)
+	}
+
+	svc := session.NewService(store)
+	if _, err := svc.AppendText(session.MessageInput{
+		SessionID:  sess.ID,
+		Role:       "user",
+		ProviderID: "openai",
+		ModelID:    "gpt-5.3-codex",
+		Text:       "hello session",
+	}); err != nil {
+		t.Fatalf("append text: %v", err)
+	}
+
+	sessionMessagesLimit = 10
+	sessionMessagesJSON = false
+	output := captureStdout(t, func() {
+		if err := runSessionMessages(nil, nil); err != nil {
+			t.Fatalf("run session messages: %v", err)
+		}
+	})
+
+	if !strings.Contains(output, "role=user") {
+		t.Fatalf("expected role in output, got: %s", output)
+	}
+	if !strings.Contains(output, "hello session") {
+		t.Fatalf("expected message text in output, got: %s", output)
+	}
+}
+
+func TestSessionMessagesCommandJSONOutput(t *testing.T) {
+	repoRoot := t.TempDir()
+	t.Chdir(repoRoot)
+
+	store, err := storage.Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open storage: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("project: %v", err)
+	}
+	sess, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("default session: %v", err)
+	}
+
+	svc := session.NewService(store)
+	if _, err := svc.AppendText(session.MessageInput{SessionID: sess.ID, Role: "user", Text: "json output test"}); err != nil {
+		t.Fatalf("append text: %v", err)
+	}
+
+	sessionMessagesLimit = 10
+	sessionMessagesJSON = true
+	t.Cleanup(func() { sessionMessagesJSON = false })
+
+	output := captureStdout(t, func() {
+		if err := runSessionMessages(nil, nil); err != nil {
+			t.Fatalf("run session messages: %v", err)
+		}
+	})
+
+	var payload []map[string]any
+	if err := json.Unmarshal([]byte(output), &payload); err != nil {
+		t.Fatalf("invalid json output: %v\noutput=%s", err, output)
+	}
+	if len(payload) == 0 {
+		t.Fatalf("expected at least one message in json output")
+	}
+	if payload[0]["role"] != "user" {
+		t.Fatalf("expected first message role=user, got: %v", payload[0]["role"])
+	}
+	parts, ok := payload[0]["parts"].([]any)
+	if !ok || len(parts) == 0 {
+		t.Fatalf("expected parts in json output, got: %#v", payload[0]["parts"])
+	}
+}
+
+func TestSessionMessagesCommandRendersStageAndCompaction(t *testing.T) {
+	repoRoot := t.TempDir()
+	t.Chdir(repoRoot)
+
+	store, err := storage.Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open storage: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("project: %v", err)
+	}
+	sess, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("default session: %v", err)
+	}
+
+	svc := session.NewService(store)
+	stagePayload, _ := json.Marshal(map[string]any{
+		"actor":     "planner",
+		"step":      "plan",
+		"message":   "Generating plan...",
+		"timestamp": "2026-03-09T00:00:00Z",
+	})
+	compactionPayload, _ := json.Marshal(map[string]any{
+		"estimated_tokens": 70000,
+		"usable_input":     56000,
+		"summary":          "Compaction summary content.",
+	})
+	if _, err := svc.AppendMessage(session.MessageInput{SessionID: sess.ID, Role: "assistant"}, []storage.SessionPart{
+		{Type: "stage", Payload: string(stagePayload)},
+		{Type: "compaction", Payload: string(compactionPayload)},
+		{Type: "stage", Payload: "{not-json"},
+	}); err != nil {
+		t.Fatalf("append stage/compaction parts: %v", err)
+	}
+
+	sessionMessagesLimit = 10
+	output := captureStdout(t, func() {
+		if err := runSessionMessages(nil, nil); err != nil {
+			t.Fatalf("run session messages: %v", err)
+		}
+	})
+
+	if !strings.Contains(output, "part=stage actor=\"planner\" step=\"plan\"") {
+		t.Fatalf("expected structured stage render, got: %s", output)
+	}
+	if !strings.Contains(output, "part=compaction estimated_tokens=70000") {
+		t.Fatalf("expected structured compaction render, got: %s", output)
+	}
+	if !strings.Contains(output, "part=stage payload=") {
+		t.Fatalf("expected malformed stage fallback render, got: %s", output)
+	}
+}

package/cmd/session_runs_test.go

@@ -0,0 +1,68 @@
+package cmd
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+	"github.com/furkanbeydemir/orch/internal/storage"
+)
+
+func TestSessionRunsJSONOutput(t *testing.T) {
+	repoRoot := t.TempDir()
+	t.Chdir(repoRoot)
+
+	store, err := storage.Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open storage: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("project: %v", err)
+	}
+	sess, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("default session: %v", err)
+	}
+
+	err = store.SaveRunState(&models.RunState{
+		ID:        "run-json-1",
+		ProjectID: projectID,
+		SessionID: sess.ID,
+		Task: models.Task{
+			ID:          "task-json-1",
+			Description: "verify runs json output",
+			CreatedAt:   time.Now(),
+		},
+		Status:    models.StatusCompleted,
+		Retries:   models.RetryState{},
+		StartedAt: time.Now(),
+	})
+	if err != nil {
+		t.Fatalf("save run state: %v", err)
+	}
+
+	sessionRunsLimit = 10
+	sessionRunsJSON = true
+	t.Cleanup(func() { sessionRunsJSON = false })
+
+	output := captureStdout(t, func() {
+		if err := runSessionRuns(nil, nil); err != nil {
+			t.Fatalf("run session runs: %v", err)
+		}
+	})
+
+	var payload []map[string]any
+	if err := json.Unmarshal([]byte(output), &payload); err != nil {
+		t.Fatalf("invalid json output: %v\noutput=%s", err, output)
+	}
+	if len(payload) == 0 {
+		t.Fatalf("expected at least one run in json output")
+	}
+	if payload[0]["id"] != "run-json-1" {
+		t.Fatalf("unexpected run id in output: %v", payload[0]["id"])
+	}
+}

package/cmd/sprint1_integration_test.go

@@ -0,0 +1,119 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+	"github.com/furkanbeydemir/orch/internal/models"
+	"github.com/furkanbeydemir/orch/internal/storage"
+)
+
+func TestRunBlockedByRepoLock(t *testing.T) {
+	repoRoot := t.TempDir()
+	t.Chdir(repoRoot)
+
+	if err := config.EnsureOrchDir(repoRoot); err != nil {
+		t.Fatalf("ensure orch dir: %v", err)
+	}
+
+	cfg := config.DefaultConfig()
+	if err := config.Save(repoRoot, cfg); err != nil {
+		t.Fatalf("save config: %v", err)
+	}
+
+	lockContent := fmt.Sprintf(`{"pid":%d,"run_id":"other-run","created_at":"%s"}`,
+		os.Getpid(), time.Now().UTC().Format(time.RFC3339Nano))
+	lockPath := filepath.Join(repoRoot, config.OrchDir, "lock")
+	if err := os.WriteFile(lockPath, []byte(lockContent), 0o644); err != nil {
+		t.Fatalf("write lock file: %v", err)
+	}
+
+	err := runRun(nil, []string{"dummy task"})
+	if err == nil {
+		t.Fatalf("expected run to be blocked by repo lock")
+	}
+	if !strings.Contains(err.Error(), "run blocked by repository lock") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestApplyRequiresDestructiveApproval(t *testing.T) {
+	repoRoot := t.TempDir()
+	t.Chdir(repoRoot)
+
+	if err := config.EnsureOrchDir(repoRoot); err != nil {
+		t.Fatalf("ensure orch dir: %v", err)
+	}
+
+	cfg := config.DefaultConfig()
+	cfg.Safety.DryRun = true
+	cfg.Safety.RequireDestructiveApproval = true
+	if err := config.Save(repoRoot, cfg); err != nil {
+		t.Fatalf("save config: %v", err)
+	}
+
+	patchContent := strings.Join([]string{
+		"diff --git a/demo.txt b/demo.txt",
+		"--- a/demo.txt",
+		"+++ b/demo.txt",
+		"@@ -1 +1 @@",
+		"-hello",
+		"+world",
+		"",
+	}, "\n")
+	store, err := storage.Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open storage: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("get project id: %v", err)
+	}
+	sess, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("ensure default session: %v", err)
+	}
+
+	err = store.SaveRunState(&models.RunState{
+		ID:        "run-test-apply",
+		ProjectID: projectID,
+		SessionID: sess.ID,
+		Task: models.Task{
+			ID:          "task-apply",
+			Description: "apply test task",
+			CreatedAt:   time.Now(),
+		},
+		Status: models.StatusCompleted,
+		Patch: &models.Patch{
+			TaskID:  "task-apply",
+			RawDiff: patchContent,
+		},
+		Retries:   models.RetryState{},
+		StartedAt: time.Now(),
+	})
+	if err != nil {
+		t.Fatalf("save run state: %v", err)
+	}
+
+	forceApply = true
+	approveDestructive = false
+	t.Cleanup(func() {
+		forceApply = false
+		approveDestructive = false
+	})
+
+	err = runApply(nil, nil)
+	if err == nil {
+		t.Fatalf("expected destructive apply to be blocked")
+	}
+	if !strings.Contains(err.Error(), "destructive apply blocked") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}

package/cmd/stats.go

@@ -0,0 +1,173 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+	"github.com/spf13/cobra"
+)
+
+var statsLimit int
+
+var statsCmd = &cobra.Command{
+	Use:   "stats",
+	Short: "Show run quality statistics",
+	Long:  `Summarizes recent runs using structured Orch artifacts such as status, review, confidence, retries, and classified test failures.`,
+	RunE:  runStats,
+}
+
+func init() {
+	rootCmd.AddCommand(statsCmd)
+	statsCmd.Flags().IntVar(&statsLimit, "limit", 50, "Maximum number of recent runs to include")
+}
+
+func runStats(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()
+
+	states, err := ctx.Store.ListRunStatesByProject(ctx.ProjectID, statsLimit)
+	if err != nil {
+		return fmt.Errorf("failed to load run states: %w", err)
+	}
+	if len(states) == 0 {
+		fmt.Println("📊 No runs found yet.")
+		fmt.Println("   Run 'orch run <task>' first.")
+		return nil
+	}
+
+	summary := summarizeRunStats(states)
+	printRunStats(summary)
+	return nil
+}
+
+type runStatsSummary struct {
+	TotalRuns             int
+	CompletedRuns         int
+	FailedRuns            int
+	InProgressRuns        int
+	AcceptedReviews       int
+	RevisedReviews        int
+	AverageConfidence     float64
+	ConfidenceRunCount    int
+	AverageRetries        float64
+	TotalRetryCount       int
+	StatusCounts          map[string]int
+	ConfidenceBandCounts  map[string]int
+	TestFailureCodeCounts map[string]int
+	LatestRunID           string
+	LatestRunStatus       string
+}
+
+func summarizeRunStats(states []*models.RunState) runStatsSummary {
+	summary := runStatsSummary{
+		TotalRuns:             len(states),
+		StatusCounts:          map[string]int{},
+		ConfidenceBandCounts:  map[string]int{},
+		TestFailureCodeCounts: map[string]int{},
+	}
+
+	var confidenceTotal float64
+	for i, state := range states {
+		if state == nil {
+			continue
+		}
+		if i == 0 {
+			summary.LatestRunID = state.ID
+			summary.LatestRunStatus = string(state.Status)
+		}
+
+		summary.StatusCounts[string(state.Status)]++
+		switch state.Status {
+		case models.StatusCompleted:
+			summary.CompletedRuns++
+		case models.StatusFailed:
+			summary.FailedRuns++
+		default:
+			summary.InProgressRuns++
+		}
+
+		if state.Review != nil {
+			switch state.Review.Decision {
+			case models.ReviewAccept:
+				summary.AcceptedReviews++
+			case models.ReviewRevise:
+				summary.RevisedReviews++
+			}
+		}
+
+		if state.Confidence != nil {
+			confidenceTotal += state.Confidence.Score
+			summary.ConfidenceRunCount++
+			if strings.TrimSpace(state.Confidence.Band) != "" {
+				summary.ConfidenceBandCounts[state.Confidence.Band]++
+			}
+		}
+
+		retries := state.Retries.Validation + state.Retries.Testing + state.Retries.Review
+		summary.TotalRetryCount += retries
+
+		for _, failure := range state.TestFailures {
+			code := strings.TrimSpace(failure.Code)
+			if code == "" {
+				code = "unknown"
+			}
+			summary.TestFailureCodeCounts[code]++
+		}
+	}
+
+	if summary.ConfidenceRunCount > 0 {
+		summary.AverageConfidence = confidenceTotal / float64(summary.ConfidenceRunCount)
+	}
+	if summary.TotalRuns > 0 {
+		summary.AverageRetries = float64(summary.TotalRetryCount) / float64(summary.TotalRuns)
+	}
+
+	return summary
+}
+
+func printRunStats(summary runStatsSummary) {
+	fmt.Println("═══════════════════════════════════════")
+	fmt.Println("📊 ORCH RUN STATS")
+	fmt.Println("═══════════════════════════════════════")
+	fmt.Printf("Runs Analyzed: %d\n", summary.TotalRuns)
+	fmt.Printf("Latest Run: %s (%s)\n", summary.LatestRunID, summary.LatestRunStatus)
+	fmt.Printf("Completed: %d\n", summary.CompletedRuns)
+	fmt.Printf("Failed: %d\n", summary.FailedRuns)
+	fmt.Printf("In Progress/Other: %d\n", summary.InProgressRuns)
+	fmt.Printf("Review Accept: %d\n", summary.AcceptedReviews)
+	fmt.Printf("Review Revise: %d\n", summary.RevisedReviews)
+	fmt.Printf("Average Retries: %.2f\n", summary.AverageRetries)
+	if summary.ConfidenceRunCount > 0 {
+		fmt.Printf("Average Confidence: %.2f across %d run(s)\n", summary.AverageConfidence, summary.ConfidenceRunCount)
+	}
+
+	printCountMap("Status Breakdown", summary.StatusCounts)
+	printCountMap("Confidence Bands", summary.ConfidenceBandCounts)
+	printCountMap("Test Failure Codes", summary.TestFailureCodeCounts)
+}
+
+func printCountMap(title string, counts map[string]int) {
+	if len(counts) == 0 {
+		return
+	}
+	fmt.Printf("\n%s\n", title)
+	keys := make([]string, 0, len(counts))
+	for key := range counts {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	for _, key := range keys {
+		fmt.Printf("  - %s: %d\n", key, counts[key])
+	}
+}

package/cmd/stats_test.go

@@ -0,0 +1,71 @@
+package cmd
+
+import (
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+func TestSummarizeRunStats(t *testing.T) {
+	now := time.Now()
+	states := []*models.RunState{
+		{
+			ID:           "run-3",
+			Task:         models.Task{ID: "task-3", Description: "latest", CreatedAt: now},
+			Status:       models.StatusFailed,
+			StartedAt:    now,
+			Review:       &models.ReviewResult{Decision: models.ReviewRevise},
+			Confidence:   &models.ConfidenceReport{Score: 0.40, Band: "very_low"},
+			Retries:      models.RetryState{Validation: 1, Testing: 1, Review: 0},
+			TestFailures: []models.TestFailure{{Code: "test_assertion_failure", Summary: "boom"}},
+		},
+		{
+			ID:         "run-2",
+			Task:       models.Task{ID: "task-2", Description: "middle", CreatedAt: now.Add(-time.Hour)},
+			Status:     models.StatusCompleted,
+			StartedAt:  now.Add(-time.Hour),
+			Review:     &models.ReviewResult{Decision: models.ReviewAccept},
+			Confidence: &models.ConfidenceReport{Score: 0.80, Band: "high"},
+			Retries:    models.RetryState{Validation: 0, Testing: 1, Review: 0},
+		},
+		{
+			ID:        "run-1",
+			Task:      models.Task{ID: "task-1", Description: "old", CreatedAt: now.Add(-2 * time.Hour)},
+			Status:    models.StatusReviewing,
+			StartedAt: now.Add(-2 * time.Hour),
+			Review:    &models.ReviewResult{Decision: models.ReviewRevise},
+			Retries:   models.RetryState{Validation: 0, Testing: 0, Review: 1},
+		},
+	}
+
+	summary := summarizeRunStats(states)
+
+	if summary.TotalRuns != 3 {
+		t.Fatalf("expected 3 runs, got %d", summary.TotalRuns)
+	}
+	if summary.LatestRunID != "run-3" {
+		t.Fatalf("expected latest run to be run-3, got %s", summary.LatestRunID)
+	}
+	if summary.CompletedRuns != 1 || summary.FailedRuns != 1 || summary.InProgressRuns != 1 {
+		t.Fatalf("unexpected status counts: %+v", summary)
+	}
+	if summary.AcceptedReviews != 1 || summary.RevisedReviews != 2 {
+		t.Fatalf("unexpected review counts: %+v", summary)
+	}
+	if summary.ConfidenceRunCount != 2 {
+		t.Fatalf("expected 2 confidence-bearing runs, got %d", summary.ConfidenceRunCount)
+	}
+	if summary.AverageConfidence < 0.599 || summary.AverageConfidence > 0.601 {
+		t.Fatalf("expected average confidence about 0.60, got %.4f", summary.AverageConfidence)
+	}
+	if summary.TotalRetryCount != 4 {
+		t.Fatalf("expected total retries 4, got %d", summary.TotalRetryCount)
+	}
+	if summary.TestFailureCodeCounts["test_assertion_failure"] != 1 {
+		t.Fatalf("expected test failure code count to be recorded")
+	}
+	if summary.ConfidenceBandCounts["high"] != 1 || summary.ConfidenceBandCounts["very_low"] != 1 {
+		t.Fatalf("unexpected confidence band counts: %+v", summary.ConfidenceBandCounts)
+	}
+}

package/cmd/version.go

@@ -0,0 +1,4 @@
+package cmd
+
+// version is overridden in release builds via GoReleaser ldflags.
+var version = "0.1.1"