Commit a2aed2947d90

@@ -0,0 +1,30 @@
+{
+  lib,
+  buildGoModule,
+  fetchFromGitHub,
+}:
+
+buildGoModule rec {
+  pname = "cliphist-cleanup";
+  version = "0.1.0";
+
+  src = fetchFromGitHub {
+    owner = "vdemeester";
+    repo = "x";
+    rev = "be677194b497b7610395f9f269418224a9ad999d";
+    hash = "sha256-AfmqSrI7XicmM+tiAvB6bcAR4HHbQmxqeTTEyEXgdng=";
+  };
+
+  vendorHash = "sha256-hocnLCzWN8srQcO3BMNkd2lt0m54Qe7sqAhUxVZlz1k=";
+
+  # Build only the cliphist-cleanup command
+  subPackages = [ "cmd/cliphist-cleanup" ];
+
+  meta = {
+    description = "Clean up cliphist clipboard history by pattern matching";
+    homepage = "https://github.com/vdemeester/x";
+    license = lib.licenses.mit;
+    platforms = lib.platforms.linux;
+    mainProgram = "cliphist-cleanup";
+  };
+}

@@ -6,21 +6,28 @@
   gh,
   fzf,
   jq,
+  fetchFromGitHub,
 }:
 
-buildGoModule {
+buildGoModule rec {
   pname = "gh-pr";
   version = "0.1.0";
-  src = ./.;
 
-  vendorHash = "sha256-hocnLCzWN8srQcO3BMNkd2lt0m54Qe7sqAhUxVZlz1k="; # No external dependencies
+  src = fetchFromGitHub {
+    owner = "vdemeester";
+    repo = "x";
+    rev = "be677194b497b7610395f9f269418224a9ad999d";
+    hash = "sha256-AfmqSrI7XicmM+tiAvB6bcAR4HHbQmxqeTTEyEXgdng=";
+  };
+
+  vendorHash = "sha256-hocnLCzWN8srQcO3BMNkd2lt0m54Qe7sqAhUxVZlz1k=";
 
   nativeBuildInputs = [
     makeWrapper
     installShellFiles
   ];
 
-  # Build all binaries
+  # Build the gh-pr command
   subPackages = [ "cmd/gh-pr" ];
 
   # Wrap binary to include gh, fzf, and jq in PATH and install completions
@@ -42,7 +49,8 @@ buildGoModule {
   '';
 
   meta = {
-    description = "GitHub Pull Request management tool with template support, workflow restart, conflict resolution, and batch commenting";
+    description = "GitHub Pull Request management tool";
+    homepage = "https://github.com/vdemeester/x";
     license = lib.licenses.mit;
     platforms = lib.platforms.unix;
     mainProgram = "gh-pr";

@@ -22,10 +22,10 @@ in
   govanityurl = pkgs.callPackage ./govanityurl { };
   batzconverter = pkgs.callPackage ./batzconverter { };
   manifest-tool = pkgs.callPackage ./manifest-tool { };
-  gh-pr = pkgs.callPackage ../tools/gh-pr { };
+  gh-pr = pkgs.callPackage ./gh-pr { };
   arr = pkgs.callPackage ../tools/arr { };
   download-kiwix-zim = pkgs.callPackage ../tools/download-kiwix-zim { };
-  cliphist-cleanup = pkgs.callPackage ../tools/cliphist-cleanup { };
+  cliphist-cleanup = pkgs.callPackage ./cliphist-cleanup { };
   toggle-color-scheme = pkgs.callPackage ./toggle-color-scheme { };
   homepage = pkgs.callPackage ./homepage { inherit globals; };
   audible-converter = pkgs.callPackage ./audible-converter { };

@@ -1,19 +0,0 @@
-{
-  lib,
-  buildGoModule,
-}:
-
-buildGoModule {
-  pname = "cliphist-cleanup";
-  version = "0.1.0";
-  src = ./.;
-
-  vendorHash = null;
-
-  meta = {
-    description = "Clean up cliphist clipboard history by pattern matching";
-    license = lib.licenses.mit;
-    platforms = lib.platforms.linux;
-    mainProgram = "cliphist-cleanup";
-  };
-}

@@ -1,3 +0,0 @@
-module cliphist-cleanup
-
-go 1.25.4

@@ -1,108 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"os"
-	"os/exec"
-	"regexp"
-	"strings"
-)
-
-func main() {
-	if len(os.Args) < 2 {
-		fmt.Fprintln(os.Stderr, "Usage: cliphist-cleanup <pattern> [pattern2] [pattern3] ...")
-		fmt.Fprintln(os.Stderr, "")
-		fmt.Fprintln(os.Stderr, "Examples:")
-		fmt.Fprintln(os.Stderr, "  cliphist-cleanup 'Signed-off-by:'")
-		fmt.Fprintln(os.Stderr, "  cliphist-cleanup '^# This is' 'Co-Authored-By:'")
-		fmt.Fprintln(os.Stderr, "")
-		fmt.Fprintln(os.Stderr, "Patterns are treated as regular expressions (case-insensitive).")
-		os.Exit(1)
-	}
-
-	// Compile patterns
-	patterns := make([]*regexp.Regexp, 0, len(os.Args)-1)
-	for _, pattern := range os.Args[1:] {
-		re, err := regexp.Compile("(?i)" + pattern)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error compiling pattern '%s': %v\n", pattern, err)
-			os.Exit(1)
-		}
-		patterns = append(patterns, re)
-	}
-
-	// Get clipboard history
-	cmd := exec.Command("cliphist", "list")
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error creating pipe: %v\n", err)
-		os.Exit(1)
-	}
-
-	if err := cmd.Start(); err != nil {
-		fmt.Fprintf(os.Stderr, "Error starting cliphist list: %v\n", err)
-		os.Exit(1)
-	}
-
-	// Read entries and delete matching ones
-	scanner := bufio.NewScanner(stdout)
-	deleted := 0
-	checked := 0
-
-	for scanner.Scan() {
-		line := scanner.Text()
-		checked++
-
-		// Check if line matches any pattern
-		matched := false
-		for _, re := range patterns {
-			if re.MatchString(line) {
-				matched = true
-				break
-			}
-		}
-
-		if matched {
-			// Delete this entry using delete-query
-			// The line format from cliphist list is: "ID\tCONTENT"
-			// We need to extract the content part after the tab
-			parts := strings.SplitN(line, "\t", 2)
-			if len(parts) < 2 {
-				continue
-			}
-
-			content := parts[1]
-			deleteCmd := exec.Command("cliphist", "delete-query", content)
-			if err := deleteCmd.Run(); err != nil {
-				fmt.Fprintf(os.Stderr, "Warning: Failed to delete entry: %v\n", err)
-			} else {
-				deleted++
-				fmt.Printf("Deleted: %s\n", truncate(content, 80))
-			}
-		}
-	}
-
-	if err := scanner.Err(); err != nil {
-		fmt.Fprintf(os.Stderr, "Error reading cliphist output: %v\n", err)
-		os.Exit(1)
-	}
-
-	if err := cmd.Wait(); err != nil {
-		fmt.Fprintf(os.Stderr, "Error waiting for cliphist: %v\n", err)
-		os.Exit(1)
-	}
-
-	fmt.Printf("\nChecked %d entries, deleted %d entries\n", checked, deleted)
-}
-
-func truncate(s string, maxLen int) string {
-	// Replace newlines with spaces for display
-	s = strings.ReplaceAll(s, "\n", " ")
-	s = strings.ReplaceAll(s, "\r", " ")
-
-	if len(s) <= maxLen {
-		return s
-	}
-	return s[:maxLen-3] + "..."
-}

@@ -1,48 +0,0 @@
-# cliphist-cleanup
-
-Clean up your clipboard history by deleting entries matching specific patterns.
-
-## Usage
-
-```bash
-cliphist-cleanup <pattern> [pattern2] [pattern3] ...
-```
-
-Patterns are treated as case-insensitive regular expressions.
-
-## Examples
-
-Delete all git sign-off entries:
-```bash
-cliphist-cleanup 'Signed-off-by:'
-```
-
-Delete multiple types of git commit messages:
-```bash
-cliphist-cleanup '# This is a combination' 'Co-Authored-By:'
-```
-
-Delete entries starting with specific text:
-```bash
-cliphist-cleanup '^password:' '^token:'
-```
-
-## How It Works
-
-1. Lists all clipboard history entries using `cliphist list`
-2. Matches each entry against the provided patterns
-3. Deletes matching entries using `cliphist delete-query`
-4. Reports the number of entries checked and deleted
-
-## Building
-
-```bash
-nix build .#cliphist-cleanup
-```
-
-## Installing
-
-Add to your home-manager packages or install directly:
-```bash
-nix profile install .#cliphist-cleanup
-```

@@ -1,374 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/vdemeester/home/tools/gh-pr/internal/output"
-)
-
-func approveCmd(out *output.Writer) *cobra.Command {
-	var (
-		prow          bool
-		merge         bool
-		force         bool
-		comment       string
-		editorComment bool
-		interactive   bool
-	)
-
-	cmd := &cobra.Command{
-		Use:   "approve [projects...]",
-		Short: "Approve pull requests",
-		Long: `Select and approve pull requests using fzf.
-
-This command lists pull requests from specified GitHub repositories and allows
-you to select and approve them interactively. You can optionally merge approved
-PRs and add custom comments.
-
-If no projects are specified, uses default Tekton projects:
-- tektoncd/pipeline
-- tektoncd/plumbing
-- tektoncd/cli
-- tektoncd/mcp-server
-
-Examples:
-  # Approve PRs from default projects
-  gh-pr approve
-
-  # Approve PRs from specific projects
-  gh-pr approve tektoncd/pipeline tektoncd/cli
-
-  # Approve with Prow comment
-  gh-pr approve -p tektoncd/pipeline
-
-  # Approve and merge
-  gh-pr approve -m tektoncd/pipeline
-
-  # Approve with custom comment
-  gh-pr approve -c "LGTM! Great work" tektoncd/pipeline
-
-  # Approve with editor for multi-line comment
-  gh-pr approve -C tektoncd/pipeline
-
-  # Force merge (requires admin)
-  gh-pr approve -m -f tektoncd/pipeline`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			projects := args
-			if len(projects) == 0 {
-				// Use default Tekton projects
-				projects = []string{
-					"tektoncd/pipeline",
-					"tektoncd/plumbing",
-					"tektoncd/cli",
-					"tektoncd/mcp-server",
-				}
-			}
-
-			return runApprove(out, approveOpts{
-				projects:      projects,
-				prow:          prow,
-				merge:         merge,
-				force:         force,
-				comment:       comment,
-				editorComment: editorComment,
-				interactive:   interactive,
-			})
-		},
-	}
-
-	cmd.Flags().BoolVarP(&prow, "prow", "p", false, "Add Prow /lgtm comment")
-	cmd.Flags().BoolVarP(&merge, "merge", "m", false, "Merge PR after approval")
-	cmd.Flags().BoolVarP(&force, "force", "f", false, "Force merge with --admin (requires admin rights)")
-	cmd.Flags().StringVarP(&comment, "comment", "c", "", "Custom approval comment")
-	cmd.Flags().BoolVarP(&editorComment, "editor", "C", false, "Open editor for multi-line comment")
-	cmd.Flags().BoolVarP(&interactive, "interactive", "i", false, "Prompt for comment interactively")
-
-	return cmd
-}
-
-type approveOpts struct {
-	projects      []string
-	prow          bool
-	merge         bool
-	force         bool
-	comment       string
-	editorComment bool
-	interactive   bool
-}
-
-func runApprove(out *output.Writer, opts approveOpts) error {
-	// Check if fzf is available
-	if _, err := exec.LookPath("fzf"); err != nil {
-		return fmt.Errorf("fzf is required but not found in PATH: %w", err)
-	}
-
-	// Handle comment options
-	commentBody := opts.comment
-	if opts.editorComment {
-		body, err := getEditorComment()
-		if err != nil {
-			return fmt.Errorf("failed to get editor comment: %w", err)
-		}
-		commentBody = body
-	} else if commentBody == "" && opts.interactive {
-		out.Info("Enter approval comment (press Enter to skip):")
-		reader := bufio.NewReader(os.Stdin)
-		line, err := reader.ReadString('\n')
-		if err != nil {
-			return fmt.Errorf("failed to read comment: %w", err)
-		}
-		commentBody = strings.TrimSpace(line)
-	}
-
-	// Process each project
-	for _, project := range opts.projects {
-		out.Info("Processing project: %s", project)
-
-		if err := processProject(out, project, commentBody, opts); err != nil {
-			out.Error("Failed to process project %s: %v", project, err)
-			continue
-		}
-	}
-
-	return nil
-}
-
-func processProject(out *output.Writer, project, commentBody string, opts approveOpts) error {
-	// Build gh pr list command
-	ghArgs := []string{"pr", "list", "--repo", project, "--json", "number,title,author"}
-
-	ghCmd := exec.Command("gh", ghArgs...)
-	ghOutput, err := ghCmd.Output()
-	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			return fmt.Errorf("gh pr list failed: %s", exitErr.Stderr)
-		}
-		return fmt.Errorf("gh pr list failed: %w", err)
-	}
-
-	prListJSON := strings.TrimSpace(string(ghOutput))
-	if prListJSON == "" || prListJSON == "[]" {
-		out.Warning("No pull requests found in %s", project)
-		return nil
-	}
-
-	// Format PR list for fzf using jq
-	jqCmd := exec.Command("jq", "-r",
-		`.[] | (.number | tostring) + "\t" + .author.login + "\t" + .title`)
-	jqCmd.Stdin = strings.NewReader(prListJSON)
-	jqOutput, err := jqCmd.Output()
-	if err != nil {
-		return fmt.Errorf("failed to format PR list: %w", err)
-	}
-
-	formattedList := strings.TrimSpace(string(jqOutput))
-	if formattedList == "" {
-		out.Warning("No pull requests to display in %s", project)
-		return nil
-	}
-
-	// Use column to align the output
-	columnCmd := exec.Command("column", "-t", "-s", "\t")
-	columnCmd.Stdin = strings.NewReader(formattedList)
-	columnOutput, err := columnCmd.Output()
-	if err != nil {
-		// If column fails, use the original formatted list
-		columnOutput = []byte(formattedList)
-	}
-
-	// Build preview command for fzf
-	previewCmd := fmt.Sprintf(`gh pr checks --repo=%s {1} --json 'name,state' 2>/dev/null | \
-		jq -r 'map(.state + ": " + .name) | .[]' || echo "No checks found"`, project)
-
-	// Use fzf for multi-select with preview
-	out.Info("Select PRs to approve from %s (Tab: multi-select, Enter: confirm)...", project)
-	fzfCmd := exec.Command("fzf",
-		"--multi",
-		"--ansi",
-		"--header", fmt.Sprintf("Select PRs from %s (Tab: select, Enter: confirm)", project),
-		"--preview", previewCmd,
-		"--preview-window", "right:50%:wrap",
-	)
-	fzfCmd.Stdin = bytes.NewReader(columnOutput)
-	fzfCmd.Stderr = os.Stderr
-
-	selectedOutput, err := fzfCmd.Output()
-	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 130 {
-			// User cancelled with Ctrl+C
-			out.Info("Selection cancelled for %s", project)
-			return nil
-		}
-		return fmt.Errorf("fzf selection failed: %w", err)
-	}
-
-	selectedPRs := strings.TrimSpace(string(selectedOutput))
-	if selectedPRs == "" {
-		out.Info("No pull requests selected from %s", project)
-		return nil
-	}
-
-	// Extract PR numbers from selected lines
-	prNumbers := []string{}
-	scanner := bufio.NewScanner(strings.NewReader(selectedPRs))
-	for scanner.Scan() {
-		line := scanner.Text()
-		// Extract PR number from the first field
-		fields := strings.Fields(line)
-		if len(fields) > 0 {
-			prNumbers = append(prNumbers, fields[0])
-		}
-	}
-
-	if len(prNumbers) == 0 {
-		out.Warning("No valid PR numbers found in selection")
-		return nil
-	}
-
-	out.Success("Selected %d pull request(s): %s", len(prNumbers), strings.Join(prNumbers, ", "))
-
-	// Approve each PR
-	failed := []string{}
-	for _, prNum := range prNumbers {
-		if err := approvePR(out, project, prNum, commentBody, opts); err != nil {
-			out.Error("Failed to approve PR #%s: %v", prNum, err)
-			failed = append(failed, prNum)
-			continue
-		}
-
-		// Merge if requested
-		if opts.merge {
-			if err := mergePR(out, project, prNum, commentBody, opts.force); err != nil {
-				out.Error("Failed to merge PR #%s: %v", prNum, err)
-				failed = append(failed, prNum)
-			}
-		}
-	}
-
-	// Summary
-	successCount := len(prNumbers) - len(failed)
-	if successCount > 0 {
-		out.Success("\nSuccessfully processed %d pull request(s) from %s", successCount, project)
-	}
-	if len(failed) > 0 {
-		out.Error("Failed to process %d pull request(s) from %s: %s",
-			len(failed), project, strings.Join(failed, ", "))
-	}
-
-	return nil
-}
-
-func approvePR(out *output.Writer, repo, prNum, commentBody string, opts approveOpts) error {
-	// Build review body
-	reviewBody := commentBody
-	if opts.prow {
-		if reviewBody != "" {
-			reviewBody = "/lgtm\n\n" + reviewBody
-		} else {
-			reviewBody = "/lgtm"
-		}
-	}
-
-	// Build gh pr review command
-	reviewArgs := []string{"pr", "review", "--repo", repo, prNum, "--approve"}
-	if reviewBody != "" {
-		reviewArgs = append(reviewArgs, "--body", reviewBody)
-	}
-
-	reviewCmd := exec.Command("gh", reviewArgs...)
-	if output, err := reviewCmd.CombinedOutput(); err != nil {
-		return fmt.Errorf("gh pr review failed: %s", output)
-	}
-
-	out.Success("✓ Approved PR #%s", prNum)
-	return nil
-}
-
-func mergePR(out *output.Writer, repo, prNum, commentBody string, force bool) error {
-	// Build merge args
-	mergeArgs := []string{"pr", "merge", "--repo", repo}
-
-	if force {
-		mergeArgs = append(mergeArgs, "--admin")
-		out.Info("Merging PR #%s with admin privileges...", prNum)
-	} else {
-		mergeArgs = append(mergeArgs, "--auto")
-	}
-
-	mergeArgs = append(mergeArgs, "--rebase", "--delete-branch")
-
-	if commentBody != "" {
-		mergeArgs = append(mergeArgs, "--body", commentBody)
-	}
-
-	mergeArgs = append(mergeArgs, prNum)
-
-	// Execute merge
-	mergeCmd := exec.Command("gh", mergeArgs...)
-	if output, err := mergeCmd.CombinedOutput(); err != nil {
-		return fmt.Errorf("gh pr merge failed: %s", output)
-	}
-
-	out.Success("✓ Merged PR #%s", prNum)
-	return nil
-}
-
-func getEditorComment() (string, error) {
-	// Create temporary file
-	tmpfile, err := os.CreateTemp("", "gh-pr-comment-*.md")
-	if err != nil {
-		return "", fmt.Errorf("failed to create temp file: %w", err)
-	}
-	defer os.Remove(tmpfile.Name())
-
-	// Write template
-	template := `# Enter your approval comment below
-# Lines starting with # will be ignored
-# Save and close the editor to continue
-
-`
-	if _, err := tmpfile.WriteString(template); err != nil {
-		return "", fmt.Errorf("failed to write template: %w", err)
-	}
-	tmpfile.Close()
-
-	// Get editor
-	editor := os.Getenv("EDITOR")
-	if editor == "" {
-		editor = "vim"
-	}
-
-	// Open editor
-	editorCmd := exec.Command(editor, tmpfile.Name())
-	editorCmd.Stdin = os.Stdin
-	editorCmd.Stdout = os.Stdout
-	editorCmd.Stderr = os.Stderr
-
-	if err := editorCmd.Run(); err != nil {
-		return "", fmt.Errorf("editor failed: %w", err)
-	}
-
-	// Read back the file
-	content, err := os.ReadFile(tmpfile.Name())
-	if err != nil {
-		return "", fmt.Errorf("failed to read comment file: %w", err)
-	}
-
-	// Filter out comment lines and empty lines
-	var lines []string
-	scanner := bufio.NewScanner(bytes.NewReader(content))
-	for scanner.Scan() {
-		line := scanner.Text()
-		if !strings.HasPrefix(line, "#") && strings.TrimSpace(line) != "" {
-			lines = append(lines, line)
-		}
-	}
-
-	return strings.Join(lines, "\n"), nil
-}

