fix: smart fizzy binary lookup to prevent circular resolution

- Replace exec.LookPath("fizzy") with findFizzy() that:
  - Checks FIZZY_PATH env var first (explicit override)
  - Walks PATH but skips entries that resolve to fizzy-md itself
  - Detects shell wrapper scripts that reference fizzy-md
- Enables fizzy-md to sit in PATH as 'fizzy' transparently
- Agents call 'fizzy' naturally, markdown→HTML happens invisibly

Closes #1 (if applicable)
Related: Fizzy card #225, #208

Author: wheeljackz

main.go

@@ -128,6 +128,64 @@ func processArgs(args []string) ([]string, error) {
 	return result, nil
 }
 
+// findFizzy locates the real fizzy binary, avoiding circular resolution.
+// Priority: FIZZY_PATH env var → PATH lookup (skipping our own binary).
+func findFizzy() string {
+	// 1. Explicit override via env var
+	if p := os.Getenv("FIZZY_PATH"); p != "" {
+		if _, err := os.Stat(p); err == nil {
+			return p
+		}
+	}
+
+	// 2. Resolve our own executable path so we can skip it
+	self, _ := os.Executable()
+	if self != "" {
+		self, _ = filepath.EvalSymlinks(self)
+	}
+
+	// 3. Walk PATH entries looking for a "fizzy" that isn't us
+	pathEnv := os.Getenv("PATH")
+	for _, dir := range filepath.SplitList(pathEnv) {
+		candidate := filepath.Join(dir, "fizzy")
+		info, err := os.Stat(candidate)
+		if err != nil || info.IsDir() {
+			continue
+		}
+
+		real, _ := filepath.EvalSymlinks(candidate)
+
+		// Skip if it resolves to ourselves (fizzy-md)
+		if self != "" && real == self {
+			continue
+		}
+
+		// Skip shell scripts that call fizzy-md (wrapper scripts)
+		if isShellWrapperForFizzyMd(candidate) {
+			continue
+		}
+
+		return candidate
+	}
+
+	return ""
+}
+
+// isShellWrapperForFizzyMd does a quick check if a file is a small shell script
+// that references fizzy-md (i.e. a wrapper that would cause a loop).
+func isShellWrapperForFizzyMd(path string) bool {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return false
+	}
+	// Only check small files (real fizzy binary is >1MB)
+	if len(data) > 4096 {
+		return false
+	}
+	content := string(data)
+	return strings.Contains(content, "fizzy-md")
+}
+
 func main() {
 	// Get original args (skip program name)
 	args := os.Args[1:]
@@ -167,11 +225,11 @@ func main() {
 		os.Exit(1)
 	}
 
-	// Find fizzy executable
-	fizzyPath, err := exec.LookPath("fizzy")
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "fizzy-md error: fizzy command not found in PATH\n")
-		fmt.Fprintf(os.Stderr, "Please install fizzy-cli: https://github.com/robzolkos/fizzy-cli\n")
+	// Find fizzy executable, avoiding circular resolution back to ourselves
+	fizzyPath := findFizzy()
+	if fizzyPath == "" {
+		fmt.Fprintf(os.Stderr, "fizzy-md error: fizzy command not found\n")
+		fmt.Fprintf(os.Stderr, "Set FIZZY_PATH or install fizzy-cli: https://github.com/robzolkos/fizzy-cli\n")
 		os.Exit(1)
 	}
 

main_test.go

@@ -456,6 +456,56 @@ func TestProcessArgsWithFiles(t *testing.T) {
 	})
 }
 
+func TestFindFizzySkipsSelf(t *testing.T) {
+	// findFizzy should not return a path that resolves to the fizzy-md binary itself
+	result := findFizzy()
+	if result == "" {
+		t.Skip("no fizzy binary found in PATH (expected in CI)")
+	}
+
+	self, _ := os.Executable()
+	if self != "" {
+		selfReal, _ := filepath.EvalSymlinks(self)
+		resultReal, _ := filepath.EvalSymlinks(result)
+		if selfReal == resultReal {
+			t.Errorf("findFizzy returned self: %s", result)
+		}
+	}
+}
+
+func TestFindFizzyRespectsEnvVar(t *testing.T) {
+	// Create a fake fizzy binary
+	tmpDir := t.TempDir()
+	fakeFizzy := filepath.Join(tmpDir, "fizzy")
+	if err := os.WriteFile(fakeFizzy, []byte("#!/bin/sh\necho fake"), 0755); err != nil {
+		t.Fatalf("failed to create fake fizzy: %v", err)
+	}
+
+	t.Setenv("FIZZY_PATH", fakeFizzy)
+	result := findFizzy()
+	if result != fakeFizzy {
+		t.Errorf("expected %s, got %s", fakeFizzy, result)
+	}
+}
+
+func TestIsShellWrapperForFizzyMd(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	// A wrapper script that references fizzy-md
+	wrapper := filepath.Join(tmpDir, "wrapper")
+	os.WriteFile(wrapper, []byte("#!/bin/sh\nexec /opt/homebrew/bin/fizzy-md \"$@\"\n"), 0755)
+	if !isShellWrapperForFizzyMd(wrapper) {
+		t.Error("expected wrapper to be detected")
+	}
+
+	// A real binary (large file, not a wrapper)
+	notWrapper := filepath.Join(tmpDir, "real")
+	os.WriteFile(notWrapper, []byte("#!/bin/sh\nexec /opt/homebrew/bin/fizzy \"$@\"\n"), 0755)
+	if isShellWrapperForFizzyMd(notWrapper) {
+		t.Error("expected non-wrapper to not be detected")
+	}
+}
+
 // Benchmark for performance requirement (<100ms)
 func BenchmarkConvertMarkdownToHTML(b *testing.B) {
 	input := `## Overview