More explicit string matching behavior, a few new flags, and tests

Author: dacharyc

audit-cli/README.md

@@ -122,11 +122,17 @@ After extraction, a report is displayed showing:
 
 Search through files for a specific substring. Can search through extracted code example files or RST source files.
 
+**Default Behavior:**
+- **Case-insensitive** search (matches "curl", "CURL", "Curl", etc.)
+- **Exact word matching** (excludes partial matches like "curl" in "libcurl")
+
+Use `--case-sensitive` to make the search case-sensitive, or `--partial-match` to allow matching the substring as part of larger words.
+
 **Basic Usage:**
 
 ```bash
-# Search in a single file
-./audit-cli search find-string path/to/file.js "substring"
+# Search in a single file (case-insensitive, exact word match)
+./audit-cli search find-string path/to/file.js "curl"
 
 # Search in a directory (non-recursive)
 ./audit-cli search find-string path/to/output "substring"
@@ -142,13 +148,24 @@ Search through files for a specific substring. Can search through extracted code
 
 # Verbose output (show file paths and language breakdown)
 ./audit-cli search find-string path/to/output "substring" -r -v
+
+# Case-sensitive search (only matches exact case)
+./audit-cli search find-string path/to/output "CURL" --case-sensitive
+
+# Partial match (includes "curl" in "libcurl")
+./audit-cli search find-string path/to/output "curl" --partial-match
+
+# Combine flags for case-sensitive partial matching
+./audit-cli search find-string path/to/output "curl" --case-sensitive --partial-match
 ```
 
 **Flags:**
 
 - `-r, --recursive` - Recursively search all files in subdirectories
 - `-f, --follow-includes` - Follow `.. include::` directives in RST files
 - `-v, --verbose` - Show file paths and language breakdown
+- `--case-sensitive` - Make search case-sensitive (default: case-insensitive)
+- `--partial-match` - Allow partial matches within words (default: exact word matching)
 
 **Report:**
 

audit-cli/commands/search/find-string/find_string.go

@@ -3,14 +3,18 @@
 // This package implements the "search find-string" subcommand, which searches through
 // extracted code example files to find occurrences of a specific substring.
 //
-// The search is case-sensitive and counts each file only once, even if the substring
-// appears multiple times in the same file.
+// By default, the search is case-insensitive and matches exact words only (not partial matches
+// within larger words). These behaviors can be changed with the --case-sensitive and
+// --partial-match flags. Each file is counted only once, even if the substring appears
+// multiple times in the same file.
 //
 // Supports:
 //   - Recursive directory scanning
 //   - Following include directives in RST files
 //   - Verbose output with file paths and language breakdown
 //   - Language detection based on file extension
