feat: wire up framework route extraction (#89)

* docs: add framework extract wiring plan

* feat(resolution): replace extractNodes with extract() returning nodes and references

* feat(resolution): add getApplicableFrameworks helper for per-language dispatch

* feat(django): emit route nodes and route->view references in extract()

* feat(flask,fastapi): emit route nodes and route->handler references

* feat(express): emit route nodes and route->handler references

* feat(laravel): emit route nodes and route->handler references

* feat(rails): emit route nodes and route->handler references

* feat(spring): emit route nodes and route->handler references

* feat(go): emit route nodes and route->handler references

* feat(rust): emit route nodes and route->handler references

* feat(aspnet): emit route nodes and route->handler references

* feat(swift,vapor): emit route nodes and route->handler references

* chore(react,svelte): migrate resolvers to extract() interface

* feat(extraction): run framework extractors after tree-sitter parse

* docs: document framework route extraction

* feat(strip-comments): add per-language comment stripper for framework extractors

Replaces comment characters and string-literal contents with spaces (not
removal) so source offsets stay valid for downstream regex match index ->
line number conversion. Handles Python triple-quoted docstrings, Ruby
=begin/=end, Rust nested block comments, and the standard //, #, /* */
forms across the supported languages.

This is consumed by framework extract() methods in a follow-up commit so
that commented-out / docstring routing examples don't surface as phantom
route nodes in the graph.

* feat(frameworks): strip comments before regex extraction (prevents phantom routes)

Pipes the per-language stripCommentsForRegex helper into every framework
extract() that scans raw source: django/flask/fastapi (python.ts),
express, laravel, rails, spring, go, rust, aspnet, vapor, plus
swiftui/uikit struct extraction in swift.ts.

Without this, examples like:

    # path('/admin/', AdminPanel.as_view())
    """ path('/users/', UserListView.as_view()) """
    urlpatterns = [path('/real/', RealView.as_view())]

produced 3 phantom route nodes. Now only the real one is extracted.

Each framework gets a regression test in __tests__/frameworks.test.ts
asserting that line-, block-, docstring- and (where relevant)
heredoc-style commented-out routes do not surface as nodes.

---------

Co-authored-by: Colby McHenry <me@colbymchenry.com>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/extraction/tree-sitter.ts

@@ -23,6 +23,10 @@ import { LiquidExtractor } from './liquid-extractor';
 import { SvelteExtractor } from './svelte-extractor';
 import { DfmExtractor } from './dfm-extractor';
 import { VueExtractor } from './vue-extractor';
+import {
+  getAllFrameworkResolvers,
+  getApplicableFrameworks,
+} from '../resolution/frameworks';
 
 // Re-export for backward compatibility
 export { generateNodeId } from './tree-sitter-helpers';
@@ -2474,43 +2478,71 @@ export class TreeSitterExtractor {
 
 
 /**
- * Extract nodes and edges from source code
+ * Extract nodes and edges from source code.
+ *
+ * If `frameworkNames` is provided, framework-specific extractors matching
+ * those names and the file's language are run after the tree-sitter pass.
+ * Their nodes/references/errors are merged into the returned result.
  */
 export function extractFromSource(
   filePath: string,
   source: string,
-  language?: Language
+  language?: Language,
+  frameworkNames?: string[]
 ): ExtractionResult {
   const detectedLanguage = language || detectLanguage(filePath, source);
   const fileExtension = path.extname(filePath).toLowerCase();
 
+  let result: ExtractionResult;
+
   // Use custom extractor for Svelte
   if (detectedLanguage === 'svelte') {
     const extractor = new SvelteExtractor(filePath, source);
-    return extractor.extract();
-  }
-
-  // Use custom extractor for Vue
-  if (detectedLanguage === 'vue') {
+    result = extractor.extract();
+  } else if (detectedLanguage === 'vue') {
+    // Use custom extractor for Vue
     const extractor = new VueExtractor(filePath, source);
-    return extractor.extract();
-  }
-
-  // Use custom extractor for Liquid
-  if (detectedLanguage === 'liquid') {
+    result = extractor.extract();
+  } else if (detectedLanguage === 'liquid') {
+    // Use custom extractor for Liquid
     const extractor = new LiquidExtractor(filePath, source);
-    return extractor.extract();
-  }
-
-  // Use custom extractor for DFM/FMX form files
-  if (
+    result = extractor.extract();
+  } else if (
     detectedLanguage === 'pascal' &&
     (fileExtension === '.dfm' || fileExtension === '.fmx')
   ) {
+    // Use custom extractor for DFM/FMX form files
     const extractor = new DfmExtractor(filePath, source);
-    return extractor.extract();
+    result = extractor.extract();
+  } else {
+    const extractor = new TreeSitterExtractor(filePath, source, detectedLanguage);
+    result = extractor.extract();
   }
 
-  const extractor = new TreeSitterExtractor(filePath, source, detectedLanguage);
-  return extractor.extract();
+  // Framework-specific extraction (routes, middleware, etc.)
+  if (frameworkNames && frameworkNames.length > 0) {
+    const allResolvers = getAllFrameworkResolvers();
+    const applicable = getApplicableFrameworks(
+      allResolvers.filter((r) => frameworkNames.includes(r.name)),
+      detectedLanguage
+    );
+    for (const fw of applicable) {
+      if (!fw.extract) continue;
+      try {
+        const fwResult = fw.extract(filePath, source);
+        result.nodes.push(...fwResult.nodes);
+        result.unresolvedReferences.push(...fwResult.references);
+      } catch (err) {
+        result.errors.push({
+          message: `Framework extractor '${fw.name}' failed: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+          filePath,
+          severity: 'warning',
+        });
+      }
+    }
+  }
+
+  return result;
 }