feat: zero data loss — ANTLR timeout triggers regex fallback instead of skipping files

Previously, files that timed out during ANTLR parsing (30s) were skipped
entirely, causing data loss and non-deterministic graphs (system-dependent).

Now:
- ANTLR timeout → regex-only detection runs on the same file
- File still produces nodes/edges via regex patterns (fewer than ANTLR but not zero)
- Nodes tagged with detection_method=regex_fallback so quality is transparent
- Added detectRegexOnly() to AbstractAntlrDetector for direct regex path
- Applied to all 3 analysis paths (run, runIndex, runSmartIndex)

Size-based ANTLR routing (deterministic, not CPU-dependent):
- Centralized 200KB guard in AntlrParserFactory.parse()
- Removed per-detector 500KB checks (AbstractPythonAntlrDetector,
  NestJSControllerDetector, TypeScriptStructuresDetector)
- < 200KB: ANTLR (always fast)
- > 200KB: regex only (AntlrParserFactory returns null → regex fallback)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: aksOps

src/main/java/io/github/randomcodespace/iq/analyzer/Analyzer.java

@@ -7,6 +7,7 @@
 import io.github.randomcodespace.iq.config.CodeIqConfig;
 import io.github.randomcodespace.iq.config.ProjectConfig;
 import io.github.randomcodespace.iq.config.ProjectConfigLoader;
+import io.github.randomcodespace.iq.detector.AbstractAntlrDetector;
 import io.github.randomcodespace.iq.detector.Detector;
 import io.github.randomcodespace.iq.detector.DetectorContext;
 import io.github.randomcodespace.iq.detector.DetectorRegistry;
