@seo-partner/adapters 0.0.0-stage → 1.0.0

package/src/astro-adapter.ts

@@ -0,0 +1,126 @@
+import path from 'node:path';
+import type { DiscoveredRoute, ExtractedRouteData } from '@seo-partner/core';
+import type { AdapterCapabilities, AdapterVersion, FrameworkAdapter } from './contract.js';
+import { parseAstroOrMarkdown } from './parsers/astro-parser.js';
+import { normalizeRoutePattern } from './parsers/route-normalizer.js';
+import { LayoutResolver } from './parsers/layout-resolver.js';
+
+export class AstroAdapter implements FrameworkAdapter {
+  public readonly id = 'astro';
+  public readonly name = 'Astro';
+  public readonly version: AdapterVersion = '1.0';
+  public readonly capabilities: AdapterCapabilities = {
+    routes: true,
+    metadata: true,
+    headings: true,
+    internalLinks: true,
+    jsonLd: true,
+    images: true,
+    robotsAndSitemap: true,
+  };
+
+  private readonly layoutResolver = new LayoutResolver();
+
+  public async detect(
+    projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+  ): Promise<boolean> {
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (
+        normalized === 'astro.config.mjs' ||
+        normalized === 'astro.config.ts' ||
+        normalized === 'astro.config.js' ||
+        normalized === 'astro.config.cjs'
+      ) {
+        return true;
+      }
+      if (normalized === 'package.json') {
+        const content = contentsByPath.get(filePath) ?? '';
+        if (content.includes('"astro"') || content.includes('"@astrojs/')) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  public async discoverRoutes(
+    projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+    sitemapPaths: ReadonlySet<string>,
+  ): Promise<ReadonlyArray<DiscoveredRoute>> {
+    const routes: DiscoveredRoute[] = [];
+
+    // Pre-cache layouts from src/layouts/**
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (normalized.startsWith('src/layouts/') && normalized.endsWith('.astro')) {
+        const content = contentsByPath.get(filePath) ?? '';
+        const parsed = parseAstroOrMarkdown(
+          {
+            pattern: '',
+            filePath,
+            routerKind: 'astro',
+            renderingMode: 'static',
+            isPrivate: false,
+            inSitemap: false,
+          },
+          content,
+        );
+        this.layoutResolver.registerLayout({
+          filePath,
+          htmlLang: parsed.routeData.htmlLang,
+          title: parsed.routeData.title,
+          description: parsed.routeData.description,
+          canonical: parsed.routeData.canonical,
+          robots: parsed.routeData.robots,
+        });
+      }
+    }
+
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (!normalized.startsWith('src/pages/')) continue;
+      if (!/\.(astro|md|mdx|html)$/i.test(normalized)) continue;
+
+      const relativeInsidePages = normalized.slice('src/pages/'.length);
+      const pattern = normalizeRoutePattern(relativeInsidePages, 'astro');
+      const inSitemap = sitemapPaths.has(pattern);
+
+      routes.push({
+        pattern,
+        filePath,
+        routerKind: 'astro',
+        renderingMode: 'static',
+        isPrivate: false,
+        inSitemap,
+      });
+    }
+
+    return routes;
+  }
+
+  public async extractRoute(
+    projectRoot: string,
+    route: DiscoveredRoute,
+    fileContent: string,
+  ): Promise<ExtractedRouteData> {
+    const parsed = parseAstroOrMarkdown(route, fileContent);
+    let extracted = parsed.routeData;
+
+    // Apply layout inheritance: check layout candidates
+    const layoutCandidates = [
+      'src/layouts/BaseLayout.astro',
+      'src/layouts/Layout.astro',
+      'src/layouts/MainLayout.astro',
+      'src/layouts/DefaultLayout.astro',
+    ];
+    extracted = this.layoutResolver.applyInheritance(extracted, layoutCandidates);
+
+    return extracted;
+  }
+}
+

package/src/contract.ts

