pf 0.0.1 → 0.0.2

package/go/Makefile

@@ -0,0 +1,37 @@
+BINARY_NAME=pf
+VERSION ?= $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
+GIT_COMMIT ?= $(shell git rev-parse --short HEAD 2>/dev/null || echo "none")
+BUILD_DATE ?= $(shell date -u '+%Y-%m-%d_%H:%M:%S')
+LDFLAGS=-ldflags "-X github.com/pullfrog/cli/cmd.Version=$(VERSION) -X github.com/pullfrog/cli/cmd.GitCommit=$(GIT_COMMIT) -X github.com/pullfrog/cli/cmd.BuildDate=$(BUILD_DATE)"
+
+.PHONY: build install clean test build-all
+
+# Build for current platform
+build:
+	go build $(LDFLAGS) -o bin/$(BINARY_NAME) .
+
+# Install to GOPATH/bin (should be in PATH)
+install:
+	go install $(LDFLAGS) .
+
+# Run tests
+test:
+	go test -v ./...
+
+# Clean build artifacts
+clean:
+	rm -rf bin/
+	go clean
+
+# Build for all platforms
+build-all: clean
+	mkdir -p bin
+	GOOS=darwin GOARCH=amd64 go build $(LDFLAGS) -o bin/$(BINARY_NAME)-darwin-amd64 .
+	GOOS=darwin GOARCH=arm64 go build $(LDFLAGS) -o bin/$(BINARY_NAME)-darwin-arm64 .
+	GOOS=linux GOARCH=amd64 go build $(LDFLAGS) -o bin/$(BINARY_NAME)-linux-amd64 .
+	GOOS=linux GOARCH=arm64 go build $(LDFLAGS) -o bin/$(BINARY_NAME)-linux-arm64 .
+	GOOS=windows GOARCH=amd64 go build $(LDFLAGS) -o bin/$(BINARY_NAME)-windows-amd64.exe .
+
+# Development build and run
+run: build
+	./bin/$(BINARY_NAME)

package/go/cmd/completion.go

