orch-code 0.1.1

package/internal/review/engine.go

@@ -0,0 +1,267 @@
+package review
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+type Engine struct{}
+
+func NewEngine() *Engine {
+	return &Engine{}
+}
+
+func (e *Engine) Evaluate(state *models.RunState, providerReview *models.ReviewResult) (*models.ReviewScorecard, *models.ReviewResult) {
+	if state == nil {
+		return nil, nil
+	}
+
+	requirementCoverage, requirementFindings := scoreRequirementCoverage(state)
+	scopeControl, scopeFindings := scoreScopeControl(state)
+	regressionRisk, regressionFindings := scoreRegressionRisk(state)
+	readability, readabilityFindings := scoreReadability(state)
+	maintainability, maintainabilityFindings := scoreMaintainability(state)
+	testAdequacy, testFindings := scoreTestAdequacy(state)
+
+	findings := make([]string, 0)
+	findings = append(findings, requirementFindings...)
+	findings = append(findings, scopeFindings...)
+	findings = append(findings, regressionFindings...)
+	findings = append(findings, readabilityFindings...)
+	findings = append(findings, maintainabilityFindings...)
+	findings = append(findings, testFindings...)
+
+	decision := models.ReviewAccept
+	average := float64(requirementCoverage+scopeControl+regressionRisk+readability+maintainability+testAdequacy) / 6.0
+	if requirementCoverage < 7 || scopeControl < 7 || testAdequacy < 7 || average < 7.5 {
+		decision = models.ReviewRevise
+	}
+	if hasFailedValidation(state.ValidationResults) {
+		decision = models.ReviewRevise
+	}
+	if providerReview != nil && providerReview.Decision == models.ReviewRevise {
+		decision = models.ReviewRevise
+		findings = append(findings, providerReview.Comments...)
+	}
+
+	scorecard := &models.ReviewScorecard{
+		RequirementCoverage: requirementCoverage,
+		ScopeControl:        scopeControl,
+		RegressionRisk:      regressionRisk,
+		Readability:         readability,
+		Maintainability:     maintainability,
+		TestAdequacy:        testAdequacy,
+		Decision:            decision,
+		Findings:            uniqueNonEmpty(findings),
+	}
+
+	finalReview := &models.ReviewResult{
+		Decision:    decision,
+		Comments:    buildReviewComments(scorecard, providerReview, average),
+		Suggestions: buildReviewSuggestions(scorecard),
+	}
+	return scorecard, finalReview
+}
+
+func scoreRequirementCoverage(state *models.RunState) (int, []string) {
+	score := 5
+	findings := []string{}
+	if state.Plan == nil || len(state.Plan.AcceptanceCriteria) == 0 {
+		return 2, []string{"Structured plan acceptance criteria are missing or incomplete."}
+	}
+	score += 2
+	if state.Patch != nil && len(state.Patch.Files) > 0 {
+		score += 1
+	} else {
+		findings = append(findings, "Patch does not contain concrete file changes for the planned task.")
+	}
+	if validationPassed(state.ValidationResults, "plan_compliance") {
+		score += 2
+	} else {
+		findings = append(findings, "Patch did not clearly satisfy plan compliance expectations.")
+	}
+	return clampScore(score), findings
+}
+
+func scoreScopeControl(state *models.RunState) (int, []string) {
+	score := 5
+	findings := []string{}
+	if validationPassed(state.ValidationResults, "scope_compliance") {
+		score += 3
+	} else {
+		score = 2
+		findings = append(findings, "Scope compliance gate did not pass cleanly.")
+	}
+	if validationPassed(state.ValidationResults, "patch_hygiene") {
+		score += 2
+	} else {
+		findings = append(findings, "Patch hygiene gate indicates the diff may be too risky or malformed.")
+	}
+	return clampScore(score), findings
+}
+
+func scoreRegressionRisk(state *models.RunState) (int, []string) {
+	score := 7
+	findings := []string{}
+	if state.TaskBrief != nil && state.TaskBrief.RiskLevel == models.RiskHigh {
+		score--
+		findings = append(findings, "Task is classified as high-risk and needs extra caution.")
+	}
+	if strings.TrimSpace(state.TestResults) == "" {
+		score -= 2
+		findings = append(findings, "Test output is empty, which weakens regression confidence.")
+	}
+	if hasFailedValidation(state.ValidationResults) {
+		score -= 3
+		findings = append(findings, "One or more validation gates failed earlier in the pipeline.")
+	}
+	if state.Retries.Testing > 0 || state.Retries.Validation > 0 {
+		score--
+		findings = append(findings, "Retry activity indicates prior instability before review.")
+	}
+	return clampScore(score), findings
+}
+
+func scoreReadability(state *models.RunState) (int, []string) {
+	score := 8
+	findings := []string{}
+	if state.Patch == nil {
+		return 3, []string{"No patch is available to assess readability."}
+	}
+	if len(state.Patch.Files) > 4 {
+		score -= 2
+		findings = append(findings, "Patch touches many files, making review and readability harder.")
+	}
+	lineCount := diffLineCount(state.Patch)
+	if lineCount > 300 {
+		score -= 3
+		findings = append(findings, "Patch is large enough to reduce readability confidence.")
+	} else if lineCount > 120 {
+		score -= 1
+	}
+	return clampScore(score), findings
+}
+
+func scoreMaintainability(state *models.RunState) (int, []string) {
+	score := 8
+	findings := []string{}
+	if state.Plan == nil {
+		score = 4
+		findings = append(findings, "Structured plan is missing, so maintainability alignment is unclear.")
+	}
+	if state.ExecutionContract == nil {
+		score -= 2
+		findings = append(findings, "Execution contract is missing, reducing maintainability guarantees.")
+	}
+	if len(state.UnresolvedFailures) > 0 {
+		score -= 2
+		findings = append(findings, "There are unresolved failures recorded in the run state.")
+	}
+	return clampScore(score), findings
+}
+
+func scoreTestAdequacy(state *models.RunState) (int, []string) {
+	score := 4
+	findings := []string{}
+	if state.Plan == nil || len(state.Plan.TestRequirements) == 0 {
+		findings = append(findings, "Plan does not define explicit test requirements.")
+	}
+	if strings.TrimSpace(state.TestResults) != "" {
+		score = 8
+	} else {
+		findings = append(findings, "No concrete test output was recorded for the review step.")
+	}
+	if state.Retries.Testing > 0 {
+		score--
+		findings = append(findings, "Tests required retries before review acceptance could be considered.")
+	}
+	return clampScore(score), findings
+}
+
+func buildReviewComments(scorecard *models.ReviewScorecard, providerReview *models.ReviewResult, average float64) []string {
+	comments := []string{
+		fmt.Sprintf("Review scorecard: requirement=%d scope=%d regression=%d readability=%d maintainability=%d test=%d avg=%.1f", scorecard.RequirementCoverage, scorecard.ScopeControl, scorecard.RegressionRisk, scorecard.Readability, scorecard.Maintainability, scorecard.TestAdequacy, average),
+	}
+	if providerReview != nil {
+		comments = append(comments, providerReview.Comments...)
+	}
+	comments = append(comments, scorecard.Findings...)
+	return uniqueNonEmpty(comments)
+}
+
+func buildReviewSuggestions(scorecard *models.ReviewScorecard) []string {
+	if scorecard == nil || scorecard.Decision != models.ReviewRevise {
+		return []string{}
+	}
+	suggestions := []string{}
+	for _, finding := range scorecard.Findings {
+		suggestions = append(suggestions, "Address review finding: "+finding)
+	}
+	if len(suggestions) == 0 {
+		suggestions = append(suggestions, "Improve the patch so that all review rubric categories meet the acceptance threshold.")
+	}
+	return uniqueNonEmpty(suggestions)
+}
+
+func validationPassed(results []models.ValidationResult, name string) bool {
+	for _, result := range results {
+		if result.Name == name {
+			return result.Status == models.ValidationPass
+		}
+	}
+	return false
+}
+
+func hasFailedValidation(results []models.ValidationResult) bool {
+	for _, result := range results {
+		if result.Status == models.ValidationFail {
+			return true
+		}
+	}
+	return false
+}
+
+func diffLineCount(patch *models.Patch) int {
+	if patch == nil {
+		return 0
+	}
+	count := 0
+	for _, line := range strings.Split(patch.RawDiff, "\n") {
+		if strings.HasPrefix(line, "+") || strings.HasPrefix(line, "-") {
+			if strings.HasPrefix(line, "+++") || strings.HasPrefix(line, "---") {
+				continue
+			}
+			count++
+		}
+	}
+	return count
+}
+
+func clampScore(score int) int {
+	if score < 0 {
+		return 0
+	}
+	if score > 10 {
+		return 10
+	}
+	return score
+}
+
+func uniqueNonEmpty(values []string) []string {
+	result := make([]string, 0, len(values))
+	seen := map[string]struct{}{}
+	for _, value := range values {
+		trimmed := strings.TrimSpace(value)
+		if trimmed == "" {
+			continue
+		}
+		if _, ok := seen[trimmed]; ok {
+			continue
+		}
+		seen[trimmed] = struct{}{}
+		result = append(result, trimmed)
+	}
+	return result
+}

