orch-code 0.1.1

package/cmd/root.go

@@ -0,0 +1,67 @@
+// Subcommands: init, plan, run, diff, apply, logs, explain, stats.
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	verbose    bool
+	configPath string
+	sessionID  string
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "orch",
+	Short: "AI-powered coding orchestrator",
+	Long: `Orch is a CLI orchestration engine that uses AI agents to execute coding tasks inside a repository.
+
+Pipeline: Task → Plan → Code → Test → Review → Patch
+
+Usage examples:
+  orch init                            # Repository analysis and configuration
+  orch plan "add redis caching"        # Generate plan only
+  orch run "fix auth bug"              # Run full pipeline
+  orch diff                            # Show generated patch
+  orch apply                           # Apply patch
+  orch logs                            # Show execution trace
+  orch explain                         # Explain latest run
+  orch stats                           # Show recent run quality stats`,
+	Version: version,
+	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+		// Do not auto-init if the command is "init" or any help command
+		if cmd.Name() == "init" || cmd.Name() == "help" || cmd.Name() == "version" {
+			return nil
+		}
+
+		cwd, err := os.Getwd()
+		if err != nil {
+			return fmt.Errorf("failed to get working directory: %w", err)
+		}
+
+		if err := AutoInitIfNeeded(cwd); err != nil {
+			return fmt.Errorf("auto-initialization failed: %w", err)
+		}
+		return nil
+	},
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return startInteractiveShell(sessionID)
+	},
+}
+
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func init() {
+	// Global flags
+	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "Verbose output mode")
+	rootCmd.PersistentFlags().StringVar(&configPath, "config", "", "Configuration file path")
+	rootCmd.PersistentFlags().StringVarP(&sessionID, "session", "s", "", "Resume interactive session id")
+}

package/cmd/run.go