@@ -0,0 +1,183 @@
+package cmd
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+var completionCmd = &cobra.Command{
+	Use:   "completion [bash|zsh|fish]",
+	Short: "Install shell completions",
+	Long: `Install shell completions for pf.
+
+Run without arguments to interactively install completions.
+Run with a shell name to output the raw completion script.
+`,
+	DisableFlagsInUseLine: true,
+	ValidArgs:             []string{"bash", "zsh", "fish"},
+	Args:                  cobra.MaximumNArgs(1),
+	RunE:                  runCompletion,
+}
+
+func init() {
+	rootCmd.AddCommand(completionCmd)
+}
+
+func runCompletion(cmd *cobra.Command, args []string) error {
+	// If shell specified, just output the script
+	if len(args) == 1 {
+		switch args[0] {
+		case "bash":
+			return rootCmd.GenBashCompletion(os.Stdout)
+		case "zsh":
+			return rootCmd.GenZshCompletion(os.Stdout)
+		case "fish":
+			return rootCmd.GenFishCompletion(os.Stdout, true)
+		}
+		return nil
+	}
+
+	// Interactive mode
+	shell := detectShell()
+	if shell == "" {
+		return fmt.Errorf("could not detect shell, please run: pf completion [bash|zsh|fish]")
+	}
+
+	completionPath := getCompletionPath(shell)
+	rcPath, rcLines := getRcConfig(shell)
+
+	// Build description of changes
+	var desc strings.Builder
+	desc.WriteString(fmt.Sprintf("1. Write completion script to %s\n", completionPath))
+	if rcPath != "" && !fileContains(rcPath, rcLines[0]) {
+		desc.WriteString(fmt.Sprintf("2. Add to %s:\n", rcPath))
+		for _, line := range rcLines {
+			desc.WriteString(fmt.Sprintf("   %s\n", line))
+		}
+	}
+
+	fmt.Printf("Install %s completions? This will:\n", shell)
+	fmt.Print(desc.String())
+	fmt.Print("\nProceed? [y/N] ")
+
+	reader := bufio.NewReader(os.Stdin)
+	response, _ := reader.ReadString('\n')
+	response = strings.TrimSpace(strings.ToLower(response))
+
+	if response != "y" && response != "yes" {
+		fmt.Println("Canceled.")
+		return nil
+	}
+
+	return installCompletion(shell, completionPath, rcPath, rcLines)
+}
+
+func detectShell() string {
+	shell := os.Getenv("SHELL")
+	if strings.Contains(shell, "zsh") {
+		return "zsh"
+	} else if strings.Contains(shell, "bash") {
+		return "bash"
+	} else if strings.Contains(shell, "fish") {
+		return "fish"
+	}
+	return ""
+}
+
+func getCompletionPath(shell string) string {
+	home, _ := os.UserHomeDir()
+
+	switch shell {
+	case "zsh":
+		return filepath.Join(home, ".zsh/completions/_pf")
+	case "bash":
+		return filepath.Join(home, ".bash_completion.d/pf")
+	case "fish":
+		return filepath.Join(home, ".config/fish/completions/pf.fish")
+	}
+	return ""
+}
+
+func getRcConfig(shell string) (string, []string) {
+	home, _ := os.UserHomeDir()
+
+	switch shell {
+	case "zsh":
+		return filepath.Join(home, ".zshrc"), []string{
+			`fpath=(~/.zsh/completions $fpath)`,
+			`autoload -Uz compinit && compinit`,
+		}
+	case "bash":
+		return filepath.Join(home, ".bashrc"), []string{
+			`source ~/.bash_completion.d/pf`,
+		}
+	case "fish":
+		// Fish auto-loads from completions dir
+		return "", nil
+	}
+	return "", nil
+}
+
+func installCompletion(shell, completionPath, rcPath string, rcLines []string) error {
+	// Ensure completion directory exists
+	dir := filepath.Dir(completionPath)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return fmt.Errorf("failed to create directory: %w", err)
+	}
+
+	// Write completion script
+	file, err := os.Create(completionPath)
+	if err != nil {
+		return fmt.Errorf("failed to create file: %w", err)
+	}
+	defer file.Close()
+
+	switch shell {
+	case "bash":
+		rootCmd.GenBashCompletion(file)
+	case "zsh":
+		rootCmd.GenZshCompletion(file)
+	case "fish":
+		rootCmd.GenFishCompletion(file, true)
+	}
+
+	fmt.Println(success.Render("✓"), "Wrote", completionPath)
+
+	// Update rc file if needed
+	if rcPath != "" && len(rcLines) > 0 && !fileContains(rcPath, rcLines[0]) {
+		f, err := os.OpenFile(rcPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+		if err != nil {
+			return fmt.Errorf("failed to open %s: %w", rcPath, err)
+		}
+		defer f.Close()
+
+		f.WriteString("\n# pf completions\n")
+		for _, line := range rcLines {
+			f.WriteString(line + "\n")
+		}
+
+		fmt.Println(success.Render("✓"), "Updated", rcPath)
+	}
+
+	fmt.Println()
+	if rcPath != "" {
+		fmt.Println("Restart your shell or run:", dim.Render("source "+rcPath))
+	} else {
+		fmt.Println("Restart your shell to enable completions.")
+	}
+
+	return nil
+}
+
+func fileContains(path, substr string) bool {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return false
+	}
+	return strings.Contains(string(data), substr)
+}

package/go/cmd/list.go

