seo-gravity-mcp 1.0.2 → 1.2.0

package/dist/adapters/nextAppAdapter.js

@@ -0,0 +1,265 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { inspectSourceFileAST } from '../utils/astLocator.js';
+export class NextAppAdapter {
+    id = 'nextjs-app-router';
+    name = 'Next.js App Router';
+    detect(projectDir) {
+        const hasPkg = fs.existsSync(path.join(projectDir, 'package.json'));
+        if (!hasPkg)
+            return false;
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, 'package.json'), 'utf-8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (!deps['next'])
+                return false;
+            return ((fs.existsSync(path.join(projectDir, 'app')) && fs.statSync(path.join(projectDir, 'app')).isDirectory()) ||
+                (fs.existsSync(path.join(projectDir, 'src/app')) && fs.statSync(path.join(projectDir, 'src/app')).isDirectory()));
+        }
+        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 hasSrcApp = fs.existsSync(path.join(projectDir, 'src/app'));
+        const routesDir = hasSrcApp ? 'src/app' : 'app';
+        return {
+            framework: 'nextjs-app-router',
+            name: pkg.name || path.basename(projectDir),
+            version: pkg.dependencies?.next || pkg.devDependencies?.next,
+            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: 3000
+        };
+    }
+    discoverRoutes(projectDir) {
+        const info = this.getProjectInfo(projectDir);
+        const fullRoutesDir = path.join(projectDir, info.routesDir || 'app');
+        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 segment = entry.name.startsWith('(') && entry.name.endsWith(')') ? '' : entry.name;
+                    const nextPrefix = segment ? (routePrefix === '/' ? `/${segment}` : `${routePrefix}/${segment}`) : routePrefix;
+                    scanDir(entryPath, nextPrefix);
+                }
+                else if (entry.isFile()) {
+                    if (/^page\.(tsx|jsx|js|ts)$/.test(entry.name)) {
+                        const relFile = path.relative(projectDir, entryPath).replace(/\\/g, '/');
+                        const routePath = routePrefix === '' ? '/' : routePrefix;
+                        const dynamicParams = this.extractDynamicParams(routePath);
+                        const astInfo = inspectSourceFileAST(entryPath);
+                        discovered.push({
+                            routePath,
+                            sourceFilePath: relFile,
+                            isDynamic: dynamicParams.length > 0,
+                            dynamicParams,
+                            routeType: 'page',
+                            hasMetadataExport: astInfo.hasMetadataExport,
+                            hasGenerateMetadata: astInfo.hasGenerateMetadata,
+                            hasSchemaMarkup: astInfo.hasSchemaMarkup,
+                            hasHeadComponent: false,
+                            isClientComponent: /['"]use client['"]/.test(fs.readFileSync(entryPath, 'utf-8')),
+                            astSourceRange: astInfo.metadataRange
+                        });
+                    }
+                    else if (/^sitemap\.(ts|js|xml)$/.test(entry.name)) {
+                        const relFile = path.relative(projectDir, entryPath).replace(/\\/g, '/');
+                        discovered.push({
+                            routePath: '/sitemap.xml',
+                            sourceFilePath: relFile,
+                            isDynamic: false,
+                            dynamicParams: [],
+                            routeType: 'sitemap',
+                            hasMetadataExport: false,
+                            hasGenerateMetadata: false,
+                            hasSchemaMarkup: false,
+                            hasHeadComponent: false,
+                            isClientComponent: false
+                        });
+                    }
+                    else if (/^robots\.(ts|js|txt)$/.test(entry.name)) {
+                        const relFile = path.relative(projectDir, entryPath).replace(/\\/g, '/');
+                        discovered.push({
+                            routePath: '/robots.txt',
+                            sourceFilePath: relFile,
+                            isDynamic: false,
+                            dynamicParams: [],
+                            routeType: 'robots',
+                            hasMetadataExport: false,
+                            hasGenerateMetadata: false,
+                            hasSchemaMarkup: false,
+                            hasHeadComponent: false,
+                            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,
+                    sourceRange: r.astSourceRange,
+                    confidence: 1.0,
+                    resolutionMethod: 'exact_match'
+                };
+            }
+        }
+        for (const r of routes) {
+            if (!r.isDynamic)
+                continue;
+            const regexStr = '^' + r.routePath
+                .replace(/\[\.\.\.([a-zA-Z0-9_-]+)\]/g, '.*')
+                .replace(/\[([a-zA-Z0-9_-]+)\]/g, '[^/]+') + '$';
+            try {
+                if (new RegExp(regexStr).test(urlPath)) {
+                    return {
+                        urlPath,
+                        matchedRoute: r,
+                        sourceFilePath: r.sourceFilePath,
+                        sourceRange: r.astSourceRange,
+                        confidence: 0.95,
+                        resolutionMethod: 'pattern_match'
+                    };
+                }
+            }
+            catch { }
+        }
+        return {
+            urlPath,
+            confidence: 0.0,
+            resolutionMethod: 'unmapped'
+        };
+    }
+    async findMetadataImplementation(projectDir, route) {
+        const fullPath = path.join(projectDir, route.sourceFilePath);
+        const ast = inspectSourceFileAST(fullPath);
+        if (ast.hasMetadataExport) {
+            return {
+                hasMetadata: true,
+                type: 'static_export',
+                sourceRange: ast.metadataRange,
+                titleSnippet: ast.extractedTitle,
+                descriptionSnippet: ast.extractedDescription
+            };
+        }
+        if (ast.hasGenerateMetadata) {
+            return {
+                hasMetadata: true,
+                type: 'dynamic_function',
+                sourceRange: ast.metadataRange
+            };
+        }
+        return { hasMetadata: false, type: 'none' };
+    }
+    async findCanonicalDeclaration(projectDir, route) {
+        const fullPath = path.join(projectDir, route.sourceFilePath);
+        const ast = inspectSourceFileAST(fullPath);
+        if (ast.hasCanonicalDeclaration) {
+            return {
+                hasCanonical: true,
+                type: 'metadata_property',
+                canonicalUrl: ast.extractedCanonical,
+                sourceRange: ast.canonicalRange
+            };
+        }
+        return { hasCanonical: false, type: 'none' };
+    }
+    async findSchemaDeclaration(projectDir, route) {
+        const fullPath = path.join(projectDir, route.sourceFilePath);
+        const ast = inspectSourceFileAST(fullPath);
+        return {
+            hasSchema: ast.hasSchemaMarkup,
+            typesFound: ast.hasSchemaMarkup ? ['JSON-LD'] : [],
+            sourceRange: ast.schemaRange
+        };
+    }
+    findRobotsConfig(projectDir) {
+        const paths = [
+            'app/robots.ts',
+            'app/robots.js',
+            'src/app/robots.ts',
+            'src/app/robots.js',
+            '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 = [
+            'app/sitemap.ts',
+            'app/sitemap.js',
+            'src/app/sitemap.ts',
+            'src/app/sitemap.js',
+            'public/sitemap.xml',
+            'sitemap.xml'
+        ];
+        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', 'public/llms-full.txt', 'llms-full.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/nextPagesAdapter.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 NextPagesAdapter 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/nextPagesAdapter.js

@@ -0,0 +1,209 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export class NextPagesAdapter {
+    id = 'nextjs-pages-router';
+    name = 'Next.js Pages Router';
+    detect(projectDir) {
+        const hasPkg = fs.existsSync(path.join(projectDir, 'package.json'));
+        if (!hasPkg)
+            return false;
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, 'package.json'), 'utf-8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (!deps['next'])
+                return false;
+            const hasPages = fs.existsSync(path.join(projectDir, 'pages')) || fs.existsSync(path.join(projectDir, 'src/pages'));
+            const hasApp = fs.existsSync(path.join(projectDir, 'app')) || fs.existsSync(path.join(projectDir, 'src/app'));
+            return hasPages && !hasApp;
+        }
+        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: 'nextjs-pages-router',
+            name: pkg.name || path.basename(projectDir),
+            version: pkg.dependencies?.next || pkg.devDependencies?.next,
+            packageManager: '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: 3000
+        };
+    }
+    discoverRoutes(projectDir) {
+        const info = this.getProjectInfo(projectDir);
+        const fullRoutesDir = path.join(projectDir, info.routesDir || '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()) {
+                    if (entry.name === 'api')
+                        continue;
+                    const nextPrefix = routePrefix === '/' ? `/${entry.name}` : `${routePrefix}/${entry.name}`;
+                    scanDir(entryPath, nextPrefix);
+                }
+                else if (entry.isFile() && /\.(tsx|jsx|js|ts)$/.test(entry.name)) {
+                    if (entry.name.startsWith('_'))
+                        continue;
+                    const baseName = entry.name.replace(/\.(tsx|jsx|js|ts)$/, '');
+                    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: /<Head\b|<title\b|<NextSeo\b/i.test(content),
+                        hasGenerateMetadata: false,
+                        hasSchemaMarkup: /application\/ld\+json/.test(content),
+                        hasHeadComponent: /<Head\b|<NextSeo\b/i.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'
+                };
+            }
+        }
+        for (const r of routes) {
+            if (!r.isDynamic)
+                continue;
+            const regexStr = '^' + r.routePath
+                .replace(/\[\.\.\.([a-zA-Z0-9_-]+)\]/g, '.*')
+                .replace(/\[([a-zA-Z0-9_-]+)\]/g, '[^/]+') + '$';
+            try {
+                if (new RegExp(regexStr).test(urlPath)) {
+                    return {
+                        urlPath,
+                        matchedRoute: r,
+                        sourceFilePath: r.sourceFilePath,
+                        confidence: 0.95,
+                        resolutionMethod: 'pattern_match'
+                    };
+                }
+            }
+            catch { }
+        }
+        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 hasHead = /<Head\b|<NextSeo\b|<title\b/i.test(content);
+        return {
+            hasMetadata: hasHead,
+            type: hasHead ? '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');
+        return {
+            hasCanonical: /rel=["']canonical["']/i.test(content),
+            type: /rel=["']canonical["']/i.test(content) ? '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');
+        return {
+            hasSchema: /application\/ld\+json/i.test(content),
+            typesFound: /application\/ld\+json/i.test(content) ? ['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'];
+        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/remixAdapter.d.ts

@@ -0,0 +1,16 @@
+import { FrameworkAdapter, MetadataLocationInfo, CanonicalLocationInfo, SchemaLocationInfo } from './types.js';
+import { DiscoveredRoute, ProjectFrameworkInfo, RouteSourceMapping } from '../types/findings.js';
+export declare class RemixAdapter 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;
+}

package/dist/adapters/remixAdapter.js

@@ -0,0 +1,118 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export class RemixAdapter {
+    id = 'remix';
+    name = 'Remix Framework';
+    detect(projectDir) {
+        const pkgPath = path.join(projectDir, 'package.json');
+        if (!fs.existsSync(pkgPath))
+            return false;
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            return Boolean(deps['@remix-run/react'] || deps['@remix-run/node']);
+        }
+        catch {
+            return false;
+        }
+    }
+    getProjectInfo(projectDir) {
+        return {
+            framework: 'remix',
+            name: path.basename(projectDir),
+            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: 'app/routes',
+            devCommand: 'npm run dev',
+            defaultDevPort: 3000
+        };
+    }
+    discoverRoutes(projectDir) {
+        const routesDir = path.join(projectDir, 'app/routes');
+        const discovered = [];
+        if (!fs.existsSync(routesDir))
+            return discovered;
+        const entries = fs.readdirSync(routesDir);
+        for (const file of entries) {
+            if (!/\.(tsx|jsx|js|ts)$/.test(file))
+                continue;
+            const base = file.replace(/\.(tsx|jsx|js|ts)$/, '');
+            const rel = path.join('app/routes', file).replace(/\\/g, '/');
+            const content = fs.readFileSync(path.join(routesDir, file), 'utf-8');
+            let routePath = '/' + base.replace(/\._index$/, '').replace(/\./g, '/').replace(/_index$/, '');
+            if (routePath === '//' || routePath === '')
+                routePath = '/';
+            discovered.push({
+                routePath,
+                sourceFilePath: rel,
+                isDynamic: routePath.includes('$') || routePath.includes(':'),
+                dynamicParams: (routePath.match(/\$([a-zA-Z0-9_-]+)/g) || []).map(p => p.slice(1)),
+                routeType: 'page',
+                hasMetadataExport: /export\s+const\s+meta\b|export\s+function\s+meta\b/.test(content),
+                hasGenerateMetadata: false,
+                hasSchemaMarkup: /application\/ld\+json/.test(content),
+                hasHeadComponent: false,
+                isClientComponent: false
+            });
+        }
+        return discovered;
+    }
+    mapRouteToSource(targetUrl, routes) {
+        let urlPath = targetUrl.startsWith('http') ? new URL(targetUrl).pathname : targetUrl;
+        urlPath = urlPath.replace(/\/$/, '') || '/';
+        const match = routes.find(r => r.routePath === urlPath);
+        return {
+            urlPath,
+            matchedRoute: match,
+            sourceFilePath: match?.sourceFilePath,
+            confidence: match ? 1.0 : 0.0,
+            resolutionMethod: match ? 'exact_match' : '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 = /export\s+(const|function)\s+meta\b/.test(content);
+        return { hasMetadata: hasMeta, type: hasMeta ? 'static_export' : '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');
+        return { hasCanonical: /canonical/.test(content), type: 'metadata_property' };
+    }
+    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');
+        return { hasSchema: /application\/ld\+json/.test(content), typesFound: ['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'];
+        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;
+    }
+}

package/dist/adapters/staticAdapter.d.ts

@@ -0,0 +1,16 @@
+import { FrameworkAdapter, MetadataLocationInfo, CanonicalLocationInfo, SchemaLocationInfo } from './types.js';
+import { DiscoveredRoute, ProjectFrameworkInfo, RouteSourceMapping } from '../types/findings.js';
+export declare class StaticAdapter 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;
+}