@qobi/seocode 0.1.0

package/dist/src/parsers/frameworks/remix.js

@@ -0,0 +1,130 @@
+import * as t from '@babel/types';
+import { astToValue } from './ast-value.js';
+import { LAYOUT_SHELL_SUPPRESS, HEAD_GOVERNED_ABSENCE_RULES } from './roles.js';
+/**
+ * Remix / React Router adapter. Metadata comes from an exported `meta` function
+ * that returns an array of descriptor objects:
+ *
+ *   export const meta: MetaFunction = () => [
+ *     { title: "…" },
+ *     { name: "description", content: "…" },
+ *     { property: "og:title", content: "…" },
+ *   ];
+ */
+function programBody(ast) {
+    return ast?.program?.body ?? [];
+}
+function importsRemix(ast) {
+    return programBody(ast).some(stmt => t.isImportDeclaration(stmt) && /^(@remix-run\/|react-router)/.test(stmt.source.value));
+}
+function findExportedFn(ast, name) {
+    for (const stmt of programBody(ast)) {
+        if (!t.isExportNamedDeclaration(stmt) || !stmt.declaration)
+            continue;
+        const d = stmt.declaration;
+        if (t.isFunctionDeclaration(d) && d.id?.name === name)
+            return d;
+        if (t.isVariableDeclaration(d)) {
+            for (const decl of d.declarations) {
+                if (t.isIdentifier(decl.id) && decl.id.name === name && decl.init &&
+                    (t.isArrowFunctionExpression(decl.init) || t.isFunctionExpression(decl.init))) {
+                    return decl.init;
+                }
+            }
+        }
+    }
+    return null;
+}
+/** Pulls the array literal a meta function returns, if statically present. */
+function returnedArray(fn) {
+    const body = fn.body;
+    if (t.isArrayExpression(body))
+        return body; // concise arrow: () => [ … ]
+    if (t.isBlockStatement(body)) {
+        for (const stmt of body.body) {
+            if (t.isReturnStatement(stmt) && stmt.argument && t.isArrayExpression(stmt.argument)) {
+                return stmt.argument;
+            }
+        }
+    }
+    return null;
+}
+const remixAdapter = {
+    name: 'remix',
+    detect(input) {
+        if (!input.ast)
+            return false;
+        if (importsRemix(input.ast))
+            return true;
+        // A routes/ file that exports a Remix-style meta or loader.
+        const inRoutes = /\/routes?\//.test(input.filePath) || /(^|\/)root\.(t|j)sx$/.test(input.filePath);
+        return inRoutes && !!findExportedFn(input.ast, 'meta');
+    },
+    apply(input, doc) {
+        const ast = input.ast;
+        const suppressedRuleIds = new Set();
+        const suppressedCategories = new Set();
+        const metaFn = findExportedFn(ast, 'meta');
+        let hasTitle = false;
+        let hasDescription = false;
+        if (metaFn) {
+            const arr = returnedArray(metaFn);
+            const line = (metaFn.loc?.start.line ?? 0);
+            if (arr) {
+                for (const el of arr.elements) {
+                    if (!el || !t.isObjectExpression(el))
+                        continue;
+                    const entry = astToValue(el);
+                    if (!entry)
+                        continue;
+                    const content = typeof entry.content === 'string' ? entry.content : '';
+                    if (typeof entry.title === 'string' && entry.title) {
+                        doc.titleTag = { value: entry.title, line };
+                        hasTitle = true;
+                    }
+                    else if (entry.name === 'description') {
+                        doc.metaDescription = { value: content, line };
+                        hasDescription = true;
+                    }
+                    else if (entry.property === 'og:title')
+                        doc.ogTitle = { value: content, line };
+                    else if (entry.property === 'og:description')
+                        doc.ogDescription = { value: content, line };
+                    else if (entry.property === 'og:image')
+                        doc.ogImage = { value: content, line };
+                    else if (entry.property === 'og:url')
+                        doc.ogUrl = { value: content, line };
+                    else if (entry.property === 'og:type')
+                        doc.ogType = { value: content, line };
+                    else if (entry.name === 'twitter:card')
+                        doc.twitterCard = { value: content, line };
+                    else if (entry.name === 'twitter:title')
+                        doc.twitterTitle = { value: content, line };
+                    else if (entry.name === 'twitter:image')
+                        doc.twitterImage = { value: content, line };
+                }
+            }
+        }
+        // Remix root (renders <html>) is the shell; route files are pages.
+        const isRoot = /(^|\/)root\.(t|j)sx$/.test(input.filePath) || /<html[\s>]/i.test(input.content) || /\{\s*children\s*\}/.test(input.content);
+        const role = isRoot ? 'layout' : 'page';
+        // Remix composes the <head> from root + nested route meta()/links() exports —
+        // absence of a head element can't be proven from one route file. Suppress the
+        // whole "missing head element" class (see HEAD_GOVERNED_ABSENCE_RULES).
+        void hasTitle;
+        void hasDescription;
+        for (const id of HEAD_GOVERNED_ABSENCE_RULES)
+            suppressedRuleIds.add(id);
+        if (role === 'layout') {
+            for (const id of LAYOUT_SHELL_SUPPRESS)
+                suppressedRuleIds.add(id);
+        }
+        return {
+            name: 'remix',
+            role,
+            suppressedRuleIds: [...suppressedRuleIds],
+            suppressedCategories: [...suppressedCategories],
+        };
+    },
+};
+export default remixAdapter;