@@ -0,0 +1,126 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
+	"github.com/pullfrog/cli/internal/store"
+	"github.com/spf13/cobra"
+)
+
+var listCmd = &cobra.Command{
+	Use:   "ls",
+	Short: "List all tracked worktrees",
+	RunE:  runList,
+}
+
+var plainOutput bool
+
+var listAliasCmd = &cobra.Command{
+	Use:    "list",
+	Hidden: true,
+	RunE:   runList,
+}
+
+func init() {
+	listCmd.Flags().BoolVarP(&plainOutput, "plain", "p", false, "Plain output (grep-friendly)")
+	rootCmd.AddCommand(listCmd)
+	rootCmd.AddCommand(listAliasCmd)
+}
+
+func runList(cmd *cobra.Command, args []string) error {
+	s, err := store.Load()
+	if err != nil {
+		return fmt.Errorf("failed to load store: %w", err)
+	}
+
+	if len(s.Worktrees) == 0 {
+		fmt.Println("No worktrees. Use 'pf new <name>' to create one.")
+		return nil
+	}
+
+	// Detect current worktree
+	cwd, _ := os.Getwd()
+	currentWorktree := ""
+	for _, wt := range s.Worktrees {
+		absPath, _ := filepath.Abs(wt.Path)
+		if strings.HasPrefix(cwd, absPath) {
+			currentWorktree = wt.Name
+			break
+		}
+	}
+
+	if plainOutput {
+		for _, wt := range s.Worktrees {
+			branch := getWorktreeBranch(wt.Path)
+			status := getWorktreeStatus(wt.Path)
+			fmt.Printf("%s\t%s\t%s\n", wt.Name, branch, status)
+		}
+		return nil
+	}
+
+	rows := [][]string{}
+	for _, wt := range s.Worktrees {
+		branch := getWorktreeBranch(wt.Path)
+		status := getWorktreeStatus(wt.Path)
+		name := wt.Name
+		if wt.Name == currentWorktree {
+			name = "*" + name
+		}
+		rows = append(rows, []string{name, branch, status})
+	}
+
+	t := table.New().
+		Border(lipgloss.NormalBorder()).
+		BorderHeader(true).
+		Headers("name", "branch", "git status").
+		Rows(rows...)
+
+	fmt.Println(t)
+
+	return nil
+}
+
+func getWorktreeBranch(path string) string {
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		return "[missing]"
+	}
+
+	cmd := exec.Command("git", "-C", path, "branch", "--show-current")
+	output, err := cmd.Output()
+	if err != nil {
+		return "[detached]"
+	}
+
+	branch := strings.TrimSpace(string(output))
+	if branch == "" {
+		return "[detached]"
+	}
+	return branch
+}
+
+func getWorktreeStatus(path string) string {
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		return ""
+	}
+
+	cmd := exec.Command("git", "-C", path, "status", "--porcelain")
+	output, err := cmd.Output()
+	if err != nil {
+		return "[error]"
+	}
+
+	status := strings.TrimSpace(string(output))
+	if status == "" {
+		return "clean"
+	}
+
+	lines := strings.Split(status, "\n")
+	return fmt.Sprintf("%d changed", len(lines))
+}
+

package/go/cmd/new.go

