atlas-mcp-web 0.1.0

package/dist/tools/contact.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Extract contact information from a page: emails, phones, social handles.
+ */
+import type { CheerioAPI } from 'cheerio';
+export declare function extractContact({ url, $, html, }: {
+    url: string;
+    $: CheerioAPI;
+    html: string;
+}): {
+    url: string;
+    emails: string[];
+    phones: string[];
+    socials: Record<string, string[]>;
+    counts: {
+        emails: number;
+        phones: number;
+        socialProfiles: number;
+    };
+};

package/dist/tools/contact.js

@@ -0,0 +1,85 @@
+/**
+ * Extract contact information from a page: emails, phones, social handles.
+ */
+const EMAIL_RE = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+// Simple international phone regex — at least 7 digits, optional + prefix, spaces/dashes/parens allowed
+const PHONE_RE = /(?:\+?\d{1,3}[\s.-]?)?\(?\d{2,4}\)?[\s.-]?\d{3,4}[\s.-]?\d{3,4}(?:[\s.-]?\d{1,4})?/g;
+const SOCIAL_PATTERNS = [
+    { platform: 'twitter', re: /(?:https?:\/\/)?(?:www\.)?(?:twitter|x)\.com\/([A-Za-z0-9_]{1,15})/g },
+    { platform: 'linkedin', re: /(?:https?:\/\/)?(?:www\.)?linkedin\.com\/(?:in|company)\/([A-Za-z0-9-_%]+)/g },
+    { platform: 'instagram', re: /(?:https?:\/\/)?(?:www\.)?instagram\.com\/([A-Za-z0-9_.]+)/g },
+    { platform: 'facebook', re: /(?:https?:\/\/)?(?:www\.)?facebook\.com\/([A-Za-z0-9.-]+)/g },
+    { platform: 'youtube', re: /(?:https?:\/\/)?(?:www\.)?youtube\.com\/(?:@[A-Za-z0-9._-]+|channel\/[A-Za-z0-9_-]+|c\/[A-Za-z0-9_-]+)/g },
+    { platform: 'github', re: /(?:https?:\/\/)?(?:www\.)?github\.com\/([A-Za-z0-9-]+)(?:\/[A-Za-z0-9_.-]+)?/g },
+    { platform: 'tiktok', re: /(?:https?:\/\/)?(?:www\.)?tiktok\.com\/@([A-Za-z0-9._]+)/g },
+];
+// Exclude common false positive domains for emails
+const EMAIL_NOISE = [
+    'example.com',
+    'domain.com',
+    'email.com',
+    'sentry.io',
+    'wixpress.com',
+    'w3.org',
+    'schema.org',
+];
+export function extractContact({ url, $, html, }) {
+    // Strip script/style content for email/phone scanning to avoid tracking noise
+    const $clone = $.root().clone();
+    $clone.find('script, style, noscript').remove();
+    const text = $clone.text();
+    // Emails from text
+    const emailSet = new Set();
+    for (const m of text.matchAll(EMAIL_RE)) {
+        const e = m[0].toLowerCase();
+        if (!EMAIL_NOISE.some((noise) => e.includes(noise)))
+            emailSet.add(e);
+    }
+    // Emails from mailto: links
+    $('a[href^="mailto:"]').each((_, el) => {
+        const href = $(el).attr('href') || '';
+        const e = href.slice(7).split('?')[0].toLowerCase();
+        if (e)
+            emailSet.add(e);
+    });
+    // Phones from text
+    const phoneSet = new Set();
+    for (const m of text.matchAll(PHONE_RE)) {
+        const normalized = m[0].replace(/\s+/g, ' ').trim();
+        const digitCount = (normalized.match(/\d/g) || []).length;
+        if (digitCount >= 7 && digitCount <= 15)
+            phoneSet.add(normalized);
+    }
+    // Phones from tel: links (more reliable)
+    $('a[href^="tel:"]').each((_, el) => {
+        const href = $(el).attr('href') || '';
+        const p = href.slice(4).trim();
+        if (p)
+            phoneSet.add(p);
+    });
+    // Social handles from the full HTML (more reliable source)
+    const socials = {};
+    for (const { platform, re } of SOCIAL_PATTERNS) {
+        const set = new Set();
+        for (const m of html.matchAll(re)) {
+            set.add(m[0].replace(/^https?:\/\//, '').replace(/^www\./, ''));
+        }
+        if (set.size > 0)
+            socials[platform] = set;
+    }
+    const socialOut = {};
+    for (const [platform, set] of Object.entries(socials)) {
+        socialOut[platform] = Array.from(set).slice(0, 20);
+    }
+    return {
+        url,
+        emails: Array.from(emailSet).slice(0, 50),
+        phones: Array.from(phoneSet).slice(0, 20),
+        socials: socialOut,
+        counts: {
+            emails: emailSet.size,
+            phones: phoneSet.size,
+            socialProfiles: Object.values(socials).reduce((sum, s) => sum + s.size, 0),
+        },
+    };
+}

package/dist/tools/links.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Extract and categorize all links from a page.
+ */
+import type { CheerioAPI } from 'cheerio';
+export declare function extractLinks({ url, $, sameDomainOnly, }: {
+    url: string;
+    $: CheerioAPI;
+    sameDomainOnly: boolean;
+}): {
+    url: string;
+    sourceDomain: string | null;
+    counts: {
+        internal: number;
+        external: number;
+        social: number;
+        email: number;
+        phone: number;
+    };
+    internal: {
+        href: string;
+        text: string;
+    }[];
+    external: {
+        href: string;
+        text: string;
+    }[];
+    social: {
+        platform: string;
+        href: string;
+        text: string;
+    }[];
+    email: string[];
+    phone: string[];
+};

package/dist/tools/links.js

@@ -0,0 +1,107 @@
+/**
+ * Extract and categorize all links from a page.
+ */
+const SOCIAL_HOSTS = {
+    'twitter.com': 'twitter',
+    'x.com': 'twitter',
+    'linkedin.com': 'linkedin',
+    'facebook.com': 'facebook',
+    'instagram.com': 'instagram',
+    'youtube.com': 'youtube',
+    'youtu.be': 'youtube',
+    'github.com': 'github',
+    'tiktok.com': 'tiktok',
+    'reddit.com': 'reddit',
+    'threads.net': 'threads',
+    'bsky.app': 'bluesky',
+    'medium.com': 'medium',
+    'discord.gg': 'discord',
+    'discord.com': 'discord',
+};
+export function extractLinks({ url, $, sameDomainOnly, }) {
+    const sourceDomain = safeDomain(url);
+    const internal = [];
+    const external = [];
+    const social = [];
+    const email = [];
+    const phone = [];
+    const seen = new Set();
+    $('a[href]').each((_, el) => {
+        const rawHref = ($(el).attr('href') || '').trim();
+        if (!rawHref)
+            return;
+        const text = ($(el).text() || '').trim().slice(0, 200);
+        // mailto:
+        if (rawHref.startsWith('mailto:')) {
+            const e = rawHref.slice(7).split('?')[0].toLowerCase();
+            if (e && !email.includes(e))
+                email.push(e);
+            return;
+        }
+        // tel:
+        if (rawHref.startsWith('tel:')) {
+            const p = rawHref.slice(4).replace(/\s+/g, '');
+            if (p && !phone.includes(p))
+                phone.push(p);
+            return;
+        }
+        // Skip anchors and javascript
+        if (rawHref.startsWith('#') || rawHref.startsWith('javascript:'))
+            return;
+        const resolved = resolve(rawHref, url);
+        if (!resolved)
+            return;
+        if (seen.has(resolved))
+            return;
+        seen.add(resolved);
+        const host = safeDomain(resolved);
+        if (!host)
+            return;
+        // Social?
+        for (const [socialHost, platform] of Object.entries(SOCIAL_HOSTS)) {
+            if (host === socialHost || host.endsWith('.' + socialHost)) {
+                social.push({ platform, href: resolved, text });
+                return;
+            }
+        }
+        const isInternal = sourceDomain && (host === sourceDomain || host.endsWith('.' + sourceDomain));
+        if (isInternal) {
+            internal.push({ href: resolved, text });
+        }
+        else if (!sameDomainOnly) {
+            external.push({ href: resolved, text });
+        }
+    });
+    return {
+        url,
+        sourceDomain,
+        counts: {
+            internal: internal.length,
+            external: external.length,
+            social: social.length,
+            email: email.length,
+            phone: phone.length,
+        },
+        internal,
+        external,
+        social,
+        email,
+        phone,
+    };
+}
+function safeDomain(u) {
+    try {
+        return new URL(u).hostname.replace(/^www\./, '').toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+function resolve(href, base) {
+    try {
+        return new URL(href, base).toString();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tools/metadata.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Complete URL metadata: Open Graph, Twitter Card, JSON-LD, favicons.
+ */
+import type { CheerioAPI } from 'cheerio';
+export declare function extractMetadata({ url, $, headers, }: {
+    url: string;
+    $: CheerioAPI;
+    headers: Record<string, string>;
+}): {
+    url: string;
+    title: string;
+    description: string | null;
+    image: string | null;
+    siteName: string | null;
+    type: string | null;
+    author: string | null;
+    language: string | null;
+    canonicalUrl: string;
+    keywords: string[];
+    themeColor: string | null;
+    openGraph: Record<string, string>;
+    twitterCard: Record<string, string>;
+    favicons: {
+        rel: string;
+        href: string;
+        sizes: string | null;
+        type: string | null;
+    }[];
+    jsonLd: unknown[];
+    structuredDataTypes: string[];
+    contentType: string | null;
+};

package/dist/tools/metadata.js

@@ -0,0 +1,112 @@
+/**
+ * Complete URL metadata: Open Graph, Twitter Card, JSON-LD, favicons.
+ */
+export function extractMetadata({ url, $, headers, }) {
+    const pageTitle = ($('title').first().text() || '').trim();
+    const lang = ($('html').attr('lang') || '').trim() || null;
+    const canonical = $('link[rel="canonical"]').attr('href') || url;
+    const metaName = {};
+    $('meta[name]').each((_, el) => {
+        const name = ($(el).attr('name') || '').toLowerCase();
+        const content = $(el).attr('content');
+        if (name && content)
+            metaName[name] = content;
+    });
+    const og = {};
+    const twitter = {};
+    $('meta[property], meta[name^="twitter:"]').each((_, el) => {
+        const key = ($(el).attr('property') || $(el).attr('name') || '').toLowerCase();
+        const content = $(el).attr('content');
+        if (!key || !content)
+            return;
+        if (key.startsWith('og:'))
+            og[key.slice(3)] = content;
+        else if (key.startsWith('twitter:'))
+            twitter[key.slice(8)] = content;
+    });
+    const favicons = [];
+    $('link').each((_, el) => {
+        const rel = ($(el).attr('rel') || '').toLowerCase();
+        const href = $(el).attr('href');
+        if (!href)
+            return;
+        if (rel.includes('icon') || rel === 'apple-touch-icon' || rel === 'mask-icon') {
+            favicons.push({
+                rel,
+                href: resolveUrl(href, url),
+                sizes: $(el).attr('sizes') || null,
+                type: $(el).attr('type') || null,
+            });
+        }
+    });
+    const jsonLd = [];
+    $('script[type="application/ld+json"]').each((_, el) => {
+        const raw = $(el).contents().text();
+        if (!raw)
+            return;
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed))
+                jsonLd.push(...parsed);
+            else
+                jsonLd.push(parsed);
+        }
+        catch {
+            // ignore malformed JSON-LD
+        }
+    });
+    const structuredTypes = new Set();
+    for (const item of jsonLd)
+        collectTypes(item, structuredTypes);
+    return {
+        url,
+        title: og.title || twitter.title || pageTitle,
+        description: og.description || twitter.description || metaName.description || null,
+        image: og.image ? resolveUrl(og.image, url) : twitter.image ? resolveUrl(twitter.image, url) : null,
+        siteName: og.site_name || null,
+        type: og.type || null,
+        author: metaName.author || null,
+        language: lang,
+        canonicalUrl: resolveUrl(canonical, url),
+        keywords: metaName.keywords
+            ? metaName.keywords.split(',').map((k) => k.trim()).filter(Boolean)
+            : [],
+        themeColor: metaName['theme-color'] || null,
+        openGraph: og,
+        twitterCard: twitter,
+        favicons,
+        jsonLd,
+        structuredDataTypes: Array.from(structuredTypes),
+        contentType: headers['content-type'] || null,
+    };
+}
+function collectTypes(node, set) {
+    if (!node || typeof node !== 'object')
+        return;
+    const obj = node;
+    const t = obj['@type'];
+    if (typeof t === 'string')
+        set.add(t);
+    else if (Array.isArray(t))
+        for (const v of t)
+            if (typeof v === 'string')
+                set.add(v);
+    for (const key of Object.keys(obj)) {
+        if (key === '@type')
+            continue;
+        const v = obj[key];
+        if (Array.isArray(v))
+            for (const item of v)
+                collectTypes(item, set);
+        else if (v && typeof v === 'object')
+            collectTypes(v, set);
+    }
+}
+function resolveUrl(href, base) {
+    try {
+        return new URL(href, base).toString();
+    }
+    catch {
+        return href;
+    }
+}

package/dist/tools/tables.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Extract all HTML tables as structured rows with headers.
+ */
+import type { CheerioAPI } from 'cheerio';
+export declare function extractTables({ url, $ }: {
+    url: string;
+    $: CheerioAPI;
+}): {
+    url: string;
+    tableCount: number;
+    tables: {
+        index: number;
+        caption: string | null;
+        headers: string[];
+        rows: Record<string, string>[];
+        rowCount: number;
+    }[];
+};

package/dist/tools/tables.js

@@ -0,0 +1,75 @@
+/**
+ * Extract all HTML tables as structured rows with headers.
+ */
+export function extractTables({ url, $ }) {
+    const tables = [];
+    $('table').each((index, tableEl) => {
+        const $table = $(tableEl);
+        const caption = ($table.find('caption').first().text() || '').trim() || null;
+        const headers = extractHeaders($, $table);
+        const rows = extractRows($, $table, headers);
+        if (rows.length > 0) {
+            tables.push({
+                index,
+                caption,
+                headers,
+                rows,
+                rowCount: rows.length,
+            });
+        }
+    });
+    return {
+        url,
+        tableCount: tables.length,
+        tables,
+    };
+}
+function extractHeaders($, $table) {
+    // Try explicit thead first
+    const $thead = $table.find('thead').first();
+    if ($thead.length) {
+        const headers = $thead
+            .find('th, td')
+            .map((_, el) => $(el).text().trim())
+            .get();
+        if (headers.length)
+            return headers;
+    }
+    // Fall back to first row with <th>
+    const $firstThRow = $table.find('tr').filter((_, tr) => $(tr).find('th').length > 0).first();
+    if ($firstThRow.length) {
+        return $firstThRow
+            .find('th, td')
+            .map((_, el) => $(el).text().trim())
+            .get();
+    }
+    // Fall back to first row
+    const $firstRow = $table.find('tr').first();
+    if ($firstRow.length) {
+        return $firstRow
+            .find('td, th')
+            .map((_, el) => $(el).text().trim())
+            .get();
+    }
+    return [];
+}
+function extractRows($, $table, headers) {
+    const rows = [];
+    const $bodyRows = $table.find('tbody tr');
+    const $rows = $bodyRows.length ? $bodyRows : $table.find('tr').slice(headers.length ? 1 : 0);
+    $rows.each((_, tr) => {
+        const cells = $(tr)
+            .find('td, th')
+            .map((_, el) => $(el).text().trim())
+            .get();
+        if (cells.length === 0)
+            return;
+        const row = {};
+        for (let i = 0; i < cells.length; i++) {
+            const key = headers[i] || `column_${i + 1}`;
+            row[key] = cells[i];
+        }
+        rows.push(row);
+    });
+    return rows;
+}

package/dist/tools/techstack.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Tech stack detection (reuses the rule engine from the Apify actor).
+ */
+import type { CheerioAPI } from 'cheerio';
+export declare function detectTechStack({ url, $, html, headers, }: {
+    url: string;
+    $: CheerioAPI;
+    html: string;
+    headers: Record<string, string>;
+}): {
+    url: string;
+    technologies: {
+        name: string;
+        category: string;
+        confidence: number;
+    }[];
+    categorized: Record<string, string[]>;
+    technologyCount: number;
+};

package/dist/tools/techstack.js

@@ -0,0 +1,138 @@
+/**
+ * Tech stack detection (reuses the rule engine from the Apify actor).
+ */
+const SIGNATURES = [
+    { name: 'WordPress', category: 'cms', rules: ['html=/wp-content\\//', 'html=/wp-includes\\//', 'meta:generator=/WordPress/i'] },
+    { name: 'Drupal', category: 'cms', rules: ['header:x-generator=/Drupal/i', 'meta:generator=/Drupal/i'] },
+    { name: 'Ghost', category: 'cms', rules: ['meta:generator=/Ghost/i', 'html=/ghost-sdk/'] },
+    { name: 'Wix', category: 'cms', rules: ['header:x-wix-request-id=/.+/', 'html=/static\\.wixstatic\\.com/'] },
+    { name: 'Squarespace', category: 'cms', rules: ['html=/static\\.squarespace\\.com/', 'header:x-contextid=/.+/'] },
+    { name: 'Webflow', category: 'cms', rules: ['html=/webflow\\.com/', 'meta:generator=/Webflow/i'] },
+    { name: 'Contentful', category: 'cms', rules: ['html=/images\\.ctfassets\\.net/'] },
+    { name: 'Sanity', category: 'cms', rules: ['html=/cdn\\.sanity\\.io/'] },
+    { name: 'Shopify', category: 'ecommerce', rules: ['header:x-shopify-stage=/.+/', 'html=/cdn\\.shopify\\.com/', 'html=/Shopify\\.theme/'] },
+    { name: 'WooCommerce', category: 'ecommerce', rules: ['html=/wp-content\\/plugins\\/woocommerce/', 'html=/woocommerce-/'] },
+    { name: 'Magento', category: 'ecommerce', rules: ['cookie=/Mage-/', 'html=/Magento_Ui/'] },
+    { name: 'BigCommerce', category: 'ecommerce', rules: ['html=/cdn\\d+\\.bigcommerce\\.com/'] },
+    { name: 'PrestaShop', category: 'ecommerce', rules: ['meta:generator=/PrestaShop/i'] },
+    { name: 'Next.js', category: 'frameworks', rules: ['header:x-powered-by=/Next\\.js/i', 'html=/_next\\/static/', 'html=/__NEXT_DATA__/'] },
+    { name: 'Nuxt.js', category: 'frameworks', rules: ['html=/_nuxt\\//', 'html=/__NUXT__/'] },
+    { name: 'React', category: 'frameworks', rules: ['html=/react(?:-dom)?[\\.@][\\d\\.]+/', 'script=/react(?:-dom)?\\..*\\.js/'] },
+    { name: 'Vue.js', category: 'frameworks', rules: ['html=/vue(?:-router)?[\\.@][\\d\\.]+/', 'script=/vue[\\.@][\\d\\.]+(?:\\.min)?\\.js/'] },
+    { name: 'Angular', category: 'frameworks', rules: ['html=/ng-version=/', 'html=/angular\\.io/'] },
+    { name: 'Svelte', category: 'frameworks', rules: ['html=/svelte-[a-z0-9]+/'] },
+    { name: 'Gatsby', category: 'frameworks', rules: ['meta:generator=/Gatsby/i', 'html=/gatsby-/'] },
+    { name: 'Astro', category: 'frameworks', rules: ['meta:generator=/Astro/i', 'html=/astro-island/'] },
+    { name: 'Remix', category: 'frameworks', rules: ['html=/\\/build\\/_shared\\//'] },
+    { name: 'nginx', category: 'hosting', rules: ['header:server=/nginx/i'] },
+    { name: 'Apache', category: 'hosting', rules: ['header:server=/Apache/i'] },
+    { name: 'Microsoft IIS', category: 'hosting', rules: ['header:server=/IIS|Microsoft-IIS/i'] },
+    { name: 'LiteSpeed', category: 'hosting', rules: ['header:server=/LiteSpeed/i'] },
+    { name: 'Caddy', category: 'hosting', rules: ['header:server=/Caddy/i'] },
+    { name: 'Express', category: 'frameworks', rules: ['header:x-powered-by=/Express/i'] },
+    { name: 'PHP', category: 'frameworks', rules: ['header:x-powered-by=/PHP/i'] },
+    { name: 'ASP.NET', category: 'frameworks', rules: ['header:x-powered-by=/ASP\\.NET/i', 'header:x-aspnet-version=/.+/'] },
+    { name: 'Ruby on Rails', category: 'frameworks', rules: ['header:x-powered-by=/Rails/i'] },
+    { name: 'Django', category: 'frameworks', rules: ['cookie=/django/i', 'cookie=/csrftoken/i'] },
+    { name: 'Laravel', category: 'frameworks', rules: ['cookie=/laravel_session/i', 'cookie=/XSRF-TOKEN/i'] },
+    { name: 'Cloudflare', category: 'cdn', rules: ['header:server=/cloudflare/i', 'header:cf-ray=/.+/'] },
+    { name: 'Amazon CloudFront', category: 'cdn', rules: ['header:via=/CloudFront/i', 'header:x-amz-cf-id=/.+/'] },
+    { name: 'Fastly', category: 'cdn', rules: ['header:x-served-by=/cache-.*/', 'header:x-fastly-request-id=/.+/'] },
+    { name: 'Akamai', category: 'cdn', rules: ['header:server=/AkamaiGHost/i', 'header:x-akamai-transformed=/.+/'] },
+    { name: 'Vercel', category: 'hosting', rules: ['header:x-vercel-id=/.+/', 'header:server=/Vercel/i'] },
+    { name: 'Netlify', category: 'hosting', rules: ['header:x-nf-request-id=/.+/', 'header:server=/Netlify/i'] },
+    { name: 'GitHub Pages', category: 'hosting', rules: ['header:server=/GitHub\\.com/i'] },
+    { name: 'Google Analytics', category: 'analytics', rules: ['script=/google-analytics\\.com\\/(ga|analytics)\\.js/', 'html=/www\\.google-analytics\\.com/', 'html=/gtag\\(/'] },
+    { name: 'Google Tag Manager', category: 'analytics', rules: ['script=/googletagmanager\\.com\\/gtm\\.js/', 'html=/GTM-[A-Z0-9]+/'] },
+    { name: 'Plausible', category: 'analytics', rules: ['script=/plausible\\.io\\/js/'] },
+    { name: 'Fathom', category: 'analytics', rules: ['script=/cdn\\.usefathom\\.com/'] },
+    { name: 'Mixpanel', category: 'analytics', rules: ['html=/mixpanel/i', 'script=/cdn\\.mxpnl\\.com/'] },
+    { name: 'Segment', category: 'analytics', rules: ['script=/cdn\\.segment\\.com\\/analytics\\.js/'] },
+    { name: 'Hotjar', category: 'analytics', rules: ['script=/static\\.hotjar\\.com/'] },
+    { name: 'Amplitude', category: 'analytics', rules: ['script=/cdn\\.amplitude\\.com/'] },
+    { name: 'PostHog', category: 'analytics', rules: ['script=/posthog\\.com/', 'html=/posthog\\.init/'] },
+    { name: 'HubSpot', category: 'marketing', rules: ['script=/js\\.hs-scripts\\.com/', 'script=/js\\.hubspot\\.com/'] },
+    { name: 'Intercom', category: 'marketing', rules: ['script=/widget\\.intercom\\.io/', 'html=/intercomSettings/'] },
+    { name: 'Drift', category: 'marketing', rules: ['script=/js\\.driftt\\.com/'] },
+    { name: 'Tailwind CSS', category: 'ui', rules: ['html=/tailwind/i', 'script=/cdn\\.tailwindcss\\.com/'] },
+    { name: 'Bootstrap', category: 'ui', rules: ['script=/bootstrap(?:\\.min)?\\.(?:js|css)/'] },
+    { name: 'jQuery', category: 'frameworks', rules: ['script=/jquery(?:-[\\d\\.]+)?(?:\\.min)?\\.js/'] },
+];
+function compileRule(rule) {
+    const eqIdx = rule.indexOf('=');
+    const kind = rule.slice(0, eqIdx);
+    const body = rule.slice(eqIdx + 1);
+    const match = body.match(/^\/(.+)\/([gimsuy]*)$/);
+    const pattern = match ? new RegExp(match[1], match[2]) : new RegExp(body);
+    return { kind, pattern };
+}
+const COMPILED = SIGNATURES.map((sig) => ({
+    ...sig,
+    compiled: sig.rules.map(compileRule),
+}));
+export function detectTechStack({ url, $, html, headers, }) {
+    const normHeaders = {};
+    for (const [k, v] of Object.entries(headers || {})) {
+        normHeaders[k.toLowerCase()] = String(v ?? '');
+    }
+    const cookieBlob = normHeaders['set-cookie'] || '';
+    const scriptUrls = [];
+    $('script[src]').each((_, el) => {
+        scriptUrls.push($(el).attr('src') || '');
+    });
+    $('link[href]').each((_, el) => {
+        scriptUrls.push($(el).attr('href') || '');
+    });
+    const scriptBlob = scriptUrls.join('\n');
+    const metaByName = {};
+    $('meta[name]').each((_, el) => {
+        const name = ($(el).attr('name') || '').toLowerCase();
+        metaByName[name] = $(el).attr('content') || '';
+    });
+    const detected = [];
+    const seen = new Set();
+    for (const sig of COMPILED) {
+        let matched = 0;
+        const total = sig.compiled.length;
+        for (const rule of sig.compiled) {
+            if (rule.kind === 'html' && rule.pattern.test(html))
+                matched++;
+            else if (rule.kind === 'script' && rule.pattern.test(scriptBlob))
+                matched++;
+            else if (rule.kind === 'cookie' && rule.pattern.test(cookieBlob))
+                matched++;
+            else if (rule.kind.startsWith('header:')) {
+                const headerName = rule.kind.slice('header:'.length);
+                const value = normHeaders[headerName];
+                if (value && rule.pattern.test(value))
+                    matched++;
+            }
+            else if (rule.kind.startsWith('meta:')) {
+                const metaName = rule.kind.slice('meta:'.length);
+                const value = metaByName[metaName];
+                if (value && rule.pattern.test(value))
+                    matched++;
+            }
+        }
+        if (matched > 0 && !seen.has(sig.name)) {
+            seen.add(sig.name);
+            detected.push({
+                name: sig.name,
+                category: sig.category,
+                confidence: Math.min(1, matched / total),
+            });
+        }
+    }
+    const categorized = {};
+    for (const tech of detected) {
+        if (!categorized[tech.category])
+            categorized[tech.category] = [];
+        categorized[tech.category].push(tech.name);
+    }
+    return {
+        url,
+        technologies: detected,
+        categorized,
+        technologyCount: detected.length,
+    };
+}