orch-code 0.1.1

package/cmd/interactive_input.go

@@ -0,0 +1,45 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+)
+
+type interactiveDispatch struct {
+	Args         []string
+	DisplayInput string
+	InputNote    string
+}
+
+func prepareInteractiveDispatch(input string) (interactiveDispatch, error) {
+	trimmed := strings.TrimSpace(input)
+	if trimmed == "" {
+		return interactiveDispatch{}, fmt.Errorf("empty input")
+	}
+
+	if strings.HasPrefix(trimmed, "?quick") {
+		payload := strings.TrimSpace(strings.TrimPrefix(trimmed, "?quick"))
+		if payload == "" {
+			return interactiveDispatch{}, fmt.Errorf("?quick requires a message")
+		}
+		return interactiveDispatch{
+			Args:         []string{"chat", buildQuickChatPrompt(payload)},
+			DisplayInput: trimmed,
+			InputNote:    "Local input transform applied: concise chat mode.",
+		}, nil
+	}
+
+	args, err := parseInteractiveInput(trimmed)
+	if err != nil {
+		return interactiveDispatch{}, err
+	}
+	return interactiveDispatch{
+		Args:         args,
+		DisplayInput: trimmed,
+	}, nil
+}
+
+func buildQuickChatPrompt(message string) string {
+	message = strings.TrimSpace(message)
+	return "Respond briefly and practically. Keep the answer tight, actionable, and under 6 lines when possible.\n\nUser request: " + message
+}

package/cmd/interactive_input_test.go

@@ -0,0 +1,55 @@
+package cmd
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestPrepareInteractiveDispatchPlainChat(t *testing.T) {
+	dispatch, err := prepareInteractiveDispatch("selam")
+	if err != nil {
+		t.Fatalf("prepare dispatch: %v", err)
+	}
+	if len(dispatch.Args) != 2 || dispatch.Args[0] != "chat" || dispatch.Args[1] != "selam" {
+		t.Fatalf("unexpected args: %+v", dispatch.Args)
+	}
+	if dispatch.DisplayInput != "selam" {
+		t.Fatalf("unexpected display input: %q", dispatch.DisplayInput)
+	}
+	if dispatch.InputNote != "" {
+		t.Fatalf("expected no input note, got %q", dispatch.InputNote)
+	}
+}
+
+func TestPrepareInteractiveDispatchRunCommand(t *testing.T) {
+	dispatch, err := prepareInteractiveDispatch("/run fix auth bug")
+	if err != nil {
+		t.Fatalf("prepare dispatch: %v", err)
+	}
+	if len(dispatch.Args) != 2 || dispatch.Args[0] != "run" || dispatch.Args[1] != "fix auth bug" {
+		t.Fatalf("unexpected args: %+v", dispatch.Args)
+	}
+}
+
+func TestPrepareInteractiveDispatchQuickTransform(t *testing.T) {
+	dispatch, err := prepareInteractiveDispatch("?quick explain confidence policy")
+	if err != nil {
+		t.Fatalf("prepare dispatch: %v", err)
+	}
+	if len(dispatch.Args) != 2 || dispatch.Args[0] != "chat" {
+		t.Fatalf("unexpected args: %+v", dispatch.Args)
+	}
+	if !strings.Contains(dispatch.Args[1], "Respond briefly and practically") {
+		t.Fatalf("expected transformed prompt, got %q", dispatch.Args[1])
+	}
+	if dispatch.InputNote == "" {
+		t.Fatalf("expected input transform note")
+	}
+}
+
+func TestPrepareInteractiveDispatchQuickRequiresMessage(t *testing.T) {
+	_, err := prepareInteractiveDispatch("?quick")
+	if err == nil {
+		t.Fatalf("expected error for empty ?quick input")
+	}
+}

package/cmd/logs.go

