@seo-partner/adapters 0.0.0-stage → 1.0.0

package/src/parsers/layout-resolver.ts

@@ -0,0 +1,112 @@
+import path from 'node:path';
+import type { ExtractedRouteData } from '@seo-partner/core';
+
+export interface ExtractedLayoutData {
+  readonly filePath: string;
+  readonly htmlLang?: { readonly value: string; readonly line: number } | null;
+  readonly title?: { readonly value: string; readonly line: number } | null;
+  readonly description?: { readonly value: string; readonly line: number } | null;
+  readonly canonical?: { readonly value: string; readonly line: number } | null;
+  readonly robots?: { readonly value: string; readonly line: number } | null;
+}
+
+export class LayoutResolver {
+  private readonly layoutsByPath = new Map<string, ExtractedLayoutData>();
+
+  public registerLayout(layout: ExtractedLayoutData): void {
+    const normalized = layout.filePath.replace(/\\/g, '/');
+    this.layoutsByPath.set(normalized, layout);
+  }
+
+  public getLayout(filePath: string): ExtractedLayoutData | undefined {
+    const normalized = filePath.replace(/\\/g, '/');
+    return this.layoutsByPath.get(normalized);
+  }
+
+  /**
+   * Applies layout inheritance to an extracted route if the route lacks metadata
+   * (such as htmlLang or fallback title).
+   */
+  public applyInheritance(
+    routeData: ExtractedRouteData,
+    parentLayoutPaths: ReadonlyArray<string>,
+  ): ExtractedRouteData {
+    let htmlLang = routeData.htmlLang;
+    let title = routeData.title;
+    let description = routeData.description;
+    let canonical = routeData.canonical;
+    let robots = routeData.robots;
+
+    // Traverse from nearest layout to root layout
+    for (const layoutPath of parentLayoutPaths) {
+      const layout = this.getLayout(layoutPath);
+      if (!layout) continue;
+
+      if (!htmlLang && layout.htmlLang) {
+        htmlLang = layout.htmlLang;
+      }
+      if (!title && layout.title) {
+        title = layout.title;
+      }
+      if (!description && layout.description) {
+        description = layout.description;
+      }
+      if (!canonical && layout.canonical) {
+        canonical = layout.canonical;
+      }
+      if (!robots && layout.robots) {
+        robots = layout.robots;
+      }
+    }
+
+    return {
+      ...routeData,
+      htmlLang,
+      title,
+      description,
+      canonical,
+      robots,
+    };
+  }
+
+  /**
+   * Finds candidate SvelteKit layout paths (+layout.svelte) starting from the page directory
+   * up to the routes root directory.
+   */
+  public findSvelteKitLayoutPaths(pageFilePath: string): ReadonlyArray<string> {
+    const normalized = pageFilePath.replace(/\\/g, '/');
+    const parts = normalized.split('/');
+    const routesIdx = parts.lastIndexOf('routes');
+    if (routesIdx === -1) return [];
+
+    const candidates: string[] = [];
+    const dirParts = parts.slice(0, -1);
+
+    // From current dir up to routes directory
+    for (let i = dirParts.length; i >= routesIdx; i--) {
+      const dir = dirParts.slice(0, i).join('/');
+      candidates.push(`${dir}/+layout.svelte`);
+    }
+
+    return candidates;
+  }
+
+  /**
+   * Resolves Django base template paths (e.g. "base.html" or "layouts/base.html").
+   */
+  public findDjangoExtendsPath(
+    templateContent: string,
+    allTemplatePaths: ReadonlyArray<string>,
+  ): string | undefined {
+    const extendsMatch = templateContent.match(/\{%\s*extends\s+['"]([^'"]+)['"]\s*%\}/i);
+    if (!extendsMatch || !extendsMatch[1]) return undefined;
+
+    const baseName = extendsMatch[1].replace(/\\/g, '/');
+    // Match against known templates
+    return allTemplatePaths.find((p) => {
+      const norm = p.replace(/\\/g, '/');
+      return norm.endsWith(baseName) || norm === baseName;
+    });
+  }
+}
+

package/src/parsers/php-route-parser.ts