@@ -0,0 +1,40 @@
+import type { DiscoveredRoute, ExtractedRouteData } from '@seo-partner/core';
+
+export type AdapterVersion = '1.0';
+
+export interface AdapterCapabilities {
+  readonly routes: boolean;
+  readonly metadata: boolean;
+  readonly headings: boolean;
+  readonly internalLinks: boolean;
+  readonly jsonLd: boolean;
+  readonly images: boolean;
+  readonly robotsAndSitemap: boolean;
+}
+
+export interface FrameworkAdapter {
+  readonly id: string;
+  readonly name: string;
+  readonly version: AdapterVersion;
+  readonly capabilities: AdapterCapabilities;
+
+  detect(
+    projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+  ): Promise<boolean>;
+
+  discoverRoutes(
+    projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+    sitemapPaths: ReadonlySet<string>,
+  ): Promise<ReadonlyArray<DiscoveredRoute>>;
+
+  extractRoute(
+    projectRoot: string,
+    route: DiscoveredRoute,
+    fileContent: string,
+  ): Promise<ExtractedRouteData>;
+}
+

package/src/detector.ts

@@ -0,0 +1,46 @@
+import type { FrameworkAdapter } from './contract.js';
+import { NextJsAdapter } from './nextjs-adapter.js';
+import { AstroAdapter } from './astro-adapter.js';
+import { NuxtAdapter } from './nuxt-adapter.js';
+import { SvelteKitAdapter } from './sveltekit-adapter.js';
+import { RemixAdapter } from './remix-adapter.js';
+import { PhpAdapter } from './php-adapter.js';
+import { DjangoAdapter } from './django-adapter.js';
+import { StaticAdapter } from './static-adapter.js';
+
+/**
+ * Detection order contract (strictly prioritized to avoid ambiguities):
+ * 1. Next.js
+ * 2. Astro
+ * 3. Nuxt 3
+ * 4. SvelteKit
+ * 5. Remix / React Router v7
+ * 6. PHP (Laravel / Symfony / Native)
+ * 7. Django (Python)
+ * 8. Static HTML
+ */
+export const BUILTIN_ADAPTERS: ReadonlyArray<FrameworkAdapter> = [
+  new NextJsAdapter(),
+  new AstroAdapter(),
+  new NuxtAdapter(),
+  new SvelteKitAdapter(),
+  new RemixAdapter(),
+  new PhpAdapter(),
+  new DjangoAdapter(),
+  new StaticAdapter(),
+];
+
+export async function detectActiveAdapters(
+  projectRoot: string,
+  filePaths: ReadonlyArray<string>,
+  contentsByPath: ReadonlyMap<string, string>,
+): Promise<ReadonlyArray<FrameworkAdapter>> {
+  const active: FrameworkAdapter[] = [];
+  for (const adapter of BUILTIN_ADAPTERS) {
+    const matched = await adapter.detect(projectRoot, filePaths, contentsByPath);
+    if (matched) {
+      active.push(adapter);
+    }
+  }
+  return active;
+}

package/src/django-adapter.ts

