command_search.go

package contexting

import (
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"time"

	"github.com/spf13/cobra"
)

func newSearchCommand() *cobra.Command {
	var rootPath string
	var indexPath string
	var runtimeFile string
	var opts SearchOptions
	var dirSummary bool
	var dirLimit int
	var drillLimit int
	var jsonOut bool
	var showTokens bool
	var useMemory bool
	var memoryOnly bool
	var summary bool

	cmd := &cobra.Command{
		Use:   "search-hints [query]",
		Short: "Find files by concept — query your codebase with natural language",
		Long: `Queries the precomputed ctxt index (files + symbols + LLM synonyms) with natural language and returns ranked file paths.

How it works:
  • Your query is tokenized and matched against filenames, symbols (functions, classes, types), and synonyms
  • Path, synonym, and symbol matches contribute bounded scores; matching more query terms adds a coverage bonus
  • Results are ranked by total score and returned

Requires an existing index (run 'ctxt init .' first).

Examples:
  ctxt search-hints "auth middleware"           Find auth-related files
  ctxt search-hints "payment" --json            JSON output for scripting
  ctxt search-hints "login" --hybrid            Add ripgrep content fallback
  ctxt search-hints "database" --explain        Show score breakdown
  ctxt search-hints "upload" --type files       Files only (no directories)
  ctxt search-hints "config" --limit 20         More results`,
		Args: cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			var absConfigPath string
			if configPath != "" {
				var cfgErr error
				absConfigPath, cfgErr = filepath.Abs(configPath)
				if cfgErr != nil {
					return fmt.Errorf("resolve config path: %w", cfgErr)
				}
			}
			cfg, err := LoadContextingConfig(absConfigPath)
			if err != nil {
				return err
			}
			if rootPath == "" {
				rootPath, err = os.Getwd()
				if err != nil {
					return fmt.Errorf("get working directory: %w", err)
				}
			}
			absRoot, err := filepath.Abs(rootPath)
			if err != nil {
				return fmt.Errorf("resolve root path: %w", err)
			}
			applyStringFlag(cmd, "index", &indexPath, cfg.Search.IndexPath)
			applyIntFlag(cmd, "limit", &opts.Limit, cfg.Search.Limit)
			applyIntFlag(cmd, "min-score", &opts.MinScore, cfg.Search.MinScore)
			applyStringFlag(cmd, "type", &opts.TypeFilter, cfg.Search.TypeFilter)
			if cfg.Search.DirSummary != nil {
				applyBoolFlag(cmd, "dir-summary", &dirSummary, *cfg.Search.DirSummary)
			}
			applyIntFlag(cmd, "dir-limit", &dirLimit, cfg.Search.DirLimit)
			applyIntFlag(cmd, "drill-limit", &drillLimit, cfg.Search.DrillLimit)
			if cfg.Search.Explain != nil {
				applyBoolFlag(cmd, "explain", &opts.IncludeDebug, *cfg.Search.Explain)
			}
			if cfg.Search.JSON != nil {
				applyBoolFlag(cmd, "json", &jsonOut, *cfg.Search.JSON)
			}
			if cfg.Search.ShowTokens != nil {
				applyBoolFlag(cmd, "show-tokens", &showTokens, *cfg.Search.ShowTokens)
			}
			if cfg.Search.UseMemory != nil {
				applyBoolFlag(cmd, "memory", &useMemory, *cfg.Search.UseMemory)
			}
			applyStringFlag(cmd, "runtime-file", &runtimeFile, cfg.Search.RuntimeFile)
			if !cmd.Flags().Changed("index") {
				indexPath = resolveConfigPath(absConfigPath, indexPath)
			}
			if runtimeFile == "" {
				runtimeFile = resolveProjectPath(filepath.Dir(indexPath), "ctx_runtime.json")
			} else if !cmd.Flags().Changed("runtime-file") {
				runtimeFile = resolveConfigPath(absConfigPath, runtimeFile)
			}

			query := args[0]
			results := make([]SearchResult, 0)
			var source string
			var indexGeneratedAt *time.Time
			var fallback *bool
			usedMemory := false
			if useMemory {
				memResp, memErr := QueryMemorySearch(runtimeFile, query, opts, absRoot)
				if memErr == nil {
					results = memResp.Results
					usedMemory = true
					source = "memory"
					if !memResp.GeneratedAt.IsZero() {
						indexGeneratedAt = &memResp.GeneratedAt
					}
					f := false
					fallback = &f
				} else if memoryOnly {
					return memErr
				}
			}
			if !usedMemory {
				index, err := LoadContextIndex(indexPath)
				if err != nil {
					if !errors.Is(err, os.ErrNotExist) {
						return err
					}
					if useMemory {
						source = "none"
						f := true
						fallback = &f
					}
					results = []SearchResult{}
				} else {
					if index.RootPath == "" {
						return fmt.Errorf("index missing root_path: regenerate index by running 'ctxt watch' or 'ctxt init' in the project directory")
					}
					if index.RootPath != absRoot {
						return fmt.Errorf("index root path mismatch: expected %s, got %s. Use --root to specify the project directory or run from the project root", absRoot, index.RootPath)
					}
					results = SearchHintsWithOptions(index, query, opts)
					source = "snapshot"
					if !index.GeneratedAt.IsZero() {
						indexGeneratedAt = &index.GeneratedAt
					}
					if useMemory {
						f := true
						fallback = &f
					}
				}
			}
			if showTokens {
				fmt.Printf("Tokens: %v\n", tokenize(query))
			}

			if summary {
				for i := range results {
					results[i].Matches = nil
					results[i].Breakdown = nil
				}
			}

			if dirSummary {
				summaries := SummarizeDirectories(results, dirLimit, drillLimit)
				if jsonOut {
					jsonStr, err := directorySummariesToJSON(summaries)
					if err != nil {
						return err
					}
					fmt.Println(jsonStr)
					return nil
				}
				printDirectorySummaries(summaries)
				return nil
			}

			if jsonOut {
				resp := SearchResponse{
					Source:           source,
					IndexGeneratedAt: indexGeneratedAt,
					Fallback:         fallback,
					Results:          results,
				}
				jsonStr, err := searchResponseToJSON(resp)
				if err != nil {
					return err
				}
				fmt.Println(jsonStr)
				return nil
			}

			if summary {
				printSummaryResults(results)
				return nil
			}

			printSearchResults(results)
			return nil
		},
	}

	cmd.Flags().StringVar(&rootPath, "root", "", "Project root path (defaults to current working directory)")
	cmd.Flags().StringVarP(&indexPath, "index", "i", ".ctxt/ctx_index.json", "Path to context JSON")
	cmd.Flags().IntVarP(&opts.Limit, "limit", "n", 10, "Maximum number of matches")
	cmd.Flags().IntVar(&opts.MinScore, "min-score", 1, "Minimum score required to return a match")
	cmd.Flags().StringVar(&opts.TypeFilter, "type", "all", "Filter result type: all|files|dirs")
	cmd.Flags().BoolVar(&dirSummary, "dir-summary", false, "Summarize top matching directories with rationale and drill-down hits")
	cmd.Flags().IntVar(&dirLimit, "dir-limit", 5, "Maximum number of directories returned in --dir-summary mode")
	cmd.Flags().IntVar(&drillLimit, "drill-limit", 3, "Maximum top hits shown per directory in --dir-summary mode")
	cmd.Flags().BoolVar(&opts.IncludeDebug, "explain", false, "Include score breakdown in output")
	cmd.Flags().BoolVar(&opts.ContentFallback, "hybrid", false, "Augment index results with content matching via ripgrep")
	cmd.Flags().IntVar(&opts.ContentMatchScore, "hybrid-score", 1, "Score for content-matched results (default 1)")
	cmd.Flags().StringVar(&opts.ContentRoot, "hybrid-root", "", "Project root for content matching (defaults to index root)")
	cmd.Flags().BoolVar(&useMemory, "memory", true, "Query live in-memory watch index when available")
	cmd.Flags().BoolVar(&memoryOnly, "memory-only", false, "Require live memory search and fail instead of falling back to snapshot")
	cmd.Flags().StringVar(&runtimeFile, "runtime-file", "", "Path to runtime memory-search state file (defaults near index path)")
	cmd.Flags().BoolVar(&jsonOut, "json", false, "Print search results as JSON")
	cmd.Flags().BoolVar(&showTokens, "show-tokens", false, "Print normalized query tokens before results")
	cmd.Flags().BoolVar(&summary, "summary", false, "Minimal output: path, type, score only")

	return cmd
}