orch-code 0.1.1

package/internal/storage/storage_test.go

@@ -0,0 +1,413 @@
+package storage
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+func TestProjectAndDefaultSessionBootstrap(t *testing.T) {
+	repoRoot := t.TempDir()
+
+	store, err := Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("get or create project: %v", err)
+	}
+
+	session, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("ensure default session: %v", err)
+	}
+	if session.Name != "default" {
+		t.Fatalf("unexpected default session name: %s", session.Name)
+	}
+
+	active, err := store.GetActiveSession(projectID)
+	if err != nil {
+		t.Fatalf("get active session: %v", err)
+	}
+	if active.ID != session.ID {
+		t.Fatalf("active session mismatch: got=%s want=%s", active.ID, session.ID)
+	}
+}
+
+func TestSessionLifecycle(t *testing.T) {
+	repoRoot := t.TempDir()
+
+	store, err := Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("get or create project: %v", err)
+	}
+
+	_, err = store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("ensure default session: %v", err)
+	}
+
+	feature, err := store.CreateSession(projectID, "feature-x")
+	if err != nil {
+		t.Fatalf("create session: %v", err)
+	}
+
+	selected, err := store.SelectSession(projectID, "feature-x")
+	if err != nil {
+		t.Fatalf("select session: %v", err)
+	}
+	if selected.ID != feature.ID {
+		t.Fatalf("selected session mismatch: got=%s want=%s", selected.ID, feature.ID)
+	}
+
+	if err := store.CloseSession(projectID, "feature-x"); err != nil {
+		t.Fatalf("close session: %v", err)
+	}
+
+	_, err = store.SelectSession(projectID, "feature-x")
+	if !errors.Is(err, ErrSessionClosed) {
+		t.Fatalf("expected closed session error, got: %v", err)
+	}
+}
+
+func TestSaveRunState(t *testing.T) {
+	repoRoot := t.TempDir()
+
+	store, err := Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("get or create project: %v", err)
+	}
+	session, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("ensure default session: %v", err)
+	}
+
+	state := &models.RunState{
+		ID:        "run-test-1",
+		ProjectID: projectID,
+		SessionID: session.ID,
+		Task: models.Task{
+			ID:          "task-1",
+			Description: "save run state",
+			CreatedAt:   time.Now(),
+		},
+		TaskBrief: &models.TaskBrief{
+			TaskID:         "task-1",
+			UserRequest:    "save run state",
+			NormalizedGoal: "Address task: save run state",
+			TaskType:       models.TaskTypeChore,
+			RiskLevel:      models.RiskLow,
+		},
+		Plan: &models.Plan{
+			TaskID:    "task-1",
+			Summary:   "Address task: save run state",
+			TaskType:  models.TaskTypeChore,
+			RiskLevel: models.RiskLow,
+			Steps:     []models.PlanStep{{Order: 1, Description: "Persist the run state."}},
+		},
+		ExecutionContract: &models.ExecutionContract{
+			TaskID:       "task-1",
+			AllowedFiles: []string{"internal/storage/storage.go"},
+			PatchBudget:  models.PatchBudget{MaxFiles: 1, MaxChangedLines: 20},
+		},
+		Patch: &models.Patch{
+			TaskID: "task-1",
+			Files: []models.PatchFile{{
+				Path:   "README.md",
+				Status: "modified",
+				Diff:   "@@ -1 +1 @@\n-old\n+new\n",
+			}},
+			RawDiff: "diff --git a/README.md b/README.md\nindex 1111111..2222222 100644\n--- a/README.md\n+++ b/README.md\n@@ -1 +1 @@\n-old\n+new\n",
+		},
+		ValidationResults: []models.ValidationResult{{
+			Name:     "task_brief_valid",
+			Stage:    "planning",
+			Status:   models.ValidationPass,
+			Severity: models.SeverityLow,
+			Summary:  "task brief persisted",
+		}},
+		RetryDirective: &models.RetryDirective{
+			Stage:        "validation",
+			Attempt:      1,
+			FailedGates:  []string{"plan_compliance"},
+			Instructions: []string{"Update the required file."},
+		},
+		Confidence: &models.ConfidenceReport{
+			Score:   0.74,
+			Band:    "medium",
+			Reasons: []string{"validation and planning artifacts are present"},
+		},
+		TestFailures: []models.TestFailure{{
+			Code:    "test_assertion_failure",
+			Summary: "expected 200 got 500",
+		}},
+		Status:    models.StatusCompleted,
+		StartedAt: time.Now(),
+	}
+
+	if err := store.SaveRunState(state); err != nil {
+		t.Fatalf("save run state: %v", err)
+	}
+
+	runs, err := store.ListRunsBySession(session.ID, 10)
+	if err != nil {
+		t.Fatalf("list runs by session: %v", err)
+	}
+	if len(runs) == 0 {
+		t.Fatalf("expected at least one run record")
+	}
+	if runs[0].ID != state.ID {
+		t.Fatalf("unexpected run id: got=%s want=%s", runs[0].ID, state.ID)
+	}
+
+	filteredByStatus, err := store.ListRunsBySessionFiltered(session.ID, 10, string(models.StatusCompleted), "")
+	if err != nil {
+		t.Fatalf("filter runs by status: %v", err)
+	}
+	if len(filteredByStatus) != 1 {
+		t.Fatalf("expected one completed run, got=%d", len(filteredByStatus))
+	}
+
+	filteredByText, err := store.ListRunsBySessionFiltered(session.ID, 10, "", "save run")
+	if err != nil {
+		t.Fatalf("filter runs by task text: %v", err)
+	}
+	if len(filteredByText) != 1 {
+		t.Fatalf("expected one text-matched run, got=%d", len(filteredByText))
+	}
+
+	latestState, err := store.GetLatestRunStateBySession(session.ID)
+	if err != nil {
+		t.Fatalf("get latest run state by session: %v", err)
+	}
+	if latestState == nil || latestState.ID != state.ID {
+		t.Fatalf("unexpected latest run state: %+v", latestState)
+	}
+
+	loadedState, err := store.GetRunState(projectID, state.ID)
+	if err != nil {
+		t.Fatalf("get run state by id: %v", err)
+	}
+	if loadedState == nil || loadedState.Task.Description != "save run state" {
+		t.Fatalf("unexpected loaded run state: %+v", loadedState)
+	}
+
+	projectStates, err := store.ListRunStatesByProject(projectID, 10)
+	if err != nil {
+		t.Fatalf("list run states by project: %v", err)
+	}
+	if len(projectStates) != 1 {
+		t.Fatalf("expected one project state, got %d", len(projectStates))
+	}
+
+	patchText, err := store.LoadLatestPatchBySession(session.ID)
+	if err != nil {
+		t.Fatalf("load latest patch by session: %v", err)
+	}
+	if patchText != state.Patch.RawDiff {
+		t.Fatalf("unexpected patch text loaded")
+	}
+}
+
+func TestSessionMessagePartLifecycle(t *testing.T) {
+	repoRoot := t.TempDir()
+
+	store, err := Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("get or create project: %v", err)
+	}
+	session, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("ensure default session: %v", err)
+	}
+
+	createdMsg, createdParts, err := store.CreateMessageWithParts(SessionMessage{
+		SessionID:  session.ID,
+		Role:       "user",
+		ProviderID: "openai",
+		ModelID:    "gpt-5.3-codex",
+	}, []SessionPart{{
+		Type:    "text",
+		Payload: `{"text":"selam"}`,
+	}})
+	if err != nil {
+		t.Fatalf("create message with parts: %v", err)
+	}
+	if createdMsg.ID == "" {
+		t.Fatalf("expected message id")
+	}
+	if len(createdParts) != 1 {
+		t.Fatalf("expected one part, got %d", len(createdParts))
+	}
+	if createdParts[0].MessageID != createdMsg.ID {
+		t.Fatalf("unexpected part message id: got=%s want=%s", createdParts[0].MessageID, createdMsg.ID)
+	}
+
+	messages, err := store.ListSessionMessages(session.ID, 10)
+	if err != nil {
+		t.Fatalf("list session messages: %v", err)
+	}
+	if len(messages) != 1 {
+		t.Fatalf("expected one message, got %d", len(messages))
+	}
+	if messages[0].Role != "user" {
+		t.Fatalf("unexpected message role: %s", messages[0].Role)
+	}
+
+	parts, err := store.ListSessionParts(createdMsg.ID)
+	if err != nil {
+		t.Fatalf("list session parts: %v", err)
+	}
+	if len(parts) != 1 {
+		t.Fatalf("expected one part, got %d", len(parts))
+	}
+	if parts[0].Type != "text" {
+		t.Fatalf("unexpected part type: %s", parts[0].Type)
+	}
+	if parts[0].Payload == "" {
+		t.Fatalf("expected payload content")
+	}
+}
+
+func TestSessionSummaryAndMetrics(t *testing.T) {
+	repoRoot := t.TempDir()
+
+	store, err := Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("get or create project: %v", err)
+	}
+	session, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("ensure default session: %v", err)
+	}
+
+	if err := store.UpsertSessionSummary(session.ID, "## Goal\nShip session-only runtime"); err != nil {
+		t.Fatalf("upsert session summary: %v", err)
+	}
+	summary, err := store.GetSessionSummary(session.ID)
+	if err != nil {
+		t.Fatalf("get session summary: %v", err)
+	}
+	if summary == nil {
+		t.Fatalf("expected session summary")
+	}
+	if summary.SummaryText == "" {
+		t.Fatalf("expected summary text")
+	}
+
+	err = store.UpsertSessionMetrics(SessionMetrics{
+		SessionID:     session.ID,
+		InputTokens:   120,
+		OutputTokens:  35,
+		TotalCost:     0.014,
+		TurnCount:     2,
+		LastMessageID: "msg-123",
+	})
+	if err != nil {
+		t.Fatalf("upsert session metrics: %v", err)
+	}
+	metrics, err := store.GetSessionMetrics(session.ID)
+	if err != nil {
+		t.Fatalf("get session metrics: %v", err)
+	}
+	if metrics == nil {
+		t.Fatalf("expected session metrics")
+	}
+	if metrics.InputTokens != 120 || metrics.OutputTokens != 35 || metrics.TurnCount != 2 {
+		t.Fatalf("unexpected metrics payload: %+v", metrics)
+	}
+}
+
+func TestCompactSessionParts(t *testing.T) {
+	repoRoot := t.TempDir()
+
+	store, err := Open(repoRoot)
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	defer store.Close()
+
+	projectID, err := store.GetOrCreateProject()
+	if err != nil {
+		t.Fatalf("get project: %v", err)
+	}
+	session, err := store.EnsureDefaultSession(projectID)
+	if err != nil {
+		t.Fatalf("ensure default session: %v", err)
+	}
+
+	for i := 0; i < 4; i++ {
+		msg, _, createErr := store.CreateMessageWithParts(SessionMessage{
+			SessionID: session.ID,
+			Role:      "user",
+		}, []SessionPart{{Type: "text", Payload: `{"text":"payload"}`}})
+		if createErr != nil {
+			t.Fatalf("create message %d: %v", i, createErr)
+		}
+		parts, listErr := store.ListSessionParts(msg.ID)
+		if listErr != nil || len(parts) != 1 {
+			t.Fatalf("list parts for %s: %v", msg.ID, listErr)
+		}
+	}
+
+	affected, err := store.CompactSessionParts(session.ID, 1)
+	if err != nil {
+		t.Fatalf("compact session parts: %v", err)
+	}
+	if affected == 0 {
+		t.Fatalf("expected compacted rows")
+	}
+
+	messages, err := store.ListSessionMessages(session.ID, 10)
+	if err != nil {
+		t.Fatalf("list session messages: %v", err)
+	}
+	if len(messages) != 4 {
+		t.Fatalf("expected 4 messages, got %d", len(messages))
+	}
+
+	compactedCount := 0
+	for _, message := range messages {
+		parts, partErr := store.ListSessionParts(message.ID)
+		if partErr != nil {
+			t.Fatalf("list parts: %v", partErr)
+		}
+		for _, part := range parts {
+			if part.Compacted {
+				compactedCount++
+			}
+		}
+	}
+	if compactedCount == 0 {
+		t.Fatalf("expected some compacted parts")
+	}
+}

