inboxscan 0.1.0__tar.gz

inboxscan-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sravya Vedantham
+
+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.

inboxscan-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: inboxscan
+Version: 0.1.0
+Summary: Find every subscription hiding in your email — zero credentials stored, nothing leaves your machine.
+Author: Sravya Vedantham
+License: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Dynamic: license-file

inboxscan-0.1.0/README.md

@@ -0,0 +1,75 @@
+# inboxscan
+
+Find every subscription hiding in your email. See exactly what you're paying for.
+
+Zero credentials stored. Nothing leaves your machine.
+
+## Install
+
+```bash
+pip install inboxscan
+```
+
+## Usage
+
+```bash
+# Scan one Gmail account
+inboxscan run --email you@gmail.com
+
+# Scan multiple accounts
+inboxscan run --email work@gmail.com --email personal@gmail.com
+
+# Get cancellation instructions
+inboxscan cancel netflix
+inboxscan cancel adobe
+
+# Print version
+inboxscan version
+```
+
+## Example output
+
+```
+INBOXSCAN REPORT
+════════════════════════════════════════════════════════════
+Scanned: personal@gmail.com, work@gmail.com
+Found: 8 subscriptions  |  Total burn: $142.93/mo
+
+ [ACTIVE]   Netflix          $15.99/mo   Mar 01   personal@gmail.com
+ [ACTIVE]   Claude Pro       $20.00/mo   Mar 01   work@gmail.com
+ [ACTIVE]   Adobe CC         $54.99/mo   Mar 03   work@gmail.com
+ [ACTIVE]   GitHub Pro        $4.00/mo   Mar 05   work@gmail.com
+ [ACTIVE]   Spotify          $10.99/mo   Mar 02   personal@gmail.com
+ [DORMANT]  Audible          $14.95/mo   Nov 02   personal@gmail.com
+ [DORMANT]  Skillshare        $9.99/mo   Oct 15   personal@gmail.com
+
+════════════════════════════════════════════════════════════
+Potential savings: $24.94/mo (cancel DORMANT subscriptions)
+
+Run 'inboxscan cancel <service>' for cancellation steps.
+```
+
+## Gmail App Password
+
+1. Go to [myaccount.google.com/security](https://myaccount.google.com/security)
+2. Enable 2-Step Verification
+3. Search "App passwords" → create one named "inboxscan"
+4. Use that 16-character password when prompted
+
+Your password is used only for the IMAP connection and is never stored.
+
+## Privacy contract
+
+- No credentials stored — app password used only during the scan session
+- No network calls beyond Gmail IMAP fetch
+- All processing happens locally on your machine
+- Results cached in `~/.inboxscan/cache.db` (your machine only)
+- Zero telemetry
+
+## Detects 40+ services
+
+Netflix, Spotify, Adobe CC, GitHub Pro, Figma, Notion, Linear, Slack, Zoom, Dropbox, Claude Pro, ChatGPT Plus, Amazon Prime, Apple One, Google One, Microsoft 365, Canva Pro, Audible, Skillshare, Duolingo Plus, Grammarly, 1Password, NordVPN, Hulu, Disney+, YouTube Premium, Cursor Pro, Vercel, Railway, Supabase, Sentry, Datadog, Cloudflare, and more.
+
+## License
+
+MIT

inboxscan-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "inboxscan"
+version = "0.1.0"
+description = "Find every subscription hiding in your email — zero credentials stored, nothing leaves your machine."
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Sravya Vedantham" }]
+dependencies = [
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "mypy>=1.0.0",
+    "black>=23.0.0",
+    "isort>=5.0.0",
+    "flake8>=6.0.0",
+]
+
+[project.scripts]
+inboxscan = "inboxscan.cli:app"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--tb=short"
+
+[tool.black]
+line-length = 88
+target-version = ["py310"]
+
+[tool.isort]
+profile = "black"

inboxscan-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

inboxscan-0.1.0/src/inboxscan/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

inboxscan-0.1.0/src/inboxscan/cache.py

@@ -0,0 +1,62 @@
+import sqlite3
+from datetime import date
+from pathlib import Path
+from typing import Optional
+
+from inboxscan.models import ScanResult, Subscription, SubscriptionStatus
+
+CACHE_PATH = Path.home() / ".inboxscan" / "cache.db"
+
+
+def _get_conn(path: Path = CACHE_PATH) -> sqlite3.Connection:
+    path.parent.mkdir(exist_ok=True)
+    conn = sqlite3.connect(path)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS subscriptions (
+            service_name TEXT,
+            amount REAL,
+            currency TEXT,
+            billing_frequency TEXT,
+            last_charge_date TEXT,
+            source_email TEXT,
+            status TEXT,
+            cancellation_url TEXT
+        )
+    """)
+    conn.commit()
+    return conn
+
+
+def save_result(result: ScanResult, path: Path = CACHE_PATH) -> None:
+    conn = _get_conn(path)
+    conn.execute("DELETE FROM subscriptions")
+    for sub in result.subscriptions:
+        conn.execute(
+            "INSERT INTO subscriptions VALUES (?,?,?,?,?,?,?,?)",
+            (sub.service_name, sub.amount, sub.currency, sub.billing_frequency,
+             sub.last_charge_date.isoformat(), sub.source_email,
+             sub.status.value, sub.cancellation_url),
+        )
+    conn.commit()
+    conn.close()
+
+
+def load_result(path: Path = CACHE_PATH) -> Optional[ScanResult]:
+    if not path.exists():
+        return None
+    conn = _get_conn(path)
+    rows = conn.execute("SELECT * FROM subscriptions").fetchall()
+    conn.close()
+    if not rows:
+        return None
+    subs = [
+        Subscription(
+            service_name=r[0], amount=r[1], currency=r[2],
+            billing_frequency=r[3],
+            last_charge_date=date.fromisoformat(r[4]),
+            source_email=r[5], status=SubscriptionStatus(r[6]),
+            cancellation_url=r[7],
+        )
+        for r in rows
+    ]
+    return ScanResult(subscriptions=subs)

inboxscan-0.1.0/src/inboxscan/canceller.py

@@ -0,0 +1,36 @@
+from rich.console import Console
+from inboxscan.detector import KNOWN_SERVICES
+
+console = Console()
+
+CANCELLATION_TEMPLATES: dict[str, str] = {
+    "Netflix": "Subject: Cancel My Subscription\n\nPlease cancel my Netflix subscription immediately and confirm via email.",
+    "Spotify": "Subject: Subscription Cancellation Request\n\nPlease cancel my Spotify Premium subscription and confirm.",
+    "Adobe CC": "Subject: Cancel Creative Cloud Subscription\n\nI would like to cancel my Adobe Creative Cloud subscription. Please process this immediately.",
+    "Audible": "Subject: Cancel Audible Membership\n\nPlease cancel my Audible membership immediately and confirm cancellation.",
+    "Skillshare": "Subject: Cancel Skillshare Subscription\n\nPlease cancel my Skillshare subscription effective immediately.",
+}
+
+
+def cancel_service(service_name: str) -> None:
+    matched = None
+    for domain, (name, url, _) in KNOWN_SERVICES.items():
+        if name.lower() == service_name.lower():
+            matched = (name, url)
+            break
+
+    if not matched:
+        console.print(f"[red]Unknown service: {service_name}[/red]")
+        console.print("Run [bold]inboxscan run[/bold] to see your active subscriptions.")
+        return
+
+    name, url = matched
+    console.print(f"\n[bold]Cancel {name}[/bold]")
+    console.print("─" * 40)
+    console.print(f"Cancellation page: [link={url}]{url}[/link]")
+
+    template = CANCELLATION_TEMPLATES.get(name)
+    if template:
+        console.print("\n[bold]Email template:[/bold]")
+        console.print(f"[dim]{template}[/dim]")
+    console.print()

inboxscan-0.1.0/src/inboxscan/cli.py

@@ -0,0 +1,67 @@
+import typer
+from typing import Optional
+from rich.console import Console
+from inboxscan import __version__
+
+app = typer.Typer(help="Find every subscription hiding in your email.")
+console = Console()
+
+
+@app.command()
+def run(
+    email: list[str] = typer.Option(..., "--email", "-e", help="Email address to scan (repeat for multiple)"),
+    password: Optional[str] = typer.Option(None, "--password", "-p", help="Gmail app password (prompted if not provided)"),
+):
+    """Scan your email for active subscriptions."""
+    from inboxscan.models import EmailAccount, ScanResult
+    from inboxscan.connector import fetch_emails
+    from inboxscan.parser import parse_raw_email
+    from inboxscan.detector import detect_service
+    from inboxscan.reporter import print_report
+    from inboxscan.cache import save_result
+
+    all_subscriptions = []
+    seen_services: set[str] = set()
+
+    for email_addr in email:
+        pw = password or typer.prompt(f"Gmail app password for {email_addr}", hide_input=True)
+        account = EmailAccount(email=email_addr, password=pw)
+        console.print(f"\n[dim]Scanning {email_addr}...[/dim]")
+
+        for msg_id, raw in fetch_emails(account):
+            parsed = parse_raw_email(raw, msg_id, email_addr)
+            if parsed is None:
+                continue
+            sub = detect_service(parsed)
+            if sub is None:
+                continue
+            key = f"{sub.service_name}:{email_addr}"
+            if key in seen_services:
+                continue
+            seen_services.add(key)
+            sub.source_email = email_addr
+            all_subscriptions.append(sub)
+
+    result = ScanResult(
+        accounts_scanned=email,
+        subscriptions=all_subscriptions,
+    )
+    save_result(result)
+    print_report(result)
+
+
+@app.command()
+def cancel(service: str = typer.Argument(..., help="Service name (e.g. netflix, spotify)")):
+    """Print cancellation instructions for a service."""
+    from inboxscan.canceller import cancel_service
+    cancel_service(service)
+
+
+@app.command()
+def version():
+    """Print the current version."""
+    console.print(f"inboxscan {__version__}")
+
+
+if __name__ == "__main__":
+    app()

inboxscan-0.1.0/src/inboxscan/connector.py

@@ -0,0 +1,35 @@
+import imaplib
+from typing import Iterator
+
+from inboxscan.models import EmailAccount
+
+SEARCH_SUBJECTS = [
+    "receipt", "invoice", "billing", "subscription",
+    "renewal", "payment confirmed", "charged",
+]
+
+
+def build_search_query() -> str:
+    parts = [f'SUBJECT "{kw}"' for kw in SEARCH_SUBJECTS]
+    query = parts[0]
+    for part in parts[1:]:
+        query = f"OR ({query}) ({part})"
+    return query
+
+
+def fetch_emails(account: EmailAccount) -> Iterator[tuple[str, bytes]]:
+    with imaplib.IMAP4_SSL(account.imap_host, account.imap_port) as imap:
+        imap.login(account.email, account.password)
+        imap.select("INBOX", readonly=True)
+        query = build_search_query()
+        _, message_numbers = imap.search(None, query)
+        if not message_numbers or not message_numbers[0]:
+            return
+        ids = message_numbers[0].split()
+        ids = ids[-500:]
+        for msg_id in ids:
+            _, data = imap.fetch(msg_id, "(RFC822)")
+            if data and data[0]:
+                raw = data[0][1]
+                if isinstance(raw, bytes):
+                    yield msg_id.decode(), raw

inboxscan-0.1.0/src/inboxscan/detector.py

@@ -0,0 +1,80 @@
+import re
+from datetime import date, timedelta
+from typing import Optional
+
+from inboxscan.models import ParsedEmail, Subscription, SubscriptionStatus
+
+KNOWN_SERVICES: dict[str, tuple[str, str, str]] = {
+    "netflix.com": ("Netflix", "https://www.netflix.com/cancelplan", "monthly"),
+    "spotify.com": ("Spotify", "https://www.spotify.com/account/subscription/cancel", "monthly"),
+    "notion.so": ("Notion", "https://www.notion.so/profile/billing", "monthly"),
+    "adobe.com": ("Adobe CC", "https://account.adobe.com/plans", "monthly"),
+    "github.com": ("GitHub Pro", "https://github.com/settings/billing", "monthly"),
+    "figma.com": ("Figma", "https://www.figma.com/settings#billing", "monthly"),
+    "linear.app": ("Linear", "https://linear.app/settings/billing", "monthly"),
+    "slack.com": ("Slack", "https://slack.com/intl/en-us/help/articles/203875027", "monthly"),
+    "zoom.us": ("Zoom", "https://zoom.us/billing", "monthly"),
+    "dropbox.com": ("Dropbox", "https://www.dropbox.com/account/plan", "monthly"),
+    "atlassian.com": ("Atlassian", "https://admin.atlassian.com/", "monthly"),
+    "anthropic.com": ("Claude Pro", "https://claude.ai/settings", "monthly"),
+    "openai.com": ("ChatGPT Plus", "https://chat.openai.com/account/billing", "monthly"),
+    "amazon.com": ("Amazon Prime", "https://www.amazon.com/manageprime", "annual"),
+    "apple.com": ("Apple One", "https://appleid.apple.com/account/manage", "monthly"),
+    "google.com": ("Google One", "https://one.google.com/about", "monthly"),
+    "microsoft.com": ("Microsoft 365", "https://account.microsoft.com/services", "annual"),
+    "canva.com": ("Canva Pro", "https://www.canva.com/settings/billing", "monthly"),
+    "audible.com": ("Audible", "https://www.audible.com/account/optout", "monthly"),
+    "skillshare.com": ("Skillshare", "https://www.skillshare.com/settings/membership", "annual"),
+    "duolingo.com": ("Duolingo Plus", "https://www.duolingo.com/settings/subscription", "monthly"),
+    "grammarly.com": ("Grammarly", "https://account.grammarly.com/subscription", "monthly"),
+    "1password.com": ("1Password", "https://my.1password.com/", "annual"),
+    "dashlane.com": ("Dashlane", "https://app.dashlane.com/settings/subscription", "annual"),
+    "nordvpn.com": ("NordVPN", "https://my.nordaccount.com/dashboard/nordvpn/", "annual"),
+    "expressvpn.com": ("ExpressVPN", "https://www.expressvpn.com/subscriptions", "annual"),
+    "hulu.com": ("Hulu", "https://secure.hulu.com/account/cancel", "monthly"),
+    "disneyplus.com": ("Disney+", "https://www.disneyplus.com/account/subscription", "monthly"),
+    "youtube.com": ("YouTube Premium", "https://www.youtube.com/paid_memberships", "monthly"),
+    "cursor.sh": ("Cursor Pro", "https://cursor.sh/settings", "monthly"),
+    "vercel.com": ("Vercel Pro", "https://vercel.com/account/billing", "monthly"),
+    "render.com": ("Render", "https://dashboard.render.com/billing", "monthly"),
+    "railway.app": ("Railway", "https://railway.app/account/billing", "monthly"),
+    "supabase.com": ("Supabase", "https://supabase.com/dashboard/account/billing", "monthly"),
+    "datadog.com": ("Datadog", "https://app.datadoghq.com/billing/plan", "monthly"),
+    "sentry.io": ("Sentry", "https://sentry.io/settings/billing/", "monthly"),
+    "cloudflare.com": ("Cloudflare", "https://dash.cloudflare.com/profile/billing", "monthly"),
+    "twilio.com": ("Twilio", "https://console.twilio.com/billing", "monthly"),
+    "mailchimp.com": ("Mailchimp", "https://us1.admin.mailchimp.com/account/billing/", "monthly"),
+}
+
+DORMANT_THRESHOLD_DAYS = 90
+
+
+def _extract_sender_domain(sender: str) -> str:
+    match = re.search(r"@([\w.]+)", sender)
+    return match.group(1).lower() if match else ""
+
+
+def detect_service(parsed_email: ParsedEmail) -> Optional[Subscription]:
+    domain = _extract_sender_domain(parsed_email.sender)
+    for service_domain, (name, cancel_url, frequency) in KNOWN_SERVICES.items():
+        if domain.endswith(service_domain):
+            if parsed_email.amount is None:
+                return None
+            return Subscription(
+                service_name=name,
+                amount=parsed_email.amount,
+                currency=parsed_email.currency,
+                billing_frequency=frequency,
+                last_charge_date=parsed_email.date,
+                source_email="",
+                status=classify_status(parsed_email.date),
+                cancellation_url=cancel_url,
+            )
+    return None
+
+
+def classify_status(last_charge_date: date) -> SubscriptionStatus:
+    days_since = (date.today() - last_charge_date).days
+    if days_since <= DORMANT_THRESHOLD_DAYS:
+        return SubscriptionStatus.ACTIVE
+    return SubscriptionStatus.DORMANT

inboxscan-0.1.0/src/inboxscan/models.py

@@ -0,0 +1,70 @@
+from dataclasses import dataclass, field
+from datetime import date
+from enum import Enum
+from typing import Optional
+
+
+class SubscriptionStatus(str, Enum):
+    ACTIVE = "ACTIVE"
+    DORMANT = "DORMANT"
+    UNKNOWN = "UNKNOWN"
+
+
+@dataclass
+class EmailAccount:
+    email: str
+    password: str  # Gmail app password — never stored
+    imap_host: str = "imap.gmail.com"
+    imap_port: int = 993
+
+
+@dataclass
+class ParsedEmail:
+    message_id: str
+    sender: str
+    subject: str
+    date: date
+    body_text: str
+    amount: Optional[float] = None
+    currency: str = "USD"
+
+
+@dataclass
+class Subscription:
+    service_name: str
+    amount: float
+    currency: str
+    billing_frequency: str  # "monthly", "annual", "unknown"
+    last_charge_date: date
+    source_email: str  # which account found this
+    status: SubscriptionStatus = SubscriptionStatus.ACTIVE
+    cancellation_url: Optional[str] = None
+
+
+@dataclass
+class ScanResult:
+    accounts_scanned: list[str] = field(default_factory=list)
+    subscriptions: list[Subscription] = field(default_factory=list)
+    unknown_charges: int = 0
+
+    @property
+    def total_monthly_burn(self) -> float:
+        total = 0.0
+        for sub in self.subscriptions:
+            if sub.status == SubscriptionStatus.ACTIVE:
+                if sub.billing_frequency == "annual":
+                    total += sub.amount / 12
+                else:
+                    total += sub.amount
+        return round(total, 2)
+
+    @property
+    def dormant_monthly_waste(self) -> float:
+        total = 0.0
+        for sub in self.subscriptions:
+            if sub.status == SubscriptionStatus.DORMANT:
+                if sub.billing_frequency == "annual":
+                    total += sub.amount / 12
+                else:
+                    total += sub.amount
+        return round(total, 2)

inboxscan-0.1.0/src/inboxscan/parser.py

@@ -0,0 +1,80 @@
+import email
+import re
+from datetime import date, datetime
+from email.message import Message
+from typing import Optional
+
+from inboxscan.models import ParsedEmail
+
+SUBSCRIPTION_KEYWORDS = [
+    "receipt", "invoice", "billing", "payment confirmed",
+    "subscription", "renewal", "charged", "your order",
+    "monthly plan", "annual plan", "membership",
+]
+
+AMOUNT_PATTERNS = [
+    r"\$\s*(\d+\.\d{2})",
+    r"USD\s*(\d+\.\d{2})",
+    r"(\d+\.\d{2})\s*USD",
+    r"amount[:\s]+\$?(\d+\.\d{2})",
+    r"charged[:\s]+\$?(\d+\.\d{2})",
+    r"total[:\s]+\$?(\d+\.\d{2})",
+]
+
+
+def is_subscription_email(subject: str) -> bool:
+    subject_lower = subject.lower()
+    return any(kw in subject_lower for kw in SUBSCRIPTION_KEYWORDS)
+
+
+def parse_amount(text: str) -> Optional[float]:
+    for pattern in AMOUNT_PATTERNS:
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            try:
+                return float(match.group(1))
+            except ValueError:
+                continue
+    return None
+
+
+def extract_body_text(msg: Message) -> str:
+    body = ""
+    if msg.is_multipart():
+        for part in msg.walk():
+            if part.get_content_type() == "text/plain":
+                payload = part.get_payload(decode=True)
+                if payload:
+                    body += payload.decode("utf-8", errors="ignore")
+    else:
+        payload = msg.get_payload(decode=True)
+        if payload:
+            body = payload.decode("utf-8", errors="ignore")
+    return body
+
+
+def parse_raw_email(raw: bytes, message_id: str, source_email: str) -> Optional[ParsedEmail]:
+    msg = email.message_from_bytes(raw)
+    subject = msg.get("Subject", "")
+    sender = msg.get("From", "")
+    date_str = msg.get("Date", "")
+
+    if not is_subscription_email(subject):
+        return None
+
+    try:
+        parsed_date = datetime.strptime(date_str[:16].strip(), "%a, %d %b %Y").date()
+    except (ValueError, TypeError):
+        parsed_date = date.today()
+
+    body = extract_body_text(msg)
+    amount = parse_amount(body) or parse_amount(subject)
+
+    return ParsedEmail(
+        message_id=message_id,
+        sender=sender,
+        subject=subject,
+        date=parsed_date,
+        body_text=body,
+        amount=amount,
+    )

inboxscan-0.1.0/src/inboxscan/reporter.py

@@ -0,0 +1,52 @@
+from rich.console import Console
+from rich.table import Table
+from rich import box
+from inboxscan.models import ScanResult, SubscriptionStatus
+
+console = Console()
+
+
+def print_report(result: ScanResult) -> None:
+    console.print("\n[bold]INBOXSCAN REPORT[/bold]")
+    console.print("═" * 60)
+    console.print(f"Scanned: {', '.join(result.accounts_scanned)}")
+    console.print(
+        f"Found: [bold]{len(result.subscriptions)}[/bold] subscriptions  "
+        f"|  Total burn: [bold green]${result.total_monthly_burn:.2f}/mo[/bold green]"
+    )
+    console.print()
+
+    table = Table(box=box.SIMPLE, show_header=False, padding=(0, 1))
+    table.add_column("Status", style="bold", width=10)
+    table.add_column("Service", width=20)
+    table.add_column("Amount", width=12)
+    table.add_column("Last charge", width=12)
+    table.add_column("Account", style="dim")
+
+    for sub in sorted(result.subscriptions, key=lambda s: s.status.value):
+        status_str = {
+            SubscriptionStatus.ACTIVE: "[green]\\[ACTIVE][/green]",
+            SubscriptionStatus.DORMANT: "[yellow]\\[DORMANT][/yellow]",
+            SubscriptionStatus.UNKNOWN: "[dim]\\[UNKNOWN][/dim]",
+        }[sub.status]
+        table.add_row(
+            status_str,
+            sub.service_name,
+            f"${sub.amount:.2f}/{sub.billing_frequency[:2]}",
+            sub.last_charge_date.strftime("%b %d"),
+            sub.source_email,
+        )
+
+    console.print(table)
+    console.print("═" * 60)
+
+    if result.dormant_monthly_waste > 0:
+        console.print(
+            f"[yellow]Potential savings: ${result.dormant_monthly_waste:.2f}/mo "
+            f"(cancel DORMANT subscriptions)[/yellow]"
+        )
+
+    if result.unknown_charges > 0:
+        console.print(f"[dim]{result.unknown_charges} unrecognized recurring charges — review manually[/dim]")
+
+    console.print("\nRun [bold]inboxscan cancel <service>[/bold] for cancellation steps.\n")

inboxscan-0.1.0/src/inboxscan.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: inboxscan
+Version: 0.1.0
+Summary: Find every subscription hiding in your email — zero credentials stored, nothing leaves your machine.
+Author: Sravya Vedantham
+License: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Dynamic: license-file

inboxscan-0.1.0/src/inboxscan.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+src/inboxscan/__init__.py
+src/inboxscan/cache.py
+src/inboxscan/canceller.py
+src/inboxscan/cli.py
+src/inboxscan/connector.py
+src/inboxscan/detector.py
+src/inboxscan/models.py
+src/inboxscan/parser.py
+src/inboxscan/reporter.py
+src/inboxscan.egg-info/PKG-INFO
+src/inboxscan.egg-info/SOURCES.txt
+src/inboxscan.egg-info/dependency_links.txt
+src/inboxscan.egg-info/entry_points.txt
+src/inboxscan.egg-info/requires.txt
+src/inboxscan.egg-info/top_level.txt
+tests/test_cache.py
+tests/test_connector.py
+tests/test_detector.py
+tests/test_models.py
+tests/test_parser.py

inboxscan-0.1.0/src/inboxscan.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

inboxscan-0.1.0/src/inboxscan.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+inboxscan = inboxscan.cli:app

inboxscan-0.1.0/src/inboxscan.egg-info/requires.txt

@@ -0,0 +1,10 @@
+typer>=0.9.0
+rich>=13.0.0
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+mypy>=1.0.0
+black>=23.0.0
+isort>=5.0.0
+flake8>=6.0.0

inboxscan-0.1.0/src/inboxscan.egg-info/top_level.txt

@@ -0,0 +1 @@
+inboxscan

inboxscan-0.1.0/tests/test_cache.py

@@ -0,0 +1,21 @@
+from datetime import date
+from pathlib import Path
+from inboxscan.cache import save_result, load_result
+from inboxscan.models import ScanResult, Subscription, SubscriptionStatus
+
+
+def test_save_and_load_roundtrip(tmp_path):
+    db_path = tmp_path / "cache.db"
+    sub = Subscription("Netflix", 15.99, "USD", "monthly", date(2026, 3, 1), "test@gmail.com", SubscriptionStatus.ACTIVE)
+    result = ScanResult(accounts_scanned=["test@gmail.com"], subscriptions=[sub])
+    save_result(result, path=db_path)
+    loaded = load_result(path=db_path)
+    assert loaded is not None
+    assert len(loaded.subscriptions) == 1
+    assert loaded.subscriptions[0].service_name == "Netflix"
+    assert loaded.subscriptions[0].amount == 15.99
+
+
+def test_load_result_missing_file(tmp_path):
+    result = load_result(path=tmp_path / "nonexistent.db")
+    assert result is None

inboxscan-0.1.0/tests/test_connector.py

@@ -0,0 +1,12 @@
+from inboxscan.connector import build_search_query
+
+
+def test_build_search_query_returns_string():
+    query = build_search_query()
+    assert isinstance(query, str)
+    assert len(query) > 0
+
+
+def test_build_search_query_contains_receipt():
+    query = build_search_query()
+    assert "receipt" in query.lower()

inboxscan-0.1.0/tests/test_detector.py

@@ -0,0 +1,37 @@
+from datetime import date, timedelta
+from inboxscan.detector import detect_service, classify_status, KNOWN_SERVICES
+from inboxscan.models import ParsedEmail, SubscriptionStatus
+
+
+def test_detect_netflix_by_sender():
+    e = ParsedEmail("id1", "billing@netflix.com", "Your Netflix receipt", date.today(), "", 15.99)
+    result = detect_service(e)
+    assert result is not None
+    assert result.service_name == "Netflix"
+
+
+def test_detect_notion_by_sender():
+    e = ParsedEmail("id2", "billing@notion.so", "Notion receipt", date.today(), "", 16.00)
+    result = detect_service(e)
+    assert result is not None
+    assert result.service_name == "Notion"
+
+
+def test_unknown_service_returns_none():
+    e = ParsedEmail("id3", "billing@unknownxyz123.com", "Your receipt", date.today(), "", 9.99)
+    result = detect_service(e)
+    assert result is None
+
+
+def test_classify_active_recent():
+    status = classify_status(date.today() - timedelta(days=20))
+    assert status == SubscriptionStatus.ACTIVE
+
+
+def test_classify_dormant_old():
+    status = classify_status(date.today() - timedelta(days=120))
+    assert status == SubscriptionStatus.DORMANT
+
+
+def test_known_services_has_minimum_entries():
+    assert len(KNOWN_SERVICES) >= 20

inboxscan-0.1.0/tests/test_models.py

@@ -0,0 +1,35 @@
+from datetime import date
+from inboxscan.models import ScanResult, Subscription, SubscriptionStatus
+
+
+def test_total_monthly_burn_active_only():
+    result = ScanResult(
+        accounts_scanned=["test@gmail.com"],
+        subscriptions=[
+            Subscription("Netflix", 15.99, "USD", "monthly", date.today(), "test@gmail.com", SubscriptionStatus.ACTIVE),
+            Subscription("Adobe", 54.99, "USD", "monthly", date.today(), "test@gmail.com", SubscriptionStatus.ACTIVE),
+        ],
+    )
+    assert result.total_monthly_burn == 70.98
+
+
+def test_annual_subscription_divided_by_12():
+    result = ScanResult(
+        accounts_scanned=["test@gmail.com"],
+        subscriptions=[
+            Subscription("GitHub", 48.00, "USD", "annual", date.today(), "test@gmail.com", SubscriptionStatus.ACTIVE),
+        ],
+    )
+    assert result.total_monthly_burn == 4.0
+
+
+def test_dormant_not_counted_in_active_burn():
+    result = ScanResult(
+        accounts_scanned=["test@gmail.com"],
+        subscriptions=[
+            Subscription("Netflix", 15.99, "USD", "monthly", date.today(), "test@gmail.com", SubscriptionStatus.ACTIVE),
+            Subscription("Audible", 14.95, "USD", "monthly", date.today(), "test@gmail.com", SubscriptionStatus.DORMANT),
+        ],
+    )
+    assert result.total_monthly_burn == 15.99
+    assert result.dormant_monthly_waste == 14.95

inboxscan-0.1.0/tests/test_parser.py

@@ -0,0 +1,26 @@
+from datetime import date
+from inboxscan.parser import parse_amount, is_subscription_email
+
+
+def test_parse_amount_dollar_sign():
+    assert parse_amount("Your charge of $15.99 has been processed") == 15.99
+
+
+def test_parse_amount_usd_format():
+    assert parse_amount("Amount: USD 54.99") == 54.99
+
+
+def test_parse_amount_no_amount():
+    assert parse_amount("Welcome to our newsletter") is None
+
+
+def test_is_subscription_email_receipt():
+    assert is_subscription_email("Your Netflix receipt for March") is True
+
+
+def test_is_subscription_email_renewal():
+    assert is_subscription_email("Your subscription has been renewed") is True
+
+
+def test_is_subscription_email_negative():
+    assert is_subscription_email("Your friend sent you a message") is False