@@ -0,0 +1,72 @@
+// Package cmd implements the logs command.
+//
+//	[analyzer] scanning repository
+//	[planner] generating plan
+//	[coder] editing userService.ts
+//	[test] running npm test
+//	[reviewer] patch approved
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/furkanbeydemir/orch/internal/logger"
+	"github.com/spf13/cobra"
+)
+
+// logsCmd represents the `orch logs` command.
+var logsCmd = &cobra.Command{
+	Use:   "logs [run-id]",
+	Short: "Shows execution trace",
+	Long:  `Lists agent execution steps in chronological order.`,
+	RunE:  runLogs,
+}
+
+func init() {
+	rootCmd.AddCommand(logsCmd)
+}
+
+func runLogs(cmd *cobra.Command, args []string) error {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	if len(args) > 0 {
+		entries, err := logger.LoadRunLog(cwd, args[0])
+		if err != nil {
+			return fmt.Errorf("failed to load logs: %w", err)
+		}
+
+		for _, entry := range entries {
+			fmt.Printf("[%s] %s | %s\n",
+				entry.Actor,
+				entry.Timestamp.Format("15:04:05"),
+				entry.Message,
+			)
+		}
+		return nil
+	}
+
+	runs, err := logger.ListRuns(cwd)
+	if err != nil {
+		fmt.Println("📋 No run records found yet.")
+		fmt.Println("   'orch run <task>' to run a task.")
+		return nil
+	}
+
+	if len(runs) == 0 {
+		fmt.Println("📋 No run records found yet.")
+		return nil
+	}
+
+	fmt.Println("📋 Run Records:")
+	fmt.Println("─────────────────────────────────────")
+	for _, run := range runs {
+		fmt.Printf("  • %s\n", run)
+	}
+	fmt.Println("\nFor details: orch logs <run-id>")
+
+	return nil
+}

package/cmd/model.go

@@ -0,0 +1,84 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var modelCmd = &cobra.Command{
+	Use:   "model",
+	Short: "Show or manage role model mapping",
+	RunE:  runModelShow,
+}
+
+var modelSetCmd = &cobra.Command{
+	Use:   "set [role] [model]",
+	Short: "Set model for role (planner|coder|reviewer)",
+	Args:  cobra.ExactArgs(2),
+	RunE:  runModelSet,
+}
+
+func init() {
+	modelCmd.AddCommand(modelSetCmd)
+	rootCmd.AddCommand(modelCmd)
+}
+
+func runModelShow(cmd *cobra.Command, args []string) error {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	cfg, err := config.Load(cwd)
+	if err != nil {
+		return fmt.Errorf("failed to load configuration: %w", err)
+	}
+
+	fmt.Println("Model Mapping")
+	fmt.Println("-------------")
+	fmt.Printf("planner:  %s\n", cfg.Provider.OpenAI.Models.Planner)
+	fmt.Printf("coder:    %s\n", cfg.Provider.OpenAI.Models.Coder)
+	fmt.Printf("reviewer: %s\n", cfg.Provider.OpenAI.Models.Reviewer)
+
+	return nil
+}
+
+func runModelSet(cmd *cobra.Command, args []string) error {
+	role := strings.ToLower(strings.TrimSpace(args[0]))
+	model := strings.TrimSpace(args[1])
+	if model == "" {
+		return fmt.Errorf("model cannot be empty")
+	}
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	cfg, err := config.Load(cwd)
+	if err != nil {
+		return fmt.Errorf("failed to load configuration: %w", err)
+	}
+
+	switch role {
+	case "planner":
+		cfg.Provider.OpenAI.Models.Planner = model
+	case "coder":
+		cfg.Provider.OpenAI.Models.Coder = model
+	case "reviewer":
+		cfg.Provider.OpenAI.Models.Reviewer = model
+	default:
+		return fmt.Errorf("invalid role: %s (expected planner|coder|reviewer)", role)
+	}
+
+	if err := config.Save(cwd, cfg); err != nil {
+		return fmt.Errorf("failed to save config: %w", err)
+	}
+
+	fmt.Printf("Model for %s set to %s\n", role, model)
+	return nil
+}

package/cmd/plan.go

