Rg missing features (#49)

* Add ripgrep compatibility features: --files, -d, --stats, -P, markdown type

  This PR adds several missing ripgrep flags and improves compatibility with the real rg command.

  New Features

  --files - List files that would be searched without requiring a pattern
  rg --files              # List all searchable files
  rg --files -t js        # List only JavaScript files
  rg --files -g '*.txt'   # List files matching glob
  rg --files -d 2         # List files up to depth 2

  -d NUM - Short alias for --max-depth
  rg -d 2 pattern         # Same as rg --max-depth 2 pattern

  --stats - Print search statistics after results
  rg --stats pattern
  # Output includes: matches, matched lines, files with matches, files searched, bytes searched

  -P/--pcre2 - Returns helpful error message (PCRE2 not supported)
  rg -P pattern
  # Error: rg: PCRE2 is not supported. Use standard regex syntax instead.

  -t markdown - Added markdown as alias for md file type
  rg -t markdown pattern  # Search .md, .markdown, .mdown, .mkd files

  Changes

  - rg-search.ts: Added listFiles() function for --files mode, stats output
  - rg-parser.ts: Added -d alias, --files/--stats flags, -P error handling
  - rg-options.ts: Added files and stats boolean options
  - file-types.ts: Added markdown type alias
  - rg.ts: Updated help text with new flags

  Tests

  Added 22 new tests covering:
  - --files with various filters (type, glob, depth, hidden)
  - -d at various depths and combined with filters
  - --stats output format and edge cases
  - markdown type matching all extensions
  - -P/--pcre2 error messages

  Test count: 417 rg tests (up from 395)

* tests-galore

* file-types

Author: cramforce

src/commands/rg/file-types.ts

@@ -14,7 +14,7 @@ export interface FileType {
  * Built-in file type definitions
  * Use `rg --type-list` to see all types in real ripgrep
  */
-export const FILE_TYPES: Record<string, FileType> = {
+const FILE_TYPES: Record<string, FileType> = {
   // Web languages
   js: { extensions: [".js", ".mjs", ".cjs", ".jsx"], globs: [] },
   ts: { extensions: [".ts", ".tsx", ".mts", ".cts"], globs: [] },
@@ -64,7 +64,11 @@ export const FILE_TYPES: Record<string, FileType> = {
   csv: { extensions: [".csv", ".tsv"], globs: [] },
 
   // Documentation
-  md: { extensions: [".md", ".markdown", ".mdown", ".mkd"], globs: [] },
+  md: { extensions: [".md", ".mdx", ".markdown", ".mdown", ".mkd"], globs: [] },
+  markdown: {
+    extensions: [".md", ".mdx", ".markdown", ".mdown", ".mkd"],
+    globs: [],
+  },
   rst: { extensions: [".rst"], globs: [] },
   txt: { extensions: [".txt", ".text"], globs: [] },
   tex: { extensions: [".tex", ".ltx", ".sty", ".cls"], globs: [] },
@@ -85,37 +89,157 @@ export const FILE_TYPES: Record<string, FileType> = {
 };
 
 /**
- * Check if a filename matches any of the specified types
+ * Mutable file type registry for runtime type modifications
+ * Supports --type-add and --type-clear flags
  */
-export function matchesType(filename: string, types: string[]): boolean {
-  const lowerFilename = filename.toLowerCase();
+export class FileTypeRegistry {
+  private types: Map<string, FileType>;
+
+  constructor() {
+    // Clone default types
+    this.types = new Map(
+      Object.entries(FILE_TYPES).map(([name, type]) => [
+        name,
+        { extensions: [...type.extensions], globs: [...type.globs] },
+      ]),
+    );
+  }
+
+  /**
+   * Add a type definition
+   * Format: "name:pattern" where pattern can be:
+   * - "*.ext" - glob pattern
+   * - "include:other" - include patterns from another type
+   */
+  addType(spec: string): void {
+    const colonIdx = spec.indexOf(":");
+    if (colonIdx === -1) return;
 
-  for (const typeName of types) {
-    const fileType = FILE_TYPES[typeName];
-    if (!fileType) continue;
+    const name = spec.slice(0, colonIdx);
+    const pattern = spec.slice(colonIdx + 1);
 
-    // Check extensions
-    for (const ext of fileType.extensions) {
-      if (lowerFilename.endsWith(ext)) {
-        return true;
+    if (pattern.startsWith("include:")) {
+      // Include patterns from another type
+      const otherName = pattern.slice(8);
+      const other = this.types.get(otherName);
+      if (other) {
+        const existing = this.types.get(name) || { extensions: [], globs: [] };
+        existing.extensions.push(...other.extensions);
+        existing.globs.push(...other.globs);
+        this.types.set(name, existing);
       }
+    } else {
+      // Add glob pattern
+      const existing = this.types.get(name) || { extensions: [], globs: [] };
+      // If pattern is like "*.ext", add to extensions
+      if (pattern.startsWith("*.") && !pattern.slice(2).includes("*")) {
+        const ext = pattern.slice(1); // Keep the dot
+        if (!existing.extensions.includes(ext)) {
+          existing.extensions.push(ext);
+        }
+      } else {
+        // Add as glob pattern
+        if (!existing.globs.includes(pattern)) {
+          existing.globs.push(pattern);
+        }
+      }
+      this.types.set(name, existing);
     }
+  }
+
+  /**
+   * Clear all patterns from a type
+   */
+  clearType(name: string): void {
+    const existing = this.types.get(name);
+    if (existing) {
+      existing.extensions = [];
+      existing.globs = [];
+    }
+  }
+
+  /**
+   * Get a type by name
+   */
+  getType(name: string): FileType | undefined {
+    return this.types.get(name);
+  }
+
+  /**
+   * Get all type names
+   */
+  getAllTypes(): Map<string, FileType> {
+    return this.types;
+  }
+
+  /**
+   * Check if a filename matches any of the specified types
+   */
+  matchesType(filename: string, typeNames: string[]): boolean {
+    const lowerFilename = filename.toLowerCase();
+
+    for (const typeName of typeNames) {
+      // Special case: 'all' matches any file with a recognized type
+      if (typeName === "all") {
+        if (this.matchesAnyType(filename)) {
+          return true;
+        }
+        continue;
+      }
+
+      const fileType = this.types.get(typeName);
+      if (!fileType) continue;
+
+      // Check extensions
+      for (const ext of fileType.extensions) {
+        if (lowerFilename.endsWith(ext)) {
+          return true;
+        }
+      }
 
-    // Check globs (simple exact match for now)
-    for (const glob of fileType.globs) {
-      if (glob.includes("*")) {
-        // Simple glob matching
-        const pattern = glob.replace(/\./g, "\\.").replace(/\*/g, ".*");
-        if (new RegExp(`^${pattern}$`, "i").test(filename)) {
+      // Check globs
+      for (const glob of fileType.globs) {
+        if (glob.includes("*")) {
+          const pattern = glob.replace(/\./g, "\\.").replace(/\*/g, ".*");
+          if (new RegExp(`^${pattern}$`, "i").test(filename)) {
+            return true;
+          }
+        } else if (lowerFilename === glob.toLowerCase()) {
           return true;
         }
-      } else if (lowerFilename === glob.toLowerCase()) {
-        return true;
       }
     }
+
+    return false;
   }
 
-  return false;
+  /**
+   * Check if a filename matches any recognized type
+   */
+  private matchesAnyType(filename: string): boolean {
+    const lowerFilename = filename.toLowerCase();
+
+    for (const fileType of this.types.values()) {
+      for (const ext of fileType.extensions) {
+        if (lowerFilename.endsWith(ext)) {
+          return true;
+        }
+      }
+
+      for (const glob of fileType.globs) {
+        if (glob.includes("*")) {
+          const pattern = glob.replace(/\./g, "\\.").replace(/\*/g, ".*");
+          if (new RegExp(`^${pattern}$`, "i").test(filename)) {
+            return true;
+          }
+        } else if (lowerFilename === glob.toLowerCase()) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
 }
 
 /**