@seo-partner/adapters 0.0.0-stage → 1.0.0

package/src/parsers/tsx-ast-parser.ts

@@ -0,0 +1,404 @@
+import ts from 'typescript';
+import type {
+  DiscoveredRoute,
+  ExtractedRouteData,
+  HeadingItem,
+  ImageItem,
+  JsonLdItem,
+  LinkItem,
+  RenderingMode,
+} from '@seo-partner/core';
+
+export function detectRenderingModeFromTsx(sourceText: string): RenderingMode {
+  const trimmed = sourceText.trimStart();
+  if (trimmed.startsWith("'use client'") || trimmed.startsWith('"use client"')) {
+    return 'client-only';
+  }
+  if (/export\s+const\s+dynamic\s*=\s*['"]force-dynamic['"]/.test(sourceText)) {
+    return 'dynamic';
+  }
+  return 'ssr-ssg';
+}
+
+function getLineNumber(sourceFile: ts.SourceFile, pos: number): number {
+  return sourceFile.getLineAndCharacterOfPosition(pos).line + 1;
+}
+
+function extractStringLiteral(node: ts.Node | undefined): string | null {
+  if (!node) return null;
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text;
+  }
+  return null;
+}
+
+function extractJsxText(node: ts.JsxElement | ts.JsxSelfClosingElement | ts.JsxFragment): string {
+  if (ts.isJsxSelfClosingElement(node)) return '';
+  const parts: string[] = [];
+  for (const child of node.children) {
+    if (ts.isJsxText(child)) {
+      const cleaned = child.getText().replace(/\s+/g, ' ').trim();
+      if (cleaned) parts.push(cleaned);
+    } else if (ts.isJsxExpression(child) && child.expression) {
+      const lit = extractStringLiteral(child.expression);
+      if (lit) parts.push(lit);
+    } else if (ts.isJsxElement(child) || ts.isJsxFragment(child)) {
+      const nested = extractJsxText(child);
+      if (nested) parts.push(nested);
+    }
+  }
+  return parts.join(' ').trim();
+}
+
+function validateJsonLdObject(
+  rawJson: string,
+  line: number,
+): JsonLdItem {
+  try {
+    const parsed = JSON.parse(rawJson) as Record<string, unknown>;
+    const contextVal = parsed['@context'];
+    const typeVal = parsed['@type'];
+    const hasValidContext =
+      typeof contextVal === 'string' && contextVal.includes('schema.org');
+    const hasValidType =
+      typeof typeVal === 'string' && typeVal.trim().length > 0;
+
+    if (!hasValidContext) {
+      return {
+        schemaType: typeof typeVal === 'string' ? typeVal : null,
+        rawJson,
+        isValid: false,
+        validationError: 'Missing or invalid @context (expected https://schema.org)',
+        line,
+      };
+    }
+    if (!hasValidType) {
+      return {
+        schemaType: null,
+        rawJson,
+        isValid: false,
+        validationError: 'Missing required @type property in JSON-LD object',
+        line,
+      };
+    }
+    return {
+      schemaType: typeVal,
+      rawJson,
+      isValid: true,
+      validationError: null,
+      line,
+    };
+  } catch (err) {
+    return {
+      schemaType: null,
+      rawJson,
+      isValid: false,
+      validationError: err instanceof Error ? err.message : 'Invalid JSON syntax',
+      line,
+    };
+  }
+}
+
+function objectLiteralToPlainObject(
+  obj: ts.ObjectLiteralExpression,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const prop of obj.properties) {
+    if (ts.isPropertyAssignment(prop)) {
+      const key = ts.isIdentifier(prop.name)
+        ? prop.name.text
+        : extractStringLiteral(prop.name) ?? prop.name.getText();
+      const val = prop.initializer;
+      const strVal = extractStringLiteral(val);
+      if (strVal !== null) {
+        result[key] = strVal;
+      } else if (val.kind === ts.SyntaxKind.TrueKeyword) {
+        result[key] = true;
+      } else if (val.kind === ts.SyntaxKind.FalseKeyword) {
+        result[key] = false;
+      } else if (ts.isNumericLiteral(val)) {
+        result[key] = Number(val.text);
+      } else if (ts.isObjectLiteralExpression(val)) {
+        result[key] = objectLiteralToPlainObject(val);
+      }
+    }
+  }
+  return result;
+}
+
+export function parseTsxRouteFile(
+  route: DiscoveredRoute,
+  fileContent: string,
+): ExtractedRouteData {
+  const sourceFile = ts.createSourceFile(
+    route.filePath,
+    fileContent,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TSX,
+  );
+
+  let title: { value: string; line: number } | null = null;
+  let description: { value: string; line: number } | null = null;
+  let canonical: { value: string; line: number } | null = null;
+  let robots: { value: string; line: number } | null = null;
+  let htmlLang: { value: string; line: number } | null | undefined = undefined;
+  const openGraph: Record<string, string> = {};
+  const hreflang: Array<{ lang: string; url: string }> = [];
+  const headings: HeadingItem[] = [];
+  const images: ImageItem[] = [];
+  const links: LinkItem[] = [];
+  const jsonLdItems: JsonLdItem[] = [];
+
+  const varObjectMap = new Map<string, { obj: Record<string, unknown>; line: number }>();
+
+  function inspectMetadataObject(obj: ts.ObjectLiteralExpression): void {
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop)) continue;
+      const propName = ts.isIdentifier(prop.name)
+        ? prop.name.text
+        : extractStringLiteral(prop.name) ?? '';
+      const line = getLineNumber(sourceFile, prop.getStart(sourceFile));
+
+      if (propName === 'title') {
+        const str = extractStringLiteral(prop.initializer);
+        if (str !== null) {
+          title = { value: str, line };
+        } else if (ts.isObjectLiteralExpression(prop.initializer)) {
+          const plain = objectLiteralToPlainObject(prop.initializer);
+          if (typeof plain['default'] === 'string') {
+            title = { value: plain['default'], line };
+          }
+        }
+      } else if (propName === 'description') {
+        const str = extractStringLiteral(prop.initializer);
+        if (str !== null) {
+          description = { value: str, line };
+        }
+      } else if (propName === 'alternates' && ts.isObjectLiteralExpression(prop.initializer)) {
+        for (const altProp of prop.initializer.properties) {
+          if (!ts.isPropertyAssignment(altProp)) continue;
+          const altName = ts.isIdentifier(altProp.name) ? altProp.name.text : '';
+          const altLine = getLineNumber(sourceFile, altProp.getStart(sourceFile));
+          if (altName === 'canonical') {
+            const cStr = extractStringLiteral(altProp.initializer);
+            if (cStr !== null) canonical = { value: cStr, line: altLine };
+          } else if (
+            altName === 'languages' &&
+            ts.isObjectLiteralExpression(altProp.initializer)
+          ) {
+            const langs = objectLiteralToPlainObject(altProp.initializer);
+            for (const [k, v] of Object.entries(langs)) {
+              if (typeof v === 'string') hreflang.push({ lang: k, url: v });
+            }
+          }
+        }
+      } else if (propName === 'robots') {
+        const str = extractStringLiteral(prop.initializer);
+        if (str !== null) {
+          robots = { value: str, line };
+        } else if (ts.isObjectLiteralExpression(prop.initializer)) {
+          const plain = objectLiteralToPlainObject(prop.initializer);
+          const parts: string[] = [];
+          if (plain['index'] === false) parts.push('noindex');
+          if (plain['index'] === true) parts.push('index');
+          if (plain['follow'] === false) parts.push('nofollow');
+          if (plain['follow'] === true) parts.push('follow');
+          robots = { value: parts.join(', ') || JSON.stringify(plain), line };
+        }
+      } else if (propName === 'openGraph' && ts.isObjectLiteralExpression(prop.initializer)) {
+        const plain = objectLiteralToPlainObject(prop.initializer);
+        for (const [k, v] of Object.entries(plain)) {
+          if (typeof v === 'string') openGraph[k] = v;
+        }
+      }
+    }
+  }
+
+  function getJsxAttributeMap(
+    attrs: ts.JsxAttributes,
+  ): Map<string, { value: string | null; expr: ts.Expression | null; line: number }> {
+    const map = new Map<
+      string,
+      { value: string | null; expr: ts.Expression | null; line: number }
+    >();
+    for (const prop of attrs.properties) {
+      if (ts.isJsxAttribute(prop)) {
+        const name = prop.name.getText(sourceFile);
+        const line = getLineNumber(sourceFile, prop.getStart(sourceFile));
+        if (!prop.initializer) {
+          map.set(name, { value: '', expr: null, line });
+        } else if (ts.isStringLiteral(prop.initializer)) {
+          map.set(name, { value: prop.initializer.text, expr: null, line });
+        } else if (
+          ts.isJsxExpression(prop.initializer) &&
+          prop.initializer.expression
+        ) {
+          const lit = extractStringLiteral(prop.initializer.expression);
+          map.set(name, {
+            value: lit,
+            expr: prop.initializer.expression,
+            line,
+          });
+        }
+      }
+    }
+    return map;
+  }
+
+  function visit(node: ts.Node): void {
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+      const varName = node.name.text;
+      if (ts.isObjectLiteralExpression(node.initializer)) {
+        if (varName === 'metadata') {
+          inspectMetadataObject(node.initializer);
+        } else {
+          varObjectMap.set(varName, {
+            obj: objectLiteralToPlainObject(node.initializer),
+            line: getLineNumber(sourceFile, node.getStart(sourceFile)),
+          });
+        }
+      }
+    }
+
+    if (
+      ts.isFunctionDeclaration(node) &&
+      node.name?.text === 'generateMetadata' &&
+      node.body
+    ) {
+      node.body.forEachChild(function walkBody(child) {
+        if (ts.isReturnStatement(child) && child.expression && ts.isObjectLiteralExpression(child.expression)) {
+          inspectMetadataObject(child.expression);
+        }
+        child.forEachChild(walkBody);
+      });
+    }
+
+    if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+      const opening = ts.isJsxElement(node) ? node.openingElement : node;
+      const tagName = opening.tagName.getText(sourceFile);
+      const line = getLineNumber(sourceFile, opening.getStart(sourceFile));
+      const attrs = getJsxAttributeMap(opening.attributes);
+
+      if (tagName === 'html') {
+        const langAttr = attrs.get('lang');
+        htmlLang = { value: langAttr?.value ?? '', line };
+      } else if (/^h[1-6]$/i.test(tagName)) {
+        const level = Number(tagName.slice(1)) as 1 | 2 | 3 | 4 | 5 | 6;
+        const text = extractJsxText(node);
+        headings.push({ level, text, line });
+      } else if (tagName === 'title' && ts.isJsxElement(node)) {
+        const text = extractJsxText(node);
+        if (text && !title) {
+          title = { value: text, line };
+        }
+      } else if (tagName === 'meta') {
+        const nameAttr = attrs.get('name')?.value?.toLowerCase();
+        const propAttr = attrs.get('property')?.value?.toLowerCase();
+        const contentAttr = attrs.get('content')?.value ?? null;
+        if (nameAttr === 'description' && contentAttr !== null && !description) {
+          description = { value: contentAttr, line };
+        } else if (nameAttr === 'robots' && contentAttr !== null && !robots) {
+          robots = { value: contentAttr, line };
+        } else if (propAttr?.startsWith('og:') && contentAttr !== null) {
+          openGraph[propAttr.slice(3)] = contentAttr;
+        }
+      } else if (tagName === 'link') {
+        const relAttr = attrs.get('rel')?.value?.toLowerCase();
+        const hrefAttr = attrs.get('href')?.value ?? null;
+        if (relAttr === 'canonical' && hrefAttr !== null && !canonical) {
+          canonical = { value: hrefAttr, line };
+        } else if (relAttr === 'alternate' && hrefAttr !== null) {
+          const hrefLangVal = attrs.get('hrefLang')?.value ?? attrs.get('hreflang')?.value;
+          if (hrefLangVal) {
+            hreflang.push({ lang: hrefLangVal, url: hrefAttr });
+          }
+        }
+      } else if (tagName === 'img' || tagName === 'Image') {
+        const srcVal = attrs.get('src')?.value ?? '';
+        const altEntry = attrs.get('alt');
+        const hasAlt = altEntry !== undefined && altEntry.value !== null && altEntry.value.trim().length > 0;
+        images.push({
+          src: srcVal,
+          alt: altEntry?.value ?? null,
+          hasAlt,
+          width: attrs.get('width')?.value ?? null,
+          height: attrs.get('height')?.value ?? null,
+          line,
+        });
+      } else if (tagName === 'a' || tagName === 'Link') {
+        const hrefVal = attrs.get('href')?.value;
+        if (hrefVal) {
+          const isExternal = /^https?:\/\//i.test(hrefVal);
+          links.push({
+            toUrl: hrefVal,
+            anchorText: extractJsxText(node),
+            kind: isExternal ? 'external' : 'internal',
+            rel: attrs.get('rel')?.value ?? null,
+            line,
+          });
+        }
+      } else if (tagName === 'script') {
+        const typeVal = attrs.get('type')?.value;
+        if (typeVal === 'application/ld+json') {
+          const dangerAttr = attrs.get('dangerouslySetInnerHTML');
+          if (dangerAttr?.expr && ts.isObjectLiteralExpression(dangerAttr.expr)) {
+            for (const p of dangerAttr.expr.properties) {
+              if (
+                ts.isPropertyAssignment(p) &&
+                p.name.getText(sourceFile) === '__html'
+              ) {
+                const strLit = extractStringLiteral(p.initializer);
+                if (strLit !== null) {
+                  jsonLdItems.push(validateJsonLdObject(strLit, line));
+                } else if (
+                  ts.isCallExpression(p.initializer) &&
+                  p.initializer.expression.getText(sourceFile) === 'JSON.stringify' &&
+                  p.initializer.arguments.length > 0
+                ) {
+                  const arg0 = p.initializer.arguments[0]!;
+                  if (ts.isObjectLiteralExpression(arg0)) {
+                    const plain = objectLiteralToPlainObject(arg0);
+                    jsonLdItems.push(
+                      validateJsonLdObject(JSON.stringify(plain), line),
+                    );
+                  } else if (ts.isIdentifier(arg0)) {
+                    const resolved = varObjectMap.get(arg0.text);
+                    if (resolved) {
+                      jsonLdItems.push(
+                        validateJsonLdObject(
+                          JSON.stringify(resolved.obj),
+                          resolved.line,
+                        ),
+                      );
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+
+  return {
+    route,
+    title,
+    description,
+    canonical,
+    robots,
+    ...(htmlLang !== undefined ? { htmlLang } : {}),
+    headings,
+    openGraph,
+    hreflang,
+    images,
+    links,
+    jsonLdItems,
+  };
+}
+

package/src/parsers/vue-sfc-parser.ts

@@ -0,0 +1,207 @@
+import type {
+  DiscoveredRoute,
+  ExtractedRouteData,
+  HeadingItem,
+  ImageItem,
+  JsonLdItem,
+  LinkItem,
+} from '@seo-partner/core';
+
+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 getAttr(attrsRaw: string, attrName: string): string | null {
+  const re = new RegExp(`\\b${attrName}\\s*=\\s*["']([^"']*)["']`, 'i');
+  const m = re.exec(attrsRaw);
+  return m ? (m[1] ?? null) : null;
+}
+
+export function parseVueSfc(
+  route: DiscoveredRoute,
+  fileContent: string,
+): ExtractedRouteData {
+  let title: { value: string; line: number } | null = null;
+  let description: { value: string; line: number } | null = null;
+  let canonical: { value: string; line: number } | null = null;
+  let robots: { value: string; line: number } | null = null;
+  let htmlLang: { value: string; line: number } | null | undefined = undefined;
+  let isDynamic = false;
+
+  const openGraph: Record<string, string> = {};
+  const hreflang: Array<{ lang: string; url: string }> = [];
+  const headings: HeadingItem[] = [];
+  const images: ImageItem[] = [];
+  const links: LinkItem[] = [];
+  const jsonLdItems: JsonLdItem[] = [];
+
+  // 1. Scan script block: <script setup> or <script>
+  const scriptMatch = /<script\b[^>]*>([\s\S]*?)<\/script>/i.exec(fileContent);
+  if (scriptMatch && scriptMatch[1]) {
+    const scriptContent = scriptMatch[1];
+    const scriptOffset = scriptMatch.index;
+
+    // useSeoMeta({ ... })
+    const useSeoMetaMatch = /useSeoMeta\s*\(\s*\{([\s\S]*?)\}\s*\)/i.exec(scriptContent);
+    if (useSeoMetaMatch && useSeoMetaMatch[1]) {
+      const metaBody = useSeoMetaMatch[1];
+      const callLine = lineNumberAtOffset(fileContent, scriptOffset + useSeoMetaMatch.index);
+
+      // title: '...' or title: "..."
+      const titleProp = /title\s*:\s*["']([^"']+)["']/i.exec(metaBody);
+      if (titleProp && !title) {
+        title = { value: titleProp[1] ?? '', line: callLine };
+      } else if (/title\s*:\s*[`()]/i.test(metaBody) && !title) {
+        title = { value: '[Valeur dynamique]', line: callLine };
+        isDynamic = true;
+      }
+
+      // description: '...'
+      const descProp = /description\s*:\s*["']([^"']+)["']/i.exec(metaBody);
+      if (descProp && !description) {
+        description = { value: descProp[1] ?? '', line: callLine };
+      }
+
+      // robots: '...'
+      const robotsProp = /robots\s*:\s*["']([^"']+)["']/i.exec(metaBody);
+      if (robotsProp && !robots) {
+        robots = { value: robotsProp[1] ?? '', line: callLine };
+      }
+
+      // ogTitle, ogDescription
+      const ogTitleProp = /ogTitle\s*:\s*["']([^"']+)["']/i.exec(metaBody);
+      if (ogTitleProp) openGraph['title'] = ogTitleProp[1] ?? '';
+      const ogDescProp = /ogDescription\s*:\s*["']([^"']+)["']/i.exec(metaBody);
+      if (ogDescProp) openGraph['description'] = ogDescProp[1] ?? '';
+    }
+
+    // useHead({ ... })
+    const useHeadMatch = /useHead\s*\(\s*\{([\s\S]*?)\}\s*\)/i.exec(scriptContent);
+    if (useHeadMatch && useHeadMatch[1]) {
+      const headBody = useHeadMatch[1];
+      const callLine = lineNumberAtOffset(fileContent, scriptOffset + useHeadMatch.index);
+
+      const titleProp = /title\s*:\s*["']([^"']+)["']/i.exec(headBody);
+      if (titleProp && !title) {
+        title = { value: titleProp[1] ?? '', line: callLine };
+      } else if (/title\s*:\s*[`()]/i.test(headBody) && !title) {
+        title = { value: '[Valeur dynamique]', line: callLine };
+        isDynamic = true;
+      }
+    }
+  }
+
+  // 2. Scan template block for components: <Title>, <Meta>, <NuxtLink>, <html lang>
+  const templateMatch = /<template\b[^>]*>([\s\S]*?)<\/template>/i.exec(fileContent);
+  const templateContent = templateMatch && templateMatch[1] ? templateMatch[1] : fileContent;
+  const templateOffset = templateMatch ? templateMatch.index : 0;
+
+  // <html lang="...">
+  const htmlTagMatch = /<html\b([^>]*?)>/i.exec(templateContent);
+  if (htmlTagMatch) {
+    const langVal = getAttr(htmlTagMatch[1] ?? '', 'lang');
+    if (langVal) {
+      htmlLang = {
+        value: langVal.trim(),
+        line: lineNumberAtOffset(fileContent, templateOffset + htmlTagMatch.index),
+      };
+    }
+  }
+
+  // <Title>...</Title> or <title>...</title>
+  const titleTagMatch = /<[Tt]itle[^>]*>([\s\S]*?)<\/[Tt]itle>/i.exec(templateContent);
+  if (titleTagMatch && !title) {
+    const rawVal = (titleTagMatch[1] ?? '').trim();
+    const line = lineNumberAtOffset(fileContent, templateOffset + titleTagMatch.index);
+    if (/\{\{[^}]+\}\}/.test(rawVal)) {
+      title = { value: '[Valeur dynamique]', line };
+      isDynamic = true;
+    } else {
+      title = { value: rawVal.replace(/\s+/g, ' '), line };
+    }
+  }
+
+  // <Meta name="..." content="..." /> or <meta ...>
+  const metaRegex = /<[Mm]eta\b([^>]*?)\/?>/gi;
+  let mMatch: RegExpExecArray | null;
+  while ((mMatch = metaRegex.exec(templateContent)) !== null) {
+    const attrs = mMatch[1] ?? '';
+    const line = lineNumberAtOffset(fileContent, templateOffset + mMatch.index);
+    const nameVal = getAttr(attrs, 'name')?.toLowerCase();
+    const contentVal = getAttr(attrs, 'content');
+    if (nameVal === 'description' && contentVal !== null && !description) {
+      description = { value: contentVal, line };
+    } else if (nameVal === 'robots' && contentVal !== null && !robots) {
+      robots = { value: contentVal, line };
+    }
+  }
+
+  // Headings: <h1> to <h6>
+  const headingRegex = /<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi;
+  let hMatch: RegExpExecArray | null;
+  while ((hMatch = headingRegex.exec(templateContent)) !== null) {
+    const level = Number(hMatch[1]) as 1 | 2 | 3 | 4 | 5 | 6;
+    const text = (hMatch[2] ?? '').replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
+    headings.push({
+      level,
+      text,
+      line: lineNumberAtOffset(fileContent, templateOffset + hMatch.index),
+    });
+  }
+
+  // Links: <NuxtLink to="..."> or <a href="...">
+  const nuxtLinkRegex = /<NuxtLink\b([^>]*?)>([\s\S]*?)<\/NuxtLink>/gi;
+  let nlMatch: RegExpExecArray | null;
+  while ((nlMatch = nuxtLinkRegex.exec(templateContent)) !== null) {
+    const attrs = nlMatch[1] ?? '';
+    const to = getAttr(attrs, 'to') || getAttr(attrs, ':to') || getAttr(attrs, 'href');
+    if (to) {
+      const anchorText = (nlMatch[2] ?? '').replace(/<[^>]+>/g, '').trim();
+      links.push({
+        toUrl: to,
+        anchorText,
+        kind: to.startsWith('http://') || to.startsWith('https://') ? 'external' : 'internal',
+        rel: getAttr(attrs, 'rel'),
+        line: lineNumberAtOffset(fileContent, templateOffset + nlMatch.index),
+      });
+    }
+  }
+
+  const aRegex = /<a\b([^>]*?)>([\s\S]*?)<\/a>/gi;
+  let aMatch: RegExpExecArray | null;
+  while ((aMatch = aRegex.exec(templateContent)) !== null) {
+    const attrs = aMatch[1] ?? '';
+    const href = getAttr(attrs, 'href');
+    if (href) {
+      const anchorText = (aMatch[2] ?? '').replace(/<[^>]+>/g, '').trim();
+      links.push({
+        toUrl: href,
+        anchorText,
+        kind: href.startsWith('http://') || href.startsWith('https://') ? 'external' : 'internal',
+        rel: getAttr(attrs, 'rel'),
+        line: lineNumberAtOffset(fileContent, templateOffset + aMatch.index),
+      });
+    }
+  }
+
+  return {
+    route,
+    title,
+    description,
+    canonical,
+    robots,
+    htmlLang,
+    headings,
+    openGraph,
+    hreflang,
+    images,
+    links,
+    jsonLdItems,
+    isDynamic,
+  };
+}
+

package/src/php-adapter.ts

@@ -0,0 +1,68 @@
+import type { DiscoveredRoute, ExtractedRouteData } from '@seo-partner/core';
+import type { AdapterCapabilities, FrameworkAdapter } from './contract.js';
+import { isPrivateRoutePattern } from './nextjs-adapter.js';
+import {
+  detectPhpFlavor,
+  discoverNativePhpRoutes,
+  parseLaravelRoutes,
+  parseSymfonyRoutes,
+} from './parsers/php-route-parser.js';
+import { parsePhpOrTemplateFile } from './parsers/php-template-parser.js';
+
+export class PhpAdapter implements FrameworkAdapter {
+  public readonly id = 'php';
+  public readonly name = 'PHP Ecosystem (Laravel / Blade, Symfony / Twig, Native PHP / Laragon)';
+  public readonly version = '1.0' as const;
+  public readonly capabilities: AdapterCapabilities = {
+    routes: true,
+    metadata: true,
+    headings: true,
+    internalLinks: true,
+    jsonLd: true,
+    images: true,
+    robotsAndSitemap: true,
+  };
+
+  public async detect(
+    _projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+  ): Promise<boolean> {
+    return detectPhpFlavor(filePaths, contentsByPath) !== null;
+  }
+
+  public async discoverRoutes(
+    _projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+    sitemapPaths: ReadonlySet<string>,
+  ): Promise<ReadonlyArray<DiscoveredRoute>> {
+    const flavor = detectPhpFlavor(filePaths, contentsByPath);
+    if (!flavor) return [];
+
+    const entries =
+      flavor === 'laravel'
+        ? parseLaravelRoutes(filePaths, contentsByPath)
+        : flavor === 'symfony'
+          ? parseSymfonyRoutes(filePaths, contentsByPath)
+          : discoverNativePhpRoutes(filePaths);
+
+    return entries.map((entry) => ({
+      pattern: entry.pattern,
+      filePath: entry.filePath,
+      routerKind: entry.flavor,
+      renderingMode: 'ssr-ssg',
+      isPrivate: isPrivateRoutePattern(entry.pattern),
+      inSitemap: sitemapPaths.has(entry.pattern),
+    }));
+  }
+
+  public async extractRoute(
+    projectRoot: string,
+    route: DiscoveredRoute,
+    fileContent: string,
+  ): Promise<ExtractedRouteData> {
+    return parsePhpOrTemplateFile(projectRoot, route, fileContent);
+  }
+}
+