procoder-cli 0.1.0

package/internal/app/app.go

@@ -0,0 +1,224 @@
+package app
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/amxv/procoder/internal/apply"
+	"github.com/amxv/procoder/internal/errs"
+	"github.com/amxv/procoder/internal/prepare"
+)
+
+const commandName = "procoder"
+
+var version = "dev"
+var runPrepare = prepare.Run
+var runApplyDryRun = apply.RunDryRun
+var runApply = apply.Run
+
+func Run(args []string, stdout, stderr io.Writer) error {
+	_ = stderr
+
+	if len(args) == 0 || isHelpArg(args[0]) {
+		printRootHelp(stdout)
+		return nil
+	}
+
+	switch args[0] {
+	case "version":
+		_, _ = fmt.Fprintf(stdout, "%s %s\n", commandName, version)
+		return nil
+	case "prepare":
+		if len(args) > 1 && isHelpArg(args[1]) {
+			printPrepareHelp(stdout)
+			return nil
+		}
+		if len(args) > 1 {
+			return errs.New(
+				errs.CodeUnknownCommand,
+				fmt.Sprintf("unknown argument %q for `procoder prepare`", args[1]),
+				errs.WithHint("run `procoder prepare --help`"),
+			)
+		}
+		result, err := runPrepare(prepare.Options{ToolVersion: version})
+		if err != nil {
+			return err
+		}
+		writeLines(stdout, prepare.FormatSuccess(result))
+		return nil
+	case "apply":
+		if len(args) > 1 && isHelpArg(args[1]) {
+			printApplyHelp(stdout)
+			return nil
+		}
+
+		parsed, err := parseApplyArgs(args[1:])
+		if err != nil {
+			return err
+		}
+
+		if parsed.DryRun {
+			plan, err := runApplyDryRun(apply.Options{
+				ReturnPackagePath: parsed.ReturnPackagePath,
+				Namespace:         parsed.Namespace,
+			})
+			if err != nil {
+				return err
+			}
+			writeLines(stdout, apply.FormatDryRun(plan))
+			return nil
+		}
+
+		result, err := runApply(apply.Options{
+			ReturnPackagePath: parsed.ReturnPackagePath,
+			Namespace:         parsed.Namespace,
+			Checkout:          parsed.Checkout,
+		})
+		if err != nil {
+			return err
+		}
+		writeLines(stdout, apply.FormatSuccess(result))
+		return nil
+	default:
+		return errs.New(
+			errs.CodeUnknownCommand,
+			fmt.Sprintf("unknown command %q", args[0]),
+			errs.WithHint(fmt.Sprintf("run `%s --help`", commandName)),
+		)
+	}
+}
+
+type applyArgs struct {
+	ReturnPackagePath string
+	DryRun            bool
+	Namespace         string
+	Checkout          bool
+}
+
+func parseApplyArgs(args []string) (applyArgs, error) {
+	parsed := applyArgs{}
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		switch {
+		case arg == "--dry-run":
+			parsed.DryRun = true
+		case arg == "--checkout":
+			parsed.Checkout = true
+		case arg == "--namespace":
+			if i+1 >= len(args) {
+				return applyArgs{}, errs.New(
+					errs.CodeUnknownCommand,
+					"missing value for `--namespace`",
+					errs.WithHint("run `procoder apply --help`"),
+				)
+			}
+			i++
+			value := strings.TrimSpace(args[i])
+			if value == "" {
+				return applyArgs{}, errs.New(
+					errs.CodeUnknownCommand,
+					"namespace prefix for `--namespace` must not be empty",
+					errs.WithHint("run `procoder apply --help`"),
+				)
+			}
+			parsed.Namespace = value
+		case strings.HasPrefix(arg, "--namespace="):
+			value := strings.TrimSpace(strings.TrimPrefix(arg, "--namespace="))
+			if value == "" {
+				return applyArgs{}, errs.New(
+					errs.CodeUnknownCommand,
+					"namespace prefix for `--namespace` must not be empty",
+					errs.WithHint("run `procoder apply --help`"),
+				)
+			}
+			parsed.Namespace = value
+		case strings.HasPrefix(arg, "-"):
+			return applyArgs{}, unknownApplyArgument(arg)
+		default:
+			if parsed.ReturnPackagePath == "" {
+				parsed.ReturnPackagePath = arg
+				continue
+			}
+			return applyArgs{}, unknownApplyArgument(arg)
+		}
+	}
+
+	if strings.TrimSpace(parsed.ReturnPackagePath) == "" {
+		return applyArgs{}, errs.New(
+			errs.CodeUnknownCommand,
+			"missing return package path for `procoder apply`",
+			errs.WithHint("run `procoder apply --help`"),
+		)
+	}
+
+	return parsed, nil
+}
+
+func unknownApplyArgument(arg string) error {
+	return errs.New(
+		errs.CodeUnknownCommand,
+		fmt.Sprintf("unknown argument %q for `procoder apply`", arg),
+		errs.WithHint("run `procoder apply --help`"),
+	)
+}
+
+func isHelpArg(v string) bool {
+	switch v {
+	case "-h", "--help", "help":
+		return true
+	default:
+		return false
+	}
+}
+
+func printRootHelp(w io.Writer) {
+	writeLines(w,
+		"procoder",
+		"",
+		"Usage:",
+		"  procoder <command> [arguments]",
+		"",
+		"Commands:",
+		"  prepare                        create a task package",
+		"  apply <return-package.zip>     apply a return package",
+		"  version                        print CLI version",
+		"",
+		"Examples:",
+		"  procoder prepare",
+		"  procoder apply procoder-return-<exchange-id>.zip --dry-run",
+		"  procoder version",
+	)
+}
+
+func printPrepareHelp(w io.Writer) {
+	writeLines(w,
+		"procoder prepare - create a task package",
+		"",
+		"Usage:",
+		"  procoder prepare",
+		"",
+		"Examples:",
+		"  procoder prepare",
+	)
+}
+
+func printApplyHelp(w io.Writer) {
+	writeLines(w,
+		"procoder apply - apply a return package",
+		"",
+		"Usage:",
+		"  procoder apply <return-package.zip> [--dry-run] [--namespace <prefix>] [--checkout]",
+		"",
+		"Examples:",
+		"  procoder apply procoder-return-<exchange-id>.zip",
+		"  procoder apply procoder-return-<exchange-id>.zip --dry-run",
+		"  procoder apply procoder-return-<exchange-id>.zip --dry-run --namespace procoder-import",
+	)
+}
+
+func writeLines(w io.Writer, lines ...string) {
+	for _, line := range lines {
+		_, _ = fmt.Fprintln(w, line)
+	}
+}