+//   - Case-insensitive search (default) or case-sensitive search (--case-sensitive flag)
+//   - Exact word matching (default) or partial matching (--partial-match flag)
 package find_string
 
 import (
@@ -32,29 +36,39 @@ import (
 //   - -r, --recursive: Recursively search all files in subdirectories
 //   - -f, --follow-includes: Follow .. include:: directives in RST files
 //   - -v, --verbose: Show file paths and language breakdown
+//   - --case-sensitive: Make search case-sensitive (default: case-insensitive)
+//   - --partial-match: Allow partial matches within words (default: exact word matching)
 func NewFindStringCommand() *cobra.Command {
 	var (
 		recursive      bool
 		followIncludes bool
 		verbose        bool
+		caseSensitive  bool
+		partialMatch   bool
 	)
 
 	cmd := &cobra.Command{
 		Use:   "find-string [filepath] [substring]",
 		Short: "Search for a substring in extracted code example files",
 		Long: `Search through extracted code example files to find occurrences of a specific substring.
-Reports the number of code examples containing the substring.`,
+Reports the number of code examples containing the substring.
+
+By default, the search is case-insensitive and matches exact words only. Use --case-sensitive
+to make the search case-sensitive, or --partial-match to allow matching the substring as part
+of larger words (e.g., "curl" matching "libcurl").`,
 		Args: cobra.ExactArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			filePath := args[0]
 			substring := args[1]
-			return runSearch(filePath, substring, recursive, followIncludes, verbose)
+			return runSearch(filePath, substring, recursive, followIncludes, verbose, caseSensitive, partialMatch)
 		},
 	}
 
 	cmd.Flags().BoolVarP(&recursive, "recursive", "r", false, "Recursively search all files in subdirectories")
 	cmd.Flags().BoolVarP(&followIncludes, "follow-includes", "f", false, "Follow .. include:: directives in RST files")
 	cmd.Flags().BoolVarP(&verbose, "verbose", "v", false, "Provide additional information during execution")
+	cmd.Flags().BoolVar(&caseSensitive, "case-sensitive", false, "Make search case-sensitive (default: case-insensitive)")
+	cmd.Flags().BoolVar(&partialMatch, "partial-match", false, "Allow partial matches within words (default: exact word matching)")
 
 	return cmd
 }
@@ -66,29 +80,31 @@ Reports the number of code examples containing the substring.`,
 //
 // Parameters:
 //   - filePath: Path to file or directory to search
-//   - substring: The substring to search for (case-sensitive)
+//   - substring: The substring to search for
 //   - recursive: If true, recursively search subdirectories
 //   - followIncludes: If true, follow .. include:: directives
 //   - verbose: If true, show detailed information during search
+//   - caseSensitive: If true, search is case-sensitive; if false, case-insensitive
+//   - partialMatch: If true, allow partial matches within words; if false, match exact words only
 //
 // Returns:
 //   - *SearchReport: Statistics about the search operation
 //   - error: Any error encountered during search
-func RunSearch(filePath string, substring string, recursive bool, followIncludes bool, verbose bool) (*SearchReport, error) {
-	return runSearchInternal(filePath, substring, recursive, followIncludes, verbose)
+func RunSearch(filePath string, substring string, recursive bool, followIncludes bool, verbose bool, caseSensitive bool, partialMatch bool) (*SearchReport, error) {
+	return runSearchInternal(filePath, substring, recursive, followIncludes, verbose, caseSensitive, partialMatch)
 }
 
 // runSearch executes the search operation (internal wrapper for CLI).
 //
 // This is a thin wrapper around runSearchInternal that discards the report
 // and only returns errors, suitable for use in the CLI command handler.
-func runSearch(filePath string, substring string, recursive bool, followIncludes bool, verbose bool) error {
-	_, err := runSearchInternal(filePath, substring, recursive, followIncludes, verbose)
+func runSearch(filePath string, substring string, recursive bool, followIncludes bool, verbose bool, caseSensitive bool, partialMatch bool) error {
+	_, err := runSearchInternal(filePath, substring, recursive, followIncludes, verbose, caseSensitive, partialMatch)
 	return err
 }
 
 // runSearchInternal contains the core logic for the search-code-examples command
-func runSearchInternal(filePath string, substring string, recursive bool, followIncludes bool, verbose bool) (*SearchReport, error) {
+func runSearchInternal(filePath string, substring string, recursive bool, followIncludes bool, verbose bool, caseSensitive bool, partialMatch bool) (*SearchReport, error) {
 	fileInfo, err := os.Stat(filePath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to access path %s: %w", filePath, err)
@@ -113,6 +129,8 @@ func runSearchInternal(filePath string, substring string, recursive bool, follow
 	if verbose {
 		fmt.Printf("Found %d files to search\n", len(filesToSearch))
 		fmt.Printf("Searching for substring: %q\n", substring)
+		fmt.Printf("Case sensitive: %v\n", caseSensitive)
+		fmt.Printf("Partial match: %v\n", partialMatch)
 		fmt.Printf("Follow includes: %v\n\n", followIncludes)
 	}
 
@@ -141,7 +159,7 @@ func runSearchInternal(filePath string, substring string, recursive bool, follow
 
 		// Search all collected files
 		for _, fileToSearch := range filesToSearchWithIncludes {
-			result, err := searchFile(fileToSearch, substring)
+			result, err := searchFile(fileToSearch, substring, caseSensitive, partialMatch)
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "Warning: failed to search %s: %v\n", fileToSearch, err)
 				continue
@@ -211,7 +229,7 @@ func collectFilesWithIncludes(filePath string, visited map[string]bool, verbose
 }
 
 // searchFile searches a single file for the substring
-func searchFile(filePath string, substring string) (SearchResult, error) {
+func searchFile(filePath string, substring string, caseSensitive bool, partialMatch bool) (SearchResult, error) {
 	result := SearchResult{
 		FilePath: filePath,
 		Language: extractLanguageFromFilename(filePath),
@@ -223,11 +241,70 @@ func searchFile(filePath string, substring string) (SearchResult, error) {
 		return result, err
 	}
 
-	result.Contains = strings.Contains(string(content), substring)
+	contentStr := string(content)
+	searchStr := substring
+
+	// Handle case sensitivity
+	if !caseSensitive {
+		contentStr = strings.ToLower(contentStr)
+		searchStr = strings.ToLower(searchStr)
+	}
+
+	// Check if substring exists in content
+	if !strings.Contains(contentStr, searchStr) {
+		return result, nil
+	}
+
+	// If partial match is allowed, we're done
+	if partialMatch {
+		result.Contains = true
+		return result, nil
+	}
+
+	// For exact word matching, check if the match is a whole word
+	result.Contains = isExactWordMatch(contentStr, searchStr)
 
 	return result, nil
 }
 
+// isExactWordMatch checks if the substring appears as a complete word in the content.
+// A word boundary is defined as the start/end of the string or a non-alphanumeric character.
+func isExactWordMatch(content string, substring string) bool {
+	// Find all occurrences of the substring
+	index := 0
+	for {
+		pos := strings.Index(content[index:], substring)
+		if pos == -1 {
+			break
+		}
+
+		actualPos := index + pos
+
+		// Check if this is a whole word match
+		// Check character before (if not at start)
+		beforeOK := actualPos == 0 || !isWordChar(rune(content[actualPos-1]))
+
+		// Check character after (if not at end)
+		afterPos := actualPos + len(substring)
+		afterOK := afterPos >= len(content) || !isWordChar(rune(content[afterPos]))
+
+		if beforeOK && afterOK {
+			return true
+		}
+
+		// Move to next potential match
+		index = actualPos + 1
+	}
+
+	return false
+}
+
+// isWordChar returns true if the character is alphanumeric or underscore.
+// These characters are considered part of a word.
+func isWordChar(c rune) bool {
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_'
+}
+
 // extractLanguageFromFilename extracts the language from the file extension
 func extractLanguageFromFilename(filePath string) string {
 	ext := filepath.Ext(filePath)