cursor-clean 0.1.0__py3-none-any.whl

cursor_clean/__init__.py

@@ -0,0 +1,3 @@
+"""cursor-clean: scan and clean Cursor Roaming data on Windows."""
+
+__version__ = "0.1.0"

cursor_clean/__main__.py

@@ -0,0 +1,4 @@
+from cursor_clean.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cursor_clean/cleaner.py

@@ -0,0 +1,147 @@
+"""Execute cleanup actions against Cursor Roaming data."""
+
+from __future__ import annotations
+
+import shutil
+import sqlite3
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from cursor_clean.scanner import AgentVersionInfo, ChatCleanupPlan, ScanReport, _dir_size, _file_size
+
+
+@dataclass
+class CleanResult:
+    chat_deleted_composers: int = 0
+    chat_deleted_kv_rows: int = 0
+    state_db_before: int = 0
+    state_db_after: int = 0
+    agent_deleted: list[str] = field(default_factory=list)
+    agent_bytes_freed: int = 0
+    cache_bytes_freed: int = 0
+    errors: list[str] = field(default_factory=list)
+
+    @property
+    def state_db_bytes_freed(self) -> int:
+        return max(0, self.state_db_before - self.state_db_after)
+
+
+def _open_rw(db_path: Path) -> sqlite3.Connection:
+    con = sqlite3.connect(str(db_path), timeout=60)
+    con.execute("PRAGMA journal_mode=WAL")
+    return con
+
+
+def clean_old_chats(db_path: Path, plan: ChatCleanupPlan) -> tuple[int, int]:
+    """Delete old composers and related cursorDiskKV rows. Returns (composers, kv_rows)."""
+    if not plan.old_composer_ids:
+        return 0, 0
+
+    con = _open_rw(db_path)
+    try:
+        con.execute("CREATE TEMP TABLE old_c (id TEXT PRIMARY KEY)")
+        con.executemany(
+            "INSERT OR IGNORE INTO old_c(id) VALUES (?)",
+            [(i,) for i in plan.old_composer_ids],
+        )
+
+        before_kv = con.total_changes
+        con.execute(
+            """
+            DELETE FROM cursorDiskKV
+            WHERE
+              (key LIKE 'composerData:%'
+               AND substr(key, 14, 36) IN (SELECT id FROM old_c))
+              OR
+              (key LIKE 'bubbleId:%'
+               AND substr(key, 10, 36) IN (SELECT id FROM old_c))
+              OR
+              (key LIKE 'checkpointId:%'
+               AND substr(key, 14, 36) IN (SELECT id FROM old_c))
+              OR
+              (key LIKE 'messageRequestContext:%'
+               AND substr(key, 23, 36) IN (SELECT id FROM old_c))
+            """
+        )
+        kv_deleted = con.total_changes - before_kv
+
+        before_h = con.total_changes
+        con.execute("DELETE FROM composerHeaders WHERE composerId IN (SELECT id FROM old_c)")
+        headers_deleted = con.total_changes - before_h
+        con.commit()
+
+        # Shrink file; must be outside a transaction and with no other writers.
+        con.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+        con.execute("VACUUM")
+        return headers_deleted, kv_deleted
+    finally:
+        con.close()
+
+
+def clean_agent_versions(versions: list[AgentVersionInfo]) -> tuple[list[str], int]:
+    """Delete agent version folders marked keep=False."""
+    deleted: list[str] = []
+    freed = 0
+    for item in versions:
+        if item.keep:
+            continue
+        size = item.size_bytes
+        shutil.rmtree(item.path, ignore_errors=False)
+        deleted.append(item.name)
+        freed += size
+    return deleted, freed
+
+
+def clean_optional_dirs(paths: dict[str, Path], *, include_cache: bool) -> int:
+    """Optionally remove CachedData / logs contents. Backup is never touched."""
+    if not include_cache:
+        return 0
+    freed = 0
+    for key in ("cached_data", "logs"):
+        path = paths[key]
+        if not path.exists():
+            continue
+        size = _dir_size(path)
+        if path.is_dir():
+            shutil.rmtree(path, ignore_errors=False)
+            path.mkdir(parents=True, exist_ok=True)
+        freed += size
+    return freed
+
+
+def clean(
+    report: ScanReport,
+    *,
+    clean_chats: bool = True,
+    clean_agents: bool = True,
+    include_cache: bool = False,
+) -> CleanResult:
+    """Apply cleanup based on a prior scan report. Does not delete state.vscdb.backup."""
+    result = CleanResult(state_db_before=_file_size(report.paths["state_db"]))
+
+    if clean_chats and report.chat and report.chat.old_composer_ids:
+        try:
+            headers, kv = clean_old_chats(report.paths["state_db"], report.chat)
+            result.chat_deleted_composers = headers
+            result.chat_deleted_kv_rows = kv
+        except (sqlite3.Error, OSError) as exc:
+            result.errors.append(f"Chat cleanup failed: {exc}")
+
+    if clean_agents:
+        try:
+            deleted, freed = clean_agent_versions(report.agent_versions)
+            result.agent_deleted = deleted
+            result.agent_bytes_freed = freed
+        except OSError as exc:
+            result.errors.append(f"Agent version cleanup failed: {exc}")
+
+    if include_cache:
+        try:
+            result.cache_bytes_freed = clean_optional_dirs(
+                report.paths, include_cache=True
+            )
+        except OSError as exc:
+            result.errors.append(f"Cache/logs cleanup failed: {exc}")
+
+    result.state_db_after = _file_size(report.paths["state_db"])
+    return result