package/internal/app/app_test.go

@@ -0,0 +1,253 @@
+package app
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/amxv/procoder/internal/apply"
+	"github.com/amxv/procoder/internal/errs"
+	"github.com/amxv/procoder/internal/prepare"
+)
+
+func TestRunRootHelp(t *testing.T) {
+	var out bytes.Buffer
+	var errBuf bytes.Buffer
+
+	err := Run([]string{"--help"}, &out, &errBuf)
+	if err != nil {
+		t.Fatalf("Run returned error: %v", err)
+	}
+
+	if !strings.Contains(out.String(), "Usage:") {
+		t.Fatalf("expected help output, got: %q", out.String())
+	}
+	if !strings.Contains(out.String(), "prepare") {
+		t.Fatalf("expected prepare command in help output, got: %q", out.String())
+	}
+}
+
+func TestRunVersion(t *testing.T) {
+	var out bytes.Buffer
+	var errBuf bytes.Buffer
+
+	err := Run([]string{"version"}, &out, &errBuf)
+	if err != nil {
+		t.Fatalf("Run returned error: %v", err)
+	}
+
+	if !strings.Contains(out.String(), "procoder ") {
+		t.Fatalf("unexpected output: %q", out.String())
+	}
+}
+
+func TestRunApplyHelpTerminology(t *testing.T) {
+	var out bytes.Buffer
+	var errBuf bytes.Buffer
+
+	err := Run([]string{"apply", "--help"}, &out, &errBuf)
+	if err != nil {
+		t.Fatalf("Run returned error: %v", err)
+	}
+
+	got := out.String()
+	if !strings.Contains(got, "return package") {
+		t.Fatalf("expected return package terminology in apply help, got: %q", got)
+	}
+	if strings.Contains(got, "<reply.zip>") {
+		t.Fatalf("unexpected stale reply terminology in apply help, got: %q", got)
+	}
+}
+
+func TestRunPrepareCommand(t *testing.T) {
+	originalRunPrepare := runPrepare
+	t.Cleanup(func() {
+		runPrepare = originalRunPrepare
+	})
+
+	runPrepare = func(opts prepare.Options) (prepare.Result, error) {
+		if opts.ToolVersion == "" {
+			t.Fatal("expected tool version to be passed into prepare options")
+		}
+		return prepare.Result{
+			ExchangeID:      "20260320-120000-a1b2c3",
+			TaskRootRef:     "refs/heads/procoder/20260320-120000-a1b2c3/task",
+			TaskPackagePath: "/tmp/procoder-task-20260320-120000-a1b2c3.zip",
+		}, nil
+	}
+
+	var out bytes.Buffer
+	var errBuf bytes.Buffer
+
+	err := Run([]string{"prepare"}, &out, &errBuf)
+	if err != nil {
+		t.Fatalf("Run returned error: %v", err)
+	}
+
+	got := out.String()
+	if !strings.Contains(got, "Prepared exchange.") {
+		t.Fatalf("expected prepare success header, got: %q", got)
+	}
+	if !strings.Contains(got, "refs/heads/procoder/20260320-120000-a1b2c3/task") {
+		t.Fatalf("expected task branch in output, got: %q", got)
+	}
+	if !strings.Contains(got, "/tmp/procoder-task-20260320-120000-a1b2c3.zip") {
+		t.Fatalf("expected task package path in output, got: %q", got)
+	}
+}
+
+func TestRunApplyDryRunCommand(t *testing.T) {
+	originalRunApplyDryRun := runApplyDryRun
+	originalRunApply := runApply
+	t.Cleanup(func() {
+		runApplyDryRun = originalRunApplyDryRun
+		runApply = originalRunApply
+	})
+	runApply = func(opts apply.Options) (apply.Result, error) {
+		t.Fatalf("write-mode apply should not be called during dry-run test: %#v", opts)
+		return apply.Result{}, nil
+	}
+
+	runApplyDryRun = func(opts apply.Options) (apply.Plan, error) {
+		if opts.ReturnPackagePath != "procoder-return-20260320-120000-a1b2c3.zip" {
+			t.Fatalf("unexpected return package path: %q", opts.ReturnPackagePath)
+		}
+		if opts.Namespace != "procoder-import" {
+			t.Fatalf("unexpected namespace: %q", opts.Namespace)
+		}
+		return apply.Plan{
+			ExchangeID:        "20260320-120000-a1b2c3",
+			ReturnPackagePath: "/tmp/procoder-return-20260320-120000-a1b2c3.zip",
+			Namespace:         "procoder-import",
+			Checks: []apply.Check{
+				{Name: "bundle verification", Detail: "git bundle verify passed"},
+			},
+			Entries: []apply.PlanEntry{
+				{
+					Action:         apply.ActionUpdate,
+					SourceRef:      "refs/heads/procoder/20260320-120000-a1b2c3/task",
+					DestinationRef: "refs/heads/procoder-import/20260320-120000-a1b2c3/task",
+					OldOID:         "old",
+					NewOID:         "new",
+					Remapped:       true,
+				},
+			},
+			Summary: apply.Summary{Updates: 1},
+		}, nil
+	}
+
+	var out bytes.Buffer
+	var errBuf bytes.Buffer
+	err := Run([]string{
+		"apply",
+		"procoder-return-20260320-120000-a1b2c3.zip",
+		"--dry-run",
+		"--namespace",
+		"procoder-import",
+	}, &out, &errBuf)
+	if err != nil {
+		t.Fatalf("Run returned error: %v", err)
+	}
+
+	got := out.String()
+	if !strings.Contains(got, "Dry-run apply plan.") {
+		t.Fatalf("expected dry-run plan header, got: %q", got)
+	}
+	if !strings.Contains(got, "REMAP") {
+		t.Fatalf("expected remap output, got: %q", got)
+	}
+}
+
+func TestRunApplyWriteModeCommand(t *testing.T) {
+	originalRunApplyDryRun := runApplyDryRun
+	originalRunApply := runApply
+	t.Cleanup(func() {
+		runApplyDryRun = originalRunApplyDryRun
+		runApply = originalRunApply
+	})
+	runApplyDryRun = func(opts apply.Options) (apply.Plan, error) {
+		t.Fatalf("dry-run apply should not be called in write-mode test: %#v", opts)
+		return apply.Plan{}, nil
+	}
+	runApply = func(opts apply.Options) (apply.Result, error) {
+		if opts.ReturnPackagePath != "procoder-return-20260320-120000-a1b2c3.zip" {
+			t.Fatalf("unexpected return package path: %q", opts.ReturnPackagePath)
+		}
+		if opts.Namespace != "procoder-import" {
+			t.Fatalf("unexpected namespace: %q", opts.Namespace)
+		}
+		if !opts.Checkout {
+			t.Fatalf("expected checkout=true in apply options")
+		}
+		return apply.Result{
+			Plan: apply.Plan{
+				ExchangeID:        "20260320-120000-a1b2c3",
+				ReturnPackagePath: "/tmp/procoder-return-20260320-120000-a1b2c3.zip",
+				Namespace:         "procoder-import",
+				Summary:           apply.Summary{Creates: 1, Updates: 1},
+			},
+			CheckedOutRef: "refs/heads/procoder-import/20260320-120000-a1b2c3/task",
+		}, nil
+	}
+
+	var out bytes.Buffer
+	var errBuf bytes.Buffer
+
+	err := Run([]string{
+		"apply",
+		"procoder-return-20260320-120000-a1b2c3.zip",
+		"--namespace",
+		"procoder-import",
+		"--checkout",
+	}, &out, &errBuf)
+	if err != nil {
+		t.Fatalf("Run returned error: %v", err)
+	}
+
+	got := out.String()
+	if !strings.Contains(got, "Applied return package.") {
+		t.Fatalf("expected apply success output, got: %q", got)
+	}
+	if !strings.Contains(got, "Checked out: refs/heads/procoder-import/20260320-120000-a1b2c3/task") {
+		t.Fatalf("expected checked-out ref in output, got: %q", got)
+	}
+}
+
+func TestRunApplyMissingPackagePath(t *testing.T) {
+	var out bytes.Buffer
+	var errBuf bytes.Buffer
+
+	err := Run([]string{"apply", "--dry-run"}, &out, &errBuf)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+
+	typed, ok := errs.As(err)
+	if !ok {
+		t.Fatalf("expected typed error, got %T", err)
+	}
+	if typed.Code != errs.CodeUnknownCommand {
+		t.Fatalf("unexpected code: got %s want %s", typed.Code, errs.CodeUnknownCommand)
+	}
+	if !strings.Contains(typed.Message, "missing return package path") {
+		t.Fatalf("expected missing path message, got %q", typed.Message)
+	}
+}
+
+func TestRunUnknownCommand(t *testing.T) {
+	var out bytes.Buffer
+	var errBuf bytes.Buffer
+
+	err := Run([]string{"unknown"}, &out, &errBuf)
+	if err == nil {
+		t.Fatal("expected error for unknown command")
+	}
+
+	typed, ok := errs.As(err)
+	if !ok {
+		t.Fatalf("expected typed error, got %T", err)
+	}
+	if typed.Code != errs.CodeUnknownCommand {
+		t.Fatalf("unexpected error code: %s", typed.Code)
+	}
+}