@@ -0,0 +1,149 @@
+// Package cmd implements the plan command.
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+	"github.com/furkanbeydemir/orch/internal/models"
+	"github.com/furkanbeydemir/orch/internal/orchestrator"
+	"github.com/spf13/cobra"
+)
+
+var planJSON bool
+
+// planCmd represents the `orch plan` command.
+var planCmd = &cobra.Command{
+	Use:   "plan [task]",
+	Short: "Generates an implementation plan for a task",
+	Long:  `Generates an AI implementation plan for the given task. Does not change code.`,
+	Args:  cobra.ExactArgs(1),
+	RunE:  runPlan,
+}
+
+func init() {
+	planCmd.Flags().BoolVar(&planJSON, "json", false, "Output the structured plan as JSON")
+	rootCmd.AddCommand(planCmd)
+}
+
+func runPlan(cmd *cobra.Command, args []string) error {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	cfg, err := config.Load(cwd)
+	if err != nil {
+		return fmt.Errorf("failed to load configuration: %w", err)
+	}
+
+	task := &models.Task{
+		ID:          fmt.Sprintf("task-%d", time.Now().UnixNano()),
+		Description: args[0],
+		CreatedAt:   time.Now(),
+	}
+
+	orch := orchestrator.New(cfg, cwd, verbose)
+	taskBrief, plan, err := orch.PlanDetailed(task)
+	if err != nil {
+		return fmt.Errorf("plan generation failed: %w", err)
+	}
+
+	if planJSON {
+		payload := struct {
+			Task      *models.Task      `json:"task"`
+			TaskBrief *models.TaskBrief `json:"task_brief,omitempty"`
+			Plan      *models.Plan      `json:"plan"`
+		}{
+			Task:      task,
+			TaskBrief: taskBrief,
+			Plan:      plan,
+		}
+		encoded, marshalErr := json.MarshalIndent(payload, "", "  ")
+		if marshalErr != nil {
+			return fmt.Errorf("failed to encode plan output: %w", marshalErr)
+		}
+		fmt.Println(string(encoded))
+		return nil
+	}
+
+	fmt.Printf("📝 Generating plan: %s\n\n", task.Description)
+	fmt.Println("═══════════════════════════════════════")
+	fmt.Println("📋 IMPLEMENTATION PLAN")
+	fmt.Println("═══════════════════════════════════════")
+
+	if taskBrief != nil {
+		fmt.Printf("\n🎯 Task Type: %s\n", taskBrief.TaskType)
+		fmt.Printf("⚠️  Risk Level: %s\n", taskBrief.RiskLevel)
+		if taskBrief.NormalizedGoal != "" {
+			fmt.Printf("🧭 Goal: %s\n", taskBrief.NormalizedGoal)
+		}
+	}
+
+	if plan != nil && plan.Summary != "" {
+		fmt.Printf("\n🗺️  Summary: %s\n", plan.Summary)
+	}
+
+	if plan != nil && len(plan.Steps) > 0 {
+		fmt.Println("\n📌 Steps:")
+		for _, step := range plan.Steps {
+			fmt.Printf("  %d. %s\n", step.Order, step.Description)
+		}
+	}
+
+	if plan != nil && len(plan.FilesToModify) > 0 {
+		fmt.Println("\n📝 Files To Modify:")
+		for _, f := range plan.FilesToModify {
+			fmt.Printf("  - %s\n", f)
+		}
+	}
+
+	if plan != nil && len(plan.FilesToInspect) > 0 {
+		fmt.Println("\n🔍 Files To Inspect:")
+		for _, f := range plan.FilesToInspect {
+			fmt.Printf("  - %s\n", f)
+		}
+	}
+
+	if plan != nil && len(plan.AcceptanceCriteria) > 0 {
+		fmt.Println("\n✅ Acceptance Criteria:")
+		for _, criterion := range plan.AcceptanceCriteria {
+			fmt.Printf("  - %s\n", criterion.Description)
+		}
+	}
+
+	if plan != nil && len(plan.Invariants) > 0 {
+		fmt.Println("\n🧱 Invariants:")
+		for _, invariant := range plan.Invariants {
+			fmt.Printf("  - %s\n", invariant)
+		}
+	}
+
+	if plan != nil && len(plan.ForbiddenChanges) > 0 {
+		fmt.Println("\n⛔ Forbidden Changes:")
+		for _, forbidden := range plan.ForbiddenChanges {
+			fmt.Printf("  - %s\n", forbidden)
+		}
+	}
+
+	if plan != nil && len(plan.Risks) > 0 {
+		fmt.Println("\n⚠️  Risks:")
+		for _, r := range plan.Risks {
+			fmt.Printf("  - %s\n", r)
+		}
+	}
+
+	if plan != nil && len(plan.TestRequirements) > 0 {
+		fmt.Println("\n🧪 Test Requirements:")
+		for _, req := range plan.TestRequirements {
+			fmt.Printf("  - %s\n", req)
+		}
+	} else if plan != nil && plan.TestStrategy != "" {
+		fmt.Printf("\n🧪 Test Strategy: %s\n", plan.TestStrategy)
+	}
+
+	return nil
+}

package/cmd/provider.go