cursor_clean/cli.py

@@ -0,0 +1,232 @@
+"""Command-line interface for cursor-clean."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from cursor_clean import __version__
+from cursor_clean.cleaner import clean
+from cursor_clean.format_utils import format_bytes
+from cursor_clean.process import cursor_is_running
+from cursor_clean.scanner import ScanReport, scan
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="cursor-clean",
+        description=(
+            "Scan and clean Cursor Roaming data on Windows: "
+            "old Composer/Agent chats and unused cursor-agent versions. "
+            "Never deletes state.vscdb.backup."
+        ),
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    def add_common(p: argparse.ArgumentParser) -> None:
+        p.add_argument(
+            "--keep-days",
+            type=int,
+            default=90,
+            help="Keep chats updated/created within this many days (default: 90).",
+        )
+        p.add_argument(
+            "--data-dir",
+            type=Path,
+            default=None,
+            help="Override Cursor Roaming root (default: %%APPDATA%%\\Cursor).",
+        )
+        p.add_argument(
+            "--deep",
+            action="store_true",
+            help="Estimate reclaimable chat blob size (slower on large DBs).",
+        )
+        p.add_argument(
+            "--include-cache",
+            action="store_true",
+            help="Also consider CachedData and logs (off by default).",
+        )
+
+    p_scan = sub.add_parser("scan", help="Scan and print reclaimable items (no changes).")
+    add_common(p_scan)
+
+    p_clean = sub.add_parser("clean", help="Scan, ask for confirmation, then clean.")
+    add_common(p_clean)
+    p_clean.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Skip interactive confirmation.",
+    )
+    p_clean.add_argument(
+        "--skip-chats",
+        action="store_true",
+        help="Do not delete old chats.",
+    )
+    p_clean.add_argument(
+        "--skip-agents",
+        action="store_true",
+        help="Do not delete old agent versions.",
+    )
+    p_clean.add_argument(
+        "--force",
+        action="store_true",
+        help="Allow cleaning while Cursor appears to be running (not recommended).",
+    )
+    return parser
+
+
+def _print_report(report: ScanReport) -> None:
+    root = report.paths["root"]
+    print(f"Cursor data: {root}")
+    print(f"state.vscdb:        {format_bytes(report.state_db_bytes)}")
+    print(
+        f"state.vscdb.backup: {format_bytes(report.state_db_backup_bytes)}  (kept, never deleted)"
+    )
+    print()
+
+    if report.chat is not None:
+        cutoff = datetime.fromtimestamp(report.chat.cutoff_ms / 1000, tz=timezone.utc)
+        print("Chats / Composer")
+        print(f"  keep-days:     {report.chat.keep_days}")
+        print(f"  cutoff (UTC):  {cutoff.strftime('%Y-%m-%d %H:%M')}")
+        print(f"  total:         {report.chat.total_composers}")
+        print(f"  older:         {report.chat.old_composers}  (candidates)")
+        if report.chat.estimated_bytes is not None:
+            print(f"  est. blobs:    {format_bytes(report.chat.estimated_bytes)}")
+        else:
+            print("  est. blobs:    (use --deep for estimate; free space shows after VACUUM)")
+        print()
+    else:
+        print("Chats / Composer: unavailable")
+        print()
+
+    print("cursor-agent versions")
+    if not report.agent_versions:
+        print("  (none found)")
+    else:
+        for v in report.agent_versions:
+            mark = "KEEP " if v.keep else "DELETE"
+            print(f"  [{mark}] {v.name:40} {format_bytes(v.size_bytes)}")
+        print(f"  reclaimable: {format_bytes(report.agent_reclaimable_bytes)}")
+    print()
+
+    if report.cached_data_bytes or report.logs_bytes:
+        print("Optional cache/logs")
+        print(f"  CachedData: {format_bytes(report.cached_data_bytes)}")
+        print(f"  logs:       {format_bytes(report.logs_bytes)}")
+        print()
+
+    for w in report.warnings:
+        print(f"WARNING: {w}")
+
+
+def cmd_scan(args: argparse.Namespace) -> int:
+    report = scan(
+        data_dir=args.data_dir,
+        keep_days=args.keep_days,
+        deep=args.deep,
+        include_cache=args.include_cache,
+    )
+    _print_report(report)
+    return 0
+
+
+def cmd_clean(args: argparse.Namespace) -> int:
+    if cursor_is_running() and not args.force:
+        print(
+            "Cursor is running. Quit Cursor completely, then retry.\n"
+            "If you are sure no Cursor process holds the DB, pass --force.",
+            file=sys.stderr,
+        )
+        return 2
+
+    report = scan(
+        data_dir=args.data_dir,
+        keep_days=args.keep_days,
+        deep=args.deep,
+        include_cache=args.include_cache,
+    )
+    _print_report(report)
+
+    will_chats = (not args.skip_chats) and report.chat and report.chat.old_composers > 0
+    will_agents = (not args.skip_agents) and report.agent_reclaimable_bytes > 0
+    will_cache = bool(args.include_cache) and (
+        report.cached_data_bytes > 0 or report.logs_bytes > 0
+    )
+
+    if not (will_chats or will_agents or will_cache):
+        print("Nothing to clean.")
+        return 0
+
+    print("Planned actions:")
+    if will_chats:
+        print(f"  - Delete {report.chat.old_composers} old chat(s), then VACUUM state.vscdb")
+    if will_agents:
+        print(
+            f"  - Delete {sum(1 for v in report.agent_versions if not v.keep)} old agent version(s) "
+            f"({format_bytes(report.agent_reclaimable_bytes)})"
+        )
+    if will_cache:
+        print(
+            f"  - Clear CachedData/logs "
+            f"({format_bytes(report.cached_data_bytes + report.logs_bytes)})"
+        )
+    print("  - state.vscdb.backup will NOT be deleted")
+
+    if not args.yes:
+        answer = input("Proceed? [y/N] ").strip().lower()
+        if answer not in {"y", "yes"}:
+            print("Aborted.")
+            return 1
+
+    result = clean(
+        report,
+        clean_chats=not args.skip_chats,
+        clean_agents=not args.skip_agents,
+        include_cache=args.include_cache,
+    )
+
+    print()
+    print("Done.")
+    if not args.skip_chats:
+        print(
+            f"  chats removed: {result.chat_deleted_composers} "
+            f"(kv rows: {result.chat_deleted_kv_rows})"
+        )
+        print(
+            f"  state.vscdb:   {format_bytes(result.state_db_before)} -> "
+            f"{format_bytes(result.state_db_after)} "
+            f"(freed {format_bytes(result.state_db_bytes_freed)})"
+        )
+    if result.agent_deleted:
+        print(
+            f"  agents removed: {len(result.agent_deleted)} "
+            f"({format_bytes(result.agent_bytes_freed)})"
+        )
+    if result.cache_bytes_freed:
+        print(f"  cache/logs:    {format_bytes(result.cache_bytes_freed)}")
+    for err in result.errors:
+        print(f"ERROR: {err}", file=sys.stderr)
+    return 1 if result.errors else 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    if args.keep_days < 1:
+        parser.error("--keep-days must be >= 1")
+    if args.command == "scan":
+        return cmd_scan(args)
+    if args.command == "clean":
+        return cmd_clean(args)
+    parser.error(f"unknown command: {args.command}")
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cursor_clean/format_utils.py

@@ -0,0 +1,16 @@
+"""Formatting helpers for human-readable sizes."""
+
+from __future__ import annotations
+
+
+def format_bytes(num: int | float) -> str:
+    """Format a byte count as a short human string."""
+    value = float(num)
+    units = ["B", "KB", "MB", "GB", "TB"]
+    for unit in units:
+        if abs(value) < 1024.0 or unit == units[-1]:
+            if unit == "B":
+                return f"{int(value)} {unit}"
+            return f"{value:.2f} {unit}"
+        value /= 1024.0
+    return f"{value:.2f} TB"

cursor_clean/paths.py

@@ -0,0 +1,38 @@
+"""Resolve Cursor data directories (Windows-first)."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def default_roaming_root() -> Path:
+    """Return the default Cursor Roaming root on this machine."""
+    appdata = os.environ.get("APPDATA")
+    if not appdata:
+        raise RuntimeError("APPDATA is not set; only Windows is supported for now.")
+    return Path(appdata) / "Cursor"
+
+
+def resolve_paths(data_dir: Path | None = None) -> dict[str, Path]:
+    """Resolve commonly used Cursor paths under Roaming."""
+    root = Path(data_dir) if data_dir else default_roaming_root()
+    global_storage = root / "User" / "globalStorage"
+    agent_versions = (
+        global_storage
+        / "anysphere.cursor-agent-worker"
+        / "agent-cli"
+        / ".local"
+        / "share"
+        / "cursor-agent"
+        / "versions"
+    )
+    return {
+        "root": root,
+        "global_storage": global_storage,
+        "state_db": global_storage / "state.vscdb",
+        "state_db_backup": global_storage / "state.vscdb.backup",
+        "agent_versions": agent_versions,
+        "cached_data": root / "CachedData",
+        "logs": root / "logs",
+    }