@@ -1,422 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/vdemeester/home/tools/gh-pr/internal/output"
-)
-
-func cleanupCmd(out *output.Writer) *cobra.Command {
-	var (
-		worktreeDir    string
-		dryRun         bool
-		checkMerged    bool
-		checkUpstream  bool
-		force          bool
-		upstreamBranch string
-	)
-
-	cmd := &cobra.Command{
-		Use:   "cleanup [DIRECTORY]",
-		Short: "Clean up git worktrees without uncommitted changes",
-		Long: `Remove git worktrees that have no uncommitted changes.
-
-This command scans for git repositories with worktrees and removes those that:
-  - Have no uncommitted changes (clean working directory)
-  - Optionally: are merged upstream (with --check-upstream)
-  - Optionally: have merged/closed PRs (with --check-merged)
-
-By default, it scans the directory used by 'resolve-conflicts' command.
-
-Examples:
-  # Clean up default worktree directory (dry run)
-  gh-pr cleanup --dry-run
-
-  # Clean up and remove worktrees
-  gh-pr cleanup
-
-  # Clean up custom directory
-  gh-pr cleanup ~/my-worktrees
-
-  # Check if commits are merged upstream before removing
-  gh-pr cleanup --check-upstream
-
-  # Check if PR is merged before removing
-  gh-pr cleanup --check-merged
-
-  # Check both upstream and PR status
-  gh-pr cleanup --check-upstream --check-merged
-
-  # Force remove even with uncommitted changes (dangerous!)
-  gh-pr cleanup --force`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			// Override worktreeDir if provided as argument
-			if len(args) > 0 {
-				worktreeDir = args[0]
-			}
-
-			return runCleanup(out, cleanupOpts{
-				worktreeDir:    worktreeDir,
-				dryRun:         dryRun,
-				checkMerged:    checkMerged,
-				checkUpstream:  checkUpstream,
-				force:          force,
-				upstreamBranch: upstreamBranch,
-			})
-		},
-	}
-
-	cmd.Flags().StringVarP(&worktreeDir, "worktree", "w", "/tmp/gh-resolve-conflicts-worktrees", "Directory containing worktrees")
-	cmd.Flags().BoolVarP(&dryRun, "dry-run", "n", false, "Show what would be removed without removing")
-	cmd.Flags().BoolVarP(&checkMerged, "check-merged", "m", false, "Only remove worktrees for merged/closed PRs")
-	cmd.Flags().BoolVarP(&checkUpstream, "check-upstream", "u", false, "Check if commits are merged upstream")
-	cmd.Flags().StringVarP(&upstreamBranch, "upstream-branch", "b", "main", "Upstream branch to check against")
-	cmd.Flags().BoolVarP(&force, "force", "f", false, "Force remove even with uncommitted changes")
-
-	return cmd
-}
-
-type cleanupOpts struct {
-	worktreeDir    string
-	dryRun         bool
-	checkMerged    bool
-	checkUpstream  bool
-	force          bool
-	upstreamBranch string
-}
-
-type mergeStatus struct {
-	prMerged        bool
-	upstreamMerged  bool
-	prChecked       bool
-	upstreamChecked bool
-}
-
-type worktreeInfo struct {
-	path   string
-	branch string
-	prNum  string
-	repo   string
-}
-
-func runCleanup(out *output.Writer, opts cleanupOpts) error {
-	if _, err := os.Stat(opts.worktreeDir); os.IsNotExist(err) {
-		out.Warning("Directory does not exist: %s", opts.worktreeDir)
-		return nil
-	}
-
-	out.Info("Scanning for git worktrees in: %s", opts.worktreeDir)
-	fmt.Println()
-
-	// Find all directories that might contain git repos
-	entries, err := os.ReadDir(opts.worktreeDir)
-	if err != nil {
-		return fmt.Errorf("failed to read directory: %w", err)
-	}
-
-	totalRemoved := 0
-	totalKept := 0
-
-	for _, entry := range entries {
-		if !entry.IsDir() {
-			continue
-		}
-
-		repoName := entry.Name()
-		repoPath := filepath.Join(opts.worktreeDir, repoName)
-
-		// Look for main directory (the base repo)
-		mainPath := filepath.Join(repoPath, "main")
-		if _, err := os.Stat(filepath.Join(mainPath, ".git")); os.IsNotExist(err) {
-			continue
-		}
-
-		out.Info("📁 Repository: %s", repoName)
-
-		// Get list of worktrees
-		worktrees, err := getWorktrees(mainPath)
-		if err != nil {
-			out.Error("Failed to list worktrees: %v", err)
-			continue
-		}
-
-		if len(worktrees) == 0 {
-			out.Info("  No worktrees found")
-			fmt.Println()
-			continue
-		}
-
-		// Process each worktree
-		for _, wt := range worktrees {
-			wt.repo = repoName
-			removed, kept, err := processWorktree(out, mainPath, wt, opts)
-			if err != nil {
-				out.Error("  Failed to process worktree %s: %v", wt.path, err)
-				continue
-			}
-			totalRemoved += removed
-			totalKept += kept
-		}
-
-		fmt.Println()
-	}
-
-	// Summary
-	if opts.dryRun {
-		out.Success("Dry run complete. Would remove %d worktrees, keeping %d", totalRemoved, totalKept)
-	} else {
-		out.Success("Cleanup complete! Removed %d worktrees, kept %d", totalRemoved, totalKept)
-	}
-
-	return nil
-}
-
-func getWorktrees(mainPath string) ([]worktreeInfo, error) {
-	cmd := exec.Command("git", "-C", mainPath, "worktree", "list", "--porcelain")
-	output, err := cmd.Output()
-	if err != nil {
-		return nil, err
-	}
-
-	var worktrees []worktreeInfo
-	var current worktreeInfo
-	prPattern := regexp.MustCompile(`^pr-(\d+)$`)
-
-	for _, line := range strings.Split(string(output), "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" {
-			if current.path != "" && !strings.HasSuffix(current.path, "/main") {
-				// Extract PR number from branch name if it matches pr-XXX
-				if matches := prPattern.FindStringSubmatch(current.branch); len(matches) > 1 {
-					current.prNum = matches[1]
-				}
-				worktrees = append(worktrees, current)
-			}
-			current = worktreeInfo{}
-			continue
-		}
-
-		if strings.HasPrefix(line, "worktree ") {
-			current.path = strings.TrimPrefix(line, "worktree ")
-		} else if strings.HasPrefix(line, "branch ") {
-			branch := strings.TrimPrefix(line, "branch ")
-			// Remove refs/heads/ prefix
-			current.branch = strings.TrimPrefix(branch, "refs/heads/")
-		}
-	}
-
-	// Don't forget the last one
-	if current.path != "" && !strings.HasSuffix(current.path, "/main") {
-		if matches := prPattern.FindStringSubmatch(current.branch); len(matches) > 1 {
-			current.prNum = matches[1]
-		}
-		worktrees = append(worktrees, current)
-	}
-
-	return worktrees, nil
-}
-
-func processWorktree(out *output.Writer, mainPath string, wt worktreeInfo, opts cleanupOpts) (removed int, kept int, err error) {
-	name := filepath.Base(wt.path)
-
-	// Check if worktree still exists
-	if _, err := os.Stat(wt.path); os.IsNotExist(err) {
-		out.Warning("  ⚠️  %s [%s] - path does not exist, pruning", name, wt.branch)
-		if !opts.dryRun {
-			cmd := exec.Command("git", "-C", mainPath, "worktree", "prune")
-			if err := cmd.Run(); err != nil {
-				return 0, 0, fmt.Errorf("failed to prune: %w", err)
-			}
-		}
-		return 1, 0, nil
-	}
-
-	// Check for uncommitted changes
-	hasChanges, err := hasUncommittedChanges(wt.path)
-	if err != nil {
-		return 0, 0, err
-	}
-
-	if hasChanges && !opts.force {
-		out.Warning("  ⚠️  %s [%s] - has uncommitted changes (keeping)", name, wt.branch)
-		return 0, 1, nil
-	}
-
-	// Check merge status
-	status := mergeStatus{}
-
-	// Check if PR is merged/closed (if requested)
-	if opts.checkMerged && wt.prNum != "" {
-		merged, err := isPRMergedOrClosed(wt.repo, wt.prNum)
-		if err != nil {
-			out.Warning("  ⚠️  %s [%s] - failed to check PR status: %v (keeping)", name, wt.branch, err)
-			return 0, 1, nil
-		}
-		status.prMerged = merged
-		status.prChecked = true
-	}
-
-	// Check if commits are merged upstream (if requested)
-	if opts.checkUpstream {
-		merged, err := isBranchMergedUpstream(mainPath, wt.branch, opts.upstreamBranch)
-		if err != nil {
-			// Don't fail, just note we couldn't check
-			status.upstreamChecked = false
-		} else {
-			status.upstreamMerged = merged
-			status.upstreamChecked = true
-		}
-	}
-
-	// Decide whether to keep or remove based on status
-	shouldRemove, reason := shouldRemoveWorktree(status, opts, wt)
-
-	if !shouldRemove {
-		printKeepStatus(out, name, wt.branch, wt.prNum, status, reason)
-		return 0, 1, nil
-	}
-
-	// Remove the worktree
-	printRemoveStatus(out, name, wt.branch, wt.prNum, status, opts.dryRun)
-
-	if !opts.dryRun {
-		cmd := exec.Command("git", "-C", mainPath, "worktree", "remove", wt.path)
-		if err := cmd.Run(); err != nil {
-			// Try with --force
-			out.Warning("     Retrying with --force...")
-			cmd = exec.Command("git", "-C", mainPath, "worktree", "remove", "--force", wt.path)
-			if err := cmd.Run(); err != nil {
-				return 0, 0, fmt.Errorf("failed to remove: %w", err)
-			}
-		}
-	}
-
-	return 1, 0, nil
-}
-
-func shouldRemoveWorktree(status mergeStatus, opts cleanupOpts, wt worktreeInfo) (bool, string) {
-	// If we're checking merge status, only remove if something is merged
-	if opts.checkMerged || opts.checkUpstream {
-		if status.prChecked && status.prMerged {
-			return true, "PR merged"
-		}
-		if status.upstreamChecked && status.upstreamMerged {
-			return true, "commits merged upstream"
-		}
-		// Neither merged, keep it
-		if status.prChecked && !status.prMerged {
-			return false, "PR still open"
-		}
-		if status.upstreamChecked && !status.upstreamMerged {
-			return false, "not merged upstream"
-		}
-		return false, "merge status unknown"
-	}
-
-	// If not checking merge status, remove all clean worktrees
-	return true, "clean"
-}
-
-func printKeepStatus(out *output.Writer, name, branch, prNum string, status mergeStatus, reason string) {
-	prLabel := ""
-	if prNum != "" {
-		prLabel = fmt.Sprintf(" PR #%s", prNum)
-	}
-
-	statusInfo := ""
-	if status.upstreamChecked {
-		if status.upstreamMerged {
-			statusInfo = " [merged upstream]"
-		} else {
-			statusInfo = " [not merged upstream]"
-		}
-	}
-	if status.prChecked {
-		if status.prMerged {
-			statusInfo += " [PR merged]"
-		} else {
-			statusInfo += " [PR open]"
-		}
-	}
-
-	out.Info("  ℹ️  %s [%s]%s%s - %s (keeping)", name, branch, prLabel, statusInfo, reason)
-}
-
-func printRemoveStatus(out *output.Writer, name, branch, prNum string, status mergeStatus, dryRun bool) {
-	prLabel := ""
-	if prNum != "" {
-		prLabel = fmt.Sprintf(" PR #%s", prNum)
-	}
-
-	action := "removing"
-	if dryRun {
-		action = "would remove"
-	}
-
-	// Use different emojis/colors based on merge status
-	if status.upstreamMerged && status.upstreamChecked {
-		// Merged upstream - use checkmark (green by default via Success)
-		fmt.Printf("  ✅ %s [%s]%s - merged upstream (%s)\n", name, branch, prLabel, action)
-	} else if status.prMerged && status.prChecked {
-		// PR merged but maybe not upstream yet - use green circle
-		fmt.Printf("  ✅ %s [%s]%s - PR merged (%s)\n", name, branch, prLabel, action)
-	} else {
-		// Clean but not verified as merged - use trash can (standard removal)
-		fmt.Printf("  🗑️  %s [%s]%s - clean (%s)\n", name, branch, prLabel, action)
-	}
-}
-
-func hasUncommittedChanges(path string) (bool, error) {
-	cmd := exec.Command("git", "-C", path, "status", "--porcelain")
-	output, err := cmd.Output()
-	if err != nil {
-		return false, err
-	}
-	return len(strings.TrimSpace(string(output))) > 0, nil
-}
-
-func isPRMergedOrClosed(repo, prNum string) (bool, error) {
-	// Use gh to check PR state
-	cmd := exec.Command("gh", "pr", "view", prNum, "--repo", repo, "--json", "state", "--jq", ".state")
-	output, err := cmd.Output()
-	if err != nil {
-		return false, err
-	}
-
-	state := strings.TrimSpace(string(output))
-	return state == "MERGED" || state == "CLOSED", nil
-}
-
-func isBranchMergedUpstream(repoPath, branch, upstreamBranch string) (bool, error) {
-	// First, check if the branch exists
-	checkCmd := exec.Command("git", "-C", repoPath, "rev-parse", "--verify", branch)
-	if err := checkCmd.Run(); err != nil {
-		// Branch doesn't exist, consider it merged/deleted
-		return true, nil
-	}
-
-	// Check if there are commits in the branch that are not in upstream
-	// git cherry returns commits that exist in branch but not in upstream
-	// Empty output means all commits are merged
-	cmd := exec.Command("git", "-C", repoPath, "cherry", upstreamBranch, branch)
-	output, err := cmd.Output()
-	if err != nil {
-		// If cherry fails, try a different approach: check if branch is ancestor of upstream
-		mergeBaseCmd := exec.Command("git", "-C", repoPath, "merge-base", "--is-ancestor", branch, upstreamBranch)
-		if mergeBaseErr := mergeBaseCmd.Run(); mergeBaseErr == nil {
-			// Branch is ancestor of upstream, so it's merged
-			return true, nil
-		}
-		return false, err
-	}
-
-	// If output is empty, all commits from branch are in upstream
-	result := strings.TrimSpace(string(output))
-	return result == "", nil
-}

