seo-gravity-mcp 1.0.2 → 1.2.0

package/dist/types/seo.d.ts

@@ -366,4 +366,28 @@ export interface ContentDecayReport {
     brokenOutboundLinks: string[];
     suggestedUpdateChecklist: string[];
 }
+export interface PageSpeedAuditReport {
+    url: string;
+    strategy: string;
+    performanceScore: number;
+    coreWebVitals: {
+        lcp: {
+            value: string;
+            status: 'Good' | 'Needs Improvement' | 'Poor';
+        };
+        fcp: {
+            value: string;
+            status: 'Good' | 'Needs Improvement' | 'Poor';
+        };
+        cls: {
+            value: string;
+            status: 'Good' | 'Needs Improvement' | 'Poor';
+        };
+        ttfb: {
+            value: string;
+            status: 'Good' | 'Needs Improvement' | 'Poor';
+        };
+    };
+    topSpeedFixes: string[];
+}
 export * from './findings.js';

package/dist/utils/astLocator.d.ts

@@ -0,0 +1,14 @@
+import { ASTSourceRange } from '../types/findings.js';
+export interface ASTMetadataInspection {
+    hasMetadataExport: boolean;
+    hasGenerateMetadata: boolean;
+    hasCanonicalDeclaration: boolean;
+    hasSchemaMarkup: boolean;
+    metadataRange?: ASTSourceRange;
+    canonicalRange?: ASTSourceRange;
+    schemaRange?: ASTSourceRange;
+    extractedTitle?: string;
+    extractedDescription?: string;
+    extractedCanonical?: string;
+}
+export declare function inspectSourceFileAST(filePath: string): ASTMetadataInspection;

package/dist/utils/astLocator.js