@@ -0,0 +1,189 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+	"github.com/furkanbeydemir/orch/internal/providers"
+	"github.com/spf13/cobra"
+)
+
+var providerJSONFlag bool
+
+var providerCmd = &cobra.Command{
+	Use:   "provider",
+	Short: "Show or manage provider settings",
+	RunE:  runProviderShow,
+}
+
+var providerSetCmd = &cobra.Command{
+	Use:   "set [provider]",
+	Short: "Set default provider",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runProviderSet,
+}
+
+var providerListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all/default/connected providers",
+	RunE:  runProviderList,
+}
+
+func init() {
+	providerCmd.Flags().BoolVar(&providerJSONFlag, "json", false, "Output as JSON")
+	providerListCmd.Flags().BoolVar(&providerJSONFlag, "json", false, "Output as JSON")
+	providerCmd.AddCommand(providerSetCmd)
+	providerCmd.AddCommand(providerListCmd)
+	rootCmd.AddCommand(providerCmd)
+}
+
+func runProviderShow(cmd *cobra.Command, args []string) error {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	cfg, err := config.Load(cwd)
+	if err != nil {
+		return fmt.Errorf("failed to load configuration: %w", err)
+	}
+
+	state, err := providers.ReadState(cwd)
+	if err != nil {
+		return err
+	}
+
+	if providerJSONFlag {
+		payload := map[string]any{
+			"all":       state.All,
+			"default":   state.Default,
+			"connected": state.Connected,
+			"openai": map[string]any{
+				"enabled":   state.OpenAI.Enabled,
+				"connected": state.OpenAI.Connected,
+				"mode":      state.OpenAI.Mode,
+				"source":    state.OpenAI.Source,
+				"reason":    state.OpenAI.Reason,
+			},
+		}
+		encoded, marshalErr := json.MarshalIndent(payload, "", "  ")
+		if marshalErr != nil {
+			return fmt.Errorf("failed to serialize provider output: %w", marshalErr)
+		}
+		fmt.Println(string(encoded))
+		return nil
+	}
+
+	fmt.Println("Provider Configuration")
+	fmt.Println("----------------------")
+	fmt.Printf("default: %s\n", cfg.Provider.Default)
+	fmt.Printf("all: %s\n", strings.Join(state.All, ", "))
+	if len(state.Connected) == 0 {
+		fmt.Println("connected: (none)")
+	} else {
+		fmt.Printf("connected: %s\n", strings.Join(state.Connected, ", "))
+	}
+	fmt.Printf("openai.enabled: %t\n", cfg.Provider.Flags.OpenAIEnabled)
+	fmt.Printf("openai.authMode: %s\n", cfg.Provider.OpenAI.AuthMode)
+	if state.OpenAI.Connected {
+		fmt.Printf("openai.connection: connected (%s)\n", state.OpenAI.Source)
+	} else {
+		fmt.Printf("openai.connection: disconnected (%s)\n", state.OpenAI.Reason)
+	}
+	fmt.Printf("openai.baseURL: %s\n", cfg.Provider.OpenAI.BaseURL)
+	fmt.Printf("openai.apiKeyEnv: %s\n", cfg.Provider.OpenAI.APIKeyEnv)
+	fmt.Printf("openai.accountTokenEnv: %s\n", cfg.Provider.OpenAI.AccountTokenEnv)
+	fmt.Printf("openai.models: planner=%s coder=%s reviewer=%s\n",
+		cfg.Provider.OpenAI.Models.Planner,
+		cfg.Provider.OpenAI.Models.Coder,
+		cfg.Provider.OpenAI.Models.Reviewer,
+	)
+
+	return nil
+}
+
+func runProviderSet(cmd *cobra.Command, args []string) error {
+	provider := strings.ToLower(strings.TrimSpace(args[0]))
+	if provider != "openai" {
+		return fmt.Errorf("unsupported provider: %s (supported: openai)", provider)
+	}
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	cfg, err := config.Load(cwd)
+	if err != nil {
+		return fmt.Errorf("failed to load configuration: %w", err)
+	}
+
+	cfg.Provider.Default = provider
+	cfg.Provider.Flags.OpenAIEnabled = true
+
+	if err := config.Save(cwd, cfg); err != nil {
+		return fmt.Errorf("failed to save config: %w", err)
+	}
+
+	fmt.Printf("Default provider set to %s\n", provider)
+	return nil
+}
+
+func runProviderList(cmd *cobra.Command, args []string) error {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	state, err := providers.ReadState(cwd)
+	if err != nil {
+		return err
+	}
+
+	if providerJSONFlag {
+		payload := map[string]any{
+			"all":       state.All,
+			"default":   state.Default,
+			"connected": state.Connected,
+		}
+		encoded, marshalErr := json.MarshalIndent(payload, "", "  ")
+		if marshalErr != nil {
+			return fmt.Errorf("failed to serialize provider output: %w", marshalErr)
+		}
+		fmt.Println(string(encoded))
+		return nil
+	}
+
+	fmt.Println("Providers")
+	fmt.Println("---------")
+	if len(state.All) == 0 {
+		fmt.Println("all: (none)")
+	} else {
+		fmt.Printf("all: %s\n", strings.Join(state.All, ", "))
+	}
+
+	if len(state.Default) == 0 {
+		fmt.Println("default: (none)")
+	} else {
+		keys := make([]string, 0, len(state.Default))
+		for provider := range state.Default {
+			keys = append(keys, provider)
+		}
+		sort.Strings(keys)
+		for _, provider := range keys {
+			fmt.Printf("default.%s: %s\n", provider, state.Default[provider])
+		}
+	}
+
+	if len(state.Connected) == 0 {
+		fmt.Println("connected: (none)")
+	} else {
+		fmt.Printf("connected: %s\n", strings.Join(state.Connected, ", "))
+	}
+
+	return nil
+}