@@ -0,0 +1,146 @@
+package cmd
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/pullfrog/cli/internal/store"
+	"github.com/spf13/cobra"
+)
+
+var newCmd = &cobra.Command{
+	Use:   "new [name]",
+	Short: "Create a new worktree with a branch",
+	Long:  `Creates a new git worktree and branch with the given name. If no name is provided, generates a random name like pf-a1b2c3d4.`,
+	Args:  cobra.MaximumNArgs(1),
+	RunE:  runNew,
+}
+
+func init() {
+	rootCmd.AddCommand(newCmd)
+}
+
+func runNew(cmd *cobra.Command, args []string) error {
+	var name string
+	if len(args) > 0 {
+		name = args[0]
+	} else {
+		name = generateName()
+	}
+
+	// Get the git root directory
+	gitRoot, err := store.GetGitRoot()
+	if err != nil {
+		return fmt.Errorf("not in a git repository: %w", err)
+	}
+
+	// Don't allow creating worktrees from within a worktree
+	gitDir, err := store.GetGitCommonDir()
+	if err != nil {
+		return fmt.Errorf("failed to get git directory: %w", err)
+	}
+	if gitRoot != filepath.Dir(gitDir) {
+		fmt.Fprintln(os.Stderr, "Error: You are inside a pf worktree.")
+		fmt.Fprintln(os.Stderr, "")
+		fmt.Fprintln(os.Stderr, "Each time you run 'pf new' or 'pf open', pf starts a subshell in the")
+		fmt.Fprintln(os.Stderr, "worktree directory. To keep subshells shallow and avoid nesting, pf")
+		fmt.Fprintln(os.Stderr, "requires you to return to the main repo before opening another worktree.")
+		fmt.Fprintln(os.Stderr, "")
+		fmt.Fprintln(os.Stderr, "To exit the current worktree:")
+		fmt.Fprintln(os.Stderr, "  exit")
+		fmt.Fprintln(os.Stderr, "")
+		fmt.Fprintln(os.Stderr, "Then re-run:")
+		fmt.Fprintf(os.Stderr, "  pf new %s\n", name)
+		os.Exit(1)
+	}
+
+	// Check if branch already exists - error if so
+	if checkBranchExists(name) {
+		return fmt.Errorf("branch '%s' already exists", name)
+	}
+
+	// Check if worktree already exists in store
+	s, err := store.Load()
+	if err != nil {
+		return fmt.Errorf("failed to load store: %w", err)
+	}
+	if s.FindByName(name) != nil {
+		return fmt.Errorf("worktree '%s' already exists - use 'pf open %s'", name, name)
+	}
+
+	// Get current branch to show what we're branching from
+	baseBranch := getCurrentBranch()
+
+	// Determine worktree path inside .git/pf/worktrees
+	repoName := filepath.Base(gitRoot)
+	worktreePath := filepath.Join(gitDir, "pf", "worktrees", name, repoName)
+
+	// Ensure directory exists
+	if err := os.MkdirAll(filepath.Dir(worktreePath), 0755); err != nil {
+		return fmt.Errorf("failed to create worktree directory: %w", err)
+	}
+
+	// Create new branch with worktree (suppress git noise)
+	gitCmd := exec.Command("git", "worktree", "add", "-b", name, worktreePath)
+	if err := gitCmd.Run(); err != nil {
+		return fmt.Errorf("failed to create worktree: %w", err)
+	}
+
+	// Track in store
+	s.Add(name, worktreePath)
+	if err := s.Save(); err != nil {
+		return fmt.Errorf("failed to save store: %w", err)
+	}
+
+	fmt.Println()
+	fmt.Println(success.Render("✓"), bold.Render(name), dim.Render("(from "+baseBranch+")"))
+	fmt.Println(dim.Render("  Subshell started. Type 'exit' to return."))
+	fmt.Println()
+
+	// Get user's shell
+	shell := os.Getenv("SHELL")
+	if shell == "" {
+		shell = "/bin/sh"
+	}
+
+	// Spawn new shell in worktree directory
+	shellCmd := exec.Command(shell)
+	shellCmd.Dir = worktreePath
+	shellCmd.Stdin = os.Stdin
+	shellCmd.Stdout = os.Stdout
+	shellCmd.Stderr = os.Stderr
+
+	if err := shellCmd.Run(); err != nil {
+		return fmt.Errorf("shell exited with error: %w", err)
+	}
+
+	fmt.Println()
+	fmt.Println(dim.Render("  Back in main worktree"))
+	fmt.Println()
+	return nil
+}
+
+func checkBranchExists(branchName string) bool {
+	cmd := exec.Command("git", "show-ref", "--verify", "--quiet", "refs/heads/"+branchName)
+	return cmd.Run() == nil
+}
+
+func getCurrentBranch() string {
+	cmd := exec.Command("git", "branch", "--show-current")
+	output, err := cmd.Output()
+	if err != nil {
+		return "HEAD"
+	}
+	return strings.TrimSpace(string(output))
+}
+
+func generateName() string {
+	bytes := make([]byte, 4)
+	rand.Read(bytes)
+	return "pf-" + hex.EncodeToString(bytes)
+}