@@ -0,0 +1,173 @@
+import path from 'node:path';
+import type { DiscoveredRoute, ExtractedRouteData } from '@seo-partner/core';
+import type { AdapterCapabilities, AdapterVersion, FrameworkAdapter } from './contract.js';
+import { parseDjangoUrls, parseDjangoViews } from './parsers/python-url-parser.js';
+import { parseDjangoTemplate } from './parsers/dtl-parser.js';
+import { LayoutResolver } from './parsers/layout-resolver.js';
+
+export class DjangoAdapter implements FrameworkAdapter {
+  public readonly id = 'django';
+  public readonly name = 'Django';
+  public readonly version: AdapterVersion = '1.0';
+  public readonly capabilities: AdapterCapabilities = {
+    routes: true,
+    metadata: true,
+    headings: true,
+    internalLinks: true,
+    jsonLd: true,
+    images: true,
+    robotsAndSitemap: true,
+  };
+
+  private readonly layoutResolver = new LayoutResolver();
+
+  public async detect(
+    projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+  ): Promise<boolean> {
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (
+        normalized === 'manage.py' ||
+        normalized.endsWith('/manage.py') ||
+        normalized === 'wsgi.py' ||
+        normalized.endsWith('/wsgi.py') ||
+        normalized === 'asgi.py' ||
+        normalized.endsWith('/asgi.py') ||
+        normalized.endsWith('settings.py')
+      ) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public async discoverRoutes(
+    projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+    sitemapPaths: ReadonlySet<string>,
+  ): Promise<ReadonlyArray<DiscoveredRoute>> {
+    const routes: DiscoveredRoute[] = [];
+
+    // 1. Pre-cache all base templates (e.g. templates/base.html, templates/*/base.html)
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (normalized.endsWith('.html')) {
+        const content = contentsByPath.get(filePath) ?? '';
+        if (
+          normalized.endsWith('base.html') ||
+          content.includes('<!DOCTYPE html>') ||
+          content.includes('<html')
+        ) {
+          const parsed = parseDjangoTemplate(
+            {
+              pattern: '',
+              filePath,
+              routerKind: 'django',
+              renderingMode: 'dynamic',
+              isPrivate: false,
+              inSitemap: false,
+            },
+            content,
+          );
+          this.layoutResolver.registerLayout({
+            filePath,
+            htmlLang: parsed.routeData.htmlLang,
+            title: parsed.routeData.title,
+            description: parsed.routeData.description,
+            canonical: parsed.routeData.canonical,
+            robots: parsed.routeData.robots,
+          });
+        }
+      }
+    }
+
+    // 2. Parse all views.py to build viewName -> templateName mapping
+    const viewToTemplate = new Map<string, string>();
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (normalized.endsWith('views.py')) {
+        const content = contentsByPath.get(filePath) ?? '';
+        const mappings = parseDjangoViews(content);
+        for (const m of mappings) {
+          viewToTemplate.set(m.viewName, m.templateName);
+        }
+      }
+    }
+
+    // 3. Parse all urls.py to discover routes
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (!normalized.endsWith('urls.py')) continue;
+
+      const content = contentsByPath.get(filePath) ?? '';
+      const patterns = parseDjangoUrls(content);
+
+      for (const p of patterns) {
+        const targetTemplateName = viewToTemplate.get(p.viewName);
+        let resolvedFilePath = filePath;
+
+        if (targetTemplateName) {
+          // Find matching template in filePaths
+          const found = filePaths.find((fp) => {
+            const norm = fp.replace(/\\/g, '/');
+            return norm.endsWith(`/${targetTemplateName}`) || norm === targetTemplateName;
+          });
+          if (found) {
+            resolvedFilePath = found;
+          }
+        } else {
+          // Conventional fallback: check for templates/<viewName>.html
+          const fallback = filePaths.find((fp) => {
+            const norm = fp.replace(/\\/g, '/');
+            return (
+              norm.endsWith(`/${p.viewName}.html`) ||
+              norm.endsWith(`templates/${p.viewName}.html`)
+            );
+          });
+          if (fallback) {
+            resolvedFilePath = fallback;
+          }
+        }
+
+        const inSitemap = sitemapPaths.has(p.pattern) || sitemapPaths.has(`${p.pattern}/`);
+
+        routes.push({
+          pattern: p.pattern,
+          filePath: resolvedFilePath,
+          routerKind: 'django',
+          renderingMode: 'dynamic',
+          isPrivate: false,
+          inSitemap,
+        });
+      }
+    }
+
+    return routes;
+  }
+
+  public async extractRoute(
+    projectRoot: string,
+    route: DiscoveredRoute,
+    fileContent: string,
+  ): Promise<ExtractedRouteData> {
+    const parsed = parseDjangoTemplate(route, fileContent);
+    let extracted = parsed.routeData;
+
+    // Resolve base template inheritance
+    const candidates: string[] = [];
+    if (parsed.extendsTemplate) {
+      candidates.push(parsed.extendsTemplate);
+      candidates.push(`templates/${parsed.extendsTemplate}`);
+    }
+    candidates.push('templates/base.html');
+    candidates.push('base.html');
+
+    extracted = this.layoutResolver.applyInheritance(extracted, candidates);
+
+    return extracted;
+  }
+}
+

package/src/index.ts

