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/resolution/frameworks/express.ts

@@ -6,9 +6,17 @@
 
 import { Node } from '../../types';
 import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';
+import { stripCommentsForRegex } from '../strip-comments';
+
+function extractTailIdent(expr: string): string | null {
+  const cleaned = expr.replace(/\s+/g, '').replace(/\(\)$/, '');
+  const m = cleaned.match(/(?:\.|^)([A-Za-z_][A-Za-z0-9_]*)$/);
+  return m ? m[1]! : null;
+}
 
 export const expressResolver: FrameworkResolver = {
   name: 'express',
+  languages: ['javascript', 'typescript'],
 
   detect(context: ResolutionContext): boolean {
     // Check for Express in package.json
@@ -90,44 +98,51 @@ export const expressResolver: FrameworkResolver = {
     return null;
   },
 
-  extractNodes(filePath: string, content: string): Node[] {
+  extract(filePath, content) {
+    if (!/\.(m?js|tsx?|cjs)$/.test(filePath)) return { nodes: [], references: [] };
     const nodes: Node[] = [];
+    const references: UnresolvedRef[] = [];
     const now = Date.now();
-
-    // Extract route definitions
-    // app.get('/path', handler) or router.get('/path', handler)
-    const routePatterns = [
-      /(app|router)\.(get|post|put|patch|delete|all|use)\(\s*['"]([^'"]+)['"]/g,
-    ];
-
-    for (const pattern of routePatterns) {
-      let match;
-      while ((match = pattern.exec(content)) !== null) {
-        const [, _obj, method, path] = match;
-        const line = content.slice(0, match.index).split('\n').length;
-
-        // Skip middleware use() without paths
-        if (method === 'use' && !path?.startsWith('/')) {
-          continue;
-        }
-
-        nodes.push({
-          id: `route:${filePath}:${method!.toUpperCase()}:${path}:${line}`,
-          kind: 'route',
-          name: `${method!.toUpperCase()} ${path}`,
-          qualifiedName: `${filePath}::${method!.toUpperCase()}:${path}`,
+    const lang = detectLanguage(filePath);
+    const safe = stripCommentsForRegex(content, lang);
+    // (app|router).METHOD('/path', handler-expr)
+    const regex = /\b(app|router)\.(get|post|put|patch|delete|all|use)\s*\(\s*['"]([^'"]+)['"]\s*,\s*([^)]+)\)/g;
+    let match: RegExpExecArray | null;
+    while ((match = regex.exec(safe)) !== null) {
+      const [, _obj, method, routePath, handlers] = match;
+      if (method === 'use' && !routePath!.startsWith('/')) continue;
+      const line = safe.slice(0, match.index).split('\n').length;
+      const routeNode: Node = {
+        id: `route:${filePath}:${line}:${method!.toUpperCase()}:${routePath}`,
+        kind: 'route',
+        name: `${method!.toUpperCase()} ${routePath}`,
+        qualifiedName: `${filePath}::${method!.toUpperCase()}:${routePath}`,
+        filePath,
+        startLine: line,
+        endLine: line,
+        startColumn: 0,
+        endColumn: match[0].length,
+        language: detectLanguage(filePath),
+        updatedAt: now,
+      };
+      nodes.push(routeNode);
+      // Handler is the LAST comma-separated argument; earlier ones are middleware.
+      const parts = handlers!.split(',').map((s) => s.trim()).filter(Boolean);
+      const last = parts[parts.length - 1];
+      const handlerName = last ? extractTailIdent(last) : null;
+      if (handlerName) {
+        references.push({
+          fromNodeId: routeNode.id,
+          referenceName: handlerName,
+          referenceKind: 'references',
+          line,
+          column: 0,
           filePath,
-          startLine: line,
-          endLine: line,
-          startColumn: 0,
-          endColumn: match[0].length,
           language: detectLanguage(filePath),
-          updatedAt: now,
         });
       }
     }
-
-    return nodes;
+    return { nodes, references };
   },
 };