package/go/cmd/open.go

@@ -0,0 +1,128 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/pullfrog/cli/internal/store"
+	"github.com/spf13/cobra"
+)
+
+var openCmd = &cobra.Command{
+	Use:               "open <name>",
+	Short:             "Open a worktree",
+	Long:              `Opens a worktree in a subshell. Type 'exit' to return.`,
+	Args:              cobra.ExactArgs(1),
+	RunE:              runOpen,
+	ValidArgsFunction: completeWorktreeNames,
+}
+
+func init() {
+	rootCmd.AddCommand(openCmd)
+}
+
+func completeWorktreeNames(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	if len(args) != 0 {
+		return nil, cobra.ShellCompDirectiveNoFileComp
+	}
+
+	s, err := store.Load()
+	if err != nil {
+		return nil, cobra.ShellCompDirectiveNoFileComp
+	}
+
+	var names []string
+	for _, wt := range s.Worktrees {
+		names = append(names, wt.Name)
+	}
+	return names, cobra.ShellCompDirectiveNoFileComp
+}
+
+func runOpen(cmd *cobra.Command, args []string) error {
+	name := args[0]
+
+	// Get git dirs
+	gitRoot, err := store.GetGitRoot()
+	if err != nil {
+		return fmt.Errorf("not in a git repository: %w", err)
+	}
+	gitDir, err := store.GetGitCommonDir()
+	if err != nil {
+		return fmt.Errorf("failed to get git directory: %w", err)
+	}
+
+	// Don't allow opening from within a worktree
+	if gitRoot != filepath.Dir(gitDir) {
+		fmt.Fprintln(os.Stderr, "Error: You are inside a pf worktree.")
+		fmt.Fprintln(os.Stderr, "")
+		fmt.Fprintln(os.Stderr, "Each time you run 'pf new' or 'pf open', pf starts a subshell in the")
+		fmt.Fprintln(os.Stderr, "worktree directory. To keep subshells shallow and avoid nesting, pf")
+		fmt.Fprintln(os.Stderr, "requires you to return to the main repo before opening another worktree.")
+		fmt.Fprintln(os.Stderr, "")
+		fmt.Fprintln(os.Stderr, "To exit the current worktree:")
+		fmt.Fprintln(os.Stderr, "  exit")
+		fmt.Fprintln(os.Stderr, "")
+		fmt.Fprintln(os.Stderr, "Then re-run:")
+		fmt.Fprintf(os.Stderr, "  pf open %s\n", name)
+		os.Exit(1)
+	}
+
+	// Check for uncommitted changes
+	statusCmd := exec.Command("git", "status", "--porcelain")
+	output, err := statusCmd.Output()
+	if err != nil {
+		return fmt.Errorf("failed to check git status: %w", err)
+	}
+
+	if strings.TrimSpace(string(output)) != "" {
+		return fmt.Errorf("uncommitted changes in current worktree - commit or stash first")
+	}
+
+	s, err := store.Load()
+	if err != nil {
+		return fmt.Errorf("failed to load store: %w", err)
+	}
+
+	wt := s.FindByName(name)
+	if wt == nil {
+		return fmt.Errorf("worktree '%s' not found", name)
+	}
+
+	// Check if directory exists
+	if _, err := os.Stat(wt.Path); os.IsNotExist(err) {
+		return fmt.Errorf("worktree directory does not exist: %s", wt.Path)
+	}
+
+	// Get user's shell
+	shell := os.Getenv("SHELL")
+	if shell == "" {
+		shell = "/bin/sh"
+	}
+
+	// Spawn new shell in worktree directory
+	shellCmd := exec.Command(shell)
+	shellCmd.Dir = wt.Path
+	shellCmd.Stdin = os.Stdin
+	shellCmd.Stdout = os.Stdout
+	shellCmd.Stderr = os.Stderr
+
+	// Get current branch of the worktree
+	branch := getWorktreeBranch(wt.Path)
+
+	fmt.Println()
+	fmt.Println(success.Render("✓"), bold.Render(name), dim.Render("("+branch+")"))
+	fmt.Println(dim.Render("  Subshell started. Type 'exit' to return."))
+	fmt.Println()
+
+	if err := shellCmd.Run(); err != nil {
+		return fmt.Errorf("shell exited with error: %w", err)
+	}
+
+	fmt.Println()
+	fmt.Println(dim.Render("  Back in main worktree"))
+	fmt.Println()
+	return nil
+}