@@ -297,7 +298,9 @@ private AnalysisResult runWithCache(Path root, Integer parallelism, AnalysisCach
                     futures.get(i).get(30, java.util.concurrent.TimeUnit.SECONDS);
                 } catch (java.util.concurrent.TimeoutException e) {
                     futures.get(i).cancel(true);
-                    log.warn("Analysis timed out for {} (30s limit), skipping", files.get(i).path());
+                    DiscoveredFile timedOutFile = files.get(i);
+                    log.warn("⏱️ ANTLR timed out for {} (30s), running regex fallback", timedOutFile.path());
+                    resultSlots[i] = analyzeFileRegexOnly(timedOutFile, root, detectorRegistry);
                 } catch (ExecutionException e) {
                     log.warn("Analysis failed for {}", files.get(i).path(), e.getCause());
                 } catch (InterruptedException e) {
@@ -586,7 +589,10 @@ private AnalysisResult runBatchedWithCache(Path root, Integer parallelism, int b
                             futures.get(i).get(30, java.util.concurrent.TimeUnit.SECONDS);
                         } catch (java.util.concurrent.TimeoutException e) {
                             futures.get(i).cancel(true);
-                            log.warn("Analysis timed out for {} (30s limit), skipping", batch.get(i).path());
+                            // Zero data loss: run regex-only fallback instead of skipping
+                            DiscoveredFile timedOutFile = batch.get(i);
+                            log.warn("⏱️ ANTLR timed out for {} (30s), running regex fallback", timedOutFile.path());
+                            resultSlots[i] = analyzeFileRegexOnly(timedOutFile, root, detectorRegistry);
                         } catch (ExecutionException e) {
                             log.warn("Analysis failed for {}", batch.get(i).path(), e.getCause());
                         } catch (InterruptedException e) {
@@ -963,7 +969,9 @@ private int[] processSmartBatch(
                 futures.get(i).get(30, java.util.concurrent.TimeUnit.SECONDS);
             } catch (java.util.concurrent.TimeoutException e) {
                 futures.get(i).cancel(true);
-                log.warn("Analysis timed out for {} (30s limit), skipping", batch.get(i).path());
+                DiscoveredFile timedOutFile = batch.get(i);
+                log.warn("⏱️ ANTLR timed out for {} (30s), running regex fallback", timedOutFile.path());
+                slots[i] = analyzeFileRegexOnly(timedOutFile, root, detectorRegistry);
             } catch (ExecutionException e) {
                 log.warn("Analysis failed for {}", batch.get(i).path(), e.getCause());
             } catch (InterruptedException e) {
@@ -1351,6 +1359,58 @@ DetectorResult analyzeFile(DiscoveredFile file, Path repoPath, DetectorRegistry
         return DetectorResult.of(allNodes, allEdges);
     }
 
+    /**
+     * Regex-only analysis fallback for files where ANTLR timed out.
+     * Ensures zero data loss — every file produces nodes via regex detection.
+     * Nodes are tagged with detection_method=regex_fallback.
+     */
+    private DetectorResult analyzeFileRegexOnly(DiscoveredFile file, Path repoPath,
+            DetectorRegistry detectorRegistry) {
+        Path absPath = repoPath.resolve(file.path());
+        String content;
+        try {
+            byte[] raw = Files.readAllBytes(absPath);
+            content = DetectorUtils.decodeContent(raw);
+        } catch (IOException e) {
+            log.debug("Could not read file for regex fallback: {}", absPath, e);
+            return DetectorResult.empty();
+        }
+
+        String moduleName = DetectorUtils.deriveModuleName(file.path().toString(), file.language());
+        var ctx = new DetectorContext(file.path().toString(), file.language(), content, null, moduleName);
+
+        List<Detector> detectors = detectorRegistry.detectorsForLanguage(file.language());
+        var allNodes = new ArrayList<CodeNode>();
+        var allEdges = new ArrayList<io.github.randomcodespace.iq.model.CodeEdge>();
+
+        for (Detector detector : detectors) {
+            try {
+                DetectorResult result;
+                if (detector instanceof AbstractAntlrDetector antlrDet) {
+                    result = antlrDet.detectRegexOnly(ctx);
+                } else {
+                    result = detector.detect(ctx);
+                }
+                allNodes.addAll(result.nodes());
+                allEdges.addAll(result.edges());
+            } catch (Throwable e) {
+                log.debug("Regex fallback detector {} failed on {}: {}",
+                        detector.getName(), file.path(), e.getMessage());
+            }
+        }
+
+        // Tag all nodes with detection method so users know quality level
+        for (CodeNode node : allNodes) {
+            node.getProperties().put("detection_method", "regex_fallback");
+            if (moduleName != null && (node.getModule() == null || node.getModule().isEmpty())) {
+                node.setModule(moduleName);
+            }
+        }
+
+        AntlrParserFactory.clearCache();
+        return DetectorResult.of(allNodes, allEdges);
+    }
+
     /**
      * Build a deterministic FileInventory from the list of discovered files.
      * Content hashes are reused from {@code cache} when available (no re-read of files).

src/main/java/io/github/randomcodespace/iq/detector/AbstractAntlrDetector.java

@@ -61,6 +61,15 @@ protected DetectorResult detectWithRegex(DetectorContext ctx) {
         return DetectorResult.empty();
     }
 
+    /**
+     * Run regex-only detection, bypassing ANTLR entirely.
+     * Used when ANTLR times out on a file — ensures the file still produces
+     * nodes/edges via regex fallback instead of being skipped (zero data loss).
+     */
+    public DetectorResult detectRegexOnly(DetectorContext ctx) {
+        return detectWithRegex(ctx);
+    }
+
     /**
      * Create a lexer from source content with error output suppressed.
      *

src/main/java/io/github/randomcodespace/iq/detector/python/AbstractPythonAntlrDetector.java

@@ -27,10 +27,7 @@ public Set<String> getSupportedLanguages() {
 
     @Override
     protected ParseTree parse(DetectorContext ctx) {
-        // Skip ANTLR for very large files (>500KB) — regex fallback is faster
-        if (ctx.content().length() > 500_000) {
-            return null;
-        }
+        // Size guard is centralized in AntlrParserFactory.parse() (200KB limit)
         return AntlrParserFactory.parse("python", ctx.content());
     }
 

src/main/java/io/github/randomcodespace/iq/detector/typescript/NestJSControllerDetector.java

@@ -56,9 +56,7 @@ protected ParseTree parse(DetectorContext ctx) {
         // Use the dedicated TypeScript ANTLR grammar for parsing;
         // detection itself still uses regex for NestJS-specific decorator patterns,
         // but the TS grammar is available for future AST-based enhancement.
-        if (ctx.content().length() > 500_000) {
-            return null;
-        }
+        // Size guard is centralized in AntlrParserFactory.parse() (200KB limit)
         return AntlrParserFactory.parse("typescript", ctx.content());
     }
 

src/main/java/io/github/randomcodespace/iq/detector/typescript/TypeScriptStructuresDetector.java

@@ -79,11 +79,7 @@ public DetectorResult detect(DetectorContext ctx) {
 
     @Override
     protected ParseTree parse(DetectorContext ctx) {
-        // Use the dedicated TypeScript ANTLR grammar for .ts files;
-        // for .js files or very large files, fall back to regex
-        if (ctx.content().length() > 500_000) {
-            return null; // triggers regex fallback
-        }
+        // Size guard is centralized in AntlrParserFactory.parse() (200KB limit)
         if ("typescript".equals(ctx.language())) {
             return AntlrParserFactory.parse(PROP_TYPESCRIPT, ctx.content());
         }

src/main/java/io/github/randomcodespace/iq/grammar/AntlrParserFactory.java

@@ -94,9 +94,11 @@ public static ParseTree parse(String language, String content) {
         }
 
         // Skip files that are too large for ANTLR — regex fallback handles them.
-        // Files >500KB cause exponential parse times in some grammars (especially TS/JS).
-        if (content.length() > 500_000) {
-            log.debug("Skipping ANTLR parse for {} ({} bytes > 500KB limit)", language, content.length());
+        // Files >200KB can cause exponential parse times in some grammars (especially TS/JS).
+        // This is a deterministic, size-based guard — same result regardless of CPU speed.
+        if (content.length() > 200_000) {
+            log.debug("Skipping ANTLR parse for {} ({} bytes > 200KB limit), regex fallback will handle",
+                    language, content.length());
             return null;
         }