company-dossier 0.1.0

package/dist/cli.js

@@ -0,0 +1,1527 @@
+#!/usr/bin/env node
+
+// src/collectors/dns.ts
+import { promises as dns } from "dns";
+
+// src/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+var USER_AGENT = "company-dossier/0.1 (+https://companydossier.lol)";
+function mkdirp(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function writeFileSafe(filePath, content) {
+  mkdirp(path.dirname(filePath));
+  fs.writeFileSync(filePath, content, "utf8");
+}
+function todayISO() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+function titleCase(str) {
+  return str.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+async function fetchText(url, timeoutMs = 1e4) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const resp = await fetch(url, {
+      signal: controller.signal,
+      headers: { "User-Agent": USER_AGENT }
+    });
+    if (!resp.ok) {
+      throw new Error(`HTTP ${resp.status}`);
+    }
+    return await resp.text();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchJSON(url, timeoutMs = 15e3) {
+  const text = await fetchText(url, timeoutMs);
+  return JSON.parse(text);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toDomain(input) {
+  return input.trim().replace(/^https?:\/\//i, "").replace(/\/.*$/, "").replace(/^www\./i, "").toLowerCase();
+}
+function looksLikeDomain(input) {
+  const trimmed = input.trim();
+  if (/^https?:\/\//i.test(trimmed)) {
+    return true;
+  }
+  return /^[a-z0-9-]+(\.[a-z0-9-]+)+$/i.test(trimmed) && !trimmed.includes(" ");
+}
+
+// src/collectors/dns.ts
+async function collectDns(domainInput) {
+  const domain = toDomain(domainInput);
+  const result = {
+    domain,
+    mxRecords: [],
+    emailProvider: "Unknown",
+    spfRecord: "",
+    dmarcRecord: "",
+    verificationTokens: [],
+    subdomains: []
+  };
+  try {
+    const mx = await dns.resolveMx(domain);
+    result.mxRecords = mx.map((r) => ({ exchange: r.exchange, priority: r.priority }));
+    const mxStr = mx.map((r) => r.exchange).join(" ").toLowerCase();
+    if (mxStr.includes("google") || mxStr.includes("gmail")) {
+      result.emailProvider = "Google Workspace";
+    } else if (mxStr.includes("outlook") || mxStr.includes("microsoft")) {
+      result.emailProvider = "Microsoft 365";
+    } else if (mxStr.includes("zoho")) {
+      result.emailProvider = "Zoho";
+    } else if (mxStr.includes("proton")) {
+      result.emailProvider = "ProtonMail";
+    } else if (mxStr.includes("amazonses") || mxStr.includes("amazon")) {
+      result.emailProvider = "Amazon SES";
+    }
+  } catch {
+  }
+  try {
+    const txt = await dns.resolveTxt(domain);
+    for (const record of txt) {
+      const joined = record.join("");
+      if (joined.startsWith("v=spf1")) {
+        result.spfRecord = joined;
+      }
+      if (joined.includes("google-site-verification") || joined.includes("MS=") || joined.includes("facebook-domain-verification") || joined.includes("apple-domain-verification") || joined.includes("atlassian-domain-verification")) {
+        result.verificationTokens.push(joined);
+      }
+    }
+  } catch {
+  }
+  try {
+    const dmarc = await dns.resolveTxt("_dmarc." + domain);
+    result.dmarcRecord = dmarc.map((r) => r.join("")).find((r) => r.startsWith("v=DMARC1")) || "";
+  } catch {
+  }
+  const subdomainChecks = ["www", "mail", "autodiscover", "blog", "shop", "app", "api"];
+  for (const sub of subdomainChecks) {
+    try {
+      const cname = await dns.resolveCname(sub + "." + domain);
+      if (cname.length > 0) {
+        result.subdomains.push(sub + "." + domain + " -> " + cname[0]);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+
+// src/collectors/website.ts
+function stripHtml(html) {
+  let text = html.replace(/<script[\s\S]*?<\/script>/gi, "");
+  text = text.replace(/<style[\s\S]*?<\/style>/gi, "");
+  text = text.replace(/<nav[\s\S]*?<\/nav>/gi, "");
+  text = text.replace(/<footer[\s\S]*?<\/footer>/gi, "");
+  text = text.replace(/<[^>]+>/g, " ");
+  text = text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ");
+  text = text.replace(/\s+/g, " ").trim();
+  return text;
+}
+function extractTitle(html) {
+  const m = html.match(/<title[^>]*>(.*?)<\/title>/is);
+  return m ? m[1].trim() : "";
+}
+function extractDescription(html) {
+  const m = html.match(/<meta[^>]+name=["']description["'][^>]+content=["']([^"']*)["']/i) || html.match(/<meta[^>]+content=["']([^"']*)["'][^>]+name=["']description["']/i);
+  return m ? m[1].trim() : "";
+}
+function extractHeadings(html) {
+  const headings = [];
+  const pattern = /<h[12][^>]*>(.*?)<\/h[12]>/gis;
+  let match;
+  while ((match = pattern.exec(html)) !== null) {
+    const text = match[1].replace(/<[^>]+>/g, "").trim();
+    if (text) {
+      headings.push(text);
+    }
+  }
+  return headings;
+}
+function extractEmails(text) {
+  const matches = text.match(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g);
+  return matches ? [...new Set(matches)] : [];
+}
+function extractPhones(text) {
+  const matches = text.match(/(?:\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g);
+  return matches ? [...new Set(matches)] : [];
+}
+function extractSocialLinks(html) {
+  const patterns = [
+    /https?:\/\/(?:www\.)?linkedin\.com\/company\/[^"'\s<>)]+/gi,
+    /https?:\/\/(?:www\.)?twitter\.com\/[^"'\s<>)]+/gi,
+    /https?:\/\/(?:www\.)?x\.com\/[^"'\s<>)]+/gi,
+    /https?:\/\/(?:www\.)?facebook\.com\/[^"'\s<>)]+/gi,
+    /https?:\/\/(?:www\.)?instagram\.com\/[^"'\s<>)]+/gi,
+    /https?:\/\/(?:www\.)?youtube\.com\/(?:@|channel\/|c\/)[^"'\s<>)]+/gi,
+    /https?:\/\/(?:www\.)?tiktok\.com\/@[^"'\s<>)]+/gi,
+    /https?:\/\/(?:www\.)?github\.com\/[^"'\s<>)]+/gi
+  ];
+  const links = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const matches = html.match(pattern);
+    if (matches) {
+      for (const m of matches) {
+        links.add(m);
+      }
+    }
+  }
+  return [...links];
+}
+function parseInternalLinks(html, origin) {
+  const urls = /* @__PURE__ */ new Set();
+  const hrefPattern = /href=["']([^"'#]+)["']/gi;
+  let match;
+  while ((match = hrefPattern.exec(html)) !== null) {
+    const href = match[1].trim();
+    if (/^(mailto:|tel:|javascript:|data:|#)/i.test(href)) {
+      continue;
+    }
+    try {
+      const resolved = new URL(href, origin);
+      if (resolved.origin === origin) {
+        resolved.hash = "";
+        urls.add(resolved.href);
+      }
+    } catch {
+    }
+  }
+  return [...urls];
+}
+function parseSitemapUrls(xml) {
+  const urls = [];
+  const locPattern = /<loc>(.*?)<\/loc>/g;
+  let match;
+  while ((match = locPattern.exec(xml)) !== null) {
+    urls.push(match[1].trim());
+  }
+  return urls;
+}
+async function processPage(url) {
+  try {
+    const html = await fetchText(url, 1e4);
+    const page = {
+      url,
+      title: extractTitle(html),
+      description: extractDescription(html),
+      headings: extractHeadings(html),
+      textContent: stripHtml(html).slice(0, 5e3)
+    };
+    return { page, html };
+  } catch {
+    return null;
+  }
+}
+async function collectWebsite(baseUrl, options = {}) {
+  const progress = options.progress || (() => {
+  });
+  const maxPages = options.maxPages ?? 25;
+  const result = {
+    url: baseUrl,
+    title: "",
+    description: "",
+    keywords: [],
+    socialLinks: [],
+    emails: [],
+    phones: [],
+    schemaOrg: null,
+    sitemapUrls: [],
+    robotsTxt: "",
+    rawHtml: "",
+    pages: [],
+    allEmails: [],
+    allPhones: [],
+    pageCount: 0
+  };
+  let origin;
+  try {
+    origin = new URL(baseUrl).origin;
+  } catch {
+    result.error = `Invalid URL: ${baseUrl}`;
+    return result;
+  }
+  const allEmailSet = /* @__PURE__ */ new Set();
+  const allPhoneSet = /* @__PURE__ */ new Set();
+  const allSocialSet = /* @__PURE__ */ new Set();
+  const crawledUrls = /* @__PURE__ */ new Set();
+  const urlsToCrawl = [];
+  progress("Fetching homepage...");
+  try {
+    const html = await fetchText(baseUrl, 15e3);
+    result.rawHtml = html;
+    result.title = extractTitle(html);
+    result.description = extractDescription(html);
+    const kwMatch = html.match(
+      /<meta[^>]+name=["']keywords["'][^>]+content=["']([^"']*)["']/i
+    );
+    if (kwMatch) {
+      result.keywords = kwMatch[1].split(",").map((k) => k.trim()).filter(Boolean);
+    }
+    const schemaMatches = html.match(
+      /<script[^>]+type=["']application\/ld\+json["'][^>]*>(.*?)<\/script>/gis
+    );
+    if (schemaMatches) {
+      try {
+        result.schemaOrg = JSON.parse(schemaMatches[0].replace(/<\/?script[^>]*>/gi, ""));
+      } catch {
+      }
+    }
+    extractEmails(html).forEach((e) => allEmailSet.add(e));
+    extractPhones(html).forEach((p) => allPhoneSet.add(p));
+    extractSocialLinks(html).forEach((s) => allSocialSet.add(s));
+    result.pages.push({
+      url: baseUrl,
+      title: result.title,
+      description: result.description,
+      headings: extractHeadings(html),
+      textContent: stripHtml(html).slice(0, 5e3)
+    });
+    crawledUrls.add(baseUrl);
+    crawledUrls.add(baseUrl.replace(/\/$/, ""));
+    const homeLinks = parseInternalLinks(html, origin);
+    for (const link of homeLinks) {
+      if (!crawledUrls.has(link) && !crawledUrls.has(link.replace(/\/$/, ""))) {
+        urlsToCrawl.push(link);
+        crawledUrls.add(link);
+      }
+    }
+    progress(`Homepage parsed. Found ${homeLinks.length} internal links.`);
+  } catch (err) {
+    result.error = err instanceof Error ? err.message : String(err);
+    return result;
+  }
+  progress("Fetching sitemap.xml...");
+  try {
+    const sitemapXml = await fetchText(origin + "/sitemap.xml", 1e4);
+    const sitemapUrls = parseSitemapUrls(sitemapXml);
+    result.sitemapUrls = sitemapUrls.slice(0, 500);
+    for (const sUrl of sitemapUrls) {
+      try {
+        const parsed = new URL(sUrl);
+        if (parsed.origin === origin && !crawledUrls.has(sUrl) && !crawledUrls.has(sUrl.replace(/\/$/, ""))) {
+          urlsToCrawl.push(sUrl);
+          crawledUrls.add(sUrl);
+        }
+      } catch {
+      }
+    }
+  } catch {
+    progress("Sitemap: not found or inaccessible.");
+  }
+  await sleep(300);
+  try {
+    result.robotsTxt = await fetchText(origin + "/robots.txt", 5e3);
+  } catch {
+  }
+  const pagesToCrawl = urlsToCrawl.slice(0, maxPages);
+  progress(`Crawling up to ${pagesToCrawl.length} internal pages...`);
+  for (let i = 0; i < pagesToCrawl.length; i++) {
+    const pageUrl = pagesToCrawl[i];
+    if (/\.(jpg|jpeg|png|gif|svg|webp|ico|css|js|woff|woff2|ttf|eot|mp4|mp3|zip|gz|pdf)(\?|$)/i.test(
+      pageUrl
+    )) {
+      continue;
+    }
+    if (i > 0) {
+      await sleep(300);
+    }
+    progress(`[${i + 1}/${pagesToCrawl.length}] Crawling: ${pageUrl}`);
+    const fetched = await processPage(pageUrl);
+    if (fetched) {
+      result.pages.push(fetched.page);
+      extractEmails(fetched.html).forEach((e) => allEmailSet.add(e));
+      extractPhones(fetched.html).forEach((p) => allPhoneSet.add(p));
+      extractSocialLinks(fetched.html).forEach((s) => allSocialSet.add(s));
+      if (pagesToCrawl.length < maxPages) {
+        const newLinks = parseInternalLinks(fetched.html, origin);
+        for (const link of newLinks) {
+          if (pagesToCrawl.length >= maxPages) {
+            break;
+          }
+          if (!crawledUrls.has(link) && !crawledUrls.has(link.replace(/\/$/, ""))) {
+            pagesToCrawl.push(link);
+            crawledUrls.add(link);
+          }
+        }
+      }
+    }
+  }
+  result.allEmails = [...allEmailSet];
+  result.allPhones = [...allPhoneSet];
+  result.socialLinks = [...allSocialSet];
+  result.emails = result.allEmails;
+  result.phones = result.allPhones;
+  result.pageCount = result.pages.length;
+  progress(
+    `Website crawl complete: ${result.pageCount} pages, ${result.allEmails.length} emails, ${result.allPhones.length} phones, ${result.socialLinks.length} social profiles.`
+  );
+  return result;
+}
+
+// src/collectors/wayback.ts
+function timestampToMonth(ts) {
+  return ts.slice(0, 4) + "-" + ts.slice(4, 6);
+}
+function formatTimestamp(ts) {
+  if (ts.length < 8) {
+    return ts;
+  }
+  return `${ts.slice(0, 4)}-${ts.slice(4, 6)}-${ts.slice(6, 8)}`;
+}
+function waybackUrl(timestamp, originalUrl) {
+  return `https://web.archive.org/web/${timestamp}/${originalUrl}`;
+}
+async function collectWayback(domainInput, progressCallback) {
+  const progress = progressCallback || (() => {
+  });
+  const domain = toDomain(domainInput);
+  const result = {
+    domain,
+    totalCaptures: 0,
+    firstCapture: "",
+    lastCapture: "",
+    uniqueUrls: [],
+    pdfUrls: [],
+    pdfWaybackUrls: [],
+    deletedPages: [],
+    contentTypeDistribution: {},
+    captureTimeline: [],
+    capturesPerMonth: 0,
+    siteGrowthSummary: ""
+  };
+  progress("Wayback: Querying all unique URLs...");
+  try {
+    const cdxUrl = `https://web.archive.org/cdx/search/cdx?url=${domain}/*&output=json&fl=timestamp,original,statuscode,mimetype&collapse=original&limit=2000`;
+    const data = await fetchJSON(cdxUrl, 3e4);
+    if (!Array.isArray(data) || data.length < 2) {
+      result.error = "No Wayback data found";
+      return result;
+    }
+    const rows = data.slice(1);
+    result.totalCaptures = rows.length;
+    const timestamps = rows.map((r) => String(r[0])).sort();
+    result.firstCapture = formatTimestamp(timestamps[0] || "");
+    result.lastCapture = formatTimestamp(timestamps[timestamps.length - 1] || "");
+    const urlSet = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      urlSet.add(String(row[1]));
+    }
+    result.uniqueUrls = [...urlSet].slice(0, 500);
+    const mimeCount = {};
+    for (const row of rows) {
+      const mime = String(row[3] || "unknown").split(";")[0].trim().toLowerCase();
+      const category = mime.includes("html") ? "HTML" : mime.includes("pdf") ? "PDF" : mime.includes("image") ? "Image" : mime.includes("javascript") || mime.includes("ecmascript") ? "JavaScript" : mime.includes("css") ? "CSS" : mime.includes("json") ? "JSON" : mime.includes("xml") ? "XML" : "Other";
+      mimeCount[category] = (mimeCount[category] || 0) + 1;
+    }
+    result.contentTypeDistribution = mimeCount;
+    const urlStatusMap = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const url = String(row[1]);
+      const status = String(row[2]);
+      const ts = String(row[0]);
+      if (!urlStatusMap.has(url)) {
+        urlStatusMap.set(url, { statuses: [], timestamps: [] });
+      }
+      urlStatusMap.get(url).statuses.push(status);
+      urlStatusMap.get(url).timestamps.push(ts);
+    }
+    for (const [url, info] of urlStatusMap) {
+      if (info.statuses.includes("200") && info.statuses[info.statuses.length - 1] !== "200") {
+        result.deletedPages.push(url);
+      }
+    }
+    progress(
+      `Wayback Q1: ${result.uniqueUrls.length} unique URLs, first: ${result.firstCapture}, last: ${result.lastCapture}`
+    );
+  } catch (err) {
+    result.error = "CDX query 1 failed: " + (err instanceof Error ? err.message : String(err));
+    return result;
+  }
+  await sleep(1500);
+  progress("Wayback: Querying PDFs...");
+  try {
+    const pdfCdxUrl = `https://web.archive.org/cdx/search/cdx?url=${domain}/*&output=json&fl=timestamp,original,statuscode,mimetype&mimetype=application/pdf&limit=500`;
+    const pdfData = await fetchJSON(pdfCdxUrl, 2e4);
+    if (Array.isArray(pdfData) && pdfData.length > 1) {
+      const pdfRows = pdfData.slice(1);
+      const pdfOriginals = /* @__PURE__ */ new Map();
+      for (const row of pdfRows) {
+        const orig = String(row[1]);
+        const ts = String(row[0]);
+        if (!pdfOriginals.has(orig) || ts > pdfOriginals.get(orig)) {
+          pdfOriginals.set(orig, ts);
+        }
+      }
+      result.pdfUrls = [...pdfOriginals.keys()];
+      const pdfEntries = [...pdfOriginals.entries()].slice(0, 10);
+      result.pdfWaybackUrls = pdfEntries.map(([orig, ts]) => waybackUrl(ts, orig));
+      progress(`Wayback Q2: ${result.pdfUrls.length} unique PDFs found.`);
+    } else {
+      progress("Wayback Q2: No PDFs found.");
+    }
+  } catch (err) {
+    progress("Wayback Q2 failed: " + (err instanceof Error ? err.message : String(err)));
+  }
+  await sleep(1500);
+  progress("Wayback: Querying capture timeline...");
+  try {
+    const timelineCdxUrl = `https://web.archive.org/cdx/search/cdx?url=${domain}/*&output=json&fl=timestamp&collapse=timestamp:6&limit=5000`;
+    const timelineData = await fetchJSON(timelineCdxUrl, 2e4);
+    if (Array.isArray(timelineData) && timelineData.length > 1) {
+      const timelineRows = timelineData.slice(1);
+      const monthCounts = /* @__PURE__ */ new Map();
+      for (const row of timelineRows) {
+        const month = timestampToMonth(String(row[0]));
+        monthCounts.set(month, (monthCounts.get(month) || 0) + 1);
+      }
+      const sortedMonths = [...monthCounts.entries()].sort(
+        (a, b) => a[0].localeCompare(b[0])
+      );
+      result.captureTimeline = sortedMonths.map(([month, count]) => ({ month, count }));
+      if (sortedMonths.length > 0) {
+        const totalMonthCaptures = sortedMonths.reduce((sum, [, c]) => sum + c, 0);
+        result.capturesPerMonth = Math.round(totalMonthCaptures / sortedMonths.length * 10) / 10;
+      }
+      if (sortedMonths.length >= 2) {
+        const firstYear = sortedMonths[0][0].slice(0, 4);
+        const lastYear = sortedMonths[sortedMonths.length - 1][0].slice(0, 4);
+        const yearSpan = parseInt(lastYear) - parseInt(firstYear) + 1;
+        const mid = Math.floor(sortedMonths.length / 2);
+        const firstHalfAvg = sortedMonths.slice(0, mid).reduce((s, [, c]) => s + c, 0) / Math.max(mid, 1);
+        const secondHalfAvg = sortedMonths.slice(mid).reduce((s, [, c]) => s + c, 0) / (sortedMonths.length - mid);
+        const growthPct = firstHalfAvg > 0 ? Math.round((secondHalfAvg - firstHalfAvg) / firstHalfAvg * 100) : 0;
+        result.siteGrowthSummary = `${yearSpan} years of captures (${firstYear}-${lastYear}). ${timelineRows.length} total timeline entries across ${sortedMonths.length} months. Avg ${result.capturesPerMonth} captures/month. Second-half activity ${growthPct >= 0 ? "+" : ""}${growthPct}% vs first-half.`;
+      }
+      progress(`Wayback Q3: ${result.captureTimeline.length} months of activity.`);
+    } else {
+      progress("Wayback Q3: No timeline data.");
+    }
+  } catch (err) {
+    progress("Wayback Q3 failed: " + (err instanceof Error ? err.message : String(err)));
+  }
+  progress(
+    `Wayback complete: ${result.totalCaptures} captures, ${result.pdfUrls.length} PDFs, ${result.deletedPages.length} deleted pages.`
+  );
+  return result;
+}
+
+// src/collectors/techstack.ts
+function extractTechStack(html) {
+  const result = {
+    cms: "Unknown",
+    analyticsIds: [],
+    gtmIds: [],
+    adPixels: [],
+    cdn: "",
+    frameworks: [],
+    metaGenerator: ""
+  };
+  try {
+    if (html.includes("wix.com") || html.includes("X-Wix")) {
+      result.cms = "Wix";
+    } else if (html.includes("wp-content") || html.includes("wordpress")) {
+      result.cms = "WordPress";
+    } else if (html.includes("Shopify.theme") || html.includes("cdn.shopify")) {
+      result.cms = "Shopify";
+    } else if (html.includes("squarespace.com") || html.includes("static1.squarespace")) {
+      result.cms = "Squarespace";
+    } else if (html.includes("webflow.com")) {
+      result.cms = "Webflow";
+    } else if (html.includes("ghost.io")) {
+      result.cms = "Ghost";
+    } else if (html.includes("hubspot")) {
+      result.cms = "HubSpot";
+    }
+    const genMatch = html.match(
+      /<meta[^>]+name=["']generator["'][^>]+content=["']([^"']*)["']/i
+    );
+    if (genMatch) {
+      result.metaGenerator = genMatch[1];
+    }
+    const ga4Matches = html.match(/G-[A-Z0-9]{6,}/g);
+    const uaMatches = html.match(/UA-\d{6,}-\d/g);
+    if (ga4Matches) {
+      result.analyticsIds.push(...new Set(ga4Matches));
+    }
+    if (uaMatches) {
+      result.analyticsIds.push(...new Set(uaMatches));
+    }
+    const gtmMatches = html.match(/GTM-[A-Z0-9]{4,}/g);
+    if (gtmMatches) {
+      result.gtmIds.push(...new Set(gtmMatches));
+    }
+    const fbPixel = html.match(/fbq\(['"]init['"],\s*['"](\d+)['"]/);
+    if (fbPixel) {
+      result.adPixels.push("Meta Pixel: " + fbPixel[1]);
+    }
+    if (/tiktok[^"']*pixel/i.test(html)) {
+      result.adPixels.push("TikTok Pixel");
+    }
+    if (/linkedin\.com\/px|_linkedin_partner_id/i.test(html)) {
+      result.adPixels.push("LinkedIn Insight Tag");
+    }
+    if (/thetradedesk|ttd/i.test(html)) {
+      result.adPixels.push("The Trade Desk");
+    }
+    if (html.includes("react") || html.includes("__NEXT_DATA__")) {
+      result.frameworks.push("React/Next.js");
+    }
+    if (html.includes("vue") || html.includes("__VUE__")) {
+      result.frameworks.push("Vue.js");
+    }
+    if (html.includes("angular")) {
+      result.frameworks.push("Angular");
+    }
+    if (html.includes("svelte")) {
+      result.frameworks.push("Svelte");
+    }
+    if (html.includes("cloudflare")) {
+      result.cdn = "Cloudflare";
+    } else if (html.includes("fastly")) {
+      result.cdn = "Fastly";
+    } else if (html.includes("akamai")) {
+      result.cdn = "Akamai";
+    } else if (html.includes("cloudfront")) {
+      result.cdn = "CloudFront (AWS)";
+    }
+  } catch (err) {
+    result.error = err instanceof Error ? err.message : String(err);
+  }
+  return result;
+}
+
+// src/collectors/search.ts
+async function urlExists(url, timeoutMs = 8e3) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const resp = await fetch(url, {
+      method: "HEAD",
+      signal: controller.signal,
+      redirect: "manual",
+      headers: { "User-Agent": USER_AGENT }
+    });
+    const status = resp.status;
+    return status === 200 || status === 301 || status === 302;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function generateSlugs(companyName) {
+  const base = companyName.toLowerCase().trim();
+  const slugs = /* @__PURE__ */ new Set();
+  slugs.add(base.replace(/[^a-z0-9]/g, ""));
+  slugs.add(
+    base.replace(/[^a-z0-9]+/g, "-").replace(/-+$/, "").replace(/^-+/, "")
+  );
+  slugs.add(
+    base.replace(/[^a-z0-9]+/g, "_").replace(/_+$/, "").replace(/^_+/, "")
+  );
+  const stripped = base.replace(/\b(inc|llc|corp|corporation|ltd|limited|co|company|group|holdings)\b/gi, "").trim();
+  if (stripped && stripped !== base) {
+    slugs.add(stripped.replace(/[^a-z0-9]/g, ""));
+    slugs.add(
+      stripped.replace(/[^a-z0-9]+/g, "-").replace(/-+$/, "").replace(/^-+/, "")
+    );
+  }
+  return [...slugs].filter((s) => s.length > 1);
+}
+function isGenericHandle(handle) {
+  const generic = /* @__PURE__ */ new Set([
+    "share",
+    "sharer",
+    "intent",
+    "home",
+    "search",
+    "login",
+    "signup",
+    "about",
+    "help",
+    "support",
+    "privacy",
+    "terms",
+    "policy",
+    "hashtag",
+    "explore",
+    "settings",
+    "legal"
+  ]);
+  return generic.has(handle.toLowerCase());
+}
+async function queryUSASpending(companyName, progress) {
+  progress("Search: Querying USASpending.gov...");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 2e4);
+  try {
+    const body = JSON.stringify({
+      filters: {
+        recipient_search_text: [companyName],
+        time_period: [
+          { start_date: "2010-01-01", end_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] }
+        ],
+        award_type_codes: ["A", "B", "C", "D"]
+      },
+      fields: [
+        "Award ID",
+        "Recipient Name",
+        "Total Obligation",
+        "Awarding Agency",
+        "Start Date",
+        "End Date",
+        "Description"
+      ],
+      limit: 25,
+      page: 1,
+      sort: "Total Obligation",
+      order: "desc"
+    });
+    const resp = await fetch("https://api.usaspending.gov/api/v2/search/spending_by_award/", {
+      method: "POST",
+      signal: controller.signal,
+      headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
+      body
+    });
+    if (!resp.ok) {
+      progress(`USASpending: HTTP ${resp.status}`);
+      return { awards: 0, total: 0, contracts: [] };
+    }
+    const data = await resp.json();
+    const awards = data.page_metadata?.total || 0;
+    const contracts = [];
+    let total = 0;
+    if (Array.isArray(data.results)) {
+      for (const r of data.results) {
+        const amt = parseFloat(String(r["Total Obligation"] ?? "0"));
+        if (!isNaN(amt)) {
+          total += amt;
+        }
+        contracts.push({
+          awardId: String(r["Award ID"] ?? ""),
+          recipientName: String(r["Recipient Name"] ?? ""),
+          totalObligation: isNaN(amt) ? 0 : amt,
+          awardingAgency: String(r["Awarding Agency"] ?? ""),
+          startDate: String(r["Start Date"] ?? ""),
+          endDate: String(r["End Date"] ?? ""),
+          description: String(r["Description"] ?? "")
+        });
+      }
+    }
+    progress(`USASpending: ${awards} awards, $${Math.round(total).toLocaleString()} total.`);
+    return { awards, total, contracts };
+  } catch (err) {
+    progress("USASpending: query failed \u2014 " + (err instanceof Error ? err.message : String(err)));
+    return { awards: 0, total: 0, contracts: [] };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function discoverSocialProfiles(companyName, progress) {
+  const slugs = generateSlugs(companyName);
+  const profiles = [];
+  const checked = /* @__PURE__ */ new Set();
+  const platforms = [
+    { name: "LinkedIn", template: (s) => `https://www.linkedin.com/company/${s}` },
+    { name: "Twitter/X", template: (s) => `https://x.com/${s}` },
+    { name: "Facebook", template: (s) => `https://www.facebook.com/${s}` },
+    { name: "Instagram", template: (s) => `https://www.instagram.com/${s}` },
+    { name: "YouTube", template: (s) => `https://www.youtube.com/@${s}` },
+    { name: "TikTok", template: (s) => `https://www.tiktok.com/@${s}` },
+    { name: "GitHub", template: (s) => `https://github.com/${s}` }
+  ];
+  progress(
+    `Search: Probing social profiles for ${slugs.length} slug(s) across ${platforms.length} platforms...`
+  );
+  for (const platform of platforms) {
+    for (const slug of slugs) {
+      const url = platform.template(slug);
+      if (checked.has(url)) {
+        continue;
+      }
+      checked.add(url);
+      if (profiles.some((p) => p.platform === platform.name)) {
+        break;
+      }
+      await sleep(700);
+      const exists = await urlExists(url);
+      if (exists) {
+        profiles.push({ platform: platform.name, url, source: "HEAD probe" });
+        progress(`Search: Found ${platform.name} profile.`);
+        break;
+      }
+    }
+  }
+  progress(`Search: ${profiles.length} social profiles discovered via probing.`);
+  return profiles;
+}
+function extractSocialFromPages(pageContents) {
+  const socialPatterns = [
+    { platform: "LinkedIn", regex: /https?:\/\/(?:www\.)?linkedin\.com\/company\/([a-zA-Z0-9_-]+)/g },
+    { platform: "Twitter/X", regex: /https?:\/\/(?:www\.)?(?:twitter\.com|x\.com)\/([a-zA-Z0-9_]+)/g },
+    { platform: "Facebook", regex: /https?:\/\/(?:www\.)?facebook\.com\/([a-zA-Z0-9._-]+)/g },
+    { platform: "Instagram", regex: /https?:\/\/(?:www\.)?instagram\.com\/([a-zA-Z0-9._]+)/g },
+    { platform: "YouTube", regex: /https?:\/\/(?:www\.)?youtube\.com\/(?:@|channel\/|c\/|user\/)([a-zA-Z0-9_-]+)/g },
+    { platform: "GitHub", regex: /https?:\/\/(?:www\.)?github\.com\/([a-zA-Z0-9_-]+)/g },
+    { platform: "TikTok", regex: /https?:\/\/(?:www\.)?tiktok\.com\/@([a-zA-Z0-9._]+)/g },
+    { platform: "Pinterest", regex: /https?:\/\/(?:www\.)?pinterest\.com\/([a-zA-Z0-9_-]+)/g },
+    { platform: "Glassdoor", regex: /https?:\/\/(?:www\.)?glassdoor\.com\/Overview\/[^"'\s]+/g },
+    { platform: "Crunchbase", regex: /https?:\/\/(?:www\.)?crunchbase\.com\/organization\/([a-zA-Z0-9_-]+)/g }
+  ];
+  const profiles = [];
+  const seen = /* @__PURE__ */ new Set();
+  const allHtml = pageContents.join("\n");
+  for (const { platform, regex } of socialPatterns) {
+    let match;
+    while ((match = regex.exec(allHtml)) !== null) {
+      const fullUrl = match[0];
+      const handle = match[1] || fullUrl;
+      const key = platform + ":" + handle.toLowerCase();
+      if (!seen.has(key) && !isGenericHandle(handle)) {
+        seen.add(key);
+        profiles.push({
+          platform,
+          url: fullUrl.startsWith("http") ? fullUrl : "https://" + fullUrl,
+          source: "website crawl"
+        });
+      }
+    }
+  }
+  return profiles;
+}
+async function collectSearch(companyName, options = {}) {
+  const progress = options.progress || (() => {
+  });
+  const result = {
+    companyName,
+    usaSpendingAwards: 0,
+    usaSpendingTotal: 0,
+    usaSpendingContracts: [],
+    socialProfiles: []
+  };
+  try {
+    const spending = await queryUSASpending(companyName, progress);
+    result.usaSpendingAwards = spending.awards;
+    result.usaSpendingTotal = spending.total;
+    result.usaSpendingContracts = spending.contracts;
+  } catch (err) {
+    progress("USASpending error: " + (err instanceof Error ? err.message : String(err)));
+  }
+  if (options.pageContents && options.pageContents.length > 0) {
+    try {
+      const extracted = extractSocialFromPages(options.pageContents);
+      const existingKeys = new Set(result.socialProfiles.map((p) => p.platform + ":" + p.url));
+      for (const profile of extracted) {
+        const key = profile.platform + ":" + profile.url;
+        if (!existingKeys.has(key)) {
+          result.socialProfiles.push(profile);
+          existingKeys.add(key);
+        }
+      }
+    } catch (err) {
+      progress("Social extraction error: " + (err instanceof Error ? err.message : String(err)));
+    }
+  }
+  if (options.probeSocial !== false) {
+    try {
+      const probed = await discoverSocialProfiles(companyName, progress);
+      const existingPlatforms = new Set(result.socialProfiles.map((p) => p.platform));
+      for (const p of probed) {
+        if (!existingPlatforms.has(p.platform)) {
+          result.socialProfiles.push(p);
+          existingPlatforms.add(p.platform);
+        }
+      }
+    } catch (err) {
+      progress("Social probe error: " + (err instanceof Error ? err.message : String(err)));
+    }
+  }
+  progress(
+    `Search complete: ${result.usaSpendingAwards} gov awards, ${result.socialProfiles.length} social profiles.`
+  );
+  return result;
+}
+
+// src/core.ts
+var SECTIONS = [
+  "overview",
+  "people",
+  "hiring",
+  "money",
+  "locations",
+  "tech",
+  "news",
+  "relationships",
+  "risk"
+];
+var GENERATOR = "company-dossier v0.1.0";
+var HOMEPAGE = "https://companydossier.lol";
+var GAP = "_Gap: no public data found \u2014 requires manual research._";
+function deriveCompanyName(target, website) {
+  const schemaName = website?.schemaOrg && typeof website.schemaOrg === "object" ? website.schemaOrg.name : void 0;
+  if (typeof schemaName === "string" && schemaName.trim()) {
+    return schemaName.trim();
+  }
+  if (!looksLikeDomain(target)) {
+    return target.trim();
+  }
+  if (website?.title) {
+    const seg = website.title.split(/[|–—\-:·]/)[0].trim();
+    if (seg && seg.length <= 60) {
+      return seg;
+    }
+  }
+  const domain = toDomain(target);
+  const root = domain.split(".")[0];
+  return titleCase(root);
+}
+function sourceLine(label) {
+  return `
+
+> Source: ${label}`;
+}
+function renderOverview(meta, d) {
+  const w = d.website;
+  const schema = w?.schemaOrg && typeof w.schemaOrg === "object" ? JSON.stringify(w.schemaOrg, null, 2) : null;
+  const desc = w?.description || "";
+  return `# 1. Overview & Identity \u2014 ${meta.companyName}
+
+| Field | Value | Source |
+|-------|-------|--------|
+| Company name | ${meta.companyName} | ${schema ? "Schema.org / HTML" : w?.title ? "HTML <title>" : "derived from domain"} |
+| Website | ${meta.websiteUrl || "N/A"} | input |
+| Domain | ${meta.domain} | input |
+| Page title | ${w?.title || "N/A"} | HTML \`<title>\` |
+| Description | ${desc || "N/A"} | meta description |
+| Pages crawled | ${w?.pageCount ?? 0} | website crawler |
+| Keywords | ${w?.keywords?.length ? w.keywords.join(", ") : "N/A"} | meta keywords |
+
+## Description
+
+${desc ? desc : GAP}${desc ? sourceLine(`${meta.websiteUrl} meta description`) : ""}
+
+## Schema.org (JSON-LD)
+
+${schema ? "```json\n" + schema + "\n```" + sourceLine(`${meta.websiteUrl} <script type="application/ld+json">`) : "_No schema.org JSON-LD found on the homepage._"}
+`;
+}
+function renderPeople(meta, d) {
+  const w = d.website;
+  const emails = w?.allEmails || [];
+  const personEmails = emails.filter((e) => /^[a-z]+([._-][a-z]+)?@/i.test(e));
+  return `# 2. People & Org Chart \u2014 ${meta.companyName}
+
+> People data from public pages is limited. Named individuals, titles, and an
+> org chart usually require LinkedIn, press, or filings \u2014 marked as gaps below.
+
+## Contact emails (${emails.length})
+
+${emails.length ? emails.map((e) => `- \`${e}\``).join("\n") + sourceLine("website crawl") : GAP}
+
+## Likely individual contacts
+
+${personEmails.length ? personEmails.map((e) => `- \`${e}\` (name-pattern email)`).join("\n") + sourceLine("inferred from email format \u2014 unverified") : "_No personal-pattern emails found._"}
+
+## Leadership & org chart
+
+${GAP}
+`;
+}
+function renderHiring(meta, d) {
+  const w = d.website;
+  const careerPages = (w?.pages || []).filter(
+    (p) => /career|job|hiring|join|work-with-us|vacanc|recruit/i.test(p.url + " " + p.title)
+  );
+  const sitemapCareer = (w?.sitemapUrls || []).filter((u) => /career|job|hiring|recruit/i.test(u));
+  return `# 3. Hiring Radar \u2014 ${meta.companyName}
+
+> Signals of growth and open roles, derived from the company's own site.
+
+## Careers / jobs pages found
+
+${careerPages.length ? careerPages.map((p) => `- [${p.title || p.url}](${p.url})`).join("\n") + sourceLine("website crawl") : "_No careers pages found during crawl._"}
+
+## Career URLs in sitemap
+
+${sitemapCareer.length ? sitemapCareer.slice(0, 30).map((u) => `- ${u}`).join("\n") + sourceLine("sitemap.xml") : "_None in sitemap (or no sitemap available)._"}
+
+## Open roles & headcount trend
+
+${GAP}
+`;
+}
+function renderMoney(meta, d) {
+  const s = d.search;
+  const contracts = s?.usaSpendingContracts || [];
+  let contractTable = "";
+  if (contracts.length) {
+    const total = s?.usaSpendingTotal || contracts.reduce((a, c) => a + c.totalObligation, 0);
+    contractTable = `### Federal contracts (USASpending.gov)
+
+> ${s?.usaSpendingAwards || contracts.length} awards found; top ${contracts.length} shown. Total obligated: $${Math.round(total).toLocaleString()}
+
+| Award ID | Agency | Amount | Period | Description |
+|----------|--------|--------|--------|-------------|
+${contracts.map(
+      (c) => `| ${c.awardId} | ${c.awardingAgency} | $${Math.round(c.totalObligation).toLocaleString()} | ${c.startDate} \u2192 ${c.endDate} | ${(c.description || "").slice(0, 80).replace(/\|/g, "/")} |`
+    ).join("\n")}${sourceLine("api.usaspending.gov")}`;
+  }
+  return `# 4. Money Trail \u2014 ${meta.companyName}
+
+> Public financial signals. Revenue, funding, and valuation for private
+> companies are rarely public and are marked as gaps.
+
+${contracts.length ? contractTable : "### Federal contracts\n\n_No USASpending.gov contract awards matched this name._"}
+
+## Funding, revenue & valuation
+
+${GAP}
+`;
+}
+function renderLocations(meta, d) {
+  const w = d.website;
+  const phones = w?.allPhones || [];
+  let address = "";
+  const schema = w?.schemaOrg;
+  if (schema && typeof schema === "object") {
+    const addr = schema.address;
+    if (addr) {
+      address = "```json\n" + JSON.stringify(addr, null, 2) + "\n```";
+    }
+  }
+  return `# 5. Locations \u2014 ${meta.companyName}
+
+## Address (schema.org)
+
+${address ? address + sourceLine("schema.org address") : "_No structured address found._"}
+
+## Phone numbers (${phones.length})
+
+${phones.length ? phones.map((p) => `- ${p}`).join("\n") + sourceLine("website crawl") : GAP}
+
+## Offices & facilities
+
+${GAP}
+`;
+}
+function renderTech(meta, d) {
+  const t = d.tech;
+  const dns2 = d.dns;
+  if (!t && !dns2) {
+    return `# 6. Tech Fingerprint \u2014 ${meta.companyName}
+
+${GAP}
+`;
+  }
+  const techBlock = t ? `## Web technology
+
+| Component | Value | Confidence |
+|-----------|-------|-----------|
+| CMS | ${t.cms} | ${t.cms !== "Unknown" ? "high" : "low"} |
+| Generator | ${t.metaGenerator || "Not detected"} | ${t.metaGenerator ? "high" : "low"} |
+| CDN | ${t.cdn || "Not detected"} | ${t.cdn ? "high" : "low"} |
+| Frameworks | ${t.frameworks.length ? t.frameworks.join(", ") : "Not detected"} | moderate |
+
+### Analytics
+${t.analyticsIds.length ? t.analyticsIds.map((id) => `- \`${id}\``).join("\n") : "_None detected._"}
+
+### Tag managers
+${t.gtmIds.length ? t.gtmIds.map((id) => `- \`${id}\``).join("\n") : "_None detected._"}
+
+### Advertising pixels
+${t.adPixels.length ? t.adPixels.map((p) => `- ${p}`).join("\n") : "_None detected._"}${sourceLine("HTML fingerprint of crawled pages")}` : "";
+  const dnsBlock = dns2 ? `## Email & DNS infrastructure
+
+**Email provider:** ${dns2.emailProvider} (from MX records)
+
+| Priority | MX Exchange |
+|----------|-------------|
+${dns2.mxRecords.length ? dns2.mxRecords.map((r) => `| ${r.priority} | ${r.exchange} |`).join("\n") : "| \u2014 | No MX records |"}
+
+**SPF:** \`${dns2.spfRecord || "none"}\`
+**DMARC:** \`${dns2.dmarcRecord || "none"}\`
+
+### Verification tokens
+${dns2.verificationTokens.length ? dns2.verificationTokens.map((v) => `- \`${v}\``).join("\n") : "_None found._"}
+
+### Subdomains (CNAME)
+${dns2.subdomains.length ? dns2.subdomains.map((s) => `- ${s}`).join("\n") : "_None detected._"}${sourceLine("DNS resolver (MX/TXT/CNAME)")}` : "";
+  return `# 6. Tech Fingerprint \u2014 ${meta.companyName}
+
+${techBlock}
+
+${dnsBlock}
+`;
+}
+function renderNews(meta, d) {
+  const wb = d.wayback;
+  if (!wb || wb.error) {
+    return `# 7. News & Timeline \u2014 ${meta.companyName}
+
+_Wayback Machine data unavailable${wb?.error ? `: ${wb.error}` : ""}._
+
+## Press & news
+
+${GAP}
+`;
+  }
+  const firstYear = wb.firstCapture ? wb.firstCapture.slice(0, 4) : "";
+  const lastYear = wb.lastCapture ? wb.lastCapture.slice(0, 4) : "";
+  const yearsActive = firstYear && lastYear ? parseInt(lastYear) - parseInt(firstYear) : 0;
+  const yearCounts = /* @__PURE__ */ new Map();
+  for (const entry of wb.captureTimeline) {
+    const year = entry.month.slice(0, 4);
+    yearCounts.set(year, (yearCounts.get(year) || 0) + entry.count);
+  }
+  const yearTable = [...yearCounts.entries()].map(([year, ct]) => `| ${year} | ${ct} |`).join("\n");
+  return `# 7. News & Timeline \u2014 ${meta.companyName}
+
+## Website history (Wayback Machine)
+
+| Metric | Value |
+|--------|-------|
+| First capture | ${wb.firstCapture || "Unknown"} |
+| Last capture | ${wb.lastCapture || "Unknown"} |
+| Years archived | ${yearsActive > 0 ? yearsActive : "Unknown"} |
+| Total captures | ${wb.totalCaptures} |
+| Unique URLs | ${wb.uniqueUrls.length} |
+| PDFs discovered | ${wb.pdfUrls.length} |
+| Deleted pages | ${wb.deletedPages.length} |
+
+${wb.siteGrowthSummary ? `**Growth:** ${wb.siteGrowthSummary}
+` : ""}
+${yearTable ? `### Captures by year
+
+| Year | Captures |
+|------|----------|
+${yearTable}
+` : ""}
+### Notable archived PDFs
+${wb.pdfWaybackUrls.length ? wb.pdfWaybackUrls.map((u) => `- ${u}`).join("\n") : "_None found._"}
+
+### Deleted pages (were live, now gone)
+${wb.deletedPages.length ? wb.deletedPages.slice(0, 30).map((u) => `- ${u}`).join("\n") : "_None detected._"}${sourceLine("web.archive.org CDX API")}
+
+## Press & news coverage
+
+${GAP}
+`;
+}
+function renderRelationships(meta, d) {
+  const s = d.search;
+  const w = d.website;
+  const social = s?.socialProfiles || [];
+  const merged = /* @__PURE__ */ new Map();
+  for (const p of social) {
+    merged.set(p.platform + ":" + p.url, p);
+  }
+  for (const link of w?.socialLinks || []) {
+    let platform = "Other";
+    if (/linkedin/i.test(link)) platform = "LinkedIn";
+    else if (/twitter|x\.com/i.test(link)) platform = "Twitter/X";
+    else if (/facebook/i.test(link)) platform = "Facebook";
+    else if (/instagram/i.test(link)) platform = "Instagram";
+    else if (/youtube/i.test(link)) platform = "YouTube";
+    else if (/tiktok/i.test(link)) platform = "TikTok";
+    else if (/github/i.test(link)) platform = "GitHub";
+    const key = platform + ":" + link;
+    if (!merged.has(key)) merged.set(key, { platform, url: link, source: "website HTML" });
+  }
+  const all = [...merged.values()];
+  return `# 8. Relationship Web \u2014 ${meta.companyName}
+
+## Social & external profiles (${all.length})
+
+${all.length ? all.map((p) => `- **${p.platform}**: [${p.url}](${p.url}) _(${p.source})_`).join("\n") : GAP}
+
+## Partners, suppliers & customers
+
+${GAP}
+`;
+}
+function renderRisk(meta, d) {
+  const flags = [];
+  const dns2 = d.dns;
+  const wb = d.wayback;
+  const w = d.website;
+  if (dns2 && !dns2.dmarcRecord) {
+    flags.push("No DMARC record \u2014 domain is more vulnerable to email spoofing. _(Source: DNS)_");
+  }
+  if (dns2 && !dns2.spfRecord) {
+    flags.push("No SPF record \u2014 sender policy not published. _(Source: DNS)_");
+  }
+  if (wb && !wb.error && wb.deletedPages.length > 0) {
+    flags.push(
+      `${wb.deletedPages.length} pages were live and are now gone \u2014 possible discontinued products or repositioning. _(Source: Wayback)_`
+    );
+  }
+  if (w?.error) {
+    flags.push(`Homepage was unreachable during crawl: ${w.error} _(Source: crawler)_`);
+  }
+  if (wb && !wb.error && wb.siteGrowthSummary.includes("-") && /-\d+%/.test(wb.siteGrowthSummary)) {
+    flags.push("Declining web-capture activity in the second half of history. _(Source: Wayback)_");
+  }
+  return `# 9. Risk Flags \u2014 ${meta.companyName}
+
+> Automated, low-confidence signals from public technical data. Not legal,
+> financial, or compliance advice. Verify before acting.
+
+## Detected flags
+
+${flags.length ? flags.map((f) => `- ${f}`).join("\n") : "_No automated risk flags raised from collected data._"}
+
+## Legal, regulatory & financial risk
+
+${GAP}
+`;
+}
+var RENDERERS = {
+  overview: renderOverview,
+  people: renderPeople,
+  hiring: renderHiring,
+  money: renderMoney,
+  locations: renderLocations,
+  tech: renderTech,
+  news: renderNews,
+  relationships: renderRelationships,
+  risk: renderRisk
+};
+var SECTION_FILENAMES = {
+  overview: "01_overview_identity.md",
+  people: "02_people_org_chart.md",
+  hiring: "03_hiring_radar.md",
+  money: "04_money_trail.md",
+  locations: "05_locations.md",
+  tech: "06_tech_fingerprint.md",
+  news: "07_news_timeline.md",
+  relationships: "08_relationship_web.md",
+  risk: "09_risk_flags.md"
+};
+var SECTION_TITLES = {
+  overview: "Overview & Identity",
+  people: "People & Org Chart",
+  hiring: "Hiring Radar",
+  money: "Money Trail",
+  locations: "Locations",
+  tech: "Tech Fingerprint",
+  news: "News & Timeline",
+  relationships: "Relationship Web",
+  risk: "Risk Flags"
+};
+function renderReadme(meta, sections) {
+  const sourceRows = meta.sources.map((s) => `| ${s.name} | ${s.status} | ${s.note || ""} |`).join("\n");
+  const nav = sections.map((id, i) => `| ${i + 1} | [${SECTION_TITLES[id]}](${SECTION_FILENAMES[id]}) |`).join("\n");
+  return `# ${meta.companyName} \u2014 Intelligence Dossier
+
+> Compiled from PUBLIC data only by ${GENERATOR} on ${meta.generatedAt}.
+> ${meta.homepage}
+
+**Target:** ${meta.target}  |  **Domain:** ${meta.domain}  |  **Website:** ${meta.websiteUrl || "N/A"}
+
+## Collection summary
+
+| Source | Status | Notes |
+|--------|--------|-------|
+${sourceRows}
+
+## Sections
+
+| # | Section |
+|---|---------|
+${nav}
+
+---
+
+Every derived claim is annotated with its source. Sections without public data
+are clearly marked as gaps requiring manual research. This dossier uses no
+private databases and no API keys are required.
+`;
+}
+async function buildDossier(target, opts = {}) {
+  const progress = opts.progress || (() => {
+  });
+  const sections = (opts.sections && opts.sections.length ? opts.sections : [...SECTIONS]).filter(
+    (s) => SECTIONS.includes(s)
+  );
+  const isDomain = looksLikeDomain(target);
+  const domain = isDomain ? toDomain(target) : "";
+  const websiteUrl = domain ? `https://${domain}` : "";
+  const needsWebsite = !!websiteUrl && sections.some(
+    (s) => ["overview", "people", "hiring", "locations", "tech", "relationships", "risk"].includes(s)
+  );
+  const needsDns = !!domain && sections.some((s) => ["tech", "risk"].includes(s));
+  const needsWayback = !!domain && sections.some((s) => ["news", "risk"].includes(s));
+  const data = {};
+  const sources = [];
+  if (needsWebsite) {
+    progress("Collecting website...");
+    data.website = await collectWebsite(websiteUrl, {
+      maxPages: opts.maxPages ?? 25,
+      progress
+    });
+    sources.push({
+      name: "Website crawl",
+      status: data.website.error ? "failed" : "ok",
+      note: data.website.error ? data.website.error : `${data.website.pageCount} pages, ${data.website.allEmails.length} emails`
+    });
+    if (data.website.rawHtml || data.website.pages.length) {
+      const allHtml = [data.website.rawHtml, ...data.website.pages.map((p) => p.textContent)].join(
+        "\n"
+      );
+      data.tech = extractTechStack(allHtml);
+      sources.push({ name: "Tech fingerprint", status: "ok", note: data.tech.cms });
+    }
+  }
+  const companyNameSeed = deriveCompanyName(target, data.website);
+  const tasks = [];
+  if (needsDns) {
+    tasks.push(
+      (async () => {
+        progress("Collecting DNS...");
+        data.dns = await collectDns(domain);
+        sources.push({
+          name: "DNS recon",
+          status: data.dns.error ? "failed" : "ok",
+          note: data.dns.error || `${data.dns.mxRecords.length} MX, provider ${data.dns.emailProvider}`
+        });
+      })()
+    );
+  }
+  if (needsWayback) {
+    tasks.push(
+      (async () => {
+        progress("Collecting Wayback history...");
+        data.wayback = await collectWayback(domain, progress);
+        sources.push({
+          name: "Wayback Machine",
+          status: data.wayback.error ? "failed" : "ok",
+          note: data.wayback.error || `${data.wayback.totalCaptures} captures`
+        });
+      })()
+    );
+  }
+  if (sections.some((s) => ["money", "relationships"].includes(s))) {
+    tasks.push(
+      (async () => {
+        progress("Collecting public search...");
+        const pageContents = data.website?.rawHtml || data.website?.pages.length ? [data.website.rawHtml, ...data.website.pages.map((p) => p.textContent) || []] : void 0;
+        data.search = await collectSearch(companyNameSeed, {
+          progress,
+          pageContents,
+          probeSocial: !opts.skipSocialProbe
+        });
+        sources.push({
+          name: "Public search",
+          status: data.search.error ? "failed" : "ok",
+          note: `${data.search.usaSpendingContracts.length} contracts, ${data.search.socialProfiles.length} social profiles`
+        });
+      })()
+    );
+  }
+  await Promise.all(tasks);
+  const companyName = deriveCompanyName(target, data.website);
+  const meta = {
+    target,
+    companyName,
+    domain: domain || "(name only)",
+    websiteUrl,
+    generatedAt: todayISO(),
+    generator: GENERATOR,
+    homepage: HOMEPAGE,
+    sectionsRequested: sections,
+    sources
+  };
+  const files = [];
+  files.push({ path: "README.md", content: renderReadme(meta, sections) });
+  for (const id of sections) {
+    files.push({ path: SECTION_FILENAMES[id], content: RENDERERS[id](meta, data) });
+  }
+  const json = {
+    meta,
+    data
+  };
+  files.push({ path: "dossier.json", content: JSON.stringify(json, null, 2) });
+  progress("Dossier assembled.");
+  return { meta, json, files };
+}
+
+// src/index.ts
+import * as path2 from "path";
+function writeDossier(result, outDir) {
+  const folderName = `${result.meta.companyName} DOSSIER`.trim();
+  const safeFolder = folderName.replace(/[/\\]/g, "_");
+  const target = path2.join(outDir, safeFolder);
+  for (const file of result.files) {
+    writeFileSafe(path2.join(target, file.path), file.content);
+  }
+  return target;
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var HELP = `company-dossier v${VERSION}
+Build a complete, sourced intelligence dossier on any company from public data.
+
+USAGE
+  company-dossier <company-or-domain> [options]
+
+ARGUMENTS
+  <company-or-domain>   A domain (acme.com / https://acme.com) or a company name.
+                        Domains unlock the full collector set; a bare name still
+                        produces a dossier from public search.
+
+OPTIONS
+  --out <dir>           Output directory (default: current directory).
+  --json                Print the dossier JSON to stdout instead of writing files.
+  --sections <list>     Comma-separated subset of sections to build.
+                        Available: ${SECTIONS.join(", ")}
+  --max-pages <n>       Max internal pages to crawl (default: 25).
+  --no-social-probe     Skip slow HEAD-probing of social platforms.
+  --quiet               Suppress progress output.
+  -h, --help            Show this help.
+  -v, --version         Show version.
+
+ENVIRONMENT
+  COMPANY_DOSSIER_ANTHROPIC_KEY   Optional. Reserved for future AI enrichment.
+                                  A useful dossier is produced WITHOUT any key.
+
+EXAMPLES
+  company-dossier acme.com
+  company-dossier acme.com --out ./research --quiet
+  company-dossier "Acme Corporation"
+  company-dossier acme.com --json > acme.json
+  company-dossier acme.com --sections overview,tech,risk
+
+Public sources only \u2014 no private databases, no API keys required.
+Learn more: https://companydossier.lol
+`;
+function parseArgs(argv) {
+  const out = {
+    out: process.cwd(),
+    json: false,
+    quiet: false,
+    skipSocialProbe: false,
+    help: false,
+    version: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case "-h":
+      case "--help":
+        out.help = true;
+        break;
+      case "-v":
+      case "--version":
+        out.version = true;
+        break;
+      case "--json":
+        out.json = true;
+        break;
+      case "--quiet":
+        out.quiet = true;
+        break;
+      case "--no-social-probe":
+        out.skipSocialProbe = true;
+        break;
+      case "--out":
+        out.out = argv[++i] ?? out.out;
+        break;
+      case "--max-pages": {
+        const n = parseInt(argv[++i] ?? "", 10);
+        if (!isNaN(n) && n > 0) out.maxPages = n;
+        break;
+      }
+      case "--sections": {
+        const list = (argv[++i] ?? "").split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+        const valid = list.filter(
+          (s) => SECTIONS.includes(s)
+        );
+        const invalid = list.filter((s) => !SECTIONS.includes(s));
+        if (invalid.length) {
+          out.error = `Unknown section(s): ${invalid.join(", ")}. Valid: ${SECTIONS.join(", ")}`;
+        }
+        out.sections = valid;
+        break;
+      }
+      default:
+        if (a.startsWith("-")) {
+          out.error = `Unknown option: ${a}`;
+        } else if (!out.target) {
+          out.target = a;
+        }
+    }
+  }
+  return out;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (args.version) {
+    process.stdout.write(VERSION + "\n");
+    return 0;
+  }
+  if (args.error) {
+    process.stderr.write(`Error: ${args.error}
+
+Run "company-dossier --help".
+`);
+    return 2;
+  }
+  if (!args.target) {
+    process.stderr.write("Error: missing <company-or-domain>.\n\n" + HELP);
+    return 2;
+  }
+  const log = args.quiet ? () => {
+  } : (msg) => process.stderr.write(msg + "\n");
+  const opts = {
+    out: args.out,
+    json: args.json,
+    sections: args.sections,
+    maxPages: args.maxPages,
+    skipSocialProbe: args.skipSocialProbe,
+    progress: log,
+    apiKeys: {
+      anthropic: process.env.COMPANY_DOSSIER_ANTHROPIC_KEY
+    }
+  };
+  let result;
+  try {
+    result = await buildDossier(args.target, opts);
+  } catch (err) {
+    process.stderr.write(
+      `Fatal: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return 1;
+  }
+  if (args.json) {
+    process.stdout.write(JSON.stringify(result.json, null, 2) + "\n");
+    return 0;
+  }
+  const folder = writeDossier(result, args.out);
+  log(`
+Dossier written to: ${folder}`);
+  log(`Files: ${result.files.map((f) => f.path).join(", ")}`);
+  if (!args.quiet) {
+    process.stdout.write(folder + "\n");
+  }
+  return 0;
+}
+main().then((code) => process.exit(code)).catch((err) => {
+  process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});