package/go/cmd/rm.go

@@ -0,0 +1,88 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/pullfrog/cli/internal/store"
+	"github.com/spf13/cobra"
+)
+
+var rmCmd = &cobra.Command{
+	Use:               "rm <name>",
+	Short:             "Remove a worktree",
+	Long:              `Removes a worktree and optionally deletes the branch.`,
+	Args:              cobra.ExactArgs(1),
+	RunE:              runRm,
+	ValidArgsFunction: completeWorktreeNames,
+}
+
+var deleteBranch bool
+
+func init() {
+	rmCmd.Flags().BoolVarP(&deleteBranch, "delete-branch", "d", false, "Also delete the branch")
+	rootCmd.AddCommand(rmCmd)
+}
+
+func runRm(cmd *cobra.Command, args []string) error {
+	name := args[0]
+
+	s, err := store.Load()
+	if err != nil {
+		return fmt.Errorf("failed to load store: %w", err)
+	}
+
+	wt := s.FindByName(name)
+	if wt == nil {
+		return fmt.Errorf("worktree '%s' not found", name)
+	}
+
+	// Check if we're currently in this worktree
+	cwd, err := os.Getwd()
+	if err == nil {
+		absWtPath, _ := filepath.Abs(wt.Path)
+		absCwd, _ := filepath.Abs(cwd)
+		if strings.HasPrefix(absCwd, absWtPath) {
+			return fmt.Errorf("cannot remove current worktree - exit first")
+		}
+	}
+
+	// Get branch before removing (for -d flag)
+	branch := getWorktreeBranch(wt.Path)
+
+	// Check if directory exists
+	if _, err := os.Stat(wt.Path); err == nil {
+		// Remove the worktree using git (suppress noise)
+		gitCmd := exec.Command("git", "worktree", "remove", wt.Path)
+		if err := gitCmd.Run(); err != nil {
+			return fmt.Errorf("failed to remove worktree: %w", err)
+		}
+	}
+
+	// Prune worktrees
+	exec.Command("git", "worktree", "prune").Run()
+
+	// Delete branch if requested
+	if deleteBranch && branch != "[missing]" && branch != "[detached]" {
+		gitCmd := exec.Command("git", "branch", "-D", branch)
+		if err := gitCmd.Run(); err != nil {
+			fmt.Fprintf(os.Stderr, "Warning: failed to delete branch %s: %v\n", branch, err)
+		}
+	}
+
+	// Remove from store
+	s.RemoveByName(name)
+	if err := s.Save(); err != nil {
+		return fmt.Errorf("failed to save store: %w", err)
+	}
+
+	if deleteBranch && branch != "[missing]" && branch != "[detached]" {
+		fmt.Println(success.Render("✓"), "Removed", bold.Render(name), dim.Render("(branch deleted)"))
+	} else {
+		fmt.Println(success.Render("✓"), "Removed", bold.Render(name))
+	}
+	return nil
+}