@@ -1,233 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/vdemeester/home/tools/gh-pr/internal/output"
-)
-
-func commentCmd(out *output.Writer) *cobra.Command {
-	var (
-		body   string
-		repo   string
-		labels []string
-		author string
-		state  string
-	)
-
-	cmd := &cobra.Command{
-		Use:   "comment",
-		Short: "Comment on multiple pull requests",
-		Long: `Select and comment on multiple pull requests using fzf.
-
-This command lists pull requests and allows you to select multiple PRs
-using fzf's multi-select feature. You can then add the same comment to
-all selected PRs.
-
-Examples:
-  gh-pr comment                           # Select PRs interactively
-  gh-pr comment --body "LGTM"            # Pre-specify the comment
-  gh-pr comment --label bug              # Filter by label
-  gh-pr comment --repo owner/repo        # Work with a specific repo
-  gh-pr comment --state all              # Include closed PRs`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runComment(out, commentOpts{
-				body:   body,
-				repo:   repo,
-				labels: labels,
-				author: author,
-				state:  state,
-			})
-		},
-	}
-
-	cmd.Flags().StringVarP(&body, "body", "b", "", "Comment body (will prompt if not provided)")
-	cmd.Flags().StringVarP(&repo, "repo", "R", "", "Repository (owner/repo format)")
-	cmd.Flags().StringSliceVarP(&labels, "label", "l", nil, "Filter PRs by label (comma-separated)")
-	cmd.Flags().StringVarP(&author, "author", "a", "", "Filter PRs by author")
-	cmd.Flags().StringVarP(&state, "state", "s", "open", "Filter by state: open, closed, merged, all")
-
-	return cmd
-}
-
-type commentOpts struct {
-	body   string
-	repo   string
-	labels []string
-	author string
-	state  string
-}
-
-func runComment(out *output.Writer, opts commentOpts) error {
-	// Check if fzf is available
-	if _, err := exec.LookPath("fzf"); err != nil {
-		return fmt.Errorf("fzf is required but not found in PATH: %w", err)
-	}
-
-	// Build gh pr list command
-	ghArgs := []string{"pr", "list"}
-
-	if opts.repo != "" {
-		ghArgs = append(ghArgs, "--repo", opts.repo)
-	}
-
-	for _, label := range opts.labels {
-		ghArgs = append(ghArgs, "--label", label)
-	}
-
-	if opts.author != "" {
-		ghArgs = append(ghArgs, "--author", opts.author)
-	}
-
-	if opts.state != "" {
-		ghArgs = append(ghArgs, "--state", opts.state)
-	}
-
-	// Get list of PRs
-	out.Info("Fetching pull requests...")
-	ghCmd := exec.Command("gh", ghArgs...)
-	ghOutput, err := ghCmd.Output()
-	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			return fmt.Errorf("gh pr list failed: %s", exitErr.Stderr)
-		}
-		return fmt.Errorf("gh pr list failed: %w", err)
-	}
-
-	prList := strings.TrimSpace(string(ghOutput))
-	if prList == "" {
-		out.Warning("No pull requests found matching the criteria.")
-		return nil
-	}
-
-	// Build preview command for fzf
-	repoFlag := ""
-	if opts.repo != "" {
-		repoFlag = fmt.Sprintf("-R %s", opts.repo)
-	}
-
-	previewCmd := fmt.Sprintf(`gh pr view {1} %s --json number,title,author,statusCheckRollup | \
-		jq -r '"# PR " + (.number | tostring) + ": " + .title,
-		       "",
-		       "Author: @" + .author.login,
-		       "",
-		       "## Status Checks:",
-		       "",
-		       (if (.statusCheckRollup // [] | length) == 0 then "  (No status checks)"
-		        else (.statusCheckRollup | map(
-		         "  " + (
-		           if .conclusion == "SUCCESS" then "✓"
-		           elif .conclusion == "FAILURE" then "✗"
-		           elif .conclusion == "PENDING" then "●"
-		           elif .conclusion == "SKIPPED" then "○"
-		           else "?"
-		           end
-		         ) + " " + .name + " (" + (.conclusion // "unknown") + ")"
-		       ) | join("\n"))
-		        end)'`, repoFlag)
-
-	// Use fzf for multi-select with preview
-	out.Info("Select pull requests (use Tab to select multiple, Enter to confirm)...")
-	fzfCmd := exec.Command("fzf",
-		"--multi",
-		"--ansi",
-		"--header", "Select PRs (Tab: select, Enter: confirm)",
-		"--preview", previewCmd,
-		"--preview-window", "right:60%:wrap",
-	)
-	fzfCmd.Stdin = strings.NewReader(prList)
-	fzfCmd.Stderr = os.Stderr
-
-	selectedOutput, err := fzfCmd.Output()
-	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 130 {
-			// User cancelled with Ctrl+C
-			out.Info("Selection cancelled.")
-			return nil
-		}
-		return fmt.Errorf("fzf selection failed: %w", err)
-	}
-
-	selectedPRs := strings.TrimSpace(string(selectedOutput))
-	if selectedPRs == "" {
-		out.Info("No pull requests selected.")
-		return nil
-	}
-
-	// Extract PR numbers from selected lines
-	prNumbers := []string{}
-	scanner := bufio.NewScanner(strings.NewReader(selectedPRs))
-	for scanner.Scan() {
-		line := scanner.Text()
-		// Extract PR number from the first field (format: "123  title...")
-		fields := strings.Fields(line)
-		if len(fields) > 0 {
-			prNumbers = append(prNumbers, fields[0])
-		}
-	}
-
-	if len(prNumbers) == 0 {
-		out.Warning("No valid PR numbers found in selection.")
-		return nil
-	}
-
-	out.Success("Selected %d pull request(s): %s", len(prNumbers), strings.Join(prNumbers, ", "))
-
-	// Get comment body if not provided
-	commentBody := opts.body
-	if commentBody == "" {
-		out.Info("Enter your comment (Ctrl+D when done):")
-		var buf bytes.Buffer
-		scanner := bufio.NewScanner(os.Stdin)
-		for scanner.Scan() {
-			buf.WriteString(scanner.Text())
-			buf.WriteString("\n")
-		}
-		if err := scanner.Err(); err != nil {
-			return fmt.Errorf("failed to read comment: %w", err)
-		}
-		commentBody = strings.TrimSpace(buf.String())
-	}
-
-	if commentBody == "" {
-		out.Warning("Empty comment body. No comments will be posted.")
-		return nil
-	}
-
-	// Comment on each PR
-	out.Info("Posting comment to %d pull request(s)...", len(prNumbers))
-	failed := []string{}
-
-	for _, prNum := range prNumbers {
-		commentArgs := []string{"pr", "comment", prNum, "--body", commentBody}
-		if opts.repo != "" {
-			commentArgs = append(commentArgs, "--repo", opts.repo)
-		}
-
-		commentCmd := exec.Command("gh", commentArgs...)
-		if err := commentCmd.Run(); err != nil {
-			out.Error("Failed to comment on PR #%s: %v", prNum, err)
-			failed = append(failed, prNum)
-		} else {
-			out.Success("Commented on PR #%s", prNum)
-		}
-	}
-
-	// Summary
-	successCount := len(prNumbers) - len(failed)
-	if successCount > 0 {
-		out.Success("\nSuccessfully commented on %d pull request(s)", successCount)
-	}
-	if len(failed) > 0 {
-		out.Error("Failed to comment on %d pull request(s): %s", len(failed), strings.Join(failed, ", "))
-		return fmt.Errorf("some comments failed")
-	}
-
-	return nil
-}

