seo-gravity-mcp 1.0.2 → 1.1.0

package/README.md

@@ -1,18 +1,17 @@
-# 🚀 SEO Gravity MCP (v1.0.2)
+# 🚀 SEO Gravity (v1.1.0)
 
 <div align="center">
 
 [![npm version](https://img.shields.io/npm/v/seo-gravity-mcp?style=for-the-badge&logo=npm&color=CB3837)](https://www.npmjs.com/package/seo-gravity-mcp)
 [![npm downloads](https://img.shields.io/npm/dm/seo-gravity-mcp?style=for-the-badge&logo=npm&color=CB3837)](https://www.npmjs.com/package/seo-gravity-mcp)
 ![MCP Protocol](https://img.shields.io/badge/MCP-Protocol-blue?style=for-the-badge&logo=anthropic)
+![CLI Ready](https://img.shields.io/badge/CLI-CI%2FCD_Ready-success?style=for-the-badge)
 ![TypeScript](https://img.shields.io/badge/TypeScript-5.7+-3178C6?style=for-the-badge&logo=typescript&logoColor=white)
-![Node.js](https://img.shields.io/badge/Node.js-18+-339933?style=for-the-badge&logo=nodedotjs&logoColor=white)
-![License](https://img.shields.io/badge/License-MIT-green?style=for-the-badge)
 ![Zero API Cost](https://img.shields.io/badge/Zero_API_Cost-100%25_Free-orange?style=for-the-badge)
 
-**The Universal SEO Intelligence, Source-Code Correlation & Remediation Engine for AI Coding Agents.**
+**The Enterprise SEO Engineering Layer for AI Coding Agents & CI/CD Pipelines.**
 
-[⚡ Instant Start](#-instant-start) • [🤖 Client Setup](#-ai-ide--mcp-client-setup) • [🧠 5-Stage Autonomous Loop](#-the-5-stage-autonomous-remediation-loop) • [🛠 Tool Catalog (35 Tools)](#-complete-tool-catalog-35-tools) • [📄 License](#-license)
+[⚡ Instant Start](#-instant-start) • [💻 CLI & CI/CD](#-command-line--cicd-runner) • [🏛 5-Layer Architecture](#-5-layer-system-architecture) • [🧩 Framework Adapters](#-modular-framework-adapters) • [🛠 Tool Catalog (35 Tools)](#-complete-tool-catalog) • [📄 License](#-license)
 
 </div>
 
@@ -20,67 +19,87 @@
 
 ## 🌟 What is SEO Gravity?
 
-**SEO Gravity** gives AI coding agents (Antigravity, Cursor, Claude Code, Windsurf, Cline, Roo Code, etc.) the autonomous ability to **understand, audit, fix, and continuously verify the SEO of the websites they build.**
+**SEO Gravity** is an **SEO engineering infrastructure layer** designed specifically for AI coding agents (Antigravity, Cursor, Claude Code, Windsurf, Cline, Roo Code, etc.) and automated CI/CD pipelines.
 
-Instead of acting as a passive "SEO metrics dump", SEO Gravity connects **rendered web signals** directly to your **source code components** (Next.js App Router, Astro, Vite/React, Remix, SvelteKit), ranks issues by impact-to-effort priority, generates code fix blueprints, and verifies that commits introduce **zero regressions**.
+Instead of operating as a passive SEO reporting tool, SEO Gravity connects **rendered web observations** directly to **source code AST nodes and line numbers** across modern web frameworks (Next.js App/Pages Router, Astro, Vite/React, Remix, SvelteKit), generates actionable code fix blueprints, and enforces invariant-based regression checks.
 
 ```text
  ┌──────────────┐     ┌──────────────┐     ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
  │ 1. DISCOVER  │ ──▶ │  2. OBSERVE  │ ──▶ │ 3. DIAGNOSE  │ ──▶ │    4. FIX    │ ──▶ │  5. VERIFY   │
- │ Framework    │     │ Live/Dev SSR │     │ Root Causes  │     │ AI Modifies  │     │ Re-crawl &   │
- │ Routes       │     │ SERP & Comp. │     │ Prioritized  │     │ Source Code  │     │ Regression   │
- │ Source Map   │     │ Crawl Graph  │     │ Action Plan  │     │ Components   │     │ Diff Check   │
+ │ Framework    │     │ Live/Dev SSR │     │ AST Line Nos │     │ AI Modifies  │     │ Invariant    │
+ │ Adapters     │     │ Crawl Graph  │     │ Prioritized  │     │ Components   │     │ Regression   │
+ │ Source Map   │     │ Provenance   │     │ Action Plan  │     │ Snippets     │     │ Git Stamping │
  └──────────────┘     └──────────────┘     └──────────────┘     └──────────────┘     └──────────────┘
 ```
 
 ---
 
-## 💡 Key Architectural Pillars
+## 🏛 5-Layer System Architecture
 
-1. **Source-to-URL Correlation**: Directly maps audited URLs (`/blog/my-post`) to source files (`app/blog/[slug]/page.tsx`), identifying missing metadata exports or canonical tags.
-2. **Canonical Finding Model**: Every audit issue produces a normalized finding with `id`, `severity`, `confidence` ($0.0-1.0$), `evidenceType` (*Observed*, *Derived*, *Heuristic*, *Predictive*), `effort`, `priorityScore`, and verification steps.
-3. **Crawl Graph & Site Architecture**: Computes BFS click depths, orphan pages, hub pages, circular link loops, and internal link equity (PageRank heuristic).
-4. **Multidimensional Health Scoring**: Breaks scores into 7 discrete dimensions (Technical, Content, Discoverability, Authority, Entity, Performance, AI Readiness) with confidence levels.
-5. **SEO Regression & Snapshot System**: Creates snapshots (`seo.gravity/v1`) before commits/PRs and validates that changes introduced 0 regressions.
-6. **Zero Paid API Requirement**: 100% functional out-of-the-box using local AST parsing, cheerio, JSDOM, Google Autocomplete, and standard web extraction.
+```text
+┌─────────────────────────────────────────────────────────────┐
+│ 1. AGENT & CLI INTERFACE                                    │
+│    MCP Server (35 tools) + Standalone CLI (`seo-gravity`)   │
+├─────────────────────────────────────────────────────────────┤
+│ 2. INTELLIGENCE & REASONING LAYER                           │
+│    Root-cause diagnosis, deterministic priority, fix plans  │
+├─────────────────────────────────────────────────────────────┤
+│ 3. ANALYSIS & INVARIANT LAYER                               │
+│    SEO Invariants (HTTP 200, canonical, schema, noindex)    │
+├─────────────────────────────────────────────────────────────┤
+│ 4. OBSERVATION LAYER (Factual Raw State)                    │
+│    Observations ≠ Findings; AST inspection, headers, DOM    │
+├─────────────────────────────────────────────────────────────┤
+│ 5. PROVIDER & ADAPTER LAYER                                 │
+│    Framework Adapters (Next, Astro, Vite), Providers, Cache │
+└─────────────────────────────────────────────────────────────┘
+```
 
 ---
 
-## ⚡ Instant Start
+## 🧩 Modular Framework Adapters
 
-Run instantly with `npx`:
+| Framework Adapter | Detection | Route Discovery | AST Inspection |
+| :--- | :--- | :--- | :--- |
+| **`NextAppAdapter`** | `next` + `app/` | App Router hierarchy, route groups `(group)`, dynamic `[slug]` | Pinpoints `metadata` export & `generateMetadata()` lines |
+| **`NextPagesAdapter`** | `next` + `pages/` | Pages router hierarchy, dynamic `[id]` | Scans `<Head>` & `<NextSeo>` JSX components |
+| **`AstroAdapter`** | `astro` + `src/pages` | `.astro`, `.md`, `.mdx` pages | Scans Astro frontmatter & `<title>` tags |
+| **`ViteReactAdapter`** | `vite` / `react` | `index.html` + React Router routes | Scans `<Helmet>` & route definition trees |
+| **`RemixAdapter`** | `@remix-run/react` | `app/routes/` | Inspects `meta` and `links` export functions |
+| **`SvelteKitAdapter`** | `@sveltejs/kit` | `src/routes/` (`+page.svelte`) | Scans `<svelte:head>` components |
+| **`StaticAdapter`** | Static HTML files | Recursive HTML directory traversal | Direct DOM / meta element inspection |
 
-```bash
-npx -y seo-gravity-mcp
-```
+---
 
-Or install globally:
+## 💻 Command-Line & CI/CD Runner
+
+SEO Gravity includes a standalone CLI binary (`seo-gravity`) for direct terminal use and GitHub Actions / CI/CD quality gates:
 
 ```bash
-npm install -g seo-gravity-mcp
+# 1. Audit project
+npx seo-gravity-mcp audit --project ./my-app
+
+# 2. Create baseline snapshot
+npx seo-gravity-mcp snapshot --project ./my-app --output baseline.json
+
+# 3. Check for SEO regressions in CI/CD PR gate (Exits with 0 or 1)
+npx seo-gravity-mcp check --project ./my-app --baseline baseline.json
+
+# 4. Targeted Git differential audit on modified routes only
+npx seo-gravity-mcp diff --project ./my-app --base-ref origin/main
 ```
 
 ---
 
-## 🤖 AI IDE & MCP Client Setup
-
-### 1. 🟣 Claude Desktop
-Add to `claude_desktop_config.json`:
+## ⚡ Instant Start (MCP Server)
 
-```json
-{
-  "mcpServers": {
-    "seo-gravity": {
-      "command": "npx",
-      "args": ["-y", "seo-gravity-mcp"]
-    }
-  }
-}
+```bash
+npx -y seo-gravity-mcp
 ```
 
-### 2. ⚡ Cursor
-Add to `.cursor/mcp.json`:
+### AI Client Configurations
 
+#### Cursor (`.cursor/mcp.json`)
 ```json
 {
   "mcpServers": {
@@ -92,9 +111,7 @@ Add to `.cursor/mcp.json`:
 }
 ```
 
-### 3. 🌊 Antigravity / Windsurf / VS Code Cline
-Add to `mcp_config.json`:
-
+#### Claude Desktop (`claude_desktop_config.json`)
 ```json
 {
   "mcpServers": {
@@ -108,78 +125,28 @@ Add to `mcp_config.json`:
 
 ---
 
-## 🛠 Complete Tool Catalog (35 Tools)
+## 🛠 Complete Tool Catalog
 
 ### Layer 0: Agent Orchestration & Remediation (Flagship)
 | Tool Name | Operational Class | Description |
 | :--- | :--- | :--- |
 | `seo_project_audit` | **Planning / Audit** | Scans workspace framework, discovers routes, correlates source files, builds crawl graph, and computes multidimensional SEO health. |
-| `seo_diagnose` | **Planning / Diagnose** | Deep root-cause inspection linking an observed issue/URL back to specific source code files with ready-to-use fix blueprints. |
+| `seo_diagnose` | **Planning / Diagnose** | Deep root-cause AST inspection linking an observed issue/URL back to specific source code line ranges with ready-to-use fix blueprints. |
 | `seo_prioritize` | **Planning / Strategy** | Ranks findings into Quick Wins, Critical Blockers, and Architectural Improvements using `(Impact × Confidence × Reach) / Effort`. |
 | `seo_fix_plan` | **Planning / Execution** | Generates an end-to-end code modification and verification plan for AI coding agents. |
-| `seo_snapshot_create` | **Verification** | Creates and saves a project SEO baseline snapshot adhering to canonical schema `seo.gravity/v1`. |
-| `seo_snapshot_compare` | **Verification** | Diffs two snapshots to compute resolved findings, new regressions, and multidimensional score deltas. |
+| `seo_snapshot_create` | **Verification** | Creates and saves a project SEO baseline snapshot with Git commit stamping adhering to schema `seo.gravity/v1`. |
+| `seo_snapshot_compare` | **Verification** | Invariant-based diffing of two snapshots to isolate resolved findings, new regressions, and multidimensional score deltas. |
 | `seo_regression_check` | **Verification / CI** | Automated pass/fail regression check with alert messages for CI/CD gates and PR bots. |
 
-### Layer 1: SERP & Competitor Intelligence
-| Tool Name | Description |
-| :--- | :--- |
-| `seo_serp_analyze` | Live Google SERP scraper returning rankings, snippets, People Also Ask (PAA), and SERP features. |
-| `seo_competitor_content_gap` | Compares target page against top 3-5 competitors for missing TF-IDF entities, subtopics, and word count deltas. |
-| `seo_competitor_profile` | Deep extraction of competitor heading tree (H1-H4), schema types, reading grade, and link ratios. |
-| `seo_competitor_diff` | 25-factor side-by-side scorecard comparing your page vs #1 competitor. |
-| `seo_forum_discussions_pulse` | Scrapes Reddit & Quora threads ranking for a query to extract user pain points and consensus. |
-
-### Layer 2: Generative Engine Optimization (GEO & AEO)
-| Tool Name | Description |
-| :--- | :--- |
-| `seo_geo_ai_readiness_audit` | Audits content for AI Overviews & Perplexity citation readiness with structured retrieval signals and evidence tiers. |
-| `seo_llms_txt_generate` | Generates standard `/llms.txt` and `/llms-full.txt` markdown context files for AI search bots. |
-| `seo_ai_bots_robots_audit` | Audits robots.txt permissions specifically for AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended). |
-
-### Layer 3: Information Gain & E-E-A-T
-| Tool Name | Description |
-| :--- | :--- |
-| `seo_information_gain_score` | Quantifies content novelty vs top 10 SERPs to prevent generic AI fluff penalties. |
-| `seo_eeat_audit` | Audits Google E-E-A-T trust signals (Person schema, author bylines, sameAs Wikidata/LinkedIn, publish/modified dates). |
-
-### Layer 4: On-Page & Content Strategy
-| Tool Name | Description |
-| :--- | :--- |
-| `seo_onpage_audit` | Deep on-page audit of pixel width, meta CTR, heading hierarchy, image alt, and slug optimization. |
-| `seo_content_brief_generate` | Generates data-backed Content Outline & Brief with target word count, H1/H2/H3 structure, and FAQs. |
-| `seo_readability_score` | Computes Flesch Reading Ease, Flesch-Kincaid Grade Level, and Gunning Fog index. |
-
-### Layer 5: Technical SEO & JavaScript Hydration
-| Tool Name | Description |
-| :--- | :--- |
-| `seo_technical_audit` | Inspects HTTP status codes, redirect chains, canonical consistency, meta robots (`noindex` leaks), and SSL. |
-| `seo_js_rendering_diff` | Compares raw server HTML vs hydrated client DOM (JavaScript SEO) to detect client-only content or broken tags. |
-| `seo_robots_txt_validate` | Validates bot crawlability against specific paths and User-Agents. |
-| `seo_sitemap_inspect` | Validates XML sitemaps, sitemap indexes, lastmod timestamps, and URL limit constraints. |
-| `seo_internal_links_analyze` | Analyzes internal link equity distribution, anchor texts, generic anchors, and nofollow flags. |
-
-### Layer 6: Keyword Research & Intent
-| Tool Name | Description |
-| :--- | :--- |
-| `seo_keyword_suggestions` | Generates keyword suggestions using Google Autocomplete and Alphabet Soup expansion. |
-| `seo_questions_find` | Finds question queries asked by users across Google (Who, What, Where, When, Why, How, Can). |
-| `seo_keyword_cluster` | Clusters keyword lists into Topic Pillars and Supporting Articles using semantic similarity. |
-| `seo_search_intent_classify` | Classifies keywords into Informational, Navigational, Commercial, or Transactional intent. |
-
-### Layer 7: Schema & Entity Graph
-| Tool Name | Description |
-| :--- | :--- |
-| `seo_entity_salience_map` | Extracts named entities, computes salience scores, and generates SPO relationship triples. |
-| `seo_schema_generate` | Generates validated Schema.org JSON-LD scripts (Article, FAQPage, Product, LocalBusiness, Organization). |
-| `seo_schema_validate` | Validates structured data against Schema.org and Google Rich Result criteria. |
-
-### Layer 8: Performance & Maintenance
-| Tool Name | Description |
-| :--- | :--- |
-| `seo_pagespeed_audit` | Checks Core Web Vitals (LCP, FCP, CLS, TTFB) with performance optimization fixes. |
-| `seo_indexnow_submit` | Submits newly created or updated URLs directly to Bing & Yandex via the IndexNow API protocol. |
-| `seo_content_decay_audit` | Scans content for freshness decay (stale year references, outdated stats, broken external links). |
+### Layers 1–8: Specialized SEO & GEO Engines
+- **Layer 1 (SERP & Competitors)**: `seo_serp_analyze`, `seo_competitor_content_gap`, `seo_competitor_profile`, `seo_competitor_diff`, `seo_forum_discussions_pulse`
+- **Layer 2 (GEO & AI Search)**: `seo_geo_ai_readiness_audit`, `seo_llms_txt_generate`, `seo_ai_bots_robots_audit`
+- **Layer 3 (Info Gain & E-E-A-T)**: `seo_information_gain_score`, `seo_eeat_audit`
+- **Layer 4 (On-Page)**: `seo_onpage_audit`, `seo_content_brief_generate`, `seo_readability_score`
+- **Layer 5 (Technical SEO)**: `seo_technical_audit`, `seo_js_rendering_diff`, `seo_robots_txt_validate`, `seo_sitemap_inspect`, `seo_internal_links_analyze`
+- **Layer 6 (Keywords & Intent)**: `seo_keyword_suggestions`, `seo_questions_find`, `seo_keyword_cluster`, `seo_search_intent_classify`
+- **Layer 7 (Schema & Entity)**: `seo_entity_salience_map`, `seo_schema_generate`, `seo_schema_validate`
+- **Layer 8 (Speed & Maintenance)**: `seo_pagespeed_audit`, `seo_indexnow_submit`, `seo_content_decay_audit`
 
 ---
 

package/dist/adapters/adapterRegistry.d.ts

@@ -0,0 +1,7 @@
+import { FrameworkAdapter } from './types.js';
+export declare class AdapterRegistry {
+    private adapters;
+    getAdapterForProject(projectDir: string): FrameworkAdapter;
+    getAdapterById(id: string): FrameworkAdapter | undefined;
+}
+export declare const defaultAdapterRegistry: AdapterRegistry;

package/dist/adapters/adapterRegistry.js

@@ -0,0 +1,30 @@
+import { NextAppAdapter } from './nextAppAdapter.js';
+import { NextPagesAdapter } from './nextPagesAdapter.js';
+import { AstroAdapter } from './astroAdapter.js';
+import { ViteReactAdapter } from './viteReactAdapter.js';
+import { RemixAdapter } from './remixAdapter.js';
+import { SvelteKitAdapter } from './svelteKitAdapter.js';
+import { StaticAdapter } from './staticAdapter.js';
+export class AdapterRegistry {
+    adapters = [
+        new NextAppAdapter(),
+        new NextPagesAdapter(),
+        new AstroAdapter(),
+        new RemixAdapter(),
+        new SvelteKitAdapter(),
+        new ViteReactAdapter(),
+        new StaticAdapter() // fallback
+    ];
+    getAdapterForProject(projectDir) {
+        for (const adapter of this.adapters) {
+            if (adapter.detect(projectDir)) {
+                return adapter;
+            }
+        }
+        return this.adapters[this.adapters.length - 1]; // fallback static
+    }
+    getAdapterById(id) {
+        return this.adapters.find(a => a.id === id);
+    }
+}
+export const defaultAdapterRegistry = new AdapterRegistry();

package/dist/adapters/astroAdapter.d.ts

@@ -0,0 +1,17 @@
+import { FrameworkAdapter, MetadataLocationInfo, CanonicalLocationInfo, SchemaLocationInfo } from './types.js';
+import { DiscoveredRoute, ProjectFrameworkInfo, RouteSourceMapping } from '../types/findings.js';
+export declare class AstroAdapter implements FrameworkAdapter {
+    id: string;
+    name: string;
+    detect(projectDir: string): boolean;
+    getProjectInfo(projectDir: string): ProjectFrameworkInfo;
+    discoverRoutes(projectDir: string): DiscoveredRoute[];
+    mapRouteToSource(targetUrl: string, routes: DiscoveredRoute[]): RouteSourceMapping;
+    findMetadataImplementation(projectDir: string, route: DiscoveredRoute): Promise<MetadataLocationInfo>;
+    findCanonicalDeclaration(projectDir: string, route: DiscoveredRoute): Promise<CanonicalLocationInfo>;
+    findSchemaDeclaration(projectDir: string, route: DiscoveredRoute): Promise<SchemaLocationInfo>;
+    findRobotsConfig(projectDir: string): string | null;
+    findSitemapConfig(projectDir: string): string | null;
+    findLlmsTxt(projectDir: string): string | null;
+    private extractDynamicParams;
+}

package/dist/adapters/astroAdapter.js

@@ -0,0 +1,191 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export class AstroAdapter {
+    id = 'astro';
+    name = 'Astro Framework';
+    detect(projectDir) {
+        const hasConfig = fs.existsSync(path.join(projectDir, 'astro.config.mjs')) ||
+            fs.existsSync(path.join(projectDir, 'astro.config.ts'));
+        if (hasConfig)
+            return true;
+        const pkgPath = path.join(projectDir, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                return Boolean(deps['astro']);
+            }
+            catch { }
+        }
+        return false;
+    }
+    getProjectInfo(projectDir) {
+        const pkgPath = path.join(projectDir, 'package.json');
+        let pkg = {};
+        if (fs.existsSync(pkgPath)) {
+            try {
+                pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            }
+            catch { }
+        }
+        const hasSrcPages = fs.existsSync(path.join(projectDir, 'src/pages'));
+        const routesDir = hasSrcPages ? 'src/pages' : 'pages';
+        return {
+            framework: 'astro',
+            name: pkg.name || path.basename(projectDir),
+            version: pkg.dependencies?.astro || pkg.devDependencies?.astro,
+            packageManager: fs.existsSync(path.join(projectDir, 'pnpm-lock.yaml'))
+                ? 'pnpm'
+                : fs.existsSync(path.join(projectDir, 'yarn.lock'))
+                    ? 'yarn'
+                    : 'npm',
+            hasTypeScript: fs.existsSync(path.join(projectDir, 'tsconfig.json')),
+            hasSitemapConfig: Boolean(this.findSitemapConfig(projectDir)),
+            hasRobotsConfig: Boolean(this.findRobotsConfig(projectDir)),
+            hasLlmsTxt: Boolean(this.findLlmsTxt(projectDir)),
+            rootDir: path.resolve(projectDir),
+            routesDir,
+            devCommand: 'npm run dev',
+            defaultDevPort: 4321
+        };
+    }
+    discoverRoutes(projectDir) {
+        const info = this.getProjectInfo(projectDir);
+        const fullRoutesDir = path.join(projectDir, info.routesDir || 'src/pages');
+        const discovered = [];
+        if (!fs.existsSync(fullRoutesDir))
+            return discovered;
+        const scanDir = (currentDir, routePrefix) => {
+            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const entryPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    const nextPrefix = routePrefix === '/' ? `/${entry.name}` : `${routePrefix}/${entry.name}`;
+                    scanDir(entryPath, nextPrefix);
+                }
+                else if (entry.isFile() && /\.(astro|md|mdx)$/.test(entry.name)) {
+                    const baseName = entry.name.replace(/\.(astro|md|mdx)$/, '');
+                    let routePath = routePrefix;
+                    if (baseName !== 'index') {
+                        routePath = routePrefix === '/' ? `/${baseName}` : `${routePrefix}/${baseName}`;
+                    }
+                    if (routePath === '')
+                        routePath = '/';
+                    const relFile = path.relative(projectDir, entryPath).replace(/\\/g, '/');
+                    const content = fs.readFileSync(entryPath, 'utf-8');
+                    const dynamicParams = this.extractDynamicParams(routePath);
+                    discovered.push({
+                        routePath,
+                        sourceFilePath: relFile,
+                        isDynamic: dynamicParams.length > 0,
+                        dynamicParams,
+                        routeType: 'page',
+                        hasMetadataExport: /title\s*=|description\s*=|astro:head|<title/.test(content),
+                        hasGenerateMetadata: false,
+                        hasSchemaMarkup: /application\/ld\+json/.test(content),
+                        hasHeadComponent: /<head|astro:head|<title/.test(content),
+                        isClientComponent: false
+                    });
+                }
+            }
+        };
+        scanDir(fullRoutesDir, '/');
+        return discovered;
+    }
+    mapRouteToSource(targetUrl, routes) {
+        let urlPath = targetUrl;
+        try {
+            if (targetUrl.startsWith('http')) {
+                urlPath = new URL(targetUrl).pathname;
+            }
+        }
+        catch {
+            urlPath = targetUrl;
+        }
+        urlPath = urlPath.replace(/\/$/, '') || '/';
+        for (const r of routes) {
+            const clean = r.routePath.replace(/\/$/, '') || '/';
+            if (clean === urlPath) {
+                return {
+                    urlPath,
+                    matchedRoute: r,
+                    sourceFilePath: r.sourceFilePath,
+                    confidence: 1.0,
+                    resolutionMethod: 'exact_match'
+                };
+            }
+        }
+        return {
+            urlPath,
+            confidence: 0.0,
+            resolutionMethod: 'unmapped'
+        };
+    }
+    async findMetadataImplementation(projectDir, route) {
+        const fullPath = path.join(projectDir, route.sourceFilePath);
+        if (!fs.existsSync(fullPath))
+            return { hasMetadata: false, type: 'none' };
+        const content = fs.readFileSync(fullPath, 'utf-8');
+        const hasMeta = /<title\b|<meta\s+name=["']description["']/i.test(content) || /title\s*:/i.test(content);
+        return {
+            hasMetadata: hasMeta,
+            type: hasMeta ? 'jsx_head' : 'none'
+        };
+    }
+    async findCanonicalDeclaration(projectDir, route) {
+        const fullPath = path.join(projectDir, route.sourceFilePath);
+        if (!fs.existsSync(fullPath))
+            return { hasCanonical: false, type: 'none' };
+        const content = fs.readFileSync(fullPath, 'utf-8');
+        const hasCanonical = /rel=["']canonical["']/i.test(content);
+        return {
+            hasCanonical,
+            type: hasCanonical ? 'link_jsx_tag' : 'none'
+        };
+    }
+    async findSchemaDeclaration(projectDir, route) {
+        const fullPath = path.join(projectDir, route.sourceFilePath);
+        if (!fs.existsSync(fullPath))
+            return { hasSchema: false, typesFound: [] };
+        const content = fs.readFileSync(fullPath, 'utf-8');
+        const hasSchema = /application\/ld\+json/i.test(content);
+        return {
+            hasSchema,
+            typesFound: hasSchema ? ['JSON-LD'] : []
+        };
+    }
+    findRobotsConfig(projectDir) {
+        const paths = ['public/robots.txt', 'robots.txt'];
+        for (const p of paths) {
+            if (fs.existsSync(path.join(projectDir, p)))
+                return p;
+        }
+        return null;
+    }
+    findSitemapConfig(projectDir) {
+        const paths = ['public/sitemap.xml', 'sitemap.xml', 'src/pages/sitemap.xml.ts'];
+        for (const p of paths) {
+            if (fs.existsSync(path.join(projectDir, p)))
+                return p;
+        }
+        return null;
+    }
+    findLlmsTxt(projectDir) {
+        const paths = ['public/llms.txt', 'llms.txt'];
+        for (const p of paths) {
+            if (fs.existsSync(path.join(projectDir, p)))
+                return p;
+        }
+        return null;
+    }
+    extractDynamicParams(routePath) {
+        const params = [];
+        const matches = routePath.match(/\[\.{0,3}([a-zA-Z0-9_-]+)\]/g);
+        if (matches) {
+            for (const m of matches) {
+                params.push(m.replace(/[\[\].]/g, ''));
+            }
+        }
+        return params;
+    }
+}

package/dist/adapters/nextAppAdapter.d.ts

@@ -0,0 +1,17 @@
+import { FrameworkAdapter, MetadataLocationInfo, CanonicalLocationInfo, SchemaLocationInfo } from './types.js';
+import { DiscoveredRoute, ProjectFrameworkInfo, RouteSourceMapping } from '../types/findings.js';
+export declare class NextAppAdapter implements FrameworkAdapter {
+    id: string;
+    name: string;
+    detect(projectDir: string): boolean;
+    getProjectInfo(projectDir: string): ProjectFrameworkInfo;
+    discoverRoutes(projectDir: string): DiscoveredRoute[];
+    mapRouteToSource(targetUrl: string, routes: DiscoveredRoute[]): RouteSourceMapping;
+    findMetadataImplementation(projectDir: string, route: DiscoveredRoute): Promise<MetadataLocationInfo>;
+    findCanonicalDeclaration(projectDir: string, route: DiscoveredRoute): Promise<CanonicalLocationInfo>;
+    findSchemaDeclaration(projectDir: string, route: DiscoveredRoute): Promise<SchemaLocationInfo>;
+    findRobotsConfig(projectDir: string): string | null;
+    findSitemapConfig(projectDir: string): string | null;
+    findLlmsTxt(projectDir: string): string | null;
+    private extractDynamicParams;
+}