autonitia-intel 0.2.0__tar.gz

autonitia_intel-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Autonitia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

autonitia_intel-0.2.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: autonitia-intel
+Version: 0.2.0
+Summary: Turn any business website into a clean, structured company profile — a graph-based extraction engine.
+Author: Syed Mukarramuddin
+License: MIT
+Project-URL: Homepage, https://github.com/Autonitia/autonitia-intel
+Project-URL: Repository, https://github.com/Autonitia/autonitia-intel
+Keywords: web-scraping,llm,company-data,lead-generation,openai,extraction,graph
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: lxml>=5.0
+Requires-Dist: openai>=1.40
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: cloudscraper>=1.2.71
+Requires-Dist: playwright>=1.40
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# autonitia-intel
+
+Turn any business website into a clean, structured company profile — and a quick read on where the opportunities are.
+
+Point it at a URL and get back the company's details (description, services, contact info, social presence) plus the tools and capabilities its site exposes. It also tells you how many opportunities a given **lens** (automation, marketing, sales…) would surface.
+
+## Install
+
+```bash
+pip install autonitia-intel
+playwright install chromium      # only needed for JavaScript-heavy sites
+export OPENAI_API_KEY=sk-...      # or pass api_key in the config
+```
+
+## Use it
+
+```python
+from autonitia_intel import ProfileGraph
+
+config = {
+    "llm": {"model": "gpt-4o-mini"},   # add "api_key": "sk-..." or use the env var
+    "lens": "automation",              # automation | marketing | sales | …
+    "verbose": True,
+}
+
+graph = ProfileGraph(source="https://example.com", config=config)
+result = graph.run()
+
+print(result.model_dump_json(indent=2))
+```
+
+Prefer the command line?
+
+```bash
+python run.py https://example.com --lens marketing --json
+```
+
+## What you get
+
+```json
+{
+  "target_company": {
+    "name": "Example Co",
+    "industry": "Real Estate",
+    "description": "...",
+    "location": "Dubai, UAE",
+    "contact": { "phones": ["..."], "emails": ["..."], "addresses": ["..."] }
+  },
+  "digital_presence": { "social_media": { "linkedin": "...", "instagram": "..." } },
+  "capabilities_present": ["phone", "whatsapp", "online_booking"],
+  "pro_features": { "lens": "automation", "opportunities_found": 2 }
+}
+```
+
+## How it works
+
+It fetches the site politely (respecting `robots.txt`, with retries and a real-browser fallback for JS-heavy pages), uses one LLM call to read out the company profile, and runs fast local checks to spot the tools and capabilities present. The opportunity count for a lens is computed locally — no guessing.
+
+## Lenses
+
+A **lens** is the perspective you analyse a site through — `automation`, `marketing`, `sales`, and more. Lenses and the signals they look for are defined as simple **YAML packs** in [`autonitia_intel/signal_packs/`](autonitia_intel/signal_packs), so you can add a new lens or industry pack without touching the Python.
+
+## Contributing
+
+Contributions welcome — the easiest place to start is a signal pack: drop a YAML file under `signal_packs/lenses/` or `signal_packs/industries/` and open a PR. Run the tests with `pytest -m "not integration"`.
+
+## Hosted version
+
+This open-source engine gives you the profile and the opportunity count. The hosted **Autonitia Intel** turns those opportunities into verified, ranked, outreach-ready intelligence over a REST API.
+
+**→ Docs & access: [autonitia.ai/intel](https://autonitia.ai/intel)**
+
+| | Free — `autonitia-intel` | Hosted — Autonitia Intel |
+|---|:---:|:---:|
+| Company profile + contact + socials | ✅ | ✅ |
+| Tool & capability detection | ✅ | ✅ |
+| Opportunity count | ✅ | — |
+| Verified capability analysis | — | ✅ |
+| Pain signals with evidence | — | ✅ |
+| Scoring (fit / opportunity / confidence) | — | ✅ |
+| Offer matching + ranked opportunities | — | ✅ |
+| Outreach messages | — | ✅ |
+| External enrichment (founders, HQ, funding) | — | ✅ |
+| REST API, async jobs, webhooks, CRM export | — | ✅ |
+
+## License
+
+MIT — see [LICENSE](LICENSE).

autonitia_intel-0.2.0/README.md

@@ -0,0 +1,88 @@
+# autonitia-intel
+
+Turn any business website into a clean, structured company profile — and a quick read on where the opportunities are.
+
+Point it at a URL and get back the company's details (description, services, contact info, social presence) plus the tools and capabilities its site exposes. It also tells you how many opportunities a given **lens** (automation, marketing, sales…) would surface.
+
+## Install
+
+```bash
+pip install autonitia-intel
+playwright install chromium      # only needed for JavaScript-heavy sites
+export OPENAI_API_KEY=sk-...      # or pass api_key in the config
+```
+
+## Use it
+
+```python
+from autonitia_intel import ProfileGraph
+
+config = {
+    "llm": {"model": "gpt-4o-mini"},   # add "api_key": "sk-..." or use the env var
+    "lens": "automation",              # automation | marketing | sales | …
+    "verbose": True,
+}
+
+graph = ProfileGraph(source="https://example.com", config=config)
+result = graph.run()
+
+print(result.model_dump_json(indent=2))
+```
+
+Prefer the command line?
+
+```bash
+python run.py https://example.com --lens marketing --json
+```
+
+## What you get
+
+```json
+{
+  "target_company": {
+    "name": "Example Co",
+    "industry": "Real Estate",
+    "description": "...",
+    "location": "Dubai, UAE",
+    "contact": { "phones": ["..."], "emails": ["..."], "addresses": ["..."] }
+  },
+  "digital_presence": { "social_media": { "linkedin": "...", "instagram": "..." } },
+  "capabilities_present": ["phone", "whatsapp", "online_booking"],
+  "pro_features": { "lens": "automation", "opportunities_found": 2 }
+}
+```
+
+## How it works
+
+It fetches the site politely (respecting `robots.txt`, with retries and a real-browser fallback for JS-heavy pages), uses one LLM call to read out the company profile, and runs fast local checks to spot the tools and capabilities present. The opportunity count for a lens is computed locally — no guessing.
+
+## Lenses
+
+A **lens** is the perspective you analyse a site through — `automation`, `marketing`, `sales`, and more. Lenses and the signals they look for are defined as simple **YAML packs** in [`autonitia_intel/signal_packs/`](autonitia_intel/signal_packs), so you can add a new lens or industry pack without touching the Python.
+
+## Contributing
+
+Contributions welcome — the easiest place to start is a signal pack: drop a YAML file under `signal_packs/lenses/` or `signal_packs/industries/` and open a PR. Run the tests with `pytest -m "not integration"`.
+
+## Hosted version
+
+This open-source engine gives you the profile and the opportunity count. The hosted **Autonitia Intel** turns those opportunities into verified, ranked, outreach-ready intelligence over a REST API.
+
+**→ Docs & access: [autonitia.ai/intel](https://autonitia.ai/intel)**
+
+| | Free — `autonitia-intel` | Hosted — Autonitia Intel |
+|---|:---:|:---:|
+| Company profile + contact + socials | ✅ | ✅ |
+| Tool & capability detection | ✅ | ✅ |
+| Opportunity count | ✅ | — |
+| Verified capability analysis | — | ✅ |
+| Pain signals with evidence | — | ✅ |
+| Scoring (fit / opportunity / confidence) | — | ✅ |
+| Offer matching + ranked opportunities | — | ✅ |
+| Outreach messages | — | ✅ |
+| External enrichment (founders, HQ, funding) | — | ✅ |
+| REST API, async jobs, webhooks, CRM export | — | ✅ |
+
+## License
+
+MIT — see [LICENSE](LICENSE).

autonitia_intel-0.2.0/autonitia_intel/__init__.py

@@ -0,0 +1,27 @@
+"""
+autonitia-intel — open-source business-website profile extractor.
+
+The FREE engine turns any business website into a clean structured profile
+(company facts, contact details, social presence, detected tools/capabilities)
+plus a *pro_features* count of opportunities. The intelligence layer — verified
+signals, scoring, offer matching, outreach — is Autonitia Intel Pro, which
+imports these same building blocks.
+
+Quick start:
+
+    from autonitia_intel import ProfileGraph
+
+    graph = ProfileGraph(lens="automation")          # bring your own key via env or args
+    profile = graph.run("https://example.com")
+    print(profile.model_dump_json(indent=2))
+
+Bring your own model key:
+
+    ProfileGraph(api_key="sk-...", model="gpt-4o-mini")
+"""
+
+from .graph import ProfileGraph
+from .models import CompanyProfile, ProfileResult
+
+__version__ = "0.2.0"
+__all__ = ["ProfileGraph", "CompanyProfile", "ProfileResult"]

autonitia_intel-0.2.0/autonitia_intel/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

autonitia_intel-0.2.0/autonitia_intel/cli.py

@@ -0,0 +1,56 @@
+"""
+CLI: autonitia-intel analyse — extract a company profile (+ opportunity pro_features).
+
+Example:
+    python -m autonitia_intel analyse --target-url https://example.com --lens automation
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .config import OUTPUT_DIR
+from .graph import ProfileGraph
+from .lenses import LENSES
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="autonitia-intel", description="Business-website profile extractor (free tier).")
+    sub = parser.add_subparsers(dest="command")
+
+    a = sub.add_parser("analyse", help="Extract a profile from a business website")
+    a.add_argument("--target-url", required=True)
+    a.add_argument("--lens", default="automation", choices=LENSES, help="Lens used only for the opportunity pro_features count")
+    a.add_argument("--api-key", default=None, help="Bring your own model key (overrides env)")
+    a.add_argument("--model", default=None, help="Model id (overrides env)")
+    a.add_argument("--no-cache", action="store_true")
+    a.add_argument("--no-telemetry", action="store_true")
+    a.add_argument("--quiet", action="store_true")
+
+    args = parser.parse_args(argv)
+    if args.command != "analyse":
+        parser.print_help()
+        sys.exit(1)
+
+    graph = ProfileGraph(
+        lens=args.lens,
+        telemetry=not args.no_telemetry,
+        verbose=not args.quiet,
+        api_key=args.api_key,
+        model=args.model,
+    )
+    if not args.quiet:
+        print(f"Analysing {args.target_url} (lens={args.lens}) ...")
+    result = graph.run(args.target_url, use_cache=not args.no_cache)
+
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    name = (result.target_company.name or "result").replace("/", "_").replace(" ", "_")
+    path = OUTPUT_DIR / f"{name}_profile.json"
+    path.write_text(result.model_dump_json(indent=2))
+
+    print(f"\nSaved: {path}\n")
+    print(result.model_dump_json(indent=2))
+
+
+if __name__ == "__main__":
+    main()

autonitia_intel-0.2.0/autonitia_intel/config.py

@@ -0,0 +1,36 @@
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+BROWSER_HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/125.0.0.0 Safari/537.36"
+    ),
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9",
+}
+
+CACHE_DIR = Path(__file__).parent.parent / "output" / ".cache"
+OUTPUT_DIR = Path(__file__).parent.parent / "output"
+REQUEST_TIMEOUT = 15
+MAX_CONTENT_CHARS = 24_000   # overall budget sent to the LLM
+PER_PAGE_CHARS = 6_000       # per-page cap so no single page (e.g. a bloated homepage) starves the rest
+MAX_SUBPAGES = 3
+
+# Crawling politeness/resilience
+RESPECT_ROBOTS = os.getenv("AUTONITIA_RESPECT_ROBOTS", "true").lower() != "false"
+FETCH_RETRIES = int(os.getenv("AUTONITIA_FETCH_RETRIES", "2"))   # extra attempts on transient errors
+ROBOTS_UA = "autonitia-intel"
+
+# Telemetry — see telemetry/telemetry.py. Nothing is sent over the network in v0.1.
+# Level 1 (execution metrics) is opt-OUT. Level 2 (dataset capture) is opt-IN.
+TELEMETRY_ENABLED = os.getenv("AUTONITIA_TELEMETRY", "true").lower() != "false"
+DATASET_CONTRIBUTION = os.getenv("AUTONITIA_DATASET", "false").lower() == "true"

autonitia_intel-0.2.0/autonitia_intel/detection/__init__.py

@@ -0,0 +1,4 @@
+from .capabilities import detect_capabilities, extract_contacts
+from .fingerprints import detect_tools
+
+__all__ = ["detect_capabilities", "detect_tools", "extract_contacts"]

autonitia_intel-0.2.0/autonitia_intel/detection/capabilities.py

@@ -0,0 +1,136 @@
+"""
+Deterministic capability + digital-presence detection.
+
+Inspects raw HTML across all fetched pages to determine observable facts:
+lead-capture methods, social links, SEO basics, tracking. No LLM.
+
+These are FACTS (present/absent), which become the evidence base for signals.
+"""
+
+import re
+
+from ..detection.fingerprints import detect_tools
+from ..models import Capabilities, SEO, SocialMedia, Tracking
+
+SOCIAL_PATTERNS = {
+    "facebook": r"https?://(?:www\.)?facebook\.com/[A-Za-z0-9_.\-/]+",
+    "instagram": r"https?://(?:www\.)?instagram\.com/[A-Za-z0-9_.\-/]+",
+    "linkedin": r"https?://(?:[a-z]{2}\.)?linkedin\.com/(?:company|in)/[A-Za-z0-9_.\-/]+",
+    "tiktok": r"https?://(?:www\.)?tiktok\.com/@[A-Za-z0-9_.\-/]+",
+    "youtube": r"https?://(?:www\.)?youtube\.com/[A-Za-z0-9_.\-/@]+",
+    "x": r"https?://(?:www\.)?(?:twitter|x)\.com/[A-Za-z0-9_]+",
+}
+
+# STRONG patterns = a real third-party tool / explicit URL → trustworthy, the
+# LLM verifier may NOT downgrade these. WEAK patterns = generic text heuristics
+# ("book now") that are easily wrong → the LLM verifier MAY override them.
+BOOKING_STRONG = [r"calendly\.com", r"fresha\.com", r"acuityscheduling\.com", r"booksy\.com",
+                  r"simplybook\.(me|it)", r"setmore\.com", r"squareup\.com/appointments"]
+BOOKING_WEAK = [r"book\s*now", r"book\s*online", r"schedule\s*(an?\s*)?appointment", r"book\s*a\s*viewing"]
+
+LIVE_CHAT_STRONG = [r"intercom", r"driftt?\.com", r"tidio", r"tawk\.to", r"crisp\.chat", r"hs-scripts"]
+LIVE_CHAT_WEAK = [r"livechat", r"chat\s*with\s*us", r"live\s*chat"]
+
+WHATSAPP_STRONG = [r"wa\.me/", r"api\.whatsapp\.com", r"whatsapp://", r"web\.whatsapp\.com",
+                   r"chat\.whatsapp\.com", r"wa\.link/"]
+WHATSAPP_WEAK = [r"click\s*to\s*whatsapp", r'aria-label=["\'][^"\']*whatsapp', r"whatsapp\s*us"]
+
+NEWSLETTER_STRONG = [r"chimpstatic", r"klaviyo", r"list-manage\.com"]
+NEWSLETTER_WEAK = [r"newsletter", r"subscribe"]
+
+# These have no reliable "strong" structural signal — treat as weak (downgradable).
+PRICING_WEAK = [r"/pricing", r">\s*pricing\s*<", r">\s*plans\s*<", r"per\s*month", r"/mo\b"]
+CASE_STUDY_WEAK = [r"case\s*stud", r"success\s*stor", r"/portfolio", r"testimonial"]
+FORM_WEAK = [r"<form[\s>]"]  # a <form> could be search/login, not a contact form → downgradable
+
+PHONE_PATTERN = r"tel:\+?[\d\s\-()]{7,}"
+EMAIL_PATTERN = r"mailto:[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+"
+
+# Capabilities the LLM verifier is allowed to downgrade when only a WEAK signal fired.
+DOWNGRADABLE = {"has_online_booking", "has_whatsapp", "has_live_chat",
+                "has_pricing", "has_case_studies", "has_contact_form", "has_newsletter"}
+
+
+def _any(patterns: list[str], html: str) -> bool:
+    return any(re.search(p, html, re.IGNORECASE) for p in patterns)
+
+
+_EMAIL_RE = re.compile(r"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}")
+_TEL_RE = re.compile(r'tel:(\+?[\d\s\-()]{7,})', re.IGNORECASE)
+_WA_RE = re.compile(r'(https?://(?:wa\.me|wa\.link|api\.whatsapp\.com|web\.whatsapp\.com|chat\.whatsapp\.com)/[^\s"\'<>]+)', re.IGNORECASE)
+
+
+def extract_contacts(html: str) -> dict:
+    """Deterministic contact extraction — a backstop/merge for the LLM output."""
+    emails = sorted({m.group(0) for m in _EMAIL_RE.finditer(html)
+                     if not m.group(0).lower().endswith((".png", ".jpg", ".gif", ".webp", ".svg"))})
+    phones = sorted({re.sub(r"\s+", " ", m.group(1)).strip() for m in _TEL_RE.finditer(html)})
+    wa = ""
+    m = _WA_RE.search(html)
+    if m:
+        wa = m.group(1)
+    return {"emails": emails, "phones": phones, "whatsapp": wa}
+
+
+def detect_capabilities(combined_html: str):
+    """
+    Returns (capabilities, social, seo, tracking, tools, strongly_detected).
+
+    `strongly_detected` is the set of capability names backed by a STRONG
+    structural signal (a real tool/URL). The LLM verifier may only downgrade
+    capabilities NOT in this set.
+    """
+    booking_strong = _any(BOOKING_STRONG, combined_html)
+    chat_strong = _any(LIVE_CHAT_STRONG, combined_html)
+    wa_strong = _any(WHATSAPP_STRONG, combined_html)
+    news_strong = _any(NEWSLETTER_STRONG, combined_html)
+
+    caps = Capabilities(
+        has_phone=bool(re.search(PHONE_PATTERN, combined_html, re.IGNORECASE)),
+        has_email=bool(re.search(EMAIL_PATTERN, combined_html, re.IGNORECASE)),
+        has_contact_form=_any(FORM_WEAK, combined_html),
+        has_whatsapp=wa_strong or _any(WHATSAPP_WEAK, combined_html),
+        has_online_booking=booking_strong or _any(BOOKING_WEAK, combined_html),
+        has_live_chat=chat_strong or _any(LIVE_CHAT_WEAK, combined_html),
+        has_pricing=_any(PRICING_WEAK, combined_html),
+        has_case_studies=_any(CASE_STUDY_WEAK, combined_html),
+        has_newsletter=news_strong or _any(NEWSLETTER_WEAK, combined_html),
+    )
+
+    strongly_detected = set()
+    if booking_strong:
+        strongly_detected.add("has_online_booking")
+    if chat_strong:
+        strongly_detected.add("has_live_chat")
+    if wa_strong:
+        strongly_detected.add("has_whatsapp")
+    if news_strong:
+        strongly_detected.add("has_newsletter")
+
+    social = SocialMedia()
+    for field, pattern in SOCIAL_PATTERNS.items():
+        m = re.search(pattern, combined_html, re.IGNORECASE)
+        if m:
+            # Skip share/intent links — keep only profile-looking URLs
+            url = m.group(0)
+            if "sharer" not in url and "intent" not in url and "/share" not in url:
+                setattr(social, field, url)
+    caps.has_social_links = any(getattr(social, f) for f in SOCIAL_PATTERNS)
+
+    seo = SEO(
+        title_tag_present=bool(re.search(r"<title[\s>]", combined_html, re.IGNORECASE)),
+        meta_description_present=bool(re.search(r'<meta[^>]+name=["\']description["\']', combined_html, re.IGNORECASE)),
+    )
+
+    tools = detect_tools(combined_html)
+    tool_names = {t["name"] for t in tools}
+    tracking = Tracking(
+        google_analytics="Google Analytics" in tool_names,
+        google_tag_manager="Google Tag Manager" in tool_names,
+        meta_pixel="Meta Pixel" in tool_names,
+        tiktok_pixel="TikTok Pixel" in tool_names,
+        linkedin_pixel="LinkedIn Insight" in tool_names,
+        hotjar="Hotjar" in tool_names,
+    )
+
+    return caps, social, seo, tracking, tools, strongly_detected

autonitia_intel-0.2.0/autonitia_intel/detection/fingerprints.py

@@ -0,0 +1,63 @@
+"""
+Deterministic technology detection.
+
+A pragmatic subset of Wappalyzer-style fingerprints: each entry matches a
+substring/regex in the raw HTML. NO LLM involved — this is fact, not inference,
+which is why it's the most defensible signal in the product.
+
+For production, swap this dict for the full Wappalyzer fingerprint database
+(https://github.com/enthec/webappanalyzer) — same matching approach, ~3000 apps.
+"""
+
+import re
+
+# name -> (category, [patterns], confidence)
+FINGERPRINTS: dict[str, tuple[str, list[str], float]] = {
+    # CMS / site builders
+    "WordPress": ("cms", [r"wp-content", r"wp-includes"], 0.92),
+    "Shopify": ("ecommerce", [r"cdn\.shopify\.com", r"Shopify\.theme"], 0.95),
+    "Wix": ("cms", [r"static\.wixstatic\.com", r"_wixCssImports"], 0.9),
+    "Webflow": ("cms", [r"assets\.website-files\.com", r"webflow\.js", r"wf-"], 0.88),
+    "Squarespace": ("cms", [r"squarespace", r"static1\.squarespace\.com"], 0.9),
+    "WooCommerce": ("ecommerce", [r"woocommerce", r"wc-ajax"], 0.85),
+    # Analytics / tracking
+    "Google Analytics": ("analytics", [r"google-analytics\.com", r"gtag\(", r"ga\('create'"], 0.9),
+    "Google Tag Manager": ("analytics", [r"googletagmanager\.com"], 0.92),
+    "Meta Pixel": ("marketing_tracking", [r"fbq\(", r"connect\.facebook\.net/[a-z_]+/fbevents\.js"], 0.93),
+    "TikTok Pixel": ("marketing_tracking", [r"analytics\.tiktok\.com"], 0.9),
+    "LinkedIn Insight": ("marketing_tracking", [r"snap\.licdn\.com"], 0.9),
+    "Hotjar": ("analytics", [r"static\.hotjar\.com", r"hotjar"], 0.85),
+    # CRM / marketing / chat
+    "HubSpot": ("crm", [r"js\.hs-scripts\.com", r"hs-scripts"], 0.9),
+    "Intercom": ("live_chat", [r"widget\.intercom\.io", r"intercomSettings"], 0.9),
+    "Drift": ("live_chat", [r"js\.driftt\.com", r"drift\.com"], 0.88),
+    "Tidio": ("live_chat", [r"code\.tidio\.co"], 0.9),
+    "Tawk.to": ("live_chat", [r"embed\.tawk\.to"], 0.9),
+    "Crisp": ("live_chat", [r"client\.crisp\.chat"], 0.9),
+    "Mailchimp": ("email_marketing", [r"chimpstatic\.com", r"list-manage\.com"], 0.85),
+    "Klaviyo": ("email_marketing", [r"klaviyo"], 0.85),
+    # Booking / forms
+    "Calendly": ("booking", [r"calendly\.com"], 0.92),
+    "Fresha": ("booking", [r"fresha\.com"], 0.9),
+    "Acuity Scheduling": ("booking", [r"acuityscheduling\.com"], 0.9),
+    "Booksy": ("booking", [r"booksy\.com"], 0.9),
+    "SimplyBook": ("booking", [r"simplybook\.(me|it)"], 0.88),
+    "Typeform": ("forms", [r"typeform\.com"], 0.88),
+    "Jotform": ("forms", [r"jotform\.com"], 0.88),
+}
+
+
+def detect_tools(html: str) -> list[dict]:
+    """Return a list of detected tools: {name, category, confidence, evidence}."""
+    found = []
+    for name, (category, patterns, confidence) in FINGERPRINTS.items():
+        for pat in patterns:
+            if re.search(pat, html, re.IGNORECASE):
+                found.append({
+                    "name": name,
+                    "category": category,
+                    "confidence": confidence,
+                    "evidence": f"matched /{pat}/",
+                })
+                break
+    return found

autonitia_intel-0.2.0/autonitia_intel/fetchers/__init__.py

@@ -0,0 +1,4 @@
+from .fetcher import fetch_html
+from .robots import RobotsDisallowed, allowed
+
+__all__ = ["fetch_html", "RobotsDisallowed", "allowed"]