@@ -0,0 +1,23 @@
+export * from './contract.js';
+export * from './detector.js';
+export * from './nextjs-adapter.js';
+export * from './astro-adapter.js';
+export * from './nuxt-adapter.js';
+export * from './sveltekit-adapter.js';
+export * from './remix-adapter.js';
+export * from './django-adapter.js';
+export * from './php-adapter.js';
+export * from './static-adapter.js';
+export * from './parsers/tsx-ast-parser.js';
+export * from './parsers/html-parser.js';
+export * from './parsers/astro-parser.js';
+export * from './parsers/vue-sfc-parser.js';
+export * from './parsers/svelte-parser.js';
+export * from './parsers/remix-parser.js';
+export * from './parsers/python-url-parser.js';
+export * from './parsers/dtl-parser.js';
+export * from './parsers/php-route-parser.js';
+export * from './parsers/php-template-parser.js';
+export * from './parsers/robots-sitemap-parser.js';
+export * from './parsers/route-normalizer.js';
+export * from './parsers/layout-resolver.js';

package/src/nextjs-adapter.ts

@@ -0,0 +1,116 @@
+import type { DiscoveredRoute, ExtractedRouteData } from '@seo-partner/core';
+import type { AdapterCapabilities, FrameworkAdapter } from './contract.js';
+import {
+  detectRenderingModeFromTsx,
+  parseTsxRouteFile,
+} from './parsers/tsx-ast-parser.js';
+
+const PRIVATE_ROUTE_PREFIXES = ['/admin', '/dashboard', '/login', '/auth', '/api', '/account'];
+
+export function isPrivateRoutePattern(pattern: string): boolean {
+  const lower = pattern.toLowerCase();
+  return PRIVATE_ROUTE_PREFIXES.some(
+    (prefix) => lower === prefix || lower.startsWith(`${prefix}/`),
+  );
+}
+
+export function appRouterPathToPattern(relPath: string): string {
+  const withoutPrefix = relPath.replace(/^(src\/)?app\//, '');
+  const withoutPage = withoutPrefix.replace(/\/?page\.(tsx|ts|jsx|js|mdx)$/, '');
+  const segments = withoutPage
+    .split('/')
+    .filter((s) => s.length > 0 && !(s.startsWith('(') && s.endsWith(')')));
+  return segments.length === 0 ? '/' : `/${segments.join('/')}`;
+}
+
+export function pagesRouterPathToPattern(relPath: string): string {
+  const withoutPrefix = relPath.replace(/^(src\/)?pages\//, '');
+  const withoutExt = withoutPrefix.replace(/\.(tsx|ts|jsx|js)$/, '');
+  if (withoutExt === 'index') return '/';
+  const cleaned = withoutExt.replace(/\/index$/, '');
+  return `/${cleaned}`;
+}
+
+export class NextJsAdapter implements FrameworkAdapter {
+  public readonly id = 'nextjs';
+  public readonly name = 'Next.js (App Router & Pages Router)';
+  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> {
+    const pkgJson = contentsByPath.get('package.json');
+    if (pkgJson && /"next"\s*:/.test(pkgJson)) {
+      return true;
+    }
+    return filePaths.some(
+      (p) =>
+        /^next\.config\.(js|mjs|ts|cjs)$/.test(p) ||
+        /^(src\/)?app\/.*page\.(tsx|ts|jsx|js)$/.test(p) ||
+        /^(src\/)?pages\/.*\.(tsx|ts|jsx|js)$/.test(p),
+    );
+  }
+
+  public async discoverRoutes(
+    _projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+    sitemapPaths: ReadonlySet<string>,
+  ): Promise<ReadonlyArray<DiscoveredRoute>> {
+    const routes: DiscoveredRoute[] = [];
+
+    for (const filePath of filePaths) {
+      if (/^(src\/)?app\/(.*\/)?page\.(tsx|ts|jsx|js)$/.test(filePath)) {
+        const pattern = appRouterPathToPattern(filePath);
+        const content = contentsByPath.get(filePath) ?? '';
+        routes.push({
+          pattern,
+          filePath,
+          routerKind: 'nextjs-app',
+          renderingMode: detectRenderingModeFromTsx(content),
+          isPrivate: isPrivateRoutePattern(pattern),
+          inSitemap: sitemapPaths.has(pattern),
+        });
+      } else if (
+        /^(src\/)?pages\/.*\.(tsx|ts|jsx|js)$/.test(filePath) &&
+        !/\/_app\./.test(filePath) &&
+        !/\/_document\./.test(filePath) &&
+        !/\/_error\./.test(filePath) &&
+        !/^(src\/)?pages\/api\//.test(filePath)
+      ) {
+        const pattern = pagesRouterPathToPattern(filePath);
+        const content = contentsByPath.get(filePath) ?? '';
+        routes.push({
+          pattern,
+          filePath,
+          routerKind: 'nextjs-pages',
+          renderingMode: detectRenderingModeFromTsx(content),
+          isPrivate: isPrivateRoutePattern(pattern),
+          inSitemap: sitemapPaths.has(pattern),
+        });
+      }
+    }
+
+    return routes;
+  }
+
+  public async extractRoute(
+    _projectRoot: string,
+    route: DiscoveredRoute,
+    fileContent: string,
+  ): Promise<ExtractedRouteData> {
+    return parseTsxRouteFile(route, fileContent);
+  }
+}
+

package/src/nuxt-adapter.ts

@@ -0,0 +1,118 @@
+import type { DiscoveredRoute, ExtractedRouteData } from '@seo-partner/core';
+import type { AdapterCapabilities, AdapterVersion, FrameworkAdapter } from './contract.js';
+import { parseVueSfc } from './parsers/vue-sfc-parser.js';
+import { normalizeRoutePattern } from './parsers/route-normalizer.js';
+import { LayoutResolver } from './parsers/layout-resolver.js';
+
+export class NuxtAdapter implements FrameworkAdapter {
+  public readonly id = 'nuxt';
+  public readonly name = 'Nuxt 3';
+  public readonly version: AdapterVersion = '1.0';
+  public readonly capabilities: AdapterCapabilities = {
+    routes: true,
+    metadata: true,
+    headings: true,
+    internalLinks: true,
+    jsonLd: true,
+    images: true,
+    robotsAndSitemap: true,
+  };
+
+  private readonly layoutResolver = new LayoutResolver();
+
+  public async detect(
+    projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+  ): Promise<boolean> {
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (
+        normalized === 'nuxt.config.ts' ||
+        normalized === 'nuxt.config.js' ||
+        normalized === 'nuxt.config.mjs'
+      ) {
+        return true;
+      }
+      if (normalized === 'package.json') {
+        const content = contentsByPath.get(filePath) ?? '';
+        if (content.includes('"nuxt"') || content.includes('"@nuxt/')) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  public async discoverRoutes(
+    projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+    sitemapPaths: ReadonlySet<string>,
+  ): Promise<ReadonlyArray<DiscoveredRoute>> {
+    const routes: DiscoveredRoute[] = [];
+
+    // Pre-cache layouts from layouts/**
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (normalized.startsWith('layouts/') && normalized.endsWith('.vue')) {
+        const content = contentsByPath.get(filePath) ?? '';
+        const parsed = parseVueSfc(
+          {
+            pattern: '',
+            filePath,
+            routerKind: 'nuxt',
+            renderingMode: 'ssr-ssg',
+            isPrivate: false,
+            inSitemap: false,
+          },
+          content,
+        );
+        this.layoutResolver.registerLayout({
+          filePath,
+          htmlLang: parsed.htmlLang,
+          title: parsed.title,
+          description: parsed.description,
+          canonical: parsed.canonical,
+          robots: parsed.robots,
+        });
+      }
+    }
+
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (!normalized.startsWith('pages/')) continue;
+      if (!normalized.endsWith('.vue')) continue;
+
+      const relativeInsidePages = normalized.slice('pages/'.length);
+      const pattern = normalizeRoutePattern(relativeInsidePages, 'nuxt');
+      const inSitemap = sitemapPaths.has(pattern);
+
+      routes.push({
+        pattern,
+        filePath,
+        routerKind: 'nuxt',
+        renderingMode: 'ssr-ssg',
+        isPrivate: false,
+        inSitemap,
+      });
+    }
+
+    return routes;
+  }
+
+  public async extractRoute(
+    projectRoot: string,
+    route: DiscoveredRoute,
+    fileContent: string,
+  ): Promise<ExtractedRouteData> {
+    let extracted = parseVueSfc(route, fileContent);
+
+    // Inherit from default layout if present
+    const layoutCandidates = ['layouts/default.vue', 'layouts/main.vue'];
+    extracted = this.layoutResolver.applyInheritance(extracted, layoutCandidates);
+
+    return extracted;
+  }
+}
+