Add completion menu for file paths

go.mod

@@ -35,8 +35,6 @@ require (
 
 require (
 	cloud.google.com/go v0.116.0 // indirect
-	github.com/google/go-cmp v0.7.0 // indirect
-	github.com/gorilla/websocket v1.5.3 // indirect
 	cloud.google.com/go/auth v0.13.0 // indirect
 	cloud.google.com/go/compute/metadata v0.6.0 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.17.0 // indirect
@@ -72,12 +70,15 @@ require (
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-viper/mapstructure/v2 v2.2.1 // indirect
 	github.com/golang-jwt/jwt/v5 v5.2.2 // indirect
+	github.com/google/go-cmp v0.7.0 // indirect
 	github.com/google/s2a-go v0.1.8 // indirect
 	github.com/googleapis/enterprise-certificate-proxy v0.3.4 // indirect
 	github.com/googleapis/gax-go/v2 v2.14.1 // indirect
 	github.com/gorilla/css v1.0.1 // indirect
+	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/kylelemons/godebug v1.1.0 // indirect
+	github.com/lithammer/fuzzysearch v1.1.8
 	github.com/lucasb-eyer/go-colorful v1.2.0
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-localereader v0.0.1 // indirect

go.sum

@@ -144,6 +144,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/lithammer/fuzzysearch v1.1.8 h1:/HIuJnjHuXS8bKaiTMeeDlW2/AyIWk2brx1V8LFgLN4=
+github.com/lithammer/fuzzysearch v1.1.8/go.mod h1:IdqeyBClc3FFqSzYq/MXESsS4S0FsZ5ajtkr5xPLts4=
 github.com/lrstanley/bubblezone v0.0.0-20250315020633-c249a3fe1231 h1:9rjt7AfnrXKNSZhp36A3/4QAZAwGGCGD/p8Bse26zms=
 github.com/lrstanley/bubblezone v0.0.0-20250315020633-c249a3fe1231/go.mod h1:S5etECMx+sZnW0Gm100Ma9J1PgVCTgNyFaqGu2b08b4=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=

internal/completions/files-folders.go

@@ -0,0 +1,191 @@
+package completions
+
+import (
+	"bytes"
+	"fmt"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/lithammer/fuzzysearch/fuzzy"
+	"github.com/opencode-ai/opencode/internal/fileutil"
+	"github.com/opencode-ai/opencode/internal/logging"
+	"github.com/opencode-ai/opencode/internal/tui/components/dialog"
+)
+
+type filesAndFoldersContextGroup struct {
+	prefix string
+}
+
+func (cg *filesAndFoldersContextGroup) GetId() string {
+	return cg.prefix
+}
+
+func (cg *filesAndFoldersContextGroup) GetEntry() dialog.CompletionItemI {
+	return dialog.NewCompletionItem(dialog.CompletionItem{
+		Title: "Files & Folders",
+		Value: "files",
+	})
+}
+
+func processNullTerminatedOutput(outputBytes []byte) []string {
+	if len(outputBytes) > 0 && outputBytes[len(outputBytes)-1] == 0 {
+		outputBytes = outputBytes[:len(outputBytes)-1]
+	}
+
+	if len(outputBytes) == 0 {
+		return []string{}
+	}
+
+	split := bytes.Split(outputBytes, []byte{0})
+	matches := make([]string, 0, len(split))
+
+	for _, p := range split {
+		if len(p) == 0 {
+			continue
+		}
+
+		path := string(p)
+		path = filepath.Join(".", path)
+
+		if !fileutil.SkipHidden(path) {
+			matches = append(matches, path)
+		}
+	}
+
+	return matches
+}
+
+func (cg *filesAndFoldersContextGroup) getFiles(query string) ([]string, error) {
+	cmdRg := fileutil.GetRgCmd("") // No glob pattern for this use case
+	cmdFzf := fileutil.GetFzfCmd(query)
+
+	var matches []string
+	// Case 1: Both rg and fzf available
+	if cmdRg != nil && cmdFzf != nil {
+		rgPipe, err := cmdRg.StdoutPipe()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get rg stdout pipe: %w", err)
+		}
+		defer rgPipe.Close()
+
+		cmdFzf.Stdin = rgPipe
+		var fzfOut bytes.Buffer
+		var fzfErr bytes.Buffer
+		cmdFzf.Stdout = &fzfOut
+		cmdFzf.Stderr = &fzfErr
+
+		if err := cmdFzf.Start(); err != nil {
+			return nil, fmt.Errorf("failed to start fzf: %w", err)
+		}
+
+		errRg := cmdRg.Run()
+		errFzf := cmdFzf.Wait()
+
+		if errRg != nil {
+			logging.Warn(fmt.Sprintf("rg command failed during pipe: %v", errRg))
+		}
+
+		if errFzf != nil {
+			if exitErr, ok := errFzf.(*exec.ExitError); ok && exitErr.ExitCode() == 1 {
+				return []string{}, nil // No matches from fzf
+			}
+			return nil, fmt.Errorf("fzf command failed: %w\nStderr: %s", errFzf, fzfErr.String())
+		}
+
+		matches = processNullTerminatedOutput(fzfOut.Bytes())
+
+		// Case 2: Only rg available
+	} else if cmdRg != nil {
+		logging.Debug("Using Ripgrep with fuzzy match fallback for file completions")
+		var rgOut bytes.Buffer
+		var rgErr bytes.Buffer
+		cmdRg.Stdout = &rgOut
+		cmdRg.Stderr = &rgErr
+
+		if err := cmdRg.Run(); err != nil {
+			return nil, fmt.Errorf("rg command failed: %w\nStderr: %s", err, rgErr.String())
+		}
+
+		allFiles := processNullTerminatedOutput(rgOut.Bytes())
+		matches = fuzzy.Find(query, allFiles)
+
+		// Case 3: Only fzf available
+	} else if cmdFzf != nil {
+		logging.Debug("Using FZF with doublestar fallback for file completions")
+		files, _, err := fileutil.GlobWithDoublestar("**/*", ".", 0)
+		if err != nil {
+			return nil, fmt.Errorf("failed to list files for fzf: %w", err)
+		}
+
+		allFiles := make([]string, 0, len(files))
+		for _, file := range files {
+			if !fileutil.SkipHidden(file) {
+				allFiles = append(allFiles, file)
+			}
+		}
+
+		var fzfIn bytes.Buffer
+		for _, file := range allFiles {
+			fzfIn.WriteString(file)
+			fzfIn.WriteByte(0)
+		}
+
+		cmdFzf.Stdin = &fzfIn
+		var fzfOut bytes.Buffer
+		var fzfErr bytes.Buffer
+		cmdFzf.Stdout = &fzfOut
+		cmdFzf.Stderr = &fzfErr
+
+		if err := cmdFzf.Run(); err != nil {
+			if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 1 {
+				return []string{}, nil
+			}
+			return nil, fmt.Errorf("fzf command failed: %w\nStderr: %s", err, fzfErr.String())
+		}
+
+		matches = processNullTerminatedOutput(fzfOut.Bytes())
+
+		// Case 4: Fallback to doublestar with fuzzy match
+	} else {
+		logging.Debug("Using doublestar with fuzzy match for file completions")
+		allFiles, _, err := fileutil.GlobWithDoublestar("**/*", ".", 0)
+		if err != nil {
+			return nil, fmt.Errorf("failed to glob files: %w", err)
+		}
+
+		filteredFiles := make([]string, 0, len(allFiles))
+		for _, file := range allFiles {
+			if !fileutil.SkipHidden(file) {
+				filteredFiles = append(filteredFiles, file)
+			}
+		}
+
+		matches = fuzzy.Find(query, filteredFiles)
+	}
+
+	return matches, nil
+}
+
+func (cg *filesAndFoldersContextGroup) GetChildEntries(query string) ([]dialog.CompletionItemI, error) {
+	matches, err := cg.getFiles(query)
+	if err != nil {
+		return nil, err
+	}
+
+	items := make([]dialog.CompletionItemI, 0, len(matches))
+	for _, file := range matches {
+		item := dialog.NewCompletionItem(dialog.CompletionItem{
+			Title: file,
+			Value: file,
+		})
+		items = append(items, item)
+	}
+
+	return items, nil
+}
+
+func NewFileAndFolderContextGroup() dialog.CompletionProvider {
+	return &filesAndFoldersContextGroup{
+		prefix: "file",
+	}
+}

internal/fileutil/fileutil.go

@@ -0,0 +1,163 @@
+package fileutil
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/bmatcuk/doublestar/v4"
+	"github.com/opencode-ai/opencode/internal/logging"
+)
+
+var (
+	rgPath  string
+	fzfPath string
+)
+
+func init() {
+	var err error
+	rgPath, err = exec.LookPath("rg")
+	if err != nil {
+		logging.Warn("Ripgrep (rg) not found in $PATH. Some features might be limited or slower.")
+		rgPath = ""
+	}
+	fzfPath, err = exec.LookPath("fzf")
+	if err != nil {
+		logging.Warn("FZF not found in $PATH. Some features might be limited or slower.")
+		fzfPath = ""
+	}
+}
+
+func GetRgCmd(globPattern string) *exec.Cmd {
+	if rgPath == "" {
+		return nil
+	}
+	rgArgs := []string{
+		"--files",
+		"-L",
+		"--null",
+	}
+	if globPattern != "" {
+		if !filepath.IsAbs(globPattern) && !strings.HasPrefix(globPattern, "/") {
+			globPattern = "/" + globPattern
+		}
+		rgArgs = append(rgArgs, "--glob", globPattern)
+	}
+	cmd := exec.Command(rgPath, rgArgs...)
+	cmd.Dir = "."
+	return cmd
+}
+
+func GetFzfCmd(query string) *exec.Cmd {
+	if fzfPath == "" {
+		return nil
+	}
+	fzfArgs := []string{
+		"--filter",
+		query,
+		"--read0",
+		"--print0",
+	}
+	cmd := exec.Command(fzfPath, fzfArgs...)
+	cmd.Dir = "."
+	return cmd
+}
+
+type FileInfo struct {
+	Path    string
+	ModTime time.Time
+}
+
+func SkipHidden(path string) bool {
+	// Check for hidden files (starting with a dot)
+	base := filepath.Base(path)
+	if base != "." && strings.HasPrefix(base, ".") {
+		return true
+	}
+
+	commonIgnoredDirs := map[string]bool{
+		".opencode":        true,
+		"node_modules":     true,
+		"vendor":           true,
+		"dist":             true,
+		"build":            true,
+		"target":           true,
+		".git":             true,
+		".idea":            true,
+		".vscode":          true,
+		"__pycache__":      true,
+		"bin":              true,
+		"obj":              true,
+		"out":              true,
+		"coverage":         true,
+		"tmp":              true,
+		"temp":             true,
+		"logs":             true,
+		"generated":        true,
+		"bower_components": true,
+		"jspm_packages":    true,
+	}
+
+	parts := strings.Split(path, string(os.PathSeparator))
+	for _, part := range parts {
+		if commonIgnoredDirs[part] {
+			return true
+		}
+	}
+	return false
+}
+
+func GlobWithDoublestar(pattern, searchPath string, limit int) ([]string, bool, error) {
+	fsys := os.DirFS(searchPath)
+	relPattern := strings.TrimPrefix(pattern, "/")
+	var matches []FileInfo
+
+	err := doublestar.GlobWalk(fsys, relPattern, func(path string, d fs.DirEntry) error {
+		if d.IsDir() {
+			return nil
+		}
+		if SkipHidden(path) {
+			return nil
+		}
+		info, err := d.Info()
+		if err != nil {
+			return nil
+		}
+		absPath := path
+		if !strings.HasPrefix(absPath, searchPath) && searchPath != "." {
+			absPath = filepath.Join(searchPath, absPath)
+		} else if !strings.HasPrefix(absPath, "/") && searchPath == "." {
+			absPath = filepath.Join(searchPath, absPath) // Ensure relative paths are joined correctly
+		}
+
+		matches = append(matches, FileInfo{Path: absPath, ModTime: info.ModTime()})
+		if limit > 0 && len(matches) >= limit*2 {
+			return fs.SkipAll
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, false, fmt.Errorf("glob walk error: %w", err)
+	}
+
+	sort.Slice(matches, func(i, j int) bool {
+		return matches[i].ModTime.After(matches[j].ModTime)
+	})
+
+	truncated := false
+	if limit > 0 && len(matches) > limit {
+		matches = matches[:limit]
+		truncated = true
+	}
+
+	results := make([]string, len(matches))
+	for i, m := range matches {
+		results[i] = m.Path
+	}
+	return results, truncated, nil
+}