package/dist/src/parsers/frameworks/roles.js

@@ -0,0 +1,63 @@
+/**
+ * Role-based rule suppression shared by all framework adapters.
+ *
+ * The idea is framework-agnostic: a "layout"/"shell" wraps page content, and a
+ * "page"/"route" inherits its document <head> from that shell. Each adapter maps
+ * its own file conventions onto these roles and reuses these sets so behaviour
+ * stays consistent across frameworks.
+ */
+// A layout/shell isn't expected to contain the page's heading outline or
+// content structured data — those belong to the pages it wraps.
+export const LAYOUT_SHELL_SUPPRESS = [
+    'missing-h1',
+    'multiple-h1',
+    'heading-hierarchy',
+    'empty-heading',
+    'missing-json-ld',
+];
+// A content page inherits its entire document shell (<html>, <head>) from the
+// layout/root: lang, canonical, hreflang, and the head tags viewport/charset/
+// favicon. None of these should be required in the page file itself.
+export const PAGE_INHERITED_FROM_LAYOUT = [
+    'missing-lang',
+    'missing-canonical',
+    'missing-hreflang',
+    'missing-viewport',
+    'missing-charset',
+    'missing-favicon',
+];
+/**
+ * The complete set of "an expected <head> element is ABSENT" rules.
+ *
+ * On a framework file this class of finding can never be proven from static
+ * analysis, because the rendered <head> is composed by the framework's Metadata
+ * API and MERGES across root layout + nested layouts + the page + generateMetadata
+ * + framework auto-fallbacks (Next.js fills og:title from title, og:description
+ * from description, etc.) + SSR-injected JSON-LD. A single source file only ever
+ * shows a fragment of that, so flagging "missing X" is a false positive.
+ *
+ * We therefore suppress this whole class on framework page/layout files and keep
+ * it fully active on plain HTML (where the <head> IS the final, complete head).
+ * Real signal on framework files still comes through: things we can POSITIVELY
+ * detect — accidental-noindex (from metadata.robots or a literal tag) and a
+ * literal invalid-json-ld block — plus all body-level content rules (headings,
+ * images, links), which reflect the real rendered DOM and are never suppressed.
+ */
+export const HEAD_GOVERNED_ABSENCE_RULES = [
+    // title / description
+    'missing-title', 'title-too-short', 'title-too-long',
+    'missing-meta-description', 'meta-description-too-short', 'meta-description-too-long',
+    // Open Graph
+    'missing-og-title', 'missing-og-description', 'missing-og-image',
+    'missing-og-url', 'missing-og-type', 'missing-og-locale',
+    // Twitter
+    'missing-twitter-card', 'missing-twitter-title', 'missing-twitter-image',
+    // technical head tags
+    'missing-canonical', 'missing-lang', 'missing-viewport',
+    'missing-charset', 'missing-favicon', 'missing-hreflang',
+    // structured data (framework SSRs JSON-LD; presence/recommendation is unprovable statically)
+    'missing-json-ld', 'json-ld-recommended-format', 'structured-data-javascript-initial-html',
+    'organization-markup', 'site-name-schema',
+    // page-structure hints that can't be verified on a framework fragment
+    'read-more-deeplink', 'missing-preload-lcp',
+];

