orch-code 0.1.1

package/internal/orchestrator/orchestrator_retry_test.go

@@ -0,0 +1,135 @@
+package orchestrator
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/agents"
+	"github.com/furkanbeydemir/orch/internal/config"
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+type agentStub struct {
+	name    string
+	execute func(input *agents.Input) (*agents.Output, error)
+}
+
+func (a agentStub) Name() string { return a.name }
+
+func (a agentStub) Execute(input *agents.Input) (*agents.Output, error) {
+	return a.execute(input)
+}
+
+func TestRunEnforcesTestRetryLimit(t *testing.T) {
+	repoRoot := t.TempDir()
+
+	cfg := config.DefaultConfig()
+	cfg.Commands.Test = "false"
+	cfg.Safety.FeatureFlags.RetryLimits = true
+	cfg.Safety.Retry.TestMax = 2
+
+	orch := New(cfg, repoRoot, false)
+	orch.planner = agentStub{name: "planner", execute: func(input *agents.Input) (*agents.Output, error) {
+		return &agents.Output{Plan: &models.Plan{
+			TaskID:             input.Task.ID,
+			Summary:            "retry test plan",
+			TaskType:           models.TaskTypeBugfix,
+			RiskLevel:          models.RiskMedium,
+			FilesToModify:      []string{"demo.go"},
+			FilesToInspect:     []string{"demo.go"},
+			AcceptanceCriteria: []models.AcceptanceCriterion{{ID: "ac-1", Description: "Patch updates demo.go."}},
+			TestRequirements:   []string{"Run configured test command."},
+			Steps:              []models.PlanStep{{Order: 1, Description: "Modify demo.go."}},
+		}}, nil
+	}}
+	orch.coder = agentStub{name: "coder", execute: func(input *agents.Input) (*agents.Output, error) {
+		return &agents.Output{Patch: &models.Patch{TaskID: input.Task.ID, RawDiff: "diff --git a/demo.go b/demo.go\n--- a/demo.go\n+++ b/demo.go\n@@ -1 +1 @@\n-old\n+new\n"}}, nil
+	}}
+	task := &models.Task{ID: "task-1", Description: "retry test", CreatedAt: time.Now()}
+
+	state, err := orch.Run(task)
+	if err == nil {
+		t.Fatalf("expected run to fail when test command always fails")
+	}
+	if state == nil {
+		t.Fatalf("expected run state")
+	}
+
+	if state.Retries.Testing != 2 {
+		t.Fatalf("unexpected testing retries. got=%d want=%d", state.Retries.Testing, 2)
+	}
+
+	if len(state.UnresolvedFailures) == 0 {
+		t.Fatalf("expected unresolved failure summary to be recorded")
+	}
+}
+
+func TestRunLogsToolPolicyDecisions(t *testing.T) {
+	repoRoot := t.TempDir()
+
+	cfg := config.DefaultConfig()
+	cfg.Commands.Test = "printf ok"
+
+	orch := New(cfg, repoRoot, false)
+	orch.planner = agentStub{name: "planner", execute: func(input *agents.Input) (*agents.Output, error) {
+		return &agents.Output{Plan: &models.Plan{
+			TaskID:             input.Task.ID,
+			Summary:            "policy log test plan",
+			TaskType:           models.TaskTypeBugfix,
+			RiskLevel:          models.RiskMedium,
+			FilesToModify:      []string{"demo.go"},
+			FilesToInspect:     []string{"demo.go"},
+			AcceptanceCriteria: []models.AcceptanceCriterion{{ID: "ac-1", Description: "Patch updates demo.go."}},
+			TestRequirements:   []string{"Run configured test command."},
+			Steps:              []models.PlanStep{{Order: 1, Description: "Modify demo.go."}},
+		}}, nil
+	}}
+	orch.coder = agentStub{name: "coder", execute: func(input *agents.Input) (*agents.Output, error) {
+		return &agents.Output{Patch: &models.Patch{TaskID: input.Task.ID, RawDiff: "diff --git a/demo.go b/demo.go\n--- a/demo.go\n+++ b/demo.go\n@@ -1 +1 @@\n-old\n+new\n"}}, nil
+	}}
+	task := &models.Task{ID: "task-2", Description: "policy log test", CreatedAt: time.Now()}
+
+	state, err := orch.Run(task)
+	if err != nil {
+		t.Fatalf("expected run to complete: %v", err)
+	}
+
+	found := false
+	for _, entry := range state.Logs {
+		if entry.Actor == "policy" && entry.Step == "decision" && strings.Contains(entry.Message, "tool=run_tests") {
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		t.Fatalf("expected policy decision log for run_tests tool")
+	}
+
+	if state.Context == nil {
+		t.Fatalf("expected context to be built and attached to run state")
+	}
+	if state.TaskBrief == nil {
+		t.Fatalf("expected task brief to be attached to run state")
+	}
+	if state.Plan == nil || len(state.Plan.AcceptanceCriteria) == 0 {
+		t.Fatalf("expected structured plan acceptance criteria to be attached to run state")
+	}
+	if state.ExecutionContract == nil || len(state.ExecutionContract.AllowedFiles) == 0 {
+		t.Fatalf("expected execution contract to be attached to run state")
+	}
+	if len(state.ValidationResults) == 0 {
+		t.Fatalf("expected validation results to be attached to run state")
+	}
+	foundPlanCompliance := false
+	for _, result := range state.ValidationResults {
+		if result.Name == "plan_compliance" {
+			foundPlanCompliance = true
+			break
+		}
+	}
+	if !foundPlanCompliance {
+		t.Fatalf("expected plan_compliance validation result")
+	}
+}

package/internal/orchestrator/review_engine_test.go

@@ -0,0 +1,50 @@
+package orchestrator
+
+import (
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/agents"
+	"github.com/furkanbeydemir/orch/internal/config"
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+func TestRunAttachesReviewScorecard(t *testing.T) {
+	repoRoot := t.TempDir()
+
+	cfg := config.DefaultConfig()
+	cfg.Commands.Test = "printf ok"
+
+	orch := New(cfg, repoRoot, false)
+	orch.planner = agentStub{name: "planner", execute: func(input *agents.Input) (*agents.Output, error) {
+		return &agents.Output{Plan: &models.Plan{
+			TaskID:             input.Task.ID,
+			Summary:            "health endpoint plan",
+			TaskType:           models.TaskTypeFeature,
+			RiskLevel:          models.RiskMedium,
+			FilesToModify:      []string{"health.go"},
+			FilesToInspect:     []string{"health.go"},
+			AcceptanceCriteria: []models.AcceptanceCriterion{{ID: "ac-1", Description: "Health endpoint is implemented."}},
+			TestRequirements:   []string{"Run configured test command."},
+			Steps:              []models.PlanStep{{Order: 1, Description: "Modify health.go."}},
+		}}, nil
+	}}
+	orch.coder = agentStub{name: "coder", execute: func(input *agents.Input) (*agents.Output, error) {
+		return &agents.Output{Patch: &models.Patch{TaskID: input.Task.ID, RawDiff: "diff --git a/health.go b/health.go\n--- a/health.go\n+++ b/health.go\n@@ -1 +1 @@\n-old\n+new\n"}}, nil
+	}}
+	task := &models.Task{ID: "task-review-1", Description: "add health endpoint", CreatedAt: time.Now()}
+
+	state, err := orch.Run(task)
+	if err != nil {
+		t.Fatalf("expected run to complete: %v", err)
+	}
+	if state.ReviewScorecard == nil {
+		t.Fatalf("expected review scorecard to be attached to run state")
+	}
+	if state.Review == nil {
+		t.Fatalf("expected final review result")
+	}
+	if state.Confidence == nil {
+		t.Fatalf("expected confidence report to be attached to run state")
+	}
+}

package/internal/orchestrator/state.go

@@ -0,0 +1,42 @@
+// Run state machine:
+//
+//	Created → Analyzing → Planning → Coding → Validating → Testing → Reviewing → Completed
+package orchestrator
+
+import (
+	"fmt"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+var validTransitions = map[models.RunStatus][]models.RunStatus{
+	models.StatusCreated:    {models.StatusAnalyzing, models.StatusFailed},
+	models.StatusAnalyzing:  {models.StatusPlanning, models.StatusFailed},
+	models.StatusPlanning:   {models.StatusCoding, models.StatusFailed},
+	models.StatusCoding:     {models.StatusValidating, models.StatusFailed},
+	models.StatusValidating: {models.StatusTesting, models.StatusCoding, models.StatusFailed},
+	models.StatusTesting:    {models.StatusReviewing, models.StatusCoding, models.StatusFailed},
+	models.StatusReviewing:  {models.StatusCompleted, models.StatusCoding, models.StatusFailed},
+	models.StatusCompleted:  {},
+	models.StatusFailed:     {},
+}
+
+func Transition(state *models.RunState, target models.RunStatus) error {
+	allowed, ok := validTransitions[state.Status]
+	if !ok {
+		return fmt.Errorf("unknown state: %s", state.Status)
+	}
+
+	for _, valid := range allowed {
+		if valid == target {
+			state.Status = target
+			return nil
+		}
+	}
+
+	return fmt.Errorf("invalid state transition: %s → %s", state.Status, target)
+}
+
+func IsTerminal(status models.RunStatus) bool {
+	return status == models.StatusCompleted || status == models.StatusFailed
+}

package/internal/orchestrator/test_classifier_test.go

@@ -0,0 +1,68 @@
+package orchestrator
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/agents"
+	"github.com/furkanbeydemir/orch/internal/config"
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+func TestRunClassifiesTestFailure(t *testing.T) {
+	repoRoot := t.TempDir()
+
+	scriptPath := filepath.Join(repoRoot, "testfail.sh")
+	if err := os.WriteFile(scriptPath, []byte("#!/bin/sh\necho '--- FAIL: TestAuth' >&2\necho 'expected 200 got 500' >&2\nexit 1\n"), 0o755); err != nil {
+		t.Fatalf("write test script: %v", err)
+	}
+
+	cfg := config.DefaultConfig()
+	cfg.Commands.Test = "sh testfail.sh"
+	cfg.Safety.FeatureFlags.RetryLimits = false
+
+	orch := New(cfg, repoRoot, false)
+	orch.planner = agentStub{name: "planner", execute: func(input *agents.Input) (*agents.Output, error) {
+		return &agents.Output{Plan: &models.Plan{
+			TaskID:             input.Task.ID,
+			Summary:            "classify test failure plan",
+			TaskType:           models.TaskTypeBugfix,
+			RiskLevel:          models.RiskMedium,
+			FilesToModify:      []string{"demo.go"},
+			FilesToInspect:     []string{"demo.go"},
+			AcceptanceCriteria: []models.AcceptanceCriterion{{ID: "ac-1", Description: "Patch updates demo.go."}},
+			TestRequirements:   []string{"Run configured test command."},
+			Steps:              []models.PlanStep{{Order: 1, Description: "Modify demo.go."}},
+		}}, nil
+	}}
+	orch.coder = agentStub{name: "coder", execute: func(input *agents.Input) (*agents.Output, error) {
+		return &agents.Output{Patch: &models.Patch{TaskID: input.Task.ID, RawDiff: "diff --git a/demo.go b/demo.go\n--- a/demo.go\n+++ b/demo.go\n@@ -1 +1 @@\n-old\n+new\n"}}, nil
+	}}
+
+	state, err := orch.Run(&models.Task{ID: "task-test-classifier", Description: "classify failing tests", CreatedAt: time.Now()})
+	if err == nil {
+		t.Fatalf("expected run to fail on test command")
+	}
+	if state == nil {
+		t.Fatalf("expected run state")
+	}
+	if len(state.TestFailures) == 0 {
+		t.Fatalf("expected classified test failures")
+	}
+	if state.TestFailures[0].Code != "test_assertion_failure" {
+		t.Fatalf("unexpected test failure code: %s", state.TestFailures[0].Code)
+	}
+	found := false
+	for _, result := range state.ValidationResults {
+		if result.Name == "required_tests_passed" && result.Status == models.ValidationFail && strings.Contains(result.Summary, "test_assertion_failure") {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("expected test gate failure to be recorded")
+	}
+}

package/internal/patch/applier.go

@@ -0,0 +1,131 @@
+// Package patch contains patch application implementation.
+package patch
+
+import (
+	"fmt"
+	"os/exec"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+type Applier struct{}
+
+type ConflictError struct {
+	Files            []string
+	Reason           string
+	BestPatchSummary string
+}
+
+func (e *ConflictError) Error() string {
+	if len(e.Files) == 0 {
+		return fmt.Sprintf("patch conflict: %s", e.Reason)
+	}
+	return fmt.Sprintf("patch conflict in %s: %s", strings.Join(e.Files, ", "), e.Reason)
+}
+
+type InvalidPatchError struct {
+	Reason           string
+	BestPatchSummary string
+}
+
+func (e *InvalidPatchError) Error() string {
+	return fmt.Sprintf("invalid patch: %s", e.Reason)
+}
+
+func NewApplier() *Applier {
+	return &Applier{}
+}
+
+// Apply applies patch content to the target repository.
+func (a *Applier) Apply(p *models.Patch, repoRoot string, dryRun bool) error {
+	if p == nil || strings.TrimSpace(p.RawDiff) == "" {
+		return fmt.Errorf("no patch to apply")
+	}
+
+	args := []string{"apply"}
+
+	if dryRun {
+		args = append(args, "--check")
+	}
+
+	// Stdin'den patch oku
+	args = append(args, "-")
+
+	cmd := exec.Command("git", args...)
+	cmd.Dir = repoRoot
+	cmd.Stdin = strings.NewReader(p.RawDiff)
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		summary := Summarize(p)
+		files := parseConflictFiles(string(output))
+		if len(files) > 0 {
+			return &ConflictError{
+				Files:            files,
+				Reason:           strings.TrimSpace(string(output)),
+				BestPatchSummary: summary,
+			}
+		}
+
+		if isInvalidPatchOutput(string(output)) {
+			return &InvalidPatchError{
+				Reason:           strings.TrimSpace(string(output)),
+				BestPatchSummary: summary,
+			}
+		}
+
+		mode := "apply"
+		if dryRun {
+			mode = "dry-run check"
+		}
+		return fmt.Errorf("patch %s failed: %s\n%s", mode, err.Error(), string(output))
+	}
+
+	return nil
+}
+
+func (a *Applier) DryRun(p *models.Patch, repoRoot string) error {
+	return a.Apply(p, repoRoot, true)
+}
+
+var (
+	patchFailedPattern    = regexp.MustCompile(`patch failed:\s+([^:]+):`)                 //nolint:gochecknoglobals
+	patchDoesNotApplyExpr = regexp.MustCompile(`error:\s+([^:]+):\s+patch does not apply`) //nolint:gochecknoglobals
+)
+
+func parseConflictFiles(output string) []string {
+	unique := map[string]struct{}{}
+
+	for _, match := range patchFailedPattern.FindAllStringSubmatch(output, -1) {
+		if len(match) > 1 {
+			unique[strings.TrimSpace(match[1])] = struct{}{}
+		}
+	}
+
+	for _, match := range patchDoesNotApplyExpr.FindAllStringSubmatch(output, -1) {
+		if len(match) > 1 {
+			unique[strings.TrimSpace(match[1])] = struct{}{}
+		}
+	}
+
+	if len(unique) == 0 {
+		return nil
+	}
+
+	files := make([]string, 0, len(unique))
+	for file := range unique {
+		files = append(files, file)
+	}
+	sort.Strings(files)
+	return files
+}
+
+func isInvalidPatchOutput(output string) bool {
+	lower := strings.ToLower(output)
+	return strings.Contains(lower, "no valid patches in input") ||
+		strings.Contains(lower, "corrupt patch") ||
+		strings.Contains(lower, "malformed patch")
+}

package/internal/patch/applier_test.go

@@ -0,0 +1,25 @@
+package patch
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestParseConflictFiles(t *testing.T) {
+	output := "error: patch failed: internal/orchestrator/orchestrator.go:10\nerror: internal/patch/patch.go: patch does not apply\n"
+
+	files := parseConflictFiles(output)
+	expected := []string{"internal/orchestrator/orchestrator.go", "internal/patch/patch.go"}
+	if !reflect.DeepEqual(files, expected) {
+		t.Fatalf("unexpected files. got=%v want=%v", files, expected)
+	}
+}
+
+func TestParserRejectsInvalidUnifiedDiff(t *testing.T) {
+	parser := NewParser()
+
+	_, err := parser.Parse("this is not a diff")
+	if err == nil {
+		t.Fatalf("expected parser to reject invalid unified diff")
+	}
+}

package/internal/patch/parser.go

@@ -0,0 +1,89 @@
+// Package patch contains unified diff parser implementation.
+//
+// Supported format:
+//
+//	diff --git a/file b/file
+//	--- a/file
+//	+++ b/file
+//	@@ -start,count +start,count @@
+//	...
+package patch
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+type Parser struct{}
+
+func NewParser() *Parser {
+	return &Parser{}
+}
+
+func (p *Parser) Parse(rawDiff string) (*models.Patch, error) {
+	patch := &models.Patch{
+		RawDiff: rawDiff,
+		Files:   make([]models.PatchFile, 0),
+	}
+
+	if strings.TrimSpace(rawDiff) == "" {
+		return patch, nil
+	}
+
+	lines := strings.Split(rawDiff, "\n")
+	hasDiffHeader := false
+	var currentFile *models.PatchFile
+	var currentDiff strings.Builder
+
+	for _, line := range lines {
+		if strings.HasPrefix(line, "diff --git") {
+			hasDiffHeader = true
+			if currentFile != nil {
+				currentFile.Diff = currentDiff.String()
+				patch.Files = append(patch.Files, *currentFile)
+			}
+
+			// Parse new file metadata
+			path := parseDiffHeader(line)
+			currentFile = &models.PatchFile{
+				Path:   path,
+				Status: "modified",
+			}
+			currentDiff.Reset()
+		}
+
+		if currentFile != nil {
+			currentDiff.WriteString(line)
+			currentDiff.WriteString("\n")
+
+			// Determine file status
+			if strings.HasPrefix(line, "new file") {
+				currentFile.Status = "added"
+			} else if strings.HasPrefix(line, "deleted file") {
+				currentFile.Status = "deleted"
+			}
+		}
+	}
+
+	if currentFile != nil {
+		currentFile.Diff = currentDiff.String()
+		patch.Files = append(patch.Files, *currentFile)
+	}
+
+	if !hasDiffHeader {
+		return nil, fmt.Errorf("invalid unified diff: missing 'diff --git' header")
+	}
+
+	return patch, nil
+}
+
+func parseDiffHeader(line string) string {
+	// Format: diff --git a/path b/path
+	parts := strings.Split(line, " ")
+	if len(parts) >= 4 {
+		return strings.TrimPrefix(parts[3], "b/")
+	}
+	return ""
+}

package/internal/patch/patch.go

@@ -0,0 +1,60 @@
+// 2. Parse - unified diff format parse
+// 5. Apply - apply to working tree
+//
+// - Patch size limits are enforced
+package patch
+
+import (
+	"fmt"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+type Pipeline struct {
+	maxFiles  int
+	maxLines  int
+	validator *Validator
+	parser    *Parser
+	applier   *Applier
+}
+
+func NewPipeline(maxFiles, maxLines int) *Pipeline {
+	return &Pipeline{
+		maxFiles:  maxFiles,
+		maxLines:  maxLines,
+		validator: NewValidator(maxFiles, maxLines),
+		parser:    NewParser(),
+		applier:   NewApplier(),
+	}
+}
+
+func (p *Pipeline) Process(rawDiff string) (*models.Patch, error) {
+	// 1. Parse
+	patchResult, err := p.parser.Parse(rawDiff)
+	if err != nil {
+		return nil, fmt.Errorf("patch parse error: %w", err)
+	}
+
+	// 2. Validate
+	if err := p.validator.Validate(patchResult); err != nil {
+		return nil, fmt.Errorf("patch validation error: %w", err)
+	}
+
+	return patchResult, nil
+}
+
+func (p *Pipeline) Validate(patch *models.Patch) error {
+	return p.validator.Validate(patch)
+}
+
+func (p *Pipeline) Preview(patch *models.Patch) string {
+	if patch == nil || patch.RawDiff == "" {
+		return "No changes to display."
+	}
+	return patch.RawDiff
+}
+
+// Apply applies patch content to the working tree.
+func (p *Pipeline) Apply(patch *models.Patch, repoRoot string, dryRun bool) error {
+	return p.applier.Apply(patch, repoRoot, dryRun)
+}

package/internal/patch/summary.go

@@ -0,0 +1,30 @@
+package patch
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+func Summarize(p *models.Patch) string {
+	if p == nil || strings.TrimSpace(p.RawDiff) == "" {
+		return "no patch available"
+	}
+
+	added := 0
+	removed := 0
+	for _, line := range strings.Split(p.RawDiff, "\n") {
+		if strings.HasPrefix(line, "+++") || strings.HasPrefix(line, "---") {
+			continue
+		}
+		if strings.HasPrefix(line, "+") {
+			added++
+		}
+		if strings.HasPrefix(line, "-") {
+			removed++
+		}
+	}
+
+	return fmt.Sprintf("files=%d added=%d removed=%d", len(p.Files), added, removed)
+}