@@ -0,0 +1,137 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import ts from 'typescript';
+export function inspectSourceFileAST(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {
+            hasMetadataExport: false,
+            hasGenerateMetadata: false,
+            hasCanonicalDeclaration: false,
+            hasSchemaMarkup: false
+        };
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const sourceFile = ts.createSourceFile(path.basename(filePath), content, ts.ScriptTarget.Latest, true, filePath.endsWith('.tsx') || filePath.endsWith('.jsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    let hasMetadataExport = false;
+    let hasGenerateMetadata = false;
+    let hasCanonicalDeclaration = false;
+    let hasSchemaMarkup = false;
+    let metadataRange;
+    let canonicalRange;
+    let schemaRange;
+    let extractedTitle;
+    let extractedDescription;
+    let extractedCanonical;
+    const getRange = (node, exportName) => {
+        const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+        return {
+            filePath,
+            startLine: start.line + 1,
+            endLine: end.line + 1,
+            startColumn: start.character + 1,
+            endColumn: end.character + 1,
+            astNodeType: ts.SyntaxKind[node.kind],
+            exportName,
+            snippet: node.getText(sourceFile).slice(0, 300)
+        };
+    };
+    const visit = (node) => {
+        // 1. Check for `export const metadata = { ... }`
+        if (ts.isVariableStatement(node)) {
+            const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+            if (isExported) {
+                for (const decl of node.declarationList.declarations) {
+                    if (ts.isIdentifier(decl.name) && decl.name.text === 'metadata') {
+                        hasMetadataExport = true;
+                        metadataRange = getRange(node, 'metadata');
+                        if (decl.initializer && ts.isObjectLiteralExpression(decl.initializer)) {
+                            for (const prop of decl.initializer.properties) {
+                                if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                                    if (prop.name.text === 'title') {
+                                        extractedTitle = prop.initializer.getText(sourceFile).replace(/['"]/g, '');
+                                    }
+                                    if (prop.name.text === 'description') {
+                                        extractedDescription = prop.initializer.getText(sourceFile).replace(/['"]/g, '');
+                                    }
+                                    if (prop.name.text === 'alternates' && ts.isObjectLiteralExpression(prop.initializer)) {
+                                        hasCanonicalDeclaration = true;
+                                        canonicalRange = getRange(prop, 'alternates.canonical');
+                                        for (const altProp of prop.initializer.properties) {
+                                            if (ts.isPropertyAssignment(altProp) && ts.isIdentifier(altProp.name) && altProp.name.text === 'canonical') {
+                                                extractedCanonical = altProp.initializer.getText(sourceFile).replace(/['"]/g, '');
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // 2. Check for `export async function generateMetadata(...)` or `export function generateMetadata(...)`
+        if (ts.isFunctionDeclaration(node) && node.name && node.name.text === 'generateMetadata') {
+            const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+            if (isExported) {
+                hasGenerateMetadata = true;
+                metadataRange = getRange(node, 'generateMetadata');
+            }
+        }
+        // 3. Check for JSX <link rel="canonical" href="..." />
+        if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node)) {
+            const tagName = node.tagName.getText(sourceFile);
+            if (tagName === 'link') {
+                const text = node.getText(sourceFile);
+                if (text.includes('rel="canonical"') || text.includes("rel='canonical'")) {
+                    hasCanonicalDeclaration = true;
+                    canonicalRange = getRange(node, 'link:canonical');
+                    const hrefMatch = text.match(/href=["']([^"']+)["']/);
+                    if (hrefMatch)
+                        extractedCanonical = hrefMatch[1];
+                }
+            }
+            // Check for <script type="application/ld+json">
+            if (tagName === 'script') {
+                const text = node.getText(sourceFile);
+                if (text.includes('application/ld+json')) {
+                    hasSchemaMarkup = true;
+                    schemaRange = getRange(node, 'schema:jsonld');
+                }
+            }
+        }
+        // Fallback search for string literal indicators
+        if (ts.isStringLiteral(node) && node.text.includes('application/ld+json')) {
+            hasSchemaMarkup = true;
+            if (!schemaRange)
+                schemaRange = getRange(node, 'schema:jsonld');
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    // Fallback regex detection if AST node missed subtle structures
+    if (!hasMetadataExport && /export\s+const\s+metadata\b/.test(content)) {
+        hasMetadataExport = true;
+    }
+    if (!hasGenerateMetadata && /export\s+(async\s+)?function\s+generateMetadata\b/.test(content)) {
+        hasGenerateMetadata = true;
+    }
+    if (!hasCanonicalDeclaration && /canonical/.test(content)) {
+        hasCanonicalDeclaration = true;
+    }
+    if (!hasSchemaMarkup && /application\/ld\+json/.test(content)) {
+        hasSchemaMarkup = true;
+    }
+    return {
+        hasMetadataExport,
+        hasGenerateMetadata,
+        hasCanonicalDeclaration,
+        hasSchemaMarkup,
+        metadataRange,
+        canonicalRange,
+        schemaRange,
+        extractedTitle,
+        extractedDescription,
+        extractedCanonical
+    };
+}

package/dist/utils/cacheManager.d.ts

@@ -0,0 +1,29 @@
+export interface CacheEntry<T> {
+    value: T;
+    cachedAt: string;
+    expiresAt: number;
+    provider: string;
+    hash: string;
+}
+export interface CacheMetadata {
+    isCached: boolean;
+    cachedAt: string;
+    ageMs: number;
+    ttlMs: number;
+    provider: string;
+    key: string;
+}
+export declare class CacheManager {
+    private cache;
+    computeKey(namespace: string, input: any): string;
+    get<T>(key: string): T | null;
+    getWithMetadata<T>(key: string): {
+        value: T;
+        metadata: CacheMetadata;
+    } | null;
+    set<T>(key: string, value: T, ttlMs?: number, provider?: string): void;
+    has(key: string): boolean;
+    clear(): void;
+    size(): number;
+}
+export declare const defaultCacheManager: CacheManager;

package/dist/utils/cacheManager.js

@@ -0,0 +1,60 @@
+import * as crypto from 'crypto';
+export class CacheManager {
+    cache = new Map();
+    computeKey(namespace, input) {
+        const serialized = typeof input === 'string' ? input : JSON.stringify(input);
+        const hash = crypto.createHash('sha256').update(serialized).digest('hex').substring(0, 16);
+        return `${namespace}:${hash}`;
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return null;
+        }
+        return entry.value;
+    }
+    getWithMetadata(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        const now = Date.now();
+        if (now > entry.expiresAt) {
+            this.cache.delete(key);
+            return null;
+        }
+        return {
+            value: entry.value,
+            metadata: {
+                isCached: true,
+                cachedAt: entry.cachedAt,
+                ageMs: now - new Date(entry.cachedAt).getTime(),
+                ttlMs: entry.expiresAt - now,
+                provider: entry.provider,
+                key
+            }
+        };
+    }
+    set(key, value, ttlMs = 300000, provider = 'internal') {
+        const hash = crypto.createHash('md5').update(JSON.stringify(value)).digest('hex');
+        this.cache.set(key, {
+            value,
+            cachedAt: new Date().toISOString(),
+            expiresAt: Date.now() + ttlMs,
+            provider,
+            hash
+        });
+    }
+    has(key) {
+        return this.get(key) !== null;
+    }
+    clear() {
+        this.cache.clear();
+    }
+    size() {
+        return this.cache.size;
+    }
+}
+export const defaultCacheManager = new CacheManager();

package/dist/utils/experimentEngine.d.ts

@@ -0,0 +1,26 @@
+export interface SEOExperiment {
+    id: string;
+    createdAt: string;
+    hypothesis: string;
+    targetRoute: string;
+    baselineHealthScore: number;
+    baselineFindingsCount: number;
+    proposedChange: string;
+    verificationCriteria: {
+        targetMetric: string;
+        expectedOutcome: string;
+    };
+    status: 'DRAFT' | 'IN_PROGRESS' | 'VERIFIED_SUCCESS' | 'VERIFIED_FAILURE';
+}
+export interface ExperimentVerificationResult {
+    schemaVersion: 'seo.gravity/v1';
+    experimentId: string;
+    status: 'VERIFIED_SUCCESS' | 'VERIFIED_FAILURE';
+    baselineScore: number;
+    currentScore: number;
+    scoreDelta: number;
+    findingsResolvedCount: number;
+    summary: string;
+}
+export declare function planExperiment(projectPath: string, targetRoute: string, hypothesis: string, proposedChange: string): Promise<SEOExperiment>;
+export declare function verifyExperiment(projectPath: string, experiment: SEOExperiment): Promise<ExperimentVerificationResult>;

package/dist/utils/experimentEngine.js

@@ -0,0 +1,41 @@
+import { createProjectSnapshot } from './snapshotEngine.js';
+import * as path from 'path';
+export async function planExperiment(projectPath, targetRoute, hypothesis, proposedChange) {
+    const resolved = path.resolve(projectPath);
+    const baseline = await createProjectSnapshot(resolved);
+    const routeFindings = baseline.findings.filter(f => f.affectedUrl === targetRoute);
+    return {
+        id: `exp_${Date.now()}`,
+        createdAt: new Date().toISOString(),
+        hypothesis,
+        targetRoute,
+        baselineHealthScore: baseline.scores.overallHealth,
+        baselineFindingsCount: routeFindings.length,
+        proposedChange,
+        verificationCriteria: {
+            targetMetric: 'Route SEO Health & Defect Resolution',
+            expectedOutcome: 'Zero regressions and defect resolved.'
+        },
+        status: 'DRAFT'
+    };
+}
+export async function verifyExperiment(projectPath, experiment) {
+    const resolved = path.resolve(projectPath);
+    const current = await createProjectSnapshot(resolved);
+    const scoreDelta = current.scores.overallHealth - experiment.baselineHealthScore;
+    const currentRouteFindings = current.findings.filter(f => f.affectedUrl === experiment.targetRoute);
+    const resolvedCount = Math.max(0, experiment.baselineFindingsCount - currentRouteFindings.length);
+    const success = scoreDelta >= 0 && resolvedCount > 0;
+    return {
+        schemaVersion: 'seo.gravity/v1',
+        experimentId: experiment.id,
+        status: success ? 'VERIFIED_SUCCESS' : 'VERIFIED_FAILURE',
+        baselineScore: experiment.baselineHealthScore,
+        currentScore: current.scores.overallHealth,
+        scoreDelta,
+        findingsResolvedCount: resolvedCount,
+        summary: success
+            ? `✅ Experiment succeeded: ${resolvedCount} issue(s) resolved, score improved by +${scoreDelta} points.`
+            : `❌ Experiment did not satisfy criteria: score delta is ${scoreDelta}, ${currentRouteFindings.length} issue(s) remain on '${experiment.targetRoute}'.`
+    };
+}

package/dist/utils/findingEngine.d.ts

@@ -1,4 +1,4 @@
-import { Finding, FindingCategory, SeverityLevel, EvidenceType, EffortLevel, PriorityTier, ReliabilityState, SourceLocation, SuggestedFix, MultiDimensionalScores, SupportedFramework } from '../types/findings.js';
+import { Finding, FindingCategory, SeverityLevel, EvidenceType, EffortLevel, PriorityTier, ReliabilityState, SourceLocation, SuggestedFix, MultiDimensionalScores, SupportedFramework, ASTSourceRange } from '../types/findings.js';
 export interface CreateFindingParams {
     id: string;
     category: FindingCategory;
@@ -9,6 +9,7 @@ export interface CreateFindingParams {
     evidence: string;
     affectedUrl: string;
     sourceLocation?: SourceLocation;
+    sourceRange?: ASTSourceRange;
     likelyRootCause?: string;
     recommendation: string;
     suggestedFix?: SuggestedFix;

package/dist/utils/findingEngine.js

@@ -61,6 +61,7 @@ export function createFinding(params) {
         evidence: params.evidence,
         affectedUrl: params.affectedUrl,
         sourceLocation: params.sourceLocation,
+        sourceRange: params.sourceRange,
         likelyRootCause: params.likelyRootCause,
         recommendation: params.recommendation,
         suggestedFix: params.suggestedFix,

package/dist/utils/gitDiffEngine.d.ts

@@ -0,0 +1,28 @@
+import { DiscoveredRoute, Finding } from '../types/findings.js';
+export interface SemanticChangeCategory {
+    affectsMetadata: boolean;
+    affectsCanonical: boolean;
+    affectsSchema: boolean;
+    affectsLinks: boolean;
+    affectsRobotsOrSitemap: boolean;
+}
+export interface DifferentialAuditResult {
+    schemaVersion: 'seo.gravity/v1';
+    projectPath: string;
+    baseRef: string;
+    headRef: string;
+    changedFiles: string[];
+    affectedRoutes: DiscoveredRoute[];
+    unaffectedRoutesCount: number;
+    semanticImpacts: Record<string, SemanticChangeCategory>;
+    targetedFindings: Finding[];
+    regressionDetected: boolean;
+    summary: string;
+}
+export declare function getChangedFilesSince(projectDir: string, baseRef?: string): string[];
+export declare function analyzeSemanticFileChange(filePath: string, projectDir: string): SemanticChangeCategory;
+export declare function mapChangedFilesToRoutes(changedFiles: string[], routes: DiscoveredRoute[]): {
+    affected: DiscoveredRoute[];
+    unaffected: DiscoveredRoute[];
+};
+export declare function runDifferentialAudit(projectDir: string, baseRef?: string, baseUrl?: string): Promise<DifferentialAuditResult>;

package/dist/utils/gitDiffEngine.js

@@ -0,0 +1,109 @@
+import { execSync } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+import { getProjectAdapter } from './projectScanner.js';
+import { createProjectSnapshot } from './snapshotEngine.js';
+import { inspectSourceFileAST } from './astLocator.js';
+export function getChangedFilesSince(projectDir, baseRef = 'HEAD~1') {
+    try {
+        const output = execSync(`git diff --name-only ${baseRef}`, {
+            cwd: projectDir,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore']
+        });
+        return output.split('\n').map(l => l.trim().replace(/\\/g, '/')).filter(Boolean);
+    }
+    catch {
+        try {
+            const status = execSync('git status --porcelain', {
+                cwd: projectDir,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore']
+            });
+            return status
+                .split('\n')
+                .map(l => l.slice(3).trim().replace(/\\/g, '/'))
+                .filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+export function analyzeSemanticFileChange(filePath, projectDir) {
+    const fullPath = path.join(projectDir, filePath);
+    if (!fs.existsSync(fullPath)) {
+        return {
+            affectsMetadata: true,
+            affectsCanonical: true,
+            affectsSchema: true,
+            affectsLinks: true,
+            affectsRobotsOrSitemap: true
+        };
+    }
+    const base = path.basename(filePath).toLowerCase();
+    if (base.includes('sitemap') || base.includes('robots') || base.includes('llms')) {
+        return {
+            affectsMetadata: false,
+            affectsCanonical: false,
+            affectsSchema: false,
+            affectsLinks: false,
+            affectsRobotsOrSitemap: true
+        };
+    }
+    const ast = inspectSourceFileAST(fullPath);
+    const content = fs.readFileSync(fullPath, 'utf-8');
+    return {
+        affectsMetadata: ast.hasMetadataExport || ast.hasGenerateMetadata || /<title\b|<meta\s+name/i.test(content),
+        affectsCanonical: ast.hasCanonicalDeclaration || /rel=["']canonical["']/i.test(content),
+        affectsSchema: ast.hasSchemaMarkup || /application\/ld\+json/i.test(content),
+        affectsLinks: /<Link\b|<a\b|href=/i.test(content),
+        affectsRobotsOrSitemap: false
+    };
+}
+export function mapChangedFilesToRoutes(changedFiles, routes) {
+    const affected = [];
+    const unaffected = [];
+    const isGlobalFile = changedFiles.some(f => f.includes('layout.') ||
+        f.includes('sitemap.') ||
+        f.includes('robots.') ||
+        f.includes('package.json') ||
+        f.includes('next.config') ||
+        f.includes('astro.config'));
+    for (const r of routes) {
+        if (isGlobalFile || changedFiles.some(f => r.sourceFilePath.includes(f) || f.includes(r.sourceFilePath))) {
+            affected.push(r);
+        }
+        else {
+            unaffected.push(r);
+        }
+    }
+    return { affected, unaffected };
+}
+export async function runDifferentialAudit(projectDir, baseRef = 'HEAD~1', baseUrl) {
+    const resolved = path.resolve(projectDir);
+    const adapter = getProjectAdapter(resolved);
+    const routes = adapter.discoverRoutes(resolved);
+    const changedFiles = getChangedFilesSince(resolved, baseRef);
+    const { affected, unaffected } = mapChangedFilesToRoutes(changedFiles, routes);
+    const semanticImpacts = {};
+    for (const file of changedFiles) {
+        semanticImpacts[file] = analyzeSemanticFileChange(file, resolved);
+    }
+    const snapshot = await createProjectSnapshot(resolved, { baseUrl });
+    const targetedFindings = snapshot.findings.filter(f => affected.some(r => r.routePath === f.affectedUrl || f.sourceLocation?.filePath === r.sourceFilePath));
+    const hasCritical = targetedFindings.some(f => f.severity === 'critical' || f.severity === 'high');
+    return {
+        schemaVersion: 'seo.gravity/v1',
+        projectPath: resolved,
+        baseRef,
+        headRef: snapshot.gitMetadata?.shortHash || 'HEAD',
+        changedFiles,
+        affectedRoutes: affected,
+        unaffectedRoutesCount: unaffected.length,
+        semanticImpacts,
+        targetedFindings,
+        regressionDetected: hasCritical,
+        summary: `Differential audit completed: ${changedFiles.length} file(s) changed, ${affected.length} route(s) affected, ${targetedFindings.length} targeted finding(s) detected.`
+    };
+}

package/dist/utils/opportunityEngine.d.ts

@@ -0,0 +1,19 @@
+export interface SEOpportunity {
+    id: string;
+    category: 'content_expansion' | 'entity_coverage' | 'schema_enhancement' | 'internal_link_hub';
+    title: string;
+    targetQueryOrTopic: string;
+    rationale: string;
+    recommendedRoutePath: string;
+    estimatedReach: 'high' | 'medium' | 'low';
+    effort: 'low' | 'medium' | 'high';
+    competitorEvidence?: string[];
+}
+export interface OpportunityReport {
+    schemaVersion: 'seo.gravity/v1';
+    projectPath: string;
+    totalOpportunitiesFound: number;
+    opportunities: SEOpportunity[];
+    summary: string;
+}
+export declare function detectOpportunities(projectPath: string, focusKeywords?: string[]): Promise<OpportunityReport>;

package/dist/utils/opportunityEngine.js

@@ -0,0 +1,61 @@
+import { getProjectAdapter } from './projectScanner.js';
+import * as path from 'path';
+export async function detectOpportunities(projectPath, focusKeywords = []) {
+    const resolved = path.resolve(projectPath);
+    const adapter = getProjectAdapter(resolved);
+    const routes = adapter.discoverRoutes(resolved);
+    const opportunities = [];
+    const routePaths = routes.map(r => r.routePath);
+    // 1. Check for core programmatic SEO / comparison hubs
+    const hasDocs = routePaths.some(p => p.includes('doc') || p.includes('guide'));
+    const hasBlog = routePaths.some(p => p.includes('blog') || p.includes('post'));
+    const hasFaq = routePaths.some(p => p.includes('faq'));
+    if (!hasFaq) {
+        opportunities.push({
+            id: 'OPP-FAQ-001',
+            category: 'content_expansion',
+            title: 'Create Dedicated FAQ & Answer Hub',
+            targetQueryOrTopic: 'Frequently Asked Questions & Product Specs',
+            rationale: 'Sites with dedicated FAQ sections qualify for FAQPage rich snippets and capture high-intent long-tail search.',
+            recommendedRoutePath: '/faq',
+            estimatedReach: 'high',
+            effort: 'low'
+        });
+    }
+    if (!hasBlog && !hasDocs) {
+        opportunities.push({
+            id: 'OPP-CONTENT-001',
+            category: 'content_expansion',
+            title: 'Establish Top-of-Funnel Educational Hub (/blog or /docs)',
+            targetQueryOrTopic: 'Industry Guides & Use-Case Articles',
+            rationale: 'Adding educational subtopics increases domain topical authority and internal linking equity.',
+            recommendedRoutePath: '/blog',
+            estimatedReach: 'high',
+            effort: 'medium'
+        });
+    }
+    // 2. Keyword-driven route opportunities
+    for (const kw of focusKeywords) {
+        const slug = kw.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+        const isCovered = routePaths.some(r => r.includes(slug));
+        if (!isCovered) {
+            opportunities.push({
+                id: `OPP-KW-${slug.slice(0, 10).toUpperCase()}`,
+                category: 'content_expansion',
+                title: `Create Target Landing Page for "${kw}"`,
+                targetQueryOrTopic: kw,
+                rationale: `Target keyword "${kw}" has search intent but lacks a matching dedicated route on the site.`,
+                recommendedRoutePath: `/${slug}`,
+                estimatedReach: 'medium',
+                effort: 'low'
+            });
+        }
+    }
+    return {
+        schemaVersion: 'seo.gravity/v1',
+        projectPath: resolved,
+        totalOpportunitiesFound: opportunities.length,
+        opportunities,
+        summary: `Identified ${opportunities.length} strategic expansion opportunities to improve topical authority and organic reach.`
+    };
+}

package/dist/utils/projectScanner.d.ts

@@ -1,4 +1,6 @@
 import { ProjectFrameworkInfo, DiscoveredRoute, RouteSourceMapping } from '../types/findings.js';
+import { FrameworkAdapter } from '../adapters/types.js';
+export declare function getProjectAdapter(projectDir: string): FrameworkAdapter;
 export declare function detectFramework(projectDir: string): ProjectFrameworkInfo;
-export declare function discoverRoutes(projectDir: string, frameworkInfo?: ProjectFrameworkInfo): DiscoveredRoute[];
-export declare function mapUrlToRouteSource(targetUrl: string, discoveredRoutes: DiscoveredRoute[]): RouteSourceMapping;
+export declare function discoverRoutes(projectDir: string, _frameworkInfo?: ProjectFrameworkInfo): DiscoveredRoute[];
+export declare function mapUrlToRouteSource(targetUrl: string, discoveredRoutes: DiscoveredRoute[], projectDir?: string): RouteSourceMapping;