package/dist/src/parsers/frameworks/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/parsers/html-parser.js

@@ -0,0 +1,118 @@
+import * as cheerio from 'cheerio';
+import { isPageDocument } from '../engine/page-detector.js';
+const FRAMEWORK_MOUNT_PATTERNS = ['id="root"', 'id="app"', 'id="__next"', 'id="__nuxt"', '<app-root'];
+export function parseHtml(filePath, content) {
+    const $ = cheerio.load(content);
+    function escapeRegex(s) {
+        return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    function findLineForTag(tag, attrName, attrValue) {
+        const pattern = attrValue
+            ? new RegExp(`<${tag}[^>]*${attrName}=["']${escapeRegex(attrValue)}["']`, 'i')
+            : new RegExp(`<${tag}[\\s>]`, 'i');
+        const match = content.match(pattern);
+        if (!match || match.index === undefined)
+            return null;
+        return content.substring(0, match.index).split('\n').length;
+    }
+    const titleEl = $('title').first();
+    const titleValue = titleEl.text().trim();
+    const titleLine = titleValue ? findLineForTag('title') : null;
+    const metaDescEl = $('meta[name="description"]').first();
+    const metaDescValue = metaDescEl.attr('content') || '';
+    const metaDescLine = metaDescValue ? findLineForTag('meta', 'name', 'description') : null;
+    const canonicalEl = $('link[rel="canonical"]').first();
+    const canonicalValue = canonicalEl.attr('href') || '';
+    const langEl = $('html').first();
+    const langValue = langEl.attr('lang') || '';
+    const viewportEl = $('meta[name="viewport"]').first();
+    const viewportValue = viewportEl.attr('content') || '';
+    const charsetEl = $('meta[charset]').first();
+    const charsetValue = charsetEl.attr('charset') || '';
+    const robotsEl = $('meta[name="robots"]').first();
+    const robotsValue = robotsEl.attr('content') || '';
+    const headings = [];
+    $('h1, h2, h3, h4, h5, h6').each((_, el) => {
+        const tag = el.tagName;
+        const text = $(el).text().trim();
+        const line = findLineForTag(tag) ?? 0;
+        headings.push({ tag, text, line });
+    });
+    const images = [];
+    $('img').each((_, el) => {
+        const src = $(el).attr('src') || '';
+        const alt = $(el).attr('alt') ?? null;
+        const loading = $(el).attr('loading') ?? null;
+        const line = findLineForTag('img', 'src', src) ?? 0;
+        images.push({ src, alt, loading, line });
+    });
+    const links = [];
+    $('a').each((_, el) => {
+        const href = $(el).attr('href') || '';
+        const text = $(el).text().trim();
+        const rel = $(el).attr('rel') ?? null;
+        const line = findLineForTag('a', 'href', href) ?? 0;
+        links.push({ href, text, rel, line });
+    });
+    const jsonLdBlocks = [];
+    $('script[type="application/ld+json"]').each((_, el) => {
+        const content_inner = $(el).html() || '';
+        const line = findLineForTag('script', 'type', 'application/ld+json') ?? 0;
+        jsonLdBlocks.push({ content: content_inner.trim(), line });
+    });
+    const preloadLinks = [];
+    $('link[rel="preload"]').each((_, el) => {
+        const href = $(el).attr('href') || '';
+        const as_ = $(el).attr('as') || '';
+        const line = findLineForTag('link', 'rel', 'preload') ?? 0;
+        preloadLinks.push({ href, as: as_, line });
+    });
+    const hreflangLinks = [];
+    $('link[rel="alternate"]').each((_, el) => {
+        const lang = $(el).attr('hreflang');
+        if (!lang)
+            return;
+        const href = $(el).attr('href') || '';
+        const attrNames = Object.keys(el.attribs || {});
+        const knownAttrs = new Set(['rel', 'hreflang', 'href', 'type']);
+        const hasExtraAttrs = attrNames.some(a => !knownAttrs.has(a));
+        const line = findLineForTag('link', 'hreflang', lang) ?? 0;
+        hreflangLinks.push({ lang, href, line, hasExtraAttrs });
+    });
+    const ogLocaleVal = $('meta[property="og:locale"]').attr('content') || '';
+    const doc = {
+        filePath,
+        fileType: 'html',
+        rawContent: content,
+        titleTag: titleValue ? { value: titleValue, line: titleLine ?? 0 } : null,
+        metaDescription: metaDescValue ? { value: metaDescValue, line: metaDescLine ?? 0 } : null,
+        metaRobots: robotsValue ? { value: robotsValue, line: findLineForTag('meta', 'name', 'robots') ?? 0 } : null,
+        canonicalUrl: canonicalValue ? { value: canonicalValue, line: findLineForTag('link', 'rel', 'canonical') ?? 0 } : null,
+        langAttribute: langValue ? { value: langValue, line: 1 } : null,
+        viewportMeta: viewportValue ? { value: viewportValue, line: findLineForTag('meta', 'name', 'viewport') ?? 0 } : null,
+        charsetMeta: charsetValue ? { value: charsetValue, line: findLineForTag('meta', 'charset', charsetValue) ?? 0 } : null,
+        ogTitle: $('meta[property="og:title"]').attr('content') ? { value: $('meta[property="og:title"]').attr('content'), line: findLineForTag('meta', 'property', 'og:title') ?? 0 } : null,
+        ogDescription: $('meta[property="og:description"]').attr('content') ? { value: $('meta[property="og:description"]').attr('content'), line: findLineForTag('meta', 'property', 'og:description') ?? 0 } : null,
+        ogImage: $('meta[property="og:image"]').attr('content') ? { value: $('meta[property="og:image"]').attr('content'), line: findLineForTag('meta', 'property', 'og:image') ?? 0 } : null,
+        ogUrl: $('meta[property="og:url"]').attr('content') ? { value: $('meta[property="og:url"]').attr('content'), line: findLineForTag('meta', 'property', 'og:url') ?? 0 } : null,
+        ogType: $('meta[property="og:type"]').attr('content') ? { value: $('meta[property="og:type"]').attr('content'), line: findLineForTag('meta', 'property', 'og:type') ?? 0 } : null,
+        ogLocale: ogLocaleVal ? { value: ogLocaleVal, line: findLineForTag('meta', 'property', 'og:locale') ?? 0 } : null,
+        twitterCard: $('meta[name="twitter:card"]').attr('content') ? { value: $('meta[name="twitter:card"]').attr('content'), line: findLineForTag('meta', 'name', 'twitter:card') ?? 0 } : null,
+        twitterTitle: $('meta[name="twitter:title"]').attr('content') ? { value: $('meta[name="twitter:title"]').attr('content'), line: findLineForTag('meta', 'name', 'twitter:title') ?? 0 } : null,
+        twitterDescription: $('meta[name="twitter:description"]').attr('content') ? { value: $('meta[name="twitter:description"]').attr('content'), line: findLineForTag('meta', 'name', 'twitter:description') ?? 0 } : null,
+        twitterImage: $('meta[name="twitter:image"]').attr('content') ? { value: $('meta[name="twitter:image"]').attr('content'), line: findLineForTag('meta', 'name', 'twitter:image') ?? 0 } : null,
+        headings,
+        images,
+        links,
+        jsonLdBlocks,
+        preloadLinks,
+        hreflangLinks,
+        hasNoindex: robotsValue.toLowerCase().includes('noindex'),
+        hasSitemapRef: content.includes('sitemap'),
+        hasFavicon: $('link[rel="icon"], link[rel="shortcut icon"]').length > 0,
+        isPageDocument: false,
+        isFrameworkShell: FRAMEWORK_MOUNT_PATTERNS.some((p) => content.includes(p)),
+    };
+    doc.isPageDocument = isPageDocument(doc);
+    return doc;
+}

package/dist/src/parsers/index.js

@@ -0,0 +1,62 @@
+import { parseHtml } from './html-parser.js';
+import { parseJsx } from './jsx-parser.js';
+import { applyFrameworkAdapters } from './frameworks/index.js';
+const SUPPORTED_EXTENSIONS = ['html', 'htm', 'js', 'jsx', 'tsx', 'vue', 'svelte', 'astro'];
+export function isSupportedFile(filename) {
+    const ext = filename.split('.').pop()?.toLowerCase() ?? '';
+    return SUPPORTED_EXTENSIONS.includes(ext);
+}
+export function parseFile(filePath, content) {
+    const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
+    switch (ext) {
+        case 'html':
+        case 'htm':
+            return parseHtml(filePath, content);
+        case 'js':
+        case 'jsx':
+            // Plain .js commonly holds JSX in React projects (Create React App, etc.),
+            // so it goes through the same JSX parser. Non-JSX .js simply yields no
+            // findings rather than being skipped.
+            return parseJsx(filePath, content, 'jsx');
+        case 'tsx':
+            return parseJsx(filePath, content, 'tsx');
+        case 'vue':
+            return parseVueLike(filePath, content);
+        case 'svelte':
+            return parseSvelteLike(filePath, content);
+        case 'astro':
+            return parseAstroLike(filePath, content);
+        default:
+            return null;
+    }
+}
+// Vue: extract <template> block and parse as HTML
+function parseVueLike(filePath, content) {
+    const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/);
+    const templateContent = templateMatch ? templateMatch[1] : content;
+    const doc = parseHtml(filePath, templateContent);
+    doc.fileType = 'vue';
+    return doc;
+}
+// Svelte: parse as HTML (Svelte templates are valid HTML supersets for our purposes)
+function parseSvelteLike(filePath, content) {
+    const doc = parseHtml(filePath, content);
+    doc.fileType = 'svelte';
+    return doc;
+}
+// Astro: a `---` frontmatter fence (JS/TS) followed by an HTML-like template.
+// Parse the template as HTML, then let the Astro adapter reconcile dynamic head
+// values and layout delegation (the frontmatter is passed along for that).
+function parseAstroLike(filePath, content) {
+    const template = stripAstroFrontmatter(content);
+    const doc = parseHtml(filePath, template);
+    doc.fileType = 'astro';
+    // HTML parsing doesn't run adapters (no AST); Astro's works off the raw source.
+    applyFrameworkAdapters({ filePath, content, fileType: 'astro' }, doc);
+    return doc;
+}
+/** Removes the leading `---\n…\n---` frontmatter block, leaving the template. */
+function stripAstroFrontmatter(content) {
+    const m = /^\s*---\r?\n[\s\S]*?\r?\n---\r?\n?/.exec(content);
+    return m ? content.slice(m[0].length) : content;
+}