package/internal/app/roundtrip_test.go

@@ -0,0 +1,215 @@
+package app_test
+
+import (
+	"archive/zip"
+	"bytes"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	apppkg "github.com/amxv/procoder/internal/app"
+	"github.com/amxv/procoder/internal/exchange"
+	"github.com/amxv/procoder/internal/returnpkg"
+	"github.com/amxv/procoder/internal/testutil/gitrepo"
+)
+
+func TestCLIEndToEndPrepareReturnApply(t *testing.T) {
+	source := gitrepo.New(t)
+	source.WriteFile("README.md", "source\n")
+	source.CommitAll("initial")
+
+	helperPath := writeHelperBinary(t)
+	t.Setenv("PROCODER_RETURN_HELPER", helperPath)
+	t.Chdir(source.Dir)
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	if err := apppkg.Run([]string{"prepare"}, &stdout, &stderr); err != nil {
+		t.Fatalf("app.Run prepare failed: %v", err)
+	}
+	if !strings.Contains(stdout.String(), "Prepared exchange.") {
+		t.Fatalf("expected prepare success output, got:\n%s", stdout.String())
+	}
+
+	taskPackages, err := filepath.Glob(filepath.Join(source.Dir, "procoder-task-*.zip"))
+	if err != nil {
+		t.Fatalf("glob task package failed: %v", err)
+	}
+	if len(taskPackages) != 1 {
+		t.Fatalf("expected exactly one task package, got %d (%v)", len(taskPackages), taskPackages)
+	}
+
+	exportRoot := unzipTaskPackage(t, taskPackages[0])
+	ex, err := exchange.ReadExchange(filepath.Join(exportRoot, ".git", "procoder", "exchange.json"))
+	if err != nil {
+		t.Fatalf("ReadExchange(export) failed: %v", err)
+	}
+
+	appendFile(t, filepath.Join(exportRoot, "README.md"), "remote change\n")
+	runGit(t, exportRoot, "add", "README.md")
+	runGit(t, exportRoot, "commit", "-m", "remote task update")
+
+	retResult, err := returnpkg.Run(returnpkg.Options{
+		CWD:         exportRoot,
+		ToolVersion: "0.1.0-test",
+		Now:         func() time.Time { return time.Date(2026, time.March, 20, 16, 0, 0, 0, time.UTC) },
+	})
+	if err != nil {
+		t.Fatalf("returnpkg.Run failed: %v", err)
+	}
+
+	retRecord := readReturnRecordFromZip(t, retResult.ReturnPackagePath)
+	taskUpdate, ok := findUpdate(retRecord.Updates, ex.Task.RootRef)
+	if !ok {
+		t.Fatalf("expected task root update in return record")
+	}
+
+	stdout.Reset()
+	stderr.Reset()
+	if err := apppkg.Run([]string{"apply", retResult.ReturnPackagePath, "--checkout"}, &stdout, &stderr); err != nil {
+		t.Fatalf("app.Run apply failed: %v", err)
+	}
+	if !strings.Contains(stdout.String(), "Applied return package.") {
+		t.Fatalf("expected apply success output, got:\n%s", stdout.String())
+	}
+	if !strings.Contains(stdout.String(), "Checked out: "+ex.Task.RootRef) {
+		t.Fatalf("expected checked-out ref in apply output, got:\n%s", stdout.String())
+	}
+
+	if got := strings.TrimSpace(source.Git("rev-parse", ex.Task.RootRef)); got != taskUpdate.NewOID {
+		t.Fatalf("task ref mismatch after CLI apply: got %q want %q", got, taskUpdate.NewOID)
+	}
+	if got := strings.TrimSpace(source.Git("symbolic-ref", "--quiet", "HEAD")); got != ex.Task.RootRef {
+		t.Fatalf("expected CLI apply to check out task ref: got %q want %q", got, ex.Task.RootRef)
+	}
+	assertNoImportRefs(t, source.Dir)
+}
+
+func writeHelperBinary(t *testing.T) string {
+	t.Helper()
+
+	path := filepath.Join(t.TempDir(), "procoder-return")
+	if err := os.WriteFile(path, []byte("#!/bin/sh\nexit 0\n"), 0o755); err != nil {
+		t.Fatalf("write helper binary failed: %v", err)
+	}
+	return path
+}
+
+func readReturnRecordFromZip(t *testing.T, zipPath string) exchange.Return {
+	t.Helper()
+
+	extracted := unzipFile(t, zipPath)
+	record, err := exchange.ReadReturn(filepath.Join(extracted, "procoder-return.json"))
+	if err != nil {
+		t.Fatalf("ReadReturn failed: %v", err)
+	}
+	return record
+}
+
+func unzipTaskPackage(t *testing.T, zipPath string) string {
+	t.Helper()
+
+	dest := unzipFile(t, zipPath)
+	return filepath.Join(dest, filepath.Base(filepath.Dir(zipPath)))
+}
+
+func unzipFile(t *testing.T, zipPath string) string {
+	t.Helper()
+
+	reader, err := zip.OpenReader(zipPath)
+	if err != nil {
+		t.Fatalf("zip.OpenReader failed: %v", err)
+	}
+	defer reader.Close()
+
+	dest := t.TempDir()
+	for _, file := range reader.File {
+		targetPath := filepath.Join(dest, file.Name)
+		safePrefix := filepath.Clean(dest) + string(os.PathSeparator)
+		if !strings.HasPrefix(filepath.Clean(targetPath), safePrefix) {
+			t.Fatalf("zip entry escapes destination: %q", file.Name)
+		}
+
+		if file.FileInfo().IsDir() {
+			if err := os.MkdirAll(targetPath, 0o755); err != nil {
+				t.Fatalf("mkdir failed: %v", err)
+			}
+			continue
+		}
+
+		if err := os.MkdirAll(filepath.Dir(targetPath), 0o755); err != nil {
+			t.Fatalf("mkdir file dir failed: %v", err)
+		}
+		in, err := file.Open()
+		if err != nil {
+			t.Fatalf("open zip entry failed: %v", err)
+		}
+		out, err := os.OpenFile(targetPath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, file.Mode())
+		if err != nil {
+			_ = in.Close()
+			t.Fatalf("open extracted file failed: %v", err)
+		}
+		if _, err := io.Copy(out, in); err != nil {
+			_ = out.Close()
+			_ = in.Close()
+			t.Fatalf("copy extracted file failed: %v", err)
+		}
+		_ = out.Close()
+		_ = in.Close()
+	}
+	return dest
+}
+
+func appendFile(t *testing.T, path, extra string) {
+	t.Helper()
+
+	f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
+	if err != nil {
+		t.Fatalf("open %s for append failed: %v", path, err)
+	}
+	if _, err := f.WriteString(extra); err != nil {
+		_ = f.Close()
+		t.Fatalf("append to %s failed: %v", path, err)
+	}
+	if err := f.Close(); err != nil {
+		t.Fatalf("close %s failed: %v", path, err)
+	}
+}
+
+func runGit(t *testing.T, dir string, args ...string) string {
+	t.Helper()
+
+	cmd := exec.Command("git", args...)
+	cmd.Dir = dir
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("git %s failed:\nstdout:\n%s\nstderr:\n%s\nerr:%v", strings.Join(args, " "), stdout.String(), stderr.String(), err)
+	}
+	return stdout.String()
+}
+
+func findUpdate(updates []exchange.RefUpdate, ref string) (exchange.RefUpdate, bool) {
+	for _, update := range updates {
+		if update.Ref == ref {
+			return update, true
+		}
+	}
+	return exchange.RefUpdate{}, false
+}
+
+func assertNoImportRefs(t *testing.T, dir string) {
+	t.Helper()
+
+	importRefs := strings.TrimSpace(runGit(t, dir, "for-each-ref", "--format=%(refname)", "refs/procoder/import"))
+	if importRefs != "" {
+		t.Fatalf("expected temporary import refs to be cleaned up, got:\n%s", importRefs)
+	}
+}