refactor: slim cmd composition root, move story video flow to internal/video

- Add newProcessor() and newProcessorConfig in processor_config.go; newStoryRunner
  and storyUltraRealistic in story.go; main.go focuses on runCommand wiring.
- Move gallery prompts, GenerateSelectedVideos, and RunStoryVideos into
  internal/video; cli.GenerateSelectedVideos delegates for GUI compatibility.
- Remove t.Parallel from Veo tests that patch newGenaiClient (race with globals).

Made-with: Cursor

1 files changed, 0 insertions, 313 deletions

diff --git a/internal/cli/prompts_test.go b/internal/cli/prompts_test.go
deleted file mode 100644
index 7eb6344..0000000
--- a/internal/cli/prompts_test.go
+++ /dev/null
@@ -1,313 +0,0 @@
-package cli
-
-import (
-	"os"
-	"path/filepath"
-	"reflect"
-	"testing"
-)
-
-// ---------------------------------------------------------------------------
-// parseSelection
-// ---------------------------------------------------------------------------
-
-func TestParseSelection_All(t *testing.T) {
-	got, err := parseSelection("all", 4)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	want := []int{1, 2, 3, 4}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("parseSelection(\"all\", 4) = %v, want %v", got, want)
-	}
-}
-
-func TestParseSelection_AllCaseInsensitive(t *testing.T) {
-	got, err := parseSelection("ALL", 3)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	want := []int{1, 2, 3}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("parseSelection(\"ALL\", 3) = %v, want %v", got, want)
-	}
-}
-
-func TestParseSelection_CommaSeparated(t *testing.T) {
-	got, err := parseSelection("1,3,5", 10)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	want := []int{1, 3, 5}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("parseSelection(\"1,3,5\", 10) = %v, want %v", got, want)
-	}
-}
-
-func TestParseSelection_SortsOutput(t *testing.T) {
-	// Input order is reversed; output must be sorted.
-	got, err := parseSelection("5,2,1", 10)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	want := []int{1, 2, 5}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("parseSelection(\"5,2,1\", 10) = %v, want %v", got, want)
-	}
-}
-
-func TestParseSelection_DuplicatesDeduped(t *testing.T) {
-	got, err := parseSelection("2,2,3", 5)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	want := []int{2, 3}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("parseSelection(\"2,2,3\", 5) = %v, want %v", got, want)
-	}
-}
-
-func TestParseSelection_SinglePage(t *testing.T) {
-	got, err := parseSelection("7", 10)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	want := []int{7}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("parseSelection(\"7\", 10) = %v, want %v", got, want)
-	}
-}
-
-func TestParseSelection_WhitespaceTrimmed(t *testing.T) {
-	got, err := parseSelection(" 1 , 3 , 5 ", 10)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	want := []int{1, 3, 5}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("parseSelection with spaces = %v, want %v", got, want)
-	}
-}
-
-func TestParseSelection_InvalidToken(t *testing.T) {
-	_, err := parseSelection("1,abc,3", 10)
-	if err == nil {
-		t.Fatal("expected error for non-numeric token, got nil")
-	}
-}
-
-func TestParseSelection_ZeroPage(t *testing.T) {
-	_, err := parseSelection("0,1", 5)
-	if err == nil {
-		t.Fatal("expected error for zero page number, got nil")
-	}
-}
-
-func TestParseSelection_NegativePage(t *testing.T) {
-	_, err := parseSelection("-1", 5)
-	if err == nil {
-		t.Fatal("expected error for negative page number, got nil")
-	}
-}
-
-func TestParseSelection_EmptyTokensIgnored(t *testing.T) {
-	// Trailing comma should not produce an error; the empty token is skipped.
-	got, err := parseSelection("1,2,", 5)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	want := []int{1, 2}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("parseSelection(\"1,2,\", 5) = %v, want %v", got, want)
-	}
-}
-
-// ---------------------------------------------------------------------------
-// extractPageNumber
-// ---------------------------------------------------------------------------
-
-func TestExtractPageNumber(t *testing.T) {
-	cases := []struct {
-		input string
-		want  int
-	}{
-		{"story_gallery_1.png", 1},
-		{"my_story_gallery_10.png", 10},
-		{"no_match.png", 0},
-		{"_gallery_.png", 0},  // missing number after marker
-		{"gallery_0.png", 0},  // zero is invalid
-		{"gallery_-1.png", 0}, // negative is invalid
-	}
-
-	for _, tc := range cases {
-		got := extractPageNumber(tc.input)
-		if got != tc.want {
-			t.Errorf("extractPageNumber(%q) = %d, want %d", tc.input, got, tc.want)
-		}
-	}
-}
-
-// ---------------------------------------------------------------------------
-// findGalleryPages
-// ---------------------------------------------------------------------------
-
-func TestFindGalleryPages_NoFiles(t *testing.T) {
-	dir := t.TempDir()
-	pages, paths, err := findGalleryPages(dir)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(pages) != 0 || len(paths) != 0 {
-		t.Errorf("expected empty results for empty dir, got pages=%v paths=%v", pages, paths)
-	}
-}
-
-func TestFindGalleryPages_WithFiles(t *testing.T) {
-	dir := t.TempDir()
-
-	// Create dummy gallery PNGs.
-	for _, name := range []string{
-		"story_gallery_1.png",
-		"story_gallery_3.png",
-		"story_gallery_2.png",
-	} {
-		if err := os.WriteFile(filepath.Join(dir, name), []byte(""), 0644); err != nil {
-			t.Fatalf("creating test file: %v", err)
-		}
-	}
-
-	pages, paths, err := findGalleryPages(dir)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	wantPages := []int{1, 2, 3}
-	if !reflect.DeepEqual(pages, wantPages) {
-		t.Errorf("pages = %v, want %v", pages, wantPages)
-	}
-
-	if len(paths) != 3 {
-		t.Errorf("expected 3 paths, got %d", len(paths))
-	}
-}
-
-// TestFindGalleryPages_Recursive verifies that gallery PNGs placed in
-// subdirectories (as the story runner writes them into comics/<slug>/) are
-// found by the recursive walk.
-func TestFindGalleryPages_Recursive(t *testing.T) {
-	root := t.TempDir()
-
-	// Simulate comics/<slug>/ layout.
-	subDir := filepath.Join(root, "comics", "my_story")
-	if err := os.MkdirAll(subDir, 0o755); err != nil {
-		t.Fatalf("creating subdir: %v", err)
-	}
-
-	for _, name := range []string{
-		"my_story_gallery_1.png",
-		"my_story_gallery_2.png",
-	} {
-		if err := os.WriteFile(filepath.Join(subDir, name), []byte(""), 0644); err != nil {
-			t.Fatalf("creating test file: %v", err)
-		}
-	}
-
-	pages, paths, err := findGalleryPages(root)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	wantPages := []int{1, 2}
-	if !reflect.DeepEqual(pages, wantPages) {
-		t.Errorf("pages = %v, want %v", pages, wantPages)
-	}
-	if len(paths) != 2 {
-		t.Errorf("expected 2 paths, got %d: %v", len(paths), paths)
-	}
-}
-
-// ---------------------------------------------------------------------------
-// filterPathsByPages
-// ---------------------------------------------------------------------------
-
-func TestFilterPathsByPages(t *testing.T) {
-	paths := []string{
-		"/comics/slug/slug_gallery_1.png",
-		"/comics/slug/slug_gallery_2.png",
-		"/comics/slug/slug_gallery_3.png",
-	}
-
-	got := filterPathsByPages(paths, []int{1, 3})
-	want := []string{
-		"/comics/slug/slug_gallery_1.png",
-		"/comics/slug/slug_gallery_3.png",
-	}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("filterPathsByPages = %v, want %v", got, want)
-	}
-}
-
-func TestFilterPathsByPages_All(t *testing.T) {
-	paths := []string{
-		"/comics/slug/slug_gallery_1.png",
-		"/comics/slug/slug_gallery_2.png",
-	}
-
-	got := filterPathsByPages(paths, []int{1, 2})
-	if !reflect.DeepEqual(got, paths) {
-		t.Errorf("filterPathsByPages all = %v, want %v", got, paths)
-	}
-}
-
-func TestFilterPathsByPages_Empty(t *testing.T) {
-	paths := []string{"/comics/slug/slug_gallery_1.png"}
-	got := filterPathsByPages(paths, []int{})
-	if len(got) != 0 {
-		t.Errorf("expected empty result, got %v", got)
-	}
-}
-
-// ---------------------------------------------------------------------------
-// parseSelection — additional edge cases
-// ---------------------------------------------------------------------------
-
-// TestParseSelection_AllWithZeroMax verifies that "all" with a zero max
-// returns an empty (but non-nil) slice, since there are no available pages.
-func TestParseSelection_AllWithZeroMax(t *testing.T) {
-	got, err := parseSelection("all", 0)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(got) != 0 {
-		t.Errorf("parseSelection(\"all\", 0): expected empty slice, got %v", got)
-	}
-}
-
-// TestParseSelection_PageExceedsMax verifies that a page number larger than
-// max is accepted without error — the caller filters against real files.
-func TestParseSelection_PageExceedsMax(t *testing.T) {
-	got, err := parseSelection("99", 5)
-	if err != nil {
-		t.Fatalf("unexpected error for page > max: %v", err)
-	}
-	want := []int{99}
-	if len(got) != 1 || got[0] != want[0] {
-		t.Errorf("parseSelection(\"99\", 5) = %v, want %v", got, want)
-	}
-}
-
-// TestParseSelection_OnlyWhitespace verifies that a purely whitespace input
-// (after trimming) is treated as "all" via the caller, but parseSelection
-// itself should not receive it — nonetheless it should not panic.
-func TestParseSelection_EmptyAfterTrim(t *testing.T) {
-	// Empty string after trimming: no tokens, so result is empty, no error.
-	got, err := parseSelection("   ", 5)
-	if err != nil {
-		t.Fatalf("unexpected error for all-whitespace input: %v", err)
-	}
-	// "all" is the keyword path — plain whitespace is NOT "all", so the
-	// comma-split path runs and produces an empty result (all tokens are "").
-	if len(got) != 0 {
-		t.Errorf("parseSelection(\"   \", 5): expected empty slice, got %v", got)
-	}
-}