package/internal/testing/classifier.go

@@ -0,0 +1,80 @@
+package testingx
+
+import (
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+type Classifier struct{}
+
+func NewClassifier() *Classifier {
+	return &Classifier{}
+}
+
+func (c *Classifier) Classify(output, errText string) []models.TestFailure {
+	combined := strings.TrimSpace(strings.Join([]string{strings.TrimSpace(output), strings.TrimSpace(errText)}, "\n"))
+	if combined == "" {
+		return []models.TestFailure{{
+			Code:    "test_setup_failure",
+			Summary: "test command failed without output",
+			Details: []string{"No test output was captured from the failed command."},
+		}}
+	}
+
+	lines := splitNonEmptyLines(combined)
+	lower := strings.ToLower(combined)
+
+	switch {
+	case strings.Contains(lower, "timed out") || strings.Contains(lower, "timeout"):
+		return []models.TestFailure{{
+			Code:    "test_timeout",
+			Summary: "test command timed out",
+			Details: lines,
+		}}
+	case strings.Contains(lower, "panic:") || strings.Contains(lower, "segmentation fault"):
+		return []models.TestFailure{{
+			Code:    "test_setup_failure",
+			Summary: "test runtime crashed or panicked",
+			Details: lines,
+		}}
+	case strings.Contains(lower, "no test files"):
+		return []models.TestFailure{{
+			Code:    "missing_required_tests",
+			Summary: "required tests appear to be missing",
+			Details: lines,
+		}}
+	case strings.Contains(lower, "assert") || strings.Contains(lower, "expected") || strings.Contains(lower, "--- fail") || strings.Contains(lower, "not equal"):
+		return []models.TestFailure{{
+			Code:    "test_assertion_failure",
+			Summary: "test assertions failed",
+			Details: lines,
+		}}
+	case strings.Contains(lower, "flake") || strings.Contains(lower, "flaky"):
+		return []models.TestFailure{{
+			Code:    "flaky_test_suspected",
+			Summary: "test output suggests flaky behavior",
+			Details: lines,
+			Flaky:   true,
+		}}
+	default:
+		return []models.TestFailure{{
+			Code:    "test_setup_failure",
+			Summary: "test command failed",
+			Details: lines,
+		}}
+	}
+}
+
+func splitNonEmptyLines(text string) []string {
+	parts := strings.Split(strings.TrimSpace(text), "\n")
+	result := make([]string, 0, len(parts))
+	for _, part := range parts {
+		trimmed := strings.TrimSpace(part)
+		if trimmed == "" {
+			continue
+		}
+		result = append(result, trimmed)
+	}
+	return result
+}

package/internal/testing/classifier_test.go

@@ -0,0 +1,36 @@
+package testingx
+
+import "testing"
+
+func TestClassifierDetectsAssertionFailure(t *testing.T) {
+	classifier := NewClassifier()
+	failures := classifier.Classify("--- FAIL: TestAuth\nexpected 200 got 500", "")
+	if len(failures) != 1 {
+		t.Fatalf("expected one failure classification")
+	}
+	if failures[0].Code != "test_assertion_failure" {
+		t.Fatalf("unexpected failure code: %s", failures[0].Code)
+	}
+}
+
+func TestClassifierDetectsTimeout(t *testing.T) {
+	classifier := NewClassifier()
+	failures := classifier.Classify("", "command timed out after 30s")
+	if len(failures) != 1 {
+		t.Fatalf("expected one failure classification")
+	}
+	if failures[0].Code != "test_timeout" {
+		t.Fatalf("unexpected failure code: %s", failures[0].Code)
+	}
+}
+
+func TestClassifierDetectsMissingTests(t *testing.T) {
+	classifier := NewClassifier()
+	failures := classifier.Classify("?   package/foo [no test files]", "")
+	if len(failures) != 1 {
+		t.Fatalf("expected one failure classification")
+	}
+	if failures[0].Code != "missing_required_tests" {
+		t.Fatalf("unexpected failure code: %s", failures[0].Code)
+	}
+}

package/internal/tools/command.go

@@ -0,0 +1,160 @@
+package tools
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+const (
+	defaultCommandTimeout = 60 * time.Second
+	defaultTestTimeout    = 120 * time.Second
+	maxOutputBytes        = 50 * 1024
+)
+
+type RunCommandTool struct {
+	repoRoot string
+}
+
+func NewRunCommandTool(repoRoot string) *RunCommandTool {
+	return &RunCommandTool{repoRoot: repoRoot}
+}
+
+func (t *RunCommandTool) Name() string { return "run_command" }
+
+func (t *RunCommandTool) Description() string { return "Runs a system command" }
+
+func (t *RunCommandTool) Execute(params map[string]string) (*models.ToolResult, error) {
+	command, ok := params["command"]
+	if !ok {
+		return Failure("run_command", ErrCodeInvalidParams, "run_command: 'command' parameter is required", ""), nil
+	}
+
+	if risky, reason := classifyCommandRisk(command); risky && strings.TrimSpace(params["approved"]) != "true" {
+		return Failure("run_command", ErrCodePolicyBlocked, fmt.Sprintf("command blocked by safety policy: %s", reason), ""), nil
+	}
+
+	timeout := parseTimeout(params, defaultCommandTimeout)
+	return runCommand("run_command", t.repoRoot, command, timeout)
+}
+
+type RunTestsTool struct {
+	repoRoot string
+}
+
+func NewRunTestsTool(repoRoot string) *RunTestsTool {
+	return &RunTestsTool{repoRoot: repoRoot}
+}
+
+func (t *RunTestsTool) Name() string { return "run_tests" }
+
+func (t *RunTestsTool) Description() string { return "Runs project tests" }
+
+// Params: "command" optional test command (default: "go test ./...").
+func (t *RunTestsTool) Execute(params map[string]string) (*models.ToolResult, error) {
+	command := params["command"]
+	if command == "" {
+		command = "go test ./..."
+	}
+
+	timeout := parseTimeout(params, defaultTestTimeout)
+	return runCommand("run_tests", t.repoRoot, command, timeout)
+}
+
+func runCommand(toolName, repoRoot, command string, timeout time.Duration) (*models.ToolResult, error) {
+
+	parts := strings.Fields(command)
+	if len(parts) == 0 {
+		return Failure(toolName, ErrCodeInvalidParams, "empty command", ""), nil
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	cmd := exec.CommandContext(ctx, parts[0], parts[1:]...)
+	cmd.Dir = repoRoot
+
+	output, err := cmd.CombinedOutput()
+	if errors.Is(ctx.Err(), context.DeadlineExceeded) {
+		return Failure(toolName, ErrCodeTimeout, fmt.Sprintf("command timed out after %s", timeout), truncateOutput(string(output))), nil
+	}
+
+	normalizedOutput, truncatedPath, truncated := normalizeOutput(repoRoot, toolName, output)
+	if err != nil {
+		result := Failure(toolName, ErrCodeExecution, err.Error(), normalizedOutput)
+		if truncated {
+			result.ErrorCode = ErrCodeOutputTrunc
+			result.Metadata = map[string]string{"output_file": truncatedPath}
+		}
+		return result, nil
+	}
+
+	result := Success(toolName, normalizedOutput)
+	if truncated {
+		result.Metadata = map[string]string{"output_file": truncatedPath}
+	}
+	return result, nil
+}
+
+func parseTimeout(params map[string]string, fallback time.Duration) time.Duration {
+	raw := strings.TrimSpace(params["timeout_seconds"])
+	if raw == "" {
+		return fallback
+	}
+	seconds, err := strconv.Atoi(raw)
+	if err != nil || seconds <= 0 {
+		return fallback
+	}
+	return time.Duration(seconds) * time.Second
+}
+
+func classifyCommandRisk(command string) (bool, string) {
+	lower := strings.ToLower(strings.TrimSpace(command))
+	riskyPatterns := []string{
+		"rm -rf",
+		"mkfs",
+		"dd if=",
+		"shutdown",
+		"reboot",
+		":(){",
+	}
+	for _, pattern := range riskyPatterns {
+		if strings.Contains(lower, pattern) {
+			return true, pattern
+		}
+	}
+	return false, ""
+}
+
+func normalizeOutput(repoRoot, toolName string, output []byte) (string, string, bool) {
+	text := string(output)
+	if len(output) <= maxOutputBytes {
+		return text, "", false
+	}
+
+	if err := os.MkdirAll(filepath.Join(repoRoot, ".orch", "runs"), 0o755); err != nil {
+		return truncateOutput(text), "", true
+	}
+
+	path := filepath.Join(repoRoot, ".orch", "runs", fmt.Sprintf("%s-output-%d.log", toolName, time.Now().UnixNano()))
+	if err := os.WriteFile(path, output, 0o644); err != nil {
+		return truncateOutput(text), "", true
+	}
+
+	return fmt.Sprintf("output truncated; full output saved to %s\n%s", path, truncateOutput(text)), path, true
+}
+
+func truncateOutput(text string) string {
+	if len(text) <= maxOutputBytes {
+		return text
+	}
+	return text[:maxOutputBytes]
+}