@@ -0,0 +1,123 @@
+// Package cmd implements the run command.
+//
+// Pipeline:
+//
+//	Task → Repo Analysis → Context Selection → Planner → Coder
+//	→ Patch Validation → Test Runner → Reviewer → Result
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+	"github.com/spf13/cobra"
+)
+
+// runCmd represents the `orch run` command.
+var runCmd = &cobra.Command{
+	Use:   "run [task]",
+	Short: "Runs full pipeline",
+	Long: `Runs the full pipeline for the given task:
+analyze -> plan -> code -> validate -> test -> review.`,
+	Args: cobra.ExactArgs(1),
+	RunE: runRun,
+}
+
+func init() {
+	rootCmd.AddCommand(runCmd)
+}
+
+func runRun(cmd *cobra.Command, args []string) error {
+	result, err := executeRunTask(args[0])
+	if err != nil {
+		return err
+	}
+
+	for _, warning := range result.Warnings {
+		fmt.Printf("\n⚠ %s\n", warning)
+	}
+
+	fmt.Printf("🚀 Starting pipeline: %s\n\n", result.Task.Description)
+	printRunContextSummary(result.ProjectID, result.SessionName, result.Worktree, result.CWD, result.ExecRoot)
+
+	state := result.State
+	err = result.Err
+
+	if err != nil {
+		fmt.Printf("\n❌ Pipeline failed: %s\n", err.Error())
+		if state != nil {
+			printRunResultSummary(state)
+			if len(state.UnresolvedFailures) > 0 {
+				fmt.Println("\n⚠ Unresolved Failures:")
+				for _, failure := range state.UnresolvedFailures {
+					fmt.Printf("- %s\n", failure)
+				}
+			}
+			if strings.TrimSpace(state.BestPatchSummary) != "" {
+				fmt.Printf("\n🩹 Best Patch Summary: %s\n", state.BestPatchSummary)
+			}
+			if strings.TrimSpace(state.TestResults) != "" {
+				fmt.Println("\n🧪 Test Summary:")
+				fmt.Println(state.TestResults)
+			}
+		}
+		return err
+	}
+
+	fmt.Println("\n═══════════════════════════════════════")
+	fmt.Printf("✅ Pipeline completed: %s\n", state.Status)
+	fmt.Println("═══════════════════════════════════════")
+
+	if state.Review != nil {
+		fmt.Printf("\n📋 Review Decision: %s\n", state.Review.Decision)
+		for _, comment := range state.Review.Comments {
+			fmt.Printf("   💬 %s\n", comment)
+		}
+	}
+	if state.Confidence != nil {
+		fmt.Printf("\n🎯 Confidence: %.2f (%s)\n", state.Confidence.Score, state.Confidence.Band)
+		for _, warning := range state.Confidence.Warnings {
+			fmt.Printf("   ⚠ %s\n", warning)
+		}
+	}
+
+	if state.Patch != nil && state.Patch.RawDiff != "" {
+		fmt.Println("\n💡 To view the patch: orch diff")
+		fmt.Println("💡 To apply the patch: orch apply")
+	}
+
+	printRunResultSummary(state)
+
+	return nil
+}
+
+func printRunContextSummary(projectID, sessionName, worktree, cwd, execRoot string) {
+	fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+	fmt.Println("Run Context")
+	fmt.Printf("Project: %s\n", projectID)
+	fmt.Printf("Session: %s\n", sessionName)
+	if worktree != "" {
+		fmt.Printf("Worktree: %s\n", worktree)
+	}
+	if execRoot != cwd {
+		fmt.Printf("Execution root: %s\n", execRoot)
+	}
+	fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+}
+
+func printRunResultSummary(state *models.RunState) {
+	if state == nil {
+		return
+	}
+	fmt.Println("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+	fmt.Println("Run Summary")
+	fmt.Printf("Run ID: %s\n", state.ID)
+	fmt.Printf("Status: %s\n", state.Status)
+	fmt.Printf("Retries: validation=%d test=%d review=%d\n", state.Retries.Validation, state.Retries.Testing, state.Retries.Review)
+	if state.Confidence != nil {
+		fmt.Printf("Confidence: %.2f (%s)\n", state.Confidence.Score, state.Confidence.Band)
+	}
+	fmt.Printf("Log file: .orch/runs/%s.json\n", state.ID)
+	fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+}

package/cmd/run_engine.go

@@ -0,0 +1,208 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+	"github.com/furkanbeydemir/orch/internal/models"
+	"github.com/furkanbeydemir/orch/internal/orchestrator"
+	runlock "github.com/furkanbeydemir/orch/internal/runtime"
+	"github.com/furkanbeydemir/orch/internal/session"
+	"github.com/furkanbeydemir/orch/internal/storage"
+)
+
+type runExecutionResult struct {
+	Task        *models.Task
+	State       *models.RunState
+	Err         error
+	ProjectID   string
+	SessionName string
+	Worktree    string
+	CWD         string
+	ExecRoot    string
+	Warnings    []string
+}
+
+func executeRunTask(taskDescription string) (*runExecutionResult, error) {
+	cwd, err := getWorkingDirectory()
+	if err != nil {
+		return nil, err
+	}
+
+	cfg, err := config.Load(cwd)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load configuration: %w", err)
+	}
+
+	sessionCtx, err := loadSessionContext(cwd)
+	if err != nil {
+		return nil, err
+	}
+	defer sessionCtx.Store.Close()
+
+	execRoot := sessionCtx.ExecutionRoot(cwd)
+
+	task := &models.Task{
+		ID:          fmt.Sprintf("task-%d", time.Now().UnixNano()),
+		Description: taskDescription,
+		CreatedAt:   time.Now(),
+	}
+
+	result := &runExecutionResult{
+		Task:        task,
+		ProjectID:   sessionCtx.ProjectID,
+		SessionName: sessionCtx.Session.Name,
+		Worktree:    sessionCtx.Session.Worktree,
+		CWD:         cwd,
+		ExecRoot:    execRoot,
+		Warnings:    make([]string, 0),
+	}
+
+	svc := session.NewService(sessionCtx.Store)
+	if compacted, note, compactErr := svc.MaybeCompact(sessionCtx.Session.ID, cfg.Provider.OpenAI.Models.Coder); compactErr == nil && compacted {
+		result.Warnings = append(result.Warnings, note)
+	}
+	userMsg, sessionErr := svc.AppendText(session.MessageInput{
+		SessionID:  sessionCtx.Session.ID,
+		Role:       "user",
+		ProviderID: "orch",
+		ModelID:    "run-engine",
+		Text:       taskDescription,
+	})
+	if sessionErr != nil {
+		result.Warnings = append(result.Warnings, fmt.Sprintf("failed to persist run user message: %s", sessionErr))
+	}
+
+	var unlock func() error
+	if cfg.Safety.FeatureFlags.RepoLock {
+		lockManager := runlock.NewLockManager(execRoot, time.Duration(cfg.Safety.LockStaleAfterSeconds)*time.Second)
+		unlock, err = lockManager.Acquire(task.ID)
+		if err != nil {
+			return nil, fmt.Errorf("run blocked by repository lock: %w", err)
+		}
+		defer func() {
+			if unlockErr := unlock(); unlockErr != nil {
+				result.Warnings = append(result.Warnings, fmt.Sprintf("failed to release lock: %s", unlockErr))
+			}
+		}()
+	}
+
+	orch := orchestrator.New(cfg, execRoot, verbose)
+	state, runErr := orch.Run(task)
+	result.State = state
+	result.Err = runErr
+
+	if state != nil {
+		state.ProjectID = sessionCtx.ProjectID
+		state.SessionID = sessionCtx.Session.ID
+		if saveErr := sessionCtx.Store.SaveRunState(state); saveErr != nil {
+			result.Warnings = append(result.Warnings, fmt.Sprintf("failed to save SQLite run state: %s", saveErr))
+		}
+	}
+
+	runSummary := summarizeRunForSession(result)
+	stagePayload := map[string]any{
+		"run_id":   "",
+		"status":   "failed",
+		"warnings": result.Warnings,
+	}
+	finishReason := "error"
+	errorText := ""
+	if state != nil {
+		stagePayload["run_id"] = state.ID
+		stagePayload["status"] = string(state.Status)
+		if state.Status == models.StatusCompleted && result.Err == nil {
+			finishReason = "stop"
+		}
+	}
+	if result.Err != nil {
+		errorText = result.Err.Error()
+	}
+	payloadBytes, _ := json.Marshal(stagePayload)
+	parentID := ""
+	if userMsg != nil {
+		parentID = userMsg.Message.ID
+	}
+	assistantParts := []storage.SessionPart{{Type: "stage", Payload: string(payloadBytes)}}
+	assistantParts = append(assistantParts, buildStagePartsFromRunState(state)...)
+	if _, appendErr := svc.AppendMessage(session.MessageInput{
+		SessionID:    sessionCtx.Session.ID,
+		Role:         "assistant",
+		ParentID:     parentID,
+		ProviderID:   "orch",
+		ModelID:      "run-engine",
+		FinishReason: finishReason,
+		Error:        errorText,
+		Text:         runSummary,
+	}, assistantParts); appendErr != nil {
+		result.Warnings = append(result.Warnings, fmt.Sprintf("failed to persist run assistant message: %s", appendErr))
+	}
+
+	if compacted, note, compactErr := svc.MaybeCompact(sessionCtx.Session.ID, cfg.Provider.OpenAI.Models.Coder); compactErr == nil && compacted {
+		result.Warnings = append(result.Warnings, note)
+	}
+
+	return result, nil
+}
+
+func buildStagePartsFromRunState(state *models.RunState) []storage.SessionPart {
+	if state == nil || len(state.Logs) == 0 {
+		return []storage.SessionPart{}
+	}
+
+	parts := make([]storage.SessionPart, 0, len(state.Logs))
+	for _, entry := range state.Logs {
+		payload := map[string]any{
+			"actor":     strings.TrimSpace(entry.Actor),
+			"step":      strings.TrimSpace(entry.Step),
+			"message":   strings.TrimSpace(entry.Message),
+			"timestamp": entry.Timestamp.UTC().Format(time.RFC3339Nano),
+		}
+		body, err := json.Marshal(payload)
+		if err != nil {
+			continue
+		}
+		parts = append(parts, storage.SessionPart{Type: "stage", Payload: string(body)})
+	}
+
+	return parts
+}
+
+func summarizeRunForSession(result *runExecutionResult) string {
+	if result == nil || result.State == nil {
+		if result != nil && result.Err != nil {
+			return fmt.Sprintf("Run failed: %s", result.Err.Error())
+		}
+		return "Run finished without state output"
+	}
+
+	state := result.State
+	if result.Err != nil || state.Status == models.StatusFailed {
+		errText := strings.TrimSpace(state.Error)
+		if errText == "" && result.Err != nil {
+			errText = result.Err.Error()
+		}
+		if errText == "" {
+			errText = "unknown failure"
+		}
+		return fmt.Sprintf("Run failed at status=%s: %s", state.Status, errText)
+	}
+
+	if state.Patch == nil || len(state.Patch.Files) == 0 {
+		return fmt.Sprintf("Run completed with status=%s and no patch files.", state.Status)
+	}
+
+	return fmt.Sprintf("Run completed with status=%s and %d patch file(s).", state.Status, len(state.Patch.Files))
+}
+
+func getWorkingDirectory() (string, error) {
+	return osGetwd()
+}
+
+var osGetwd = func() (string, error) {
+	return os.Getwd()
+}

package/cmd/run_engine_test.go

@@ -0,0 +1,30 @@
+package cmd
+
+import (
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/models"
+)
+
+func TestBuildStagePartsFromRunState(t *testing.T) {
+	state := &models.RunState{
+		Logs: []models.LogEntry{
+			{Timestamp: time.Now().UTC(), Actor: "planner", Step: "plan", Message: "Generating plan..."},
+			{Timestamp: time.Now().UTC(), Actor: "coder", Step: "code", Message: "Generating patch..."},
+		},
+	}
+
+	parts := buildStagePartsFromRunState(state)
+	if len(parts) != 2 {
+		t.Fatalf("expected 2 stage parts, got %d", len(parts))
+	}
+	for _, part := range parts {
+		if part.Type != "stage" {
+			t.Fatalf("expected stage part type, got %s", part.Type)
+		}
+		if part.Payload == "" {
+			t.Fatalf("expected non-empty payload")
+		}
+	}
+}