@@ -1,182 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/vdemeester/home/tools/gh-pr/internal/output"
-	"github.com/vdemeester/home/tools/gh-pr/internal/templates"
-)
-
-func createCmd(out *output.Writer) *cobra.Command {
-	var (
-		title     string
-		body      string
-		template  string
-		draft     bool
-		base      string
-		head      string
-		web       bool
-		reviewers []string
-		assignees []string
-		labels    []string
-		refresh   bool
-	)
-
-	cmd := &cobra.Command{
-		Use:   "create",
-		Short: "Create a pull request",
-		Long: `Create a pull request with optional template support.
-
-Templates are automatically discovered from:
-  - .github/PULL_REQUEST_TEMPLATE.md
-  - .github/PULL_REQUEST_TEMPLATE/
-  - docs/PULL_REQUEST_TEMPLATE.md
-
-Use --template to specify a template file, or list available templates
-with 'gh-pr list-templates'.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runCreate(out, createOpts{
-				title:     title,
-				body:      body,
-				template:  template,
-				draft:     draft,
-				base:      base,
-				head:      head,
-				web:       web,
-				reviewers: reviewers,
-				assignees: assignees,
-				labels:    labels,
-				refresh:   refresh,
-			})
-		},
-	}
-
-	cmd.Flags().StringVarP(&title, "title", "t", "", "Pull request title")
-	cmd.Flags().StringVarP(&body, "body", "b", "", "Pull request body")
-	cmd.Flags().StringVar(&template, "template", "", "Use a specific template file")
-	cmd.Flags().BoolVarP(&draft, "draft", "d", false, "Create as draft pull request")
-	cmd.Flags().StringVar(&base, "base", "", "Base branch (default: main/master)")
-	cmd.Flags().StringVar(&head, "head", "", "Head branch (default: current branch)")
-	cmd.Flags().BoolVarP(&web, "web", "w", false, "Open in web browser")
-	cmd.Flags().StringSliceVarP(&reviewers, "reviewer", "r", nil, "Request reviewers (comma-separated)")
-	cmd.Flags().StringSliceVarP(&assignees, "assignee", "a", nil, "Assign users (comma-separated)")
-	cmd.Flags().StringSliceVarP(&labels, "label", "l", nil, "Add labels (comma-separated)")
-	cmd.Flags().BoolVar(&refresh, "refresh", false, "Refresh template cache")
-
-	return cmd
-}
-
-type createOpts struct {
-	title     string
-	body      string
-	template  string
-	draft     bool
-	base      string
-	head      string
-	web       bool
-	reviewers []string
-	assignees []string
-	labels    []string
-	refresh   bool
-}
-
-func runCreate(out *output.Writer, opts createOpts) error {
-	// If template is specified, load it
-	if opts.template != "" {
-		content, err := loadTemplate(out, opts.template, opts.refresh)
-		if err != nil {
-			return err
-		}
-
-		// Use template content if body is empty
-		if opts.body == "" {
-			opts.body = content
-		}
-	}
-
-	// Build gh pr create command
-	ghArgs := []string{"pr", "create"}
-
-	if opts.title != "" {
-		ghArgs = append(ghArgs, "--title", opts.title)
-	}
-
-	if opts.body != "" {
-		ghArgs = append(ghArgs, "--body", opts.body)
-	}
-
-	if opts.draft {
-		ghArgs = append(ghArgs, "--draft")
-	}
-
-	if opts.base != "" {
-		ghArgs = append(ghArgs, "--base", opts.base)
-	}
-
-	if opts.head != "" {
-		ghArgs = append(ghArgs, "--head", opts.head)
-	}
-
-	if opts.web {
-		ghArgs = append(ghArgs, "--web")
-	}
-
-	for _, reviewer := range opts.reviewers {
-		ghArgs = append(ghArgs, "--reviewer", reviewer)
-	}
-
-	for _, assignee := range opts.assignees {
-		ghArgs = append(ghArgs, "--assignee", assignee)
-	}
-
-	for _, label := range opts.labels {
-		ghArgs = append(ghArgs, "--label", label)
-	}
-
-	out.Info("Creating pull request...")
-
-	// Execute gh command
-	cmd := exec.Command("gh", ghArgs...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Stdin = os.Stdin
-
-	if err := cmd.Run(); err != nil {
-		return fmt.Errorf("gh pr create failed: %w", err)
-	}
-
-	return nil
-}
-
-func loadTemplate(out *output.Writer, templatePath string, refresh bool) (string, error) {
-	finder, err := templates.NewFinder()
-	if err != nil {
-		return "", err
-	}
-
-	// If template path is just a name, try to find it
-	if !strings.Contains(templatePath, "/") {
-		out.Info("Searching for template: %s", templatePath)
-
-		tmplList, err := finder.Find(refresh)
-		if err != nil {
-			return "", fmt.Errorf("failed to find templates: %w", err)
-		}
-
-		for _, tmpl := range tmplList {
-			if tmpl.Name == templatePath || tmpl.Path == templatePath {
-				out.Success("Found template: %s", tmpl.Path)
-				return tmpl.Content, nil
-			}
-		}
-
-		return "", fmt.Errorf("template not found: %s", templatePath)
-	}
-
-	// Direct file path
-	return templates.ReadTemplate(templatePath)
-}

@@ -1,148 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-	"github.com/vdemeester/home/tools/gh-pr/internal/output"
-	"github.com/vdemeester/home/tools/gh-pr/internal/templates"
-)
-
-func listTemplatesCmd(out *output.Writer) *cobra.Command {
-	var (
-		refresh bool
-		verbose bool
-	)
-
-	cmd := &cobra.Command{
-		Use:   "list-templates [REPOSITORY]",
-		Short: "List available pull request templates",
-		Long: `List all pull request templates found in the repository.
-
-Templates are cached for one week by default. Use --refresh to bypass
-the cache and search for templates again.
-
-Examples:
-  gh-pr list-templates                    # List templates in current repo
-  gh-pr list-templates tektoncd/pipeline  # List templates from remote repo
-  gh-pr list-templates --verbose          # Show template previews
-  gh-pr list-templates --refresh          # Bypass cache`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			var repo string
-			if len(args) > 0 {
-				repo = args[0]
-			}
-			return runListTemplates(out, repo, refresh, verbose)
-		},
-	}
-
-	cmd.Flags().BoolVar(&refresh, "refresh", false, "Refresh template cache")
-	cmd.Flags().BoolVarP(&verbose, "verbose", "v", false, "Show template content preview")
-
-	return cmd
-}
-
-func runListTemplates(out *output.Writer, repo string, refresh, verbose bool) error {
-	finder, err := templates.NewFinder()
-	if err != nil {
-		return fmt.Errorf("failed to create template finder: %w", err)
-	}
-
-	var tmplList []templates.Template
-
-	if repo != "" {
-		// Search in remote repository
-		if refresh {
-			out.Info("Fetching templates from %s (bypassing cache)...", repo)
-		} else {
-			out.Info("Searching for templates in %s...", repo)
-		}
-
-		tmplList, err = finder.FindInRepo(repo, refresh)
-		if err != nil {
-			return fmt.Errorf("failed to find templates in %s: %w", repo, err)
-		}
-	} else {
-		// Search in current repository
-		if refresh {
-			out.Info("Refreshing template cache...")
-		}
-
-		tmplList, err = finder.Find(refresh)
-		if err != nil {
-			return fmt.Errorf("failed to find templates: %w", err)
-		}
-	}
-
-	if len(tmplList) == 0 {
-		if repo != "" {
-			out.Warning("No pull request templates found in %s.", repo)
-		} else {
-			out.Warning("No pull request templates found.")
-		}
-		out.Println("")
-		out.Println("Templates are typically located in:")
-		out.Println("  - .github/PULL_REQUEST_TEMPLATE.md")
-		out.Println("  - .github/PULL_REQUEST_TEMPLATE/")
-		out.Println("  - docs/PULL_REQUEST_TEMPLATE.md")
-		return nil
-	}
-
-	if repo != "" {
-		out.Success("Found %d pull request template(s) in %s:", len(tmplList), repo)
-	} else {
-		out.Success("Found %d pull request template(s):", len(tmplList))
-	}
-	out.Println("")
-
-	for i, tmpl := range tmplList {
-		out.Println("%d. %s", i+1, tmpl.Name)
-		out.Println("   Path: %s", tmpl.Path)
-
-		if verbose {
-			// Show first few lines of template
-			lines := splitLines(tmpl.Content, 5)
-			out.Println("   Preview:")
-			for _, line := range lines {
-				out.Println("     %s", line)
-			}
-			if len(lines) == 5 {
-				out.Println("     ...")
-			}
-		}
-
-		if i < len(tmplList)-1 {
-			out.Println("")
-		}
-	}
-
-	out.Println("")
-	out.Info("Use 'gh-pr create --template <name>' to create a PR with a template")
-
-	return nil
-}
-
-func splitLines(content string, max int) []string {
-	lines := []string{}
-	current := ""
-
-	for i, char := range content {
-		if char == '\n' {
-			lines = append(lines, current)
-			current = ""
-
-			if len(lines) >= max {
-				break
-			}
-		} else {
-			current += string(char)
-		}
-
-		// Handle last line
-		if i == len(content)-1 && current != "" {
-			lines = append(lines, current)
-		}
-	}
-
-	return lines
-}