package/dist/src/parsers/jsx-parser.js

@@ -0,0 +1,174 @@
+import { parse } from '@babel/parser';
+import _traverse from '@babel/traverse';
+import * as t from '@babel/types';
+// @babel/traverse is CJS with a default export; handle both ESM and CJS interop
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traverse = _traverse.default ?? _traverse;
+import { isPageDocument } from '../engine/page-detector.js';
+import { applyFrameworkAdapters } from './frameworks/index.js';
+export function parseJsx(filePath, content, fileType) {
+    const doc = createEmptyDocument(filePath, fileType, content);
+    let ast;
+    try {
+        ast = parse(content, {
+            sourceType: 'module',
+            plugins: fileType === 'tsx' ? ['typescript', 'jsx'] : ['jsx'],
+        });
+    }
+    catch (err) {
+        console.warn(`[WARN] Failed to parse JSX/TSX file ${filePath}:`, err);
+        return doc;
+    }
+    traverse(ast, {
+        JSXElement(path) {
+            const opening = path.node.openingElement;
+            const tagName = t.isJSXIdentifier(opening.name) ? opening.name.name : '';
+            const line = opening.loc?.start.line ?? 0;
+            const getAttr = (name) => {
+                const attr = opening.attributes.find((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name) && a.name.name === name);
+                if (!attr)
+                    return null;
+                if (t.isStringLiteral(attr.value))
+                    return attr.value.value;
+                if (t.isJSXExpressionContainer(attr.value) && t.isStringLiteral(attr.value.expression)) {
+                    return attr.value.expression.value;
+                }
+                return '';
+            };
+            // Title tag (Next.js / react-helmet pattern)
+            if (tagName === 'title') {
+                const text = path.node.children
+                    .filter(t.isJSXText)
+                    .map((c) => c.value)
+                    .join('').trim();
+                doc.titleTag = { value: text, line };
+            }
+            // Meta tags
+            if (tagName === 'meta') {
+                const name = getAttr('name');
+                const property = getAttr('property');
+                const content_ = getAttr('content');
+                // charset: JSX uses charSet (camelCase), HTML uses charset
+                const charset = getAttr('charSet') || getAttr('charset');
+                if (charset)
+                    doc.charsetMeta = { value: charset, line };
+                if (name === 'description')
+                    doc.metaDescription = { value: content_ ?? '', line };
+                if (name === 'robots') {
+                    doc.metaRobots = { value: content_ ?? '', line };
+                    if ((content_ ?? '').toLowerCase().includes('noindex'))
+                        doc.hasNoindex = true;
+                }
+                if (name === 'viewport')
+                    doc.viewportMeta = { value: content_ ?? '', line };
+                if (name === 'twitter:card')
+                    doc.twitterCard = { value: content_ ?? '', line };
+                if (name === 'twitter:title')
+                    doc.twitterTitle = { value: content_ ?? '', line };
+                if (name === 'twitter:description')
+                    doc.twitterDescription = { value: content_ ?? '', line };
+                if (name === 'twitter:image')
+                    doc.twitterImage = { value: content_ ?? '', line };
+                if (property === 'og:title')
+                    doc.ogTitle = { value: content_ ?? '', line };
+                if (property === 'og:description')
+                    doc.ogDescription = { value: content_ ?? '', line };
+                if (property === 'og:image')
+                    doc.ogImage = { value: content_ ?? '', line };
+                if (property === 'og:url')
+                    doc.ogUrl = { value: content_ ?? '', line };
+                if (property === 'og:type')
+                    doc.ogType = { value: content_ ?? '', line };
+                if (property === 'og:locale')
+                    doc.ogLocale = { value: content_ ?? '', line };
+            }
+            // Link tags
+            if (tagName === 'link') {
+                const rel = getAttr('rel');
+                if (rel === 'canonical')
+                    doc.canonicalUrl = { value: getAttr('href') ?? '', line };
+                if (rel === 'preload')
+                    doc.preloadLinks.push({ href: getAttr('href') ?? '', as: getAttr('as') ?? '', line });
+                if (rel === 'icon' || rel === 'shortcut icon')
+                    doc.hasFavicon = true;
+                const hreflang = getAttr('hreflang');
+                if (rel === 'alternate' && hreflang) {
+                    doc.hreflangLinks.push({ lang: hreflang, href: getAttr('href') ?? '', line, hasExtraAttrs: false });
+                }
+            }
+            // HTML lang attribute
+            if (tagName === 'html') {
+                const lang = getAttr('lang');
+                if (lang)
+                    doc.langAttribute = { value: lang, line };
+            }
+            // Headings
+            if (/^h[1-6]$/.test(tagName)) {
+                const literal = path.node.children
+                    .filter(t.isJSXText)
+                    .map((c) => c.value)
+                    .join('').trim();
+                // A heading whose text comes from an expression ({title}) or a nested
+                // element (<span>…</span>, <Icon/>) is NOT empty — it renders real text.
+                // Only truly childless headings should trip empty-heading.
+                const hasDynamicContent = path.node.children.some((c) => (t.isJSXExpressionContainer(c) && !t.isJSXEmptyExpression(c.expression)) ||
+                    t.isJSXElement(c) ||
+                    t.isJSXFragment(c));
+                const text = literal || (hasDynamicContent ? '…' : '');
+                doc.headings.push({ tag: tagName, text, line });
+            }
+            // Images
+            if (tagName === 'img') {
+                const src = getAttr('src') ?? '';
+                const alt = getAttr('alt');
+                const loading = getAttr('loading');
+                doc.images.push({ src, alt, loading, line });
+            }
+            // Anchors
+            if (tagName === 'a') {
+                const href = getAttr('href') ?? '';
+                const rel = getAttr('rel');
+                const text = path.node.children
+                    .filter(t.isJSXText)
+                    .map((c) => c.value)
+                    .join('').trim();
+                doc.links.push({ href, text, rel, line });
+            }
+            // Script for JSON-LD
+            if (tagName === 'script' && getAttr('type') === 'application/ld+json') {
+                const inner = path.node.children
+                    .filter(t.isJSXText)
+                    .map((c) => c.value)
+                    .join('').trim();
+                // Runtime-generated JSON-LD can't be validated statically. In React the
+                // body is set via dangerouslySetInnerHTML={{__html: JSON.stringify(...)}},
+                // or as an expression child {jsonString} — either way there's no literal
+                // JSON to read, so mark it dynamic (the block still counts as "present",
+                // but the invalid-json-ld rule won't flag it).
+                const hasDangerousHtml = path.node.openingElement.attributes.some((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name) && a.name.name === 'dangerouslySetInnerHTML');
+                const hasExpressionChild = path.node.children.some((c) => t.isJSXExpressionContainer(c));
+                const dynamic = hasDangerousHtml || hasExpressionChild || inner.length === 0;
+                doc.jsonLdBlocks.push({ content: inner, line, dynamic });
+            }
+        },
+    });
+    // Framework awareness: let an adapter (Next.js, Remix, …) read metadata the
+    // raw JSX traversal can't see and declare role-based rule scoping. Runs after
+    // the JSX pass so adapters can also use what was found literally.
+    applyFrameworkAdapters({ filePath, content, fileType, ast }, doc);
+    doc.isPageDocument = isPageDocument(doc);
+    return doc;
+}
+function createEmptyDocument(filePath, fileType, rawContent) {
+    return {
+        filePath, fileType, rawContent,
+        titleTag: null, metaDescription: null, metaRobots: null,
+        canonicalUrl: null, langAttribute: null, viewportMeta: null, charsetMeta: null,
+        ogTitle: null, ogDescription: null, ogImage: null, ogUrl: null, ogType: null, ogLocale: null,
+        twitterCard: null, twitterTitle: null, twitterDescription: null, twitterImage: null,
+        headings: [], images: [], links: [], jsonLdBlocks: [], preloadLinks: [], hreflangLinks: [],
+        hasNoindex: false, hasSitemapRef: false, hasFavicon: false,
+        isPageDocument: false,
+        isFrameworkShell: false,
+    };
+}