package/internal/review/engine_test.go

@@ -0,0 +1,103 @@
+package review
+
+import (
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+func TestEvaluateAcceptsHealthyRun(t *testing.T) {
+	engine := NewEngine()
+	state := &models.RunState{
+		Task:      models.Task{ID: "task-1", Description: "fix auth bug", CreatedAt: time.Now()},
+		TaskBrief: &models.TaskBrief{TaskID: "task-1", TaskType: models.TaskTypeBugfix, RiskLevel: models.RiskMedium},
+		Plan: &models.Plan{
+			TaskID:             "task-1",
+			AcceptanceCriteria: []models.AcceptanceCriterion{{ID: "ac-1", Description: "Bug no longer occurs."}},
+			TestRequirements:   []string{"Run go test ./..."},
+		},
+		ExecutionContract: &models.ExecutionContract{AllowedFiles: []string{"internal/auth/service.go"}},
+		Patch: &models.Patch{
+			RawDiff: "diff --git a/internal/auth/service.go b/internal/auth/service.go\n--- a/internal/auth/service.go\n+++ b/internal/auth/service.go\n@@ -1 +1 @@\n-old\n+new\n",
+			Files:   []models.PatchFile{{Path: "internal/auth/service.go"}},
+		},
+		ValidationResults: []models.ValidationResult{
+			{Name: "patch_hygiene", Status: models.ValidationPass},
+			{Name: "scope_compliance", Status: models.ValidationPass},
+			{Name: "plan_compliance", Status: models.ValidationPass},
+		},
+		TestResults: "ok   github.com/example/project/auth 0.100s",
+	}
+
+	scorecard, review := engine.Evaluate(state, nil)
+	if scorecard == nil || review == nil {
+		t.Fatalf("expected scorecard and review")
+	}
+	if scorecard.Decision != models.ReviewAccept {
+		t.Fatalf("expected accept decision, got %s", scorecard.Decision)
+	}
+	if review.Decision != models.ReviewAccept {
+		t.Fatalf("expected accept review, got %s", review.Decision)
+	}
+}
+
+func TestEvaluateRevisesWhenScopeFails(t *testing.T) {
+	engine := NewEngine()
+	state := &models.RunState{
+		Task:      models.Task{ID: "task-2", Description: "feature task", CreatedAt: time.Now()},
+		TaskBrief: &models.TaskBrief{TaskID: "task-2", TaskType: models.TaskTypeFeature, RiskLevel: models.RiskMedium},
+		Plan: &models.Plan{
+			TaskID:             "task-2",
+			AcceptanceCriteria: []models.AcceptanceCriterion{{ID: "ac-1", Description: "Feature works."}},
+			TestRequirements:   []string{"Run tests"},
+		},
+		Patch: &models.Patch{Files: []models.PatchFile{{Path: "internal/feature/service.go"}}},
+		ValidationResults: []models.ValidationResult{
+			{Name: "scope_compliance", Status: models.ValidationFail, Summary: "out of scope"},
+			{Name: "plan_compliance", Status: models.ValidationFail, Summary: "missing required file"},
+		},
+		TestResults: "ok",
+	}
+
+	scorecard, review := engine.Evaluate(state, nil)
+	if scorecard.Decision != models.ReviewRevise {
+		t.Fatalf("expected revise scorecard decision, got %s", scorecard.Decision)
+	}
+	if review.Decision != models.ReviewRevise {
+		t.Fatalf("expected revise review decision, got %s", review.Decision)
+	}
+	if len(scorecard.Findings) == 0 {
+		t.Fatalf("expected findings for revise decision")
+	}
+}
+
+func TestEvaluateRespectsProviderReviseSignal(t *testing.T) {
+	engine := NewEngine()
+	state := &models.RunState{
+		Task:      models.Task{ID: "task-3", Description: "review provider", CreatedAt: time.Now()},
+		TaskBrief: &models.TaskBrief{TaskID: "task-3", TaskType: models.TaskTypeFeature, RiskLevel: models.RiskLow},
+		Plan: &models.Plan{
+			TaskID:             "task-3",
+			AcceptanceCriteria: []models.AcceptanceCriterion{{ID: "ac-1", Description: "Feature works."}},
+			TestRequirements:   []string{"Run tests"},
+		},
+		ExecutionContract: &models.ExecutionContract{AllowedFiles: []string{"internal/feature/service.go"}},
+		Patch:             &models.Patch{Files: []models.PatchFile{{Path: "internal/feature/service.go"}}},
+		ValidationResults: []models.ValidationResult{
+			{Name: "patch_hygiene", Status: models.ValidationPass},
+			{Name: "scope_compliance", Status: models.ValidationPass},
+			{Name: "plan_compliance", Status: models.ValidationPass},
+		},
+		TestResults: "ok",
+	}
+
+	providerReview := &models.ReviewResult{Decision: models.ReviewRevise, Comments: []string{"revise: missing edge case"}}
+	scorecard, review := engine.Evaluate(state, providerReview)
+	if scorecard.Decision != models.ReviewRevise {
+		t.Fatalf("expected provider revise to force revise")
+	}
+	if review.Decision != models.ReviewRevise {
+		t.Fatalf("expected final review revise")
+	}
+}

package/internal/runstore/store.go

@@ -0,0 +1,137 @@
+package runstore
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+const (
+	latestRunFile = "latest-run-id"
+	latestPatch   = "latest.patch"
+)
+
+func SaveRunState(repoRoot string, state *models.RunState) error {
+	if state == nil {
+		return fmt.Errorf("run state cannot be nil")
+	}
+
+	if err := config.EnsureOrchDir(repoRoot); err != nil {
+		return err
+	}
+
+	data, err := json.MarshalIndent(state, "", "  ")
+	if err != nil {
+		return fmt.Errorf("marshal run state: %w", err)
+	}
+
+	runsDir := filepath.Join(repoRoot, config.OrchDir, config.RunsDir)
+	statePath := filepath.Join(runsDir, state.ID+".state")
+	if err := os.WriteFile(statePath, data, 0o644); err != nil {
+		return fmt.Errorf("write run state: %w", err)
+	}
+
+	latestRunPath := filepath.Join(repoRoot, config.OrchDir, latestRunFile)
+	if err := os.WriteFile(latestRunPath, []byte(state.ID), 0o644); err != nil {
+		return fmt.Errorf("write latest run id: %w", err)
+	}
+
+	patchPath := filepath.Join(repoRoot, config.OrchDir, latestPatch)
+	if state.Patch != nil && strings.TrimSpace(state.Patch.RawDiff) != "" {
+		if err := os.WriteFile(patchPath, []byte(state.Patch.RawDiff), 0o644); err != nil {
+			return fmt.Errorf("write latest patch: %w", err)
+		}
+	} else {
+		if err := os.Remove(patchPath); err != nil && !os.IsNotExist(err) {
+			return fmt.Errorf("remove stale latest patch: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func LoadLatestRunState(repoRoot string) (*models.RunState, error) {
+	latestRunPath := filepath.Join(repoRoot, config.OrchDir, latestRunFile)
+	runIDBytes, err := os.ReadFile(latestRunPath)
+	if err != nil {
+		return nil, fmt.Errorf("read latest run id: %w", err)
+	}
+
+	runID := strings.TrimSpace(string(runIDBytes))
+	if runID == "" {
+		return nil, fmt.Errorf("latest run id is empty")
+	}
+
+	return LoadRunState(repoRoot, runID)
+}
+
+func LoadRunState(repoRoot, runID string) (*models.RunState, error) {
+	runID = strings.TrimSpace(runID)
+	if runID == "" {
+		return nil, fmt.Errorf("run id is required")
+	}
+
+	statePath := filepath.Join(repoRoot, config.OrchDir, config.RunsDir, runID+".state")
+	data, err := os.ReadFile(statePath)
+	if err != nil {
+		return nil, fmt.Errorf("read run state: %w", err)
+	}
+
+	var state models.RunState
+	if err := json.Unmarshal(data, &state); err != nil {
+		return nil, fmt.Errorf("unmarshal run state: %w", err)
+	}
+
+	return &state, nil
+}
+
+func ListRunStates(repoRoot string, limit int) ([]*models.RunState, error) {
+	if err := config.EnsureOrchDir(repoRoot); err != nil {
+		return nil, err
+	}
+
+	runsDir := filepath.Join(repoRoot, config.OrchDir, config.RunsDir)
+	entries, err := os.ReadDir(runsDir)
+	if err != nil {
+		return nil, fmt.Errorf("read runs dir: %w", err)
+	}
+
+	states := make([]*models.RunState, 0, len(entries))
+	for _, entry := range entries {
+		if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".state") {
+			continue
+		}
+		runID := strings.TrimSuffix(entry.Name(), ".state")
+		state, err := LoadRunState(repoRoot, runID)
+		if err != nil {
+			return nil, fmt.Errorf("load run %s: %w", runID, err)
+		}
+		states = append(states, state)
+	}
+
+	sort.SliceStable(states, func(i, j int) bool {
+		return states[i].StartedAt.After(states[j].StartedAt)
+	})
+
+	if limit > 0 && len(states) > limit {
+		states = states[:limit]
+	}
+
+	return states, nil
+}
+
+func LoadLatestPatch(repoRoot string) (string, error) {
+	patchPath := filepath.Join(repoRoot, config.OrchDir, latestPatch)
+	data, err := os.ReadFile(patchPath)
+	if err != nil {
+		return "", fmt.Errorf("read latest patch: %w", err)
+	}
+
+	return string(data), nil
+}

package/internal/runstore/store_test.go

@@ -0,0 +1,59 @@
+package runstore
+
+import (
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+func TestListRunStatesSortedAndLimited(t *testing.T) {
+	repoRoot := t.TempDir()
+	now := time.Now().UTC()
+
+	states := []*models.RunState{
+		{ID: "run-older", Task: models.Task{ID: "task-1", Description: "older", CreatedAt: now}, Status: models.StatusCompleted, StartedAt: now.Add(-2 * time.Hour)},
+		{ID: "run-newer", Task: models.Task{ID: "task-2", Description: "newer", CreatedAt: now}, Status: models.StatusFailed, StartedAt: now.Add(-1 * time.Hour)},
+	}
+	for _, state := range states {
+		if err := SaveRunState(repoRoot, state); err != nil {
+			t.Fatalf("save run state %s: %v", state.ID, err)
+		}
+	}
+
+	loaded, err := ListRunStates(repoRoot, 1)
+	if err != nil {
+		t.Fatalf("list run states: %v", err)
+	}
+	if len(loaded) != 1 {
+		t.Fatalf("expected 1 run, got %d", len(loaded))
+	}
+	if loaded[0].ID != "run-newer" {
+		t.Fatalf("expected newest run first, got %s", loaded[0].ID)
+	}
+}
+
+func TestLoadRunState(t *testing.T) {
+	repoRoot := t.TempDir()
+	state := &models.RunState{
+		ID:         "run-1",
+		Task:       models.Task{ID: "task-1", Description: "demo", CreatedAt: time.Now()},
+		Status:     models.StatusCompleted,
+		StartedAt:  time.Now(),
+		Confidence: &models.ConfidenceReport{Score: 0.88, Band: "high"},
+	}
+	if err := SaveRunState(repoRoot, state); err != nil {
+		t.Fatalf("save run state: %v", err)
+	}
+
+	loaded, err := LoadRunState(repoRoot, state.ID)
+	if err != nil {
+		t.Fatalf("load run state: %v", err)
+	}
+	if loaded.ID != state.ID {
+		t.Fatalf("unexpected run id: got=%s want=%s", loaded.ID, state.ID)
+	}
+	if loaded.Confidence == nil || loaded.Confidence.Band != "high" {
+		t.Fatalf("expected confidence report to roundtrip")
+	}
+}