cursor_clean/process.py

@@ -0,0 +1,38 @@
+"""Detect whether Cursor is currently running."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+
+
+CURSOR_PROCESS_NAMES = {"cursor.exe", "cursor"}
+
+
+def cursor_is_running() -> bool:
+    """Return True if a Cursor process appears to be running."""
+    if sys.platform == "win32":
+        try:
+            completed = subprocess.run(
+                ["tasklist", "/FI", "IMAGENAME eq Cursor.exe", "/FO", "CSV", "/NH"],
+                capture_output=True,
+                text=True,
+                check=False,
+                creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
+            )
+        except OSError:
+            return False
+        out = (completed.stdout or "").strip().lower()
+        return "cursor.exe" in out
+
+    try:
+        completed = subprocess.run(
+            ["ps", "-A", "-o", "comm="],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except OSError:
+        return False
+    names = {(line.strip().split("/")[-1] or "").lower() for line in completed.stdout.splitlines()}
+    return bool(names & CURSOR_PROCESS_NAMES)

cursor_clean/scanner.py

@@ -0,0 +1,218 @@
+"""Scan Cursor Roaming data for reclaimable space."""
+
+from __future__ import annotations
+
+import sqlite3
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from cursor_clean.paths import resolve_paths
+
+
+@dataclass
+class AgentVersionInfo:
+    name: str
+    path: Path
+    size_bytes: int
+    keep: bool
+
+
+@dataclass
+class ChatCleanupPlan:
+    keep_days: int
+    cutoff_ms: int
+    total_composers: int
+    old_composers: int
+    old_composer_ids: list[str] = field(default_factory=list)
+    estimated_bytes: int | None = None  # filled when deep=True
+
+
+@dataclass
+class ScanReport:
+    paths: dict[str, Path]
+    state_db_bytes: int
+    state_db_backup_bytes: int
+    chat: ChatCleanupPlan | None
+    agent_versions: list[AgentVersionInfo]
+    cached_data_bytes: int
+    logs_bytes: int
+    warnings: list[str] = field(default_factory=list)
+
+    @property
+    def agent_reclaimable_bytes(self) -> int:
+        return sum(v.size_bytes for v in self.agent_versions if not v.keep)
+
+    @property
+    def chat_reclaimable_bytes(self) -> int | None:
+        if self.chat is None:
+            return None
+        return self.chat.estimated_bytes
+
+
+def _dir_size(path: Path) -> int:
+    if not path.exists():
+        return 0
+    if path.is_file():
+        return path.stat().st_size
+    total = 0
+    for p in path.rglob("*"):
+        try:
+            if p.is_file():
+                total += p.stat().st_size
+        except OSError:
+            continue
+    return total
+
+
+def _file_size(path: Path) -> int:
+    try:
+        return path.stat().st_size if path.is_file() else 0
+    except OSError:
+        return 0
+
+
+def _open_ro(db_path: Path) -> sqlite3.Connection:
+    uri = db_path.resolve().as_uri() + "?mode=ro"
+    con = sqlite3.connect(uri, uri=True, timeout=30)
+    con.execute("PRAGMA query_only=ON")
+    return con
+
+
+def _composer_cutoff_ms(keep_days: int) -> int:
+    return int((time.time() - keep_days * 86400) * 1000)
+
+
+def scan_old_composers(
+    db_path: Path,
+    keep_days: int = 90,
+    *,
+    deep: bool = False,
+) -> ChatCleanupPlan:
+    """Find composers older than keep_days.
+
+    Age uses COALESCE(NULLIF(lastUpdatedAt,0), createdAt).
+    deep=True estimates reclaimable blob bytes (slower on large DBs).
+    """
+    cutoff = _composer_cutoff_ms(keep_days)
+    con = _open_ro(db_path)
+    try:
+        total = con.execute("SELECT COUNT(*) FROM composerHeaders").fetchone()[0]
+        rows = con.execute(
+            """
+            SELECT composerId
+            FROM composerHeaders
+            WHERE COALESCE(NULLIF(lastUpdatedAt, 0), createdAt) < ?
+            ORDER BY COALESCE(NULLIF(lastUpdatedAt, 0), createdAt) ASC
+            """,
+            (cutoff,),
+        ).fetchall()
+        old_ids = [r[0] for r in rows if r[0]]
+        estimated: int | None = None
+        if deep and old_ids:
+            estimated = _estimate_composer_blob_bytes(con, old_ids)
+        return ChatCleanupPlan(
+            keep_days=keep_days,
+            cutoff_ms=cutoff,
+            total_composers=int(total),
+            old_composers=len(old_ids),
+            old_composer_ids=old_ids,
+            estimated_bytes=estimated,
+        )
+    finally:
+        con.close()
+
+
+def _estimate_composer_blob_bytes(con: sqlite3.Connection, old_ids: list[str]) -> int:
+    """Sum LENGTH(value) for keys belonging to old composers.
+
+    Uses chunked IN (...) so it works on read-only connections (no TEMP table).
+    """
+    total = 0
+    # Keep SQL parameter lists manageable.
+    chunk_size = 400
+    prefixes = (
+        ("composerData:", 14),
+        ("bubbleId:", 10),
+        ("checkpointId:", 14),
+        ("messageRequestContext:", 23),
+    )
+    for i in range(0, len(old_ids), chunk_size):
+        chunk = old_ids[i : i + chunk_size]
+        placeholders = ",".join("?" * len(chunk))
+        parts = []
+        params: list[str] = []
+        for prefix, start in prefixes:
+            parts.append(
+                f"(key LIKE ? AND substr(key, {start}, 36) IN ({placeholders}))"
+            )
+            params.append(f"{prefix}%")
+            params.extend(chunk)
+        sql = f"SELECT COALESCE(SUM(LENGTH(value)), 0) FROM cursorDiskKV WHERE {' OR '.join(parts)}"
+        row = con.execute(sql, params).fetchone()
+        total += int(row[0] if row else 0)
+    return total
+
+
+def scan_agent_versions(versions_dir: Path) -> list[AgentVersionInfo]:
+    """List agent CLI versions; keep the newest non-tmp folder."""
+    if not versions_dir.is_dir():
+        return []
+
+    entries: list[AgentVersionInfo] = []
+    for child in versions_dir.iterdir():
+        if not child.is_dir():
+            continue
+        entries.append(
+            AgentVersionInfo(
+                name=child.name,
+                path=child,
+                size_bytes=_dir_size(child),
+                keep=False,
+            )
+        )
+
+    real = [e for e in entries if not e.name.startswith(".tmp")]
+    if real:
+        # Version folder names are date-prefixed (YYYY.MM.DD-...), lexicographic max ~= newest.
+        newest = max(real, key=lambda e: e.name)
+        for e in entries:
+            e.keep = e.name == newest.name
+    return sorted(entries, key=lambda e: (e.keep, e.name), reverse=True)
+
+
+def scan(
+    *,
+    data_dir: Path | None = None,
+    keep_days: int = 90,
+    deep: bool = False,
+    include_cache: bool = False,
+) -> ScanReport:
+    """Scan Cursor data and build a cleanup report."""
+    paths = resolve_paths(data_dir)
+    warnings: list[str] = []
+
+    state_db = paths["state_db"]
+    chat: ChatCleanupPlan | None = None
+    if state_db.is_file():
+        try:
+            chat = scan_old_composers(state_db, keep_days=keep_days, deep=deep)
+        except sqlite3.Error as exc:
+            warnings.append(f"Failed to read state.vscdb: {exc}")
+    else:
+        warnings.append(f"state.vscdb not found: {state_db}")
+
+    agents = scan_agent_versions(paths["agent_versions"])
+    cached = _dir_size(paths["cached_data"]) if include_cache else 0
+    logs = _dir_size(paths["logs"]) if include_cache else 0
+
+    return ScanReport(
+        paths=paths,
+        state_db_bytes=_file_size(state_db),
+        state_db_backup_bytes=_file_size(paths["state_db_backup"]),
+        chat=chat,
+        agent_versions=agents,
+        cached_data_bytes=cached,
+        logs_bytes=logs,
+        warnings=warnings,
+    )

cursor_clean-0.1.0.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: cursor-clean
+Version: 0.1.0
+Summary: Scan and clean Cursor Roaming data: old chats and unused agent versions.
+Author: cursor-clean contributors
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/cursor-clean/
+Keywords: cursor,cleanup,disk,sqlite,windows
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# cursor-clean
+
+Scan and clean **Cursor** Roaming data on Windows:
+
+- Old Composer / Agent chats (default: keep last **90** days)
+- Unused `cursor-agent` CLI versions (keep newest only)
+- Optional: `CachedData` / `logs`
+
+**Never deletes** `state.vscdb.backup`.
+
+## Install
+
+```bash
+pip install cursor-clean
+```
+
+Requires Python 3.9+.
+
+## Usage
+
+Quit Cursor before cleaning (the tool checks for running processes).
+
+```bash
+# Preview only
+cursor-clean scan
+
+# Preview with blob size estimate (slower)
+cursor-clean scan --deep
+
+# Keep 60 days instead of 90
+cursor-clean scan --keep-days 60
+
+# Clean after confirmation
+cursor-clean clean
+
+# Non-interactive
+cursor-clean clean -y --keep-days 90
+
+# Also clear CachedData / logs
+cursor-clean clean --include-cache
+```
+
+## What it touches
+
+| Path | Action |
+|------|--------|
+| `%APPDATA%\Cursor\User\globalStorage\state.vscdb` | Delete old chat rows, then `VACUUM` |
+| `...\anysphere.cursor-agent-worker\...\versions\*` | Keep newest version folder, delete the rest |
+| `state.vscdb.backup` | **Left alone** |
+| `CachedData`, `logs` | Only with `--include-cache` |
+
+Chat age uses `COALESCE(lastUpdatedAt, createdAt)` from `composerHeaders`.
+
+## Safety
+
+1. Prefer `scan` first.
+2. Fully quit Cursor before `clean`.
+3. Backup is retained by design.
+4. No local “deletion log” is written.
+
+## Override data directory
+
+```bash
+cursor-clean scan --data-dir "D:\CursorData"
+```
+
+## License
+
+MIT

cursor_clean-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+cursor_clean/__init__.py,sha256=u7tcSlBFJFOUY8avlYUCqMIcyOSOegHbVhU1JAL5odU,90
+cursor_clean/__main__.py,sha256=-372QWzIkcMWhIHFqbH2y8HpD3snLiMv8ZgE1S2Fu-0,91
+cursor_clean/cleaner.py,sha256=AsZwg8LOihYRg5Z4CLD_LrKdvs9hIBetXueTQUDxff8,4835
+cursor_clean/cli.py,sha256=K3JzCdlgI4wpk4Xh3r21U9BJrFYXmQwQe1TSi70Shi0,7552
+cursor_clean/format_utils.py,sha256=m1kzAjuhsS7aLQUZSeOnrh51_Rdj4-IMIc9SayrqrOg,496
+cursor_clean/paths.py,sha256=fT6tMaca8r0OiDdiOuu_WWMcFwH5HXfppPU-uceF-mE,1178
+cursor_clean/process.py,sha256=JFPZdrKzGslHiRnklT6gkrwsF6ECYAp8iU2XCmWs4wg,1121
+cursor_clean/scanner.py,sha256=d2iMobENbhNkeJdDEXWTKgP7V3hM0PoqdyiNFuNTiMw,6347
+cursor_clean-0.1.0.dist-info/licenses/LICENSE,sha256=LdBgiaZ8HIKY9ioCV2U1zbA1wc7iSi8Oi_ecdYsz8MQ,1082
+cursor_clean-0.1.0.dist-info/METADATA,sha256=JYTRtGppVw0oh7c5B4CmDJ5P_MmAtmijeP4M57gE8po,2288
+cursor_clean-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cursor_clean-0.1.0.dist-info/entry_points.txt,sha256=TfM7sAkz-f2TYsrHzMzijdPV6VDT5KdLpVEPvuq96nM,55
+cursor_clean-0.1.0.dist-info/top_level.txt,sha256=_EbOl6JtABz_u1TPJ953TBwvMvS2k1Dph_baphNmGoM,13
+cursor_clean-0.1.0.dist-info/RECORD,,

cursor_clean-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cursor_clean-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cursor-clean = cursor_clean.cli:main

cursor_clean-0.1.0.dist-info/licenses/LICENSE

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

cursor_clean-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cursor_clean