package/dist/src/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/worker-env.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@qobi/seocode",
+  "version": "0.1.0",
+  "description": "Framework-aware technical SEO review for your codebase — zero-config CLI that catches deploy-blocking SEO regressions (noindex, dynamic metadata, broken JSON-LD) before you push.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/src/cli/index.js",
+  "bin": {
+    "seocode": "./dist/src/cli/index.js"
+  },
+  "keywords": [
+    "seo",
+    "cli",
+    "nextjs",
+    "remix",
+    "astro",
+    "json-ld",
+    "metadata",
+    "pre-commit",
+    "lint",
+    "static-analysis"
+  ],
+  "files": [
+    "dist/src/cli",
+    "dist/src/engine",
+    "dist/src/parsers",
+    "dist/src/config",
+    "dist/src/billing",
+    "dist/src/types",
+    "rules/seo-rules.json"
+  ],
+  "scripts": {
+    "dev": "wrangler pages dev . --compatibility-date=2024-09-23",
+    "deploy": "wrangler pages deploy .",
+    "build": "tsc",
+    "cli": "node dist/src/cli/index.js",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest --runInBand",
+    "test:watch": "node --experimental-vm-modules node_modules/.bin/jest --watch",
+    "lint": "eslint src --ext .ts,.tsx",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.24.0",
+    "@babel/traverse": "^7.24.0",
+    "@babel/types": "^7.24.0",
+    "cheerio": "^1.0.0"
+  },
+  "devDependencies": {
+    "@octokit/app": "^15.0.0",
+    "@octokit/rest": "^21.0.0",
+    "@octokit/webhooks": "^13.0.0",
+    "@types/babel__traverse": "^7.20.0",
+    "@types/cheerio": "^0.22.35",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.12.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.4.0",
+    "wrangler": "^3.0.0"
+  },
+  "jest": {
+    "preset": "ts-jest/presets/default-esm",
+    "testEnvironment": "node",
+    "testMatch": ["**/tests/**/*.test.ts"],
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    },
+    "transform": {
+      "^.+\\.tsx?$": ["ts-jest", { "useESM": true, "tsconfig": "tsconfig.test.json", "isolatedModules": true }]
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}