@@ -1,54 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/spf13/cobra"
-	"github.com/vdemeester/home/tools/gh-pr/internal/output"
-)
-
-var version = "0.1.0"
-
-func main() {
-	if err := rootCmd().Execute(); err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
-	}
-}
-
-func rootCmd() *cobra.Command {
-	out := output.Default()
-
-	cmd := &cobra.Command{
-		Use:   "gh-pr",
-		Short: "GitHub Pull Request management tool",
-		Long: `A comprehensive tool for managing GitHub pull requests.
-
-Combines PR creation with template support, workflow management,
-and conflict resolution in a single command-line interface.`,
-		SilenceUsage:  true,
-		SilenceErrors: true,
-	}
-
-	cmd.AddCommand(versionCmd())
-	cmd.AddCommand(createCmd(out))
-	cmd.AddCommand(listTemplatesCmd(out))
-	cmd.AddCommand(restartFailedCmd(out))
-	cmd.AddCommand(resolveConflictsCmd(out))
-	cmd.AddCommand(commentCmd(out))
-	cmd.AddCommand(approveCmd(out))
-	cmd.AddCommand(cleanupCmd(out))
-
-	return cmd
-}
-
-func versionCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "version",
-		Short: "Print version information",
-		Run: func(cmd *cobra.Command, args []string) {
-			fmt.Printf("gh-pr version %s\n", version)
-		},
-	}
-}