@@ -0,0 +1,254 @@
+export type PhpFlavor = 'laravel' | 'symfony' | 'php';
+
+export interface DiscoveredPhpRouteEntry {
+  readonly pattern: string;
+  readonly filePath: string;
+  readonly flavor: PhpFlavor;
+}
+
+export function detectPhpFlavor(
+  filePaths: ReadonlyArray<string>,
+  contentsByPath: ReadonlyMap<string, string>,
+): PhpFlavor | null {
+  const composerJson = contentsByPath.get('composer.json') ?? '';
+  if (
+    composerJson.includes('laravel/framework') ||
+    filePaths.includes('artisan') ||
+    filePaths.some((p) => p.endsWith('.blade.php'))
+  ) {
+    return 'laravel';
+  }
+
+  if (
+    composerJson.includes('symfony/framework-bundle') ||
+    composerJson.includes('symfony/twig-bundle') ||
+    filePaths.some((p) => p.endsWith('.html.twig'))
+  ) {
+    return 'symfony';
+  }
+
+  if (filePaths.some((p) => p.endsWith('.php'))) {
+    return 'php';
+  }
+
+  return null;
+}
+
+function normalizeRoutePattern(rawPattern: string): string {
+  const trimmed = rawPattern.trim();
+  if (!trimmed || trimmed === '/') return '/';
+  const withSlash = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+  return withSlash.length > 1 && withSlash.endsWith('/')
+    ? withSlash.slice(0, -1)
+    : withSlash;
+}
+
+export function parseLaravelRoutes(
+  filePaths: ReadonlyArray<string>,
+  contentsByPath: ReadonlyMap<string, string>,
+): ReadonlyArray<DiscoveredPhpRouteEntry> {
+  const viewPathByDotName = new Map<string, string>();
+  for (const fp of filePaths) {
+    if (fp.startsWith('resources/views/') && fp.endsWith('.blade.php')) {
+      const rel = fp
+        .slice('resources/views/'.length)
+        .slice(0, -'.blade.php'.length);
+      const dotName = rel.replace(/\//g, '.');
+      viewPathByDotName.set(dotName, fp);
+      viewPathByDotName.set(rel, fp);
+    }
+  }
+
+  const results: DiscoveredPhpRouteEntry[] = [];
+  const mappedFiles = new Set<string>();
+  const webPhp = contentsByPath.get('routes/web.php') ?? '';
+
+  if (webPhp) {
+    // 1. Route::view('/uri', 'view.name')
+    const routeViewRegex =
+      /Route::view\s*\(\s*['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]/g;
+    let m: RegExpExecArray | null;
+    while ((m = routeViewRegex.exec(webPhp)) !== null) {
+      const pattern = normalizeRoutePattern(m[1] ?? '/');
+      const viewName = m[2] ?? '';
+      const filePath = viewPathByDotName.get(viewName);
+      if (filePath) {
+        results.push({ pattern, filePath, flavor: 'laravel' });
+        mappedFiles.add(filePath);
+      }
+    }
+
+    // 2. Route::get('/uri', function() { return view('view.name'); })
+    const routeClosureRegex =
+      /Route::(?:get|any)\s*\(\s*['"]([^'"]+)['"][\s\S]*?view\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    while ((m = routeClosureRegex.exec(webPhp)) !== null) {
+      const pattern = normalizeRoutePattern(m[1] ?? '/');
+      const viewName = m[2] ?? '';
+      const filePath = viewPathByDotName.get(viewName);
+      if (filePath && !mappedFiles.has(filePath)) {
+        results.push({ pattern, filePath, flavor: 'laravel' });
+        mappedFiles.add(filePath);
+      }
+    }
+
+    // 3. Controller-based routes: Route::get('/uri', [Controller::class, 'method'])
+    const routeControllerRegex =
+      /Route::(?:get|any)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(?:\[|\w+Controller)/g;
+    while ((m = routeControllerRegex.exec(webPhp)) !== null) {
+      const pattern = normalizeRoutePattern(m[1] ?? '/');
+      if (!results.some((r) => r.pattern === pattern)) {
+        results.push({ pattern, filePath: 'routes/web.php', flavor: 'laravel' });
+      }
+    }
+  }
+
+  // Fallback for any public Blade view not explicitly matched in routes/web.php
+  for (const [dotName, filePath] of viewPathByDotName.entries()) {
+    if (mappedFiles.has(filePath) || dotName.includes('/')) continue;
+    if (
+      dotName.startsWith('layouts.') ||
+      dotName.startsWith('components.') ||
+      dotName.startsWith('partials.') ||
+      dotName.startsWith('emails.') ||
+      dotName.startsWith('errors.') ||
+      dotName.startsWith('vendor.')
+    ) {
+      continue;
+    }
+    const pattern =
+      dotName === 'welcome' || dotName === 'home' || dotName === 'index'
+        ? '/'
+        : `/${dotName.replace(/\.index$/, '').replace(/\./g, '/')}`;
+    results.push({
+      pattern: normalizeRoutePattern(pattern),
+      filePath,
+      flavor: 'laravel',
+    });
+    mappedFiles.add(filePath);
+  }
+
+  return results;
+}
+
+export function parseSymfonyRoutes(
+  filePaths: ReadonlyArray<string>,
+  contentsByPath: ReadonlyMap<string, string>,
+): ReadonlyArray<DiscoveredPhpRouteEntry> {
+  const twigTemplates = new Set<string>(
+    filePaths.filter((p) => p.startsWith('templates/') && p.endsWith('.html.twig')),
+  );
+
+  const results: DiscoveredPhpRouteEntry[] = [];
+  const mappedFiles = new Set<string>();
+
+  // 1. Parse PHP 8 #[Route('/path')] attributes in src/Controller/**/*.php
+  for (const fp of filePaths) {
+    if (!fp.startsWith('src/Controller/') || !fp.endsWith('.php')) continue;
+    const content = contentsByPath.get(fp) ?? '';
+    const attrRegex =
+      /#\[Route\s*\(\s*(?:path:\s*)?['"]([^'"]+)['"][^\]]*\)\][\s\S]*?\$this->render\s*\(\s*['"]([^'"]+)['"]/g;
+    let m: RegExpExecArray | null;
+    while ((m = attrRegex.exec(content)) !== null) {
+      const pattern = normalizeRoutePattern(m[1] ?? '/');
+      const relTwig = (m[2] ?? '').replace(/^\/+/, '');
+      const fullTwig = `templates/${relTwig}`;
+      if (twigTemplates.has(fullTwig)) {
+        results.push({ pattern, filePath: fullTwig, flavor: 'symfony' });
+        mappedFiles.add(fullTwig);
+      }
+    }
+  }
+
+  // 2. Parse config/routes.yaml
+  const routesYaml = contentsByPath.get('config/routes.yaml') ?? '';
+  if (routesYaml) {
+    const blocks = routesYaml.split(/\r?\n(?=[a-zA-Z0-9_-]+:\s*$)/m);
+    for (const block of blocks) {
+      const pathMatch = /\bpath:\s*['"]?([^\s'"]+)['"]?/.exec(block);
+      const ctrlMatch =
+        /\bcontroller:\s*[\w\\]+\\([A-Za-z0-9_]+)Controller::([a-zA-Z0-9_]+)/.exec(
+          block,
+        );
+      if (pathMatch?.[1] && ctrlMatch?.[1] && ctrlMatch[2]) {
+        const pattern = normalizeRoutePattern(pathMatch[1]);
+        const folder = ctrlMatch[1].toLowerCase();
+        const action = ctrlMatch[2].toLowerCase();
+        const candidate = `templates/${folder}/${action}.html.twig`;
+        if (twigTemplates.has(candidate) && !mappedFiles.has(candidate)) {
+          results.push({ pattern, filePath: candidate, flavor: 'symfony' });
+          mappedFiles.add(candidate);
+        }
+      }
+    }
+  }
+
+  // 3. Fallback for unmapped public templates
+  for (const twigPath of twigTemplates) {
+    if (mappedFiles.has(twigPath)) continue;
+    const rel = twigPath.slice('templates/'.length, -'.html.twig'.length);
+    if (
+      rel === 'base' ||
+      rel.startsWith('layouts/') ||
+      rel.startsWith('partials/') ||
+      rel.startsWith('components/') ||
+      rel.startsWith('bundles/')
+    ) {
+      continue;
+    }
+    const cleaned = rel.replace(/\/index$/, '');
+    const pattern =
+      cleaned === 'home' || cleaned === 'index' || cleaned === 'default'
+        ? '/'
+        : normalizeRoutePattern(cleaned);
+    results.push({ pattern, filePath: twigPath, flavor: 'symfony' });
+    mappedFiles.add(twigPath);
+  }
+
+  return results;
+}
+
+export function discoverNativePhpRoutes(
+  filePaths: ReadonlyArray<string>,
+): ReadonlyArray<DiscoveredPhpRouteEntry> {
+  const results: DiscoveredPhpRouteEntry[] = [];
+  const publicPhpFiles = filePaths.filter(
+    (p) => p.startsWith('public/') && p.endsWith('.php'),
+  );
+
+  if (publicPhpFiles.length > 0) {
+    for (const fp of publicPhpFiles) {
+      const rel = fp.slice('public/'.length);
+      const pattern =
+        rel === 'index.php' ? '/' : normalizeRoutePattern(rel);
+      results.push({ pattern, filePath: fp, flavor: 'php' });
+    }
+    return results;
+  }
+
+  for (const fp of filePaths) {
+    if (!fp.endsWith('.php')) continue;
+    const lower = fp.toLowerCase();
+    if (
+      lower === 'artisan' ||
+      lower.startsWith('includes/') ||
+      lower.startsWith('inc/') ||
+      lower.startsWith('config/') ||
+      lower.startsWith('vendor/') ||
+      lower.startsWith('routes/') ||
+      lower.startsWith('src/') ||
+      lower.startsWith('app/') ||
+      lower.startsWith('tests/') ||
+      lower.endsWith('header.php') ||
+      lower.endsWith('footer.php') ||
+      lower.endsWith('functions.php')
+    ) {
+      continue;
+    }
+    const pattern =
+      fp === 'index.php' ? '/' : normalizeRoutePattern(fp);
+    results.push({ pattern, filePath: fp, flavor: 'php' });
+  }
+
+  return results;
+}
+

package/src/parsers/php-template-parser.ts

@@ -0,0 +1,303 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { DiscoveredRoute, ExtractedRouteData } from '@seo-partner/core';
+import { parseStaticHtmlOrMarkdown } from './html-parser.js';
+
+function lineNumberAtOffset(content: string, offset: number): number {
+  let line = 1;
+  for (let i = 0; i < offset && i < content.length; i += 1) {
+    if (content.charCodeAt(i) === 10) line += 1;
+  }
+  return line;
+}
+
+function readProjectFileSafe(projectRoot: string, relOrAbsPath: string): string | null {
+  try {
+    const full = path.isAbsolute(relOrAbsPath)
+      ? relOrAbsPath
+      : path.join(projectRoot, relOrAbsPath);
+    if (fs.existsSync(full) && fs.statSync(full).isFile()) {
+      return fs.readFileSync(full, 'utf-8');
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function extractBladeMetadata(
+  projectRoot: string,
+  route: DiscoveredRoute,
+  fileContent: string,
+): ExtractedRouteData {
+  const base = parseStaticHtmlOrMarkdown(
+    { ...route, routerKind: 'static-html' },
+    fileContent,
+  );
+
+  let title = base.title;
+  let description = base.description;
+  let canonical = base.canonical;
+  let robots = base.robots;
+  let htmlLang = base.htmlLang;
+
+  // 1. Check @section('title', '...') or @section('title')...@endsection
+  const inlineTitleMatch =
+    /@section\s*\(\s*['"]title['"]\s*,\s*['"]([^'"]*)['"]\s*\)/i.exec(fileContent);
+  if (inlineTitleMatch) {
+    title = {
+      value: (inlineTitleMatch[1] ?? '').trim(),
+      line: lineNumberAtOffset(fileContent, inlineTitleMatch.index),
+    };
+  } else {
+    const blockTitleMatch =
+      /@section\s*\(\s*['"]title['"]\s*\)([\s\S]*?)@(?:endsection|stop)/i.exec(
+        fileContent,
+      );
+    if (blockTitleMatch) {
+      title = {
+        value: (blockTitleMatch[1] ?? '').replace(/<[^>]+>/g, '').trim(),
+        line: lineNumberAtOffset(fileContent, blockTitleMatch.index),
+      };
+    }
+  }
+
+  // 2. Check @section('description', '...')
+  const inlineDescMatch =
+    /@section\s*\(\s*['"](?:description|meta_description)['"]\s*,\s*['"]([^'"]*)['"]\s*\)/i.exec(
+      fileContent,
+    );
+  if (inlineDescMatch) {
+    description = {
+      value: (inlineDescMatch[1] ?? '').trim(),
+      line: lineNumberAtOffset(fileContent, inlineDescMatch.index),
+    };
+  }
+
+  // 3. Resolve @extends('layouts.app')
+  const extendsMatch = /@extends\s*\(\s*['"]([^'"]+)['"]\s*\)/i.exec(fileContent);
+  if (extendsMatch?.[1]) {
+    const layoutRel = `resources/views/${extendsMatch[1].replace(/\./g, '/')}.blade.php`;
+    const layoutContent = readProjectFileSafe(projectRoot, layoutRel);
+    if (layoutContent) {
+      const layoutParsed = parseStaticHtmlOrMarkdown(
+        { ...route, filePath: layoutRel, routerKind: 'static-html' },
+        layoutContent,
+      );
+      if (htmlLang === undefined && layoutParsed.htmlLang !== undefined) {
+        htmlLang = layoutParsed.htmlLang;
+      }
+      if (!title) {
+        const yieldTitleDefault =
+          /@yield\s*\(\s*['"]title['"]\s*,\s*['"]([^'"]+)['"]\s*\)/i.exec(
+            layoutContent,
+          );
+        if (yieldTitleDefault?.[1]) {
+          title = {
+            value: yieldTitleDefault[1].trim(),
+            line: lineNumberAtOffset(layoutContent, yieldTitleDefault.index),
+          };
+        } else if (
+          layoutParsed.title &&
+          !layoutParsed.title.value.includes('@yield')
+        ) {
+          title = layoutParsed.title;
+        }
+      }
+      if (!description) {
+        const yieldDescDefault =
+          /@yield\s*\(\s*['"]description['"]\s*,\s*['"]([^'"]+)['"]\s*\)/i.exec(
+            layoutContent,
+          );
+        if (yieldDescDefault?.[1] && yieldDescDefault[1].trim().length > 0) {
+          description = {
+            value: yieldDescDefault[1].trim(),
+            line: lineNumberAtOffset(layoutContent, yieldDescDefault.index),
+          };
+        } else if (
+          layoutParsed.description &&
+          !layoutParsed.description.value.includes('@yield') &&
+          layoutParsed.description.value.trim().length > 0
+        ) {
+          description = layoutParsed.description;
+        }
+      }
+      if (!canonical && layoutParsed.canonical) {
+        canonical = layoutParsed.canonical;
+      }
+      if (!robots && layoutParsed.robots) {
+        robots = layoutParsed.robots;
+      }
+    }
+  }
+
+  return {
+    ...base,
+    route,
+    title,
+    description,
+    canonical,
+    robots,
+    ...(htmlLang !== undefined ? { htmlLang } : {}),
+  };
+}
+
+function extractTwigMetadata(
+  projectRoot: string,
+  route: DiscoveredRoute,
+  fileContent: string,
+): ExtractedRouteData {
+  const base = parseStaticHtmlOrMarkdown(
+    { ...route, routerKind: 'static-html' },
+    fileContent,
+  );
+
+  let title = base.title;
+  let description = base.description;
+  let canonical = base.canonical;
+  let robots = base.robots;
+  let htmlLang = base.htmlLang;
+
+  // 1. Check {% block title %}...{% endblock %}
+  const blockTitleMatch =
+    /\{%\s*block\s+title\s*%\}[\s\S]*?\{%\s*endblock(?:\s+title)?\s*%\}/i.exec(
+      fileContent,
+    );
+  if (blockTitleMatch) {
+    const inner = blockTitleMatch[0]
+      .replace(/^\{%\s*block\s+title\s*%\}/i, '')
+      .replace(/\{%\s*endblock(?:\s+title)?\s*%\}$/i, '')
+      .replace(/<[^>]+>/g, '')
+      .trim();
+    if (inner) {
+      title = {
+        value: inner,
+        line: lineNumberAtOffset(fileContent, blockTitleMatch.index),
+      };
+    }
+  }
+
+  // 2. Resolve {% extends 'base.html.twig' %}
+  const extendsMatch = /\{%\s*extends\s+['"]([^'"]+)['"]\s*%\}/i.exec(fileContent);
+  if (extendsMatch?.[1]) {
+    const parentRel = `templates/${extendsMatch[1].replace(/^\/+/, '')}`;
+    const parentContent = readProjectFileSafe(projectRoot, parentRel);
+    if (parentContent) {
+      const parentParsed = parseStaticHtmlOrMarkdown(
+        { ...route, filePath: parentRel, routerKind: 'static-html' },
+        parentContent,
+      );
+      if (htmlLang === undefined && parentParsed.htmlLang !== undefined) {
+        htmlLang = parentParsed.htmlLang;
+      }
+      if (!title && parentParsed.title) {
+        const cleanedParentTitle = parentParsed.title.value
+          .replace(/\{%\s*block\s+title\s*%\}/i, '')
+          .replace(/\{%\s*endblock(?:\s+title)?\s*%\}/i, '')
+          .trim();
+        if (cleanedParentTitle) {
+          title = {
+            value: cleanedParentTitle,
+            line: parentParsed.title.line,
+          };
+        }
+      }
+      if (!description && parentParsed.description) {
+        description = parentParsed.description;
+      }
+      if (!canonical && parentParsed.canonical) {
+        canonical = parentParsed.canonical;
+      }
+    }
+  }
+
+  return {
+    ...base,
+    route,
+    title,
+    description,
+    canonical,
+    robots,
+    ...(htmlLang !== undefined ? { htmlLang } : {}),
+  };
+}
+
+function extractNativePhpMetadata(
+  projectRoot: string,
+  route: DiscoveredRoute,
+  fileContent: string,
+): ExtractedRouteData {
+  const base = parseStaticHtmlOrMarkdown(
+    { ...route, routerKind: 'static-html' },
+    fileContent,
+  );
+
+  let title = base.title;
+  let description = base.description;
+  let canonical = base.canonical;
+  let robots = base.robots;
+  let htmlLang = base.htmlLang;
+
+  // Check for PHP include/require of a header file (e.g. require_once __DIR__ . '/../includes/header.php';)
+  const includeRegex =
+    /\b(?:include|include_once|require|require_once)\b[^;]*?['"]([^'"]+\.php)['"]/gi;
+  let m: RegExpExecArray | null;
+  const currentFileDir = path.dirname(path.join(projectRoot, route.filePath));
+
+  while ((m = includeRegex.exec(fileContent)) !== null) {
+    const rawInc = (m[1] ?? '').replace(/^\/+/, '');
+    const candidateRelToDir = path.resolve(currentFileDir, rawInc);
+    const candidateRelToRoot = path.resolve(projectRoot, rawInc);
+
+    const incContent =
+      readProjectFileSafe(projectRoot, candidateRelToDir) ??
+      readProjectFileSafe(projectRoot, candidateRelToRoot);
+
+    if (incContent) {
+      const incParsed = parseStaticHtmlOrMarkdown(
+        { ...route, routerKind: 'static-html' },
+        incContent,
+      );
+      if (htmlLang === undefined && incParsed.htmlLang !== undefined) {
+        htmlLang = incParsed.htmlLang;
+      }
+      if (!title && incParsed.title) {
+        title = incParsed.title;
+      }
+      if (!description && incParsed.description) {
+        description = incParsed.description;
+      }
+      if (!canonical && incParsed.canonical) {
+        canonical = incParsed.canonical;
+      }
+      if (!robots && incParsed.robots) {
+        robots = incParsed.robots;
+      }
+    }
+  }
+
+  return {
+    ...base,
+    route,
+    title,
+    description,
+    canonical,
+    robots,
+    ...(htmlLang !== undefined ? { htmlLang } : {}),
+  };
+}
+
+export function parsePhpOrTemplateFile(
+  projectRoot: string,
+  route: DiscoveredRoute,
+  fileContent: string,
+): ExtractedRouteData {
+  if (route.filePath.endsWith('.blade.php') || route.routerKind === 'laravel') {
+    return extractBladeMetadata(projectRoot, route, fileContent);
+  }
+  if (route.filePath.endsWith('.html.twig') || route.routerKind === 'symfony') {
+    return extractTwigMetadata(projectRoot, route, fileContent);
+  }
+  return extractNativePhpMetadata(projectRoot, route, fileContent);
+}
+