package/cmd/provider_model_doctor_test.go

@@ -0,0 +1,91 @@
+package cmd
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+)
+
+func TestProviderAndModelCommands(t *testing.T) {
+	repoRoot := t.TempDir()
+	t.Chdir(repoRoot)
+
+	if err := config.EnsureOrchDir(repoRoot); err != nil {
+		t.Fatalf("ensure orch dir: %v", err)
+	}
+	if err := config.Save(repoRoot, config.DefaultConfig()); err != nil {
+		t.Fatalf("save config: %v", err)
+	}
+
+	if err := runProviderSet(nil, []string{"openai"}); err != nil {
+		t.Fatalf("provider set: %v", err)
+	}
+
+	if err := runModelSet(nil, []string{"coder", "gpt-5.3-codex"}); err != nil {
+		t.Fatalf("model set: %v", err)
+	}
+
+	if err := runProviderShow(nil, nil); err != nil {
+		t.Fatalf("provider show: %v", err)
+	}
+	if err := runModelShow(nil, nil); err != nil {
+		t.Fatalf("model show: %v", err)
+	}
+}
+
+func TestDoctorFailsWithoutAPIKey(t *testing.T) {
+	repoRoot := t.TempDir()
+	t.Chdir(repoRoot)
+
+	if err := config.EnsureOrchDir(repoRoot); err != nil {
+		t.Fatalf("ensure orch dir: %v", err)
+	}
+	if err := config.Save(repoRoot, config.DefaultConfig()); err != nil {
+		t.Fatalf("save config: %v", err)
+	}
+
+	t.Setenv("OPENAI_API_KEY", "")
+	err := runDoctor(nil, nil)
+	if err == nil {
+		t.Fatalf("expected doctor failure without API key")
+	}
+	if !strings.Contains(err.Error(), "doctor failed") {
+		t.Fatalf("unexpected doctor error: %v", err)
+	}
+}
+
+func TestProviderListJSONOutput(t *testing.T) {
+	repoRoot := t.TempDir()
+	t.Chdir(repoRoot)
+
+	if err := config.EnsureOrchDir(repoRoot); err != nil {
+		t.Fatalf("ensure orch dir: %v", err)
+	}
+	if err := config.Save(repoRoot, config.DefaultConfig()); err != nil {
+		t.Fatalf("save config: %v", err)
+	}
+
+	providerJSONFlag = true
+	defer func() { providerJSONFlag = false }()
+
+	out := captureStdout(t, func() {
+		if err := runProviderList(nil, nil); err != nil {
+			t.Fatalf("provider list: %v", err)
+		}
+	})
+
+	var payload map[string]any
+	if err := json.Unmarshal([]byte(out), &payload); err != nil {
+		t.Fatalf("invalid json output: %v\noutput=%s", err, out)
+	}
+
+	all, ok := payload["all"].([]any)
+	if !ok || len(all) == 0 {
+		t.Fatalf("expected non-empty all providers, got: %#v", payload["all"])
+	}
+	if all[0] != "openai" {
+		t.Fatalf("expected openai in all providers, got: %#v", all)
+	}
+}