@@ -1,244 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/vdemeester/home/tools/gh-pr/internal/conflicts"
-	"github.com/vdemeester/home/tools/gh-pr/internal/output"
-)
-
-func resolveConflictsCmd(out *output.Writer) *cobra.Command {
-	var (
-		worktreeDir string
-		noWorktree  bool
-		noPush      bool
-		org         string
-		author      string
-	)
-
-	cmd := &cobra.Command{
-		Use:   "resolve-conflicts [REPOSITORY[#PR_NUMBER]]",
-		Short: "Resolve merge conflicts in pull requests",
-		Long: `List pull requests with merge conflicts and resolve them interactively.
-
-This command helps you resolve merge conflicts in pull requests by:
-  - Fetching the PR branch
-  - Creating a worktree or using existing repo
-  - Performing rebase against the base branch
-  - Launching conflict resolution tools (emacs ediff or git mergetool)
-  - Force-pushing resolved changes (optional)
-
-Examples:
-  gh-pr resolve-conflicts                 # Search for your conflicting PRs
-  gh-pr resolve-conflicts owner/repo#123  # Resolve specific PR
-  gh-pr resolve-conflicts -o tektoncd     # Filter by organization
-  gh-pr resolve-conflicts -n              # Use existing repo, no worktree
-  gh-pr resolve-conflicts -N              # Don't auto-push after resolution`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			var repo, prNumber string
-
-			if len(args) > 0 {
-				arg := args[0]
-				if strings.Contains(arg, "#") {
-					parts := strings.SplitN(arg, "#", 2)
-					repo = parts[0]
-					prNumber = parts[1]
-				} else {
-					repo = arg
-				}
-			}
-
-			return runResolveConflicts(out, resolveConflictsOpts{
-				worktreeDir: worktreeDir,
-				useWorktree: !noWorktree,
-				autoPush:    !noPush,
-				org:         org,
-				author:      author,
-				repo:        repo,
-				prNumber:    prNumber,
-			})
-		},
-	}
-
-	cmd.Flags().StringVarP(&worktreeDir, "worktree", "w", "/tmp/gh-resolve-conflicts-worktrees", "Create worktrees in DIR")
-	cmd.Flags().BoolVarP(&noWorktree, "no-worktree", "n", false, "Use existing repo instead of worktrees")
-	cmd.Flags().BoolVarP(&noPush, "no-push", "N", false, "Do NOT auto-push after resolution")
-	cmd.Flags().StringVarP(&org, "org", "o", "", "Filter PRs by organization")
-	cmd.Flags().StringVarP(&author, "author", "a", "@me", "Filter PRs by author")
-
-	return cmd
-}
-
-type resolveConflictsOpts struct {
-	worktreeDir string
-	useWorktree bool
-	autoPush    bool
-	org         string
-	author      string
-	repo        string
-	prNumber    string
-}
-
-func runResolveConflicts(out *output.Writer, opts resolveConflictsOpts) error {
-	resolver := conflicts.NewResolver(out, opts.worktreeDir, opts.useWorktree, opts.autoPush)
-
-	// If specific PR is provided, resolve it directly
-	if opts.prNumber != "" {
-		if opts.repo == "" {
-			return fmt.Errorf("repository must be specified when using #PR_NUMBER")
-		}
-
-		pr, err := resolver.FindConflictingPR(opts.repo, opts.prNumber)
-		if err != nil {
-			return err
-		}
-
-		out.Success("PR #%d: %s", pr.Number, pr.Title)
-		out.Println("")
-
-		return resolver.ResolvePR(opts.repo, pr)
-	}
-
-	// Interactive mode: search for conflicting PRs
-	prs, err := resolver.FindConflictingPRs(opts.org, opts.author)
-	if err != nil {
-		return err
-	}
-
-	if len(prs) == 0 {
-		out.Success("No pull requests with merge conflicts found!")
-		return nil
-	}
-
-	out.Success("Found %d pull request(s) with merge conflicts", len(prs))
-
-	// Check if fzf is available
-	if _, err := exec.LookPath("fzf"); err != nil {
-		return fmt.Errorf("fzf is required but not found in PATH: %w", err)
-	}
-
-	// Build fzf input with formatted PR information
-	var fzfInput strings.Builder
-	prMap := make(map[int]*conflicts.PRInfo) // Map PR number to info for later lookup
-
-	for _, pr := range prs {
-		prMap[pr.Number] = &pr
-		// Format: "#123  Title here (@author) [repo]"
-		repo := pr.HeadRepository.NameWithOwner
-		fzfInput.WriteString(fmt.Sprintf("#%-6d %s (@%s) [%s]\n",
-			pr.Number, pr.Title, pr.Author.Login, repo))
-	}
-
-	// Build preview command for fzf
-	// We need to extract the repo from the selection and fetch PR details
-	previewCmd := `echo {} | awk '{print $1, $(NF)}' | sed 's/\[//;s/\]//' | \
-		xargs -I{} sh -c 'PR=$(echo {} | cut -d" " -f1); REPO=$(echo {} | cut -d" " -f2); \
-		gh pr view $PR -R $REPO --json number,title,author,headRefName,baseRefName,mergeable,statusCheckRollup 2>/dev/null | \
-		jq -r "\"# PR \" + (.number | tostring) + \": \" + .title,
-		       \"\",
-		       \"Author: @\" + .author.login,
-		       \"\",
-		       \"## Branches:\",
-		       \"\",
-		       \"  \" + .headRefName + \" → \" + .baseRefName,
-		       \"\",
-		       \"## Merge Status: \" + (.mergeable // \"unknown\"),
-		       \"\",
-		       \"## Status Checks:\",
-		       \"\",
-		       (if (.statusCheckRollup // [] | length) == 0 then \"  (No status checks)\"
-		        else (.statusCheckRollup | map(
-		         \"  \" + (
-		           if .conclusion == \"SUCCESS\" then \"✓\"
-		           elif .conclusion == \"FAILURE\" then \"✗\"
-		           elif .conclusion == \"PENDING\" then \"●\"
-		           elif .conclusion == \"SKIPPED\" then \"○\"
-		           else \"?\"
-		           end
-		         ) + \" \" + .name + \" (\" + (.conclusion // \"unknown\") + \")\"
-		       ) | join(\"\\n\"))
-		        end)"'`
-
-	// Use fzf for multi-select with preview
-	out.Info("Select pull requests to resolve (use Tab to select multiple, Enter to confirm)...")
-	fzfCmd := exec.Command("fzf",
-		"--multi",
-		"--ansi",
-		"--header", "Select PRs to resolve conflicts (Tab: select, Enter: confirm)",
-		"--preview", previewCmd,
-		"--preview-window", "right:60%:wrap",
-	)
-	fzfCmd.Stdin = strings.NewReader(fzfInput.String())
-	fzfCmd.Stderr = os.Stderr
-
-	selectedOutput, err := fzfCmd.Output()
-	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 130 {
-			// User cancelled with Ctrl+C
-			out.Info("Selection cancelled.")
-			return nil
-		}
-		return fmt.Errorf("fzf selection failed: %w", err)
-	}
-
-	selectedPRs := strings.TrimSpace(string(selectedOutput))
-	if selectedPRs == "" {
-		out.Info("No pull requests selected.")
-		return nil
-	}
-
-	// Extract PR numbers from selected lines
-	selectedPRNumbers := []int{}
-	scanner := bufio.NewScanner(strings.NewReader(selectedPRs))
-	for scanner.Scan() {
-		line := scanner.Text()
-		// Extract PR number from format "#123  Title..."
-		if strings.HasPrefix(line, "#") {
-			var prNum int
-			if _, err := fmt.Sscanf(line, "#%d", &prNum); err == nil {
-				selectedPRNumbers = append(selectedPRNumbers, prNum)
-			}
-		}
-	}
-
-	if len(selectedPRNumbers) == 0 {
-		out.Warning("No valid PR numbers found in selection.")
-		return nil
-	}
-
-	out.Success("Selected %d pull request(s)", len(selectedPRNumbers))
-	out.Println("")
-
-	// Resolve selected PRs
-	for _, prNum := range selectedPRNumbers {
-		pr, ok := prMap[prNum]
-		if !ok {
-			out.Warning("PR #%d not found in the list, skipping...", prNum)
-			continue
-		}
-
-		// Determine repository from PR
-		repo := pr.HeadRepository.NameWithOwner
-		if pr.IsCrossRepository {
-			out.Warning("Skipping cross-repository PR #%d (requires manual handling)", prNum)
-			continue
-		}
-
-		if err := resolver.ResolvePR(repo, pr); err != nil {
-			out.Error("Failed to resolve PR #%d: %v", prNum, err)
-			out.Println("")
-			continue
-		}
-
-		out.Success("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
-		out.Println("")
-	}
-
-	out.Success("Done!")
-	return nil
-}