xcode-cleaner 0.1.0__tar.gz

xcode_cleaner-0.1.0/LICENSE

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

xcode_cleaner-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: xcode-cleaner
+Version: 0.1.0
+Summary: CLI tool to reclaim disk space from Xcode build artifacts, caches, and simulators
+Author: cdunkel
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/cdunkel/xcode-cleaner
+Project-URL: Repository, https://github.com/cdunkel/xcode-cleaner
+Project-URL: Issues, https://github.com/cdunkel/xcode-cleaner/issues
+Keywords: xcode,macos,disk-space,cleanup,cli,simulators,derived-data
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Filesystems
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=13.0
+Requires-Dist: InquirerPy>=0.3.4
+Dynamic: license-file
+
+# xcode-cleaner
+
+A CLI tool to reclaim disk space from Xcode build artifacts, caches, and simulators.
+
+## What It Scans
+
+| Category | Path |
+|----------|------|
+| Derived Data | `~/Library/Developer/Xcode/DerivedData` |
+| Archives | `~/Library/Developer/Xcode/Archives` |
+| iOS Device Support | `~/Library/Developer/Xcode/iOS DeviceSupport` |
+| watchOS Device Support | `~/Library/Developer/Xcode/watchOS DeviceSupport` |
+| tvOS Device Support | `~/Library/Developer/Xcode/tvOS DeviceSupport` |
+| Simulators | Managed via `xcrun simctl` |
+| Xcode Caches | `~/Library/Caches/com.apple.dt.Xcode` |
+
+## Installation
+
+From PyPI:
+
+```
+pip install xcode-cleaner
+```
+
+From source:
+
+```
+git clone https://github.com/cdunkel/xcode-cleaner.git
+cd xcode-cleaner
+pip install .
+```
+
+## Usage
+
+**Scan and display a disk usage report:**
+
+```
+xcode-cleaner scan
+```
+
+**Interactively select and delete items to free space:**
+
+```
+xcode-cleaner clean
+```
+
+**Preview what would be deleted without actually deleting:**
+
+```
+xcode-cleaner clean --dry-run
+```
+
+## Requirements
+
+- macOS
+- Python 3.9+
+- Xcode (for simulator management)
+
+## License
+
+MIT

xcode_cleaner-0.1.0/README.md

@@ -0,0 +1,61 @@
+# xcode-cleaner
+
+A CLI tool to reclaim disk space from Xcode build artifacts, caches, and simulators.
+
+## What It Scans
+
+| Category | Path |
+|----------|------|
+| Derived Data | `~/Library/Developer/Xcode/DerivedData` |
+| Archives | `~/Library/Developer/Xcode/Archives` |
+| iOS Device Support | `~/Library/Developer/Xcode/iOS DeviceSupport` |
+| watchOS Device Support | `~/Library/Developer/Xcode/watchOS DeviceSupport` |
+| tvOS Device Support | `~/Library/Developer/Xcode/tvOS DeviceSupport` |
+| Simulators | Managed via `xcrun simctl` |
+| Xcode Caches | `~/Library/Caches/com.apple.dt.Xcode` |
+
+## Installation
+
+From PyPI:
+
+```
+pip install xcode-cleaner
+```
+
+From source:
+
+```
+git clone https://github.com/cdunkel/xcode-cleaner.git
+cd xcode-cleaner
+pip install .
+```
+
+## Usage
+
+**Scan and display a disk usage report:**
+
+```
+xcode-cleaner scan
+```
+
+**Interactively select and delete items to free space:**
+
+```
+xcode-cleaner clean
+```
+
+**Preview what would be deleted without actually deleting:**
+
+```
+xcode-cleaner clean --dry-run
+```
+
+## Requirements
+
+- macOS
+- Python 3.9+
+- Xcode (for simulator management)
+
+## License
+
+MIT

xcode_cleaner-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xcode-cleaner"
+version = "0.1.0"
+description = "CLI tool to reclaim disk space from Xcode build artifacts, caches, and simulators"
+requires-python = ">=3.9"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "cdunkel" }]
+keywords = ["xcode", "macos", "disk-space", "cleanup", "cli", "simulators", "derived-data"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Filesystems",
+]
+dependencies = [
+    "click>=8.0",
+    "rich>=13.0",
+    "InquirerPy>=0.3.4",
+]
+
+[project.urls]
+Homepage = "https://github.com/cdunkel/xcode-cleaner"
+Repository = "https://github.com/cdunkel/xcode-cleaner"
+Issues = "https://github.com/cdunkel/xcode-cleaner/issues"
+
+[project.scripts]
+xcode-cleaner = "xcode_cleaner.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

xcode_cleaner-0.1.0/setup.cfg

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

xcode_cleaner-0.1.0/src/xcode_cleaner/__init__.py

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

xcode_cleaner-0.1.0/src/xcode_cleaner/__main__.py

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

xcode_cleaner-0.1.0/src/xcode_cleaner/cleaner.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import shutil
+
+from rich.progress import Progress
+
+from xcode_cleaner.constants import CATEGORY_PATHS, DEVICE_SUPPORT_PATHS, Category
+from xcode_cleaner.display import console
+from xcode_cleaner.models import DeletionResult, ScanItem
+from xcode_cleaner.simulators import delete_runtime, delete_simulator
+from xcode_cleaner.sizes import format_size
+
+# Resolved allowed base directories for path validation
+_ALLOWED_BASES = tuple(
+    p.resolve() for p in (*CATEGORY_PATHS.values(), *DEVICE_SUPPORT_PATHS)
+)
+
+
+def confirm_deletion(items: list[ScanItem]) -> bool:
+    """Ask the user to confirm deletion."""
+    total = sum(item.size_bytes for item in items)
+    console.print(
+        f"\n[bold yellow]Delete {len(items)} item(s) ({format_size(total)})? "
+        f"This cannot be undone.[/bold yellow]"
+    )
+    answer = console.input("[bold]Proceed? (y/N): [/bold]").strip().lower()
+    return answer in ("y", "yes")
+
+
+def delete_items(items: list[ScanItem]) -> list[DeletionResult]:
+    """Delete the selected items, returning results for each."""
+    results: list[DeletionResult] = []
+
+    with Progress(console=console) as progress:
+        task = progress.add_task("Deleting...", total=len(items))
+        for item in items:
+            try:
+                if item.item_id is not None:
+                    if item.category == Category.SIMULATOR_RUNTIMES:
+                        delete_runtime(item.item_id)
+                    else:
+                        delete_simulator(item.item_id)
+                elif item.path is not None:
+                    if item.path.is_symlink():
+                        item.path.unlink()
+                    else:
+                        resolved = item.path.resolve()
+                        if not any(
+                            resolved == base or str(resolved).startswith(str(base) + "/")
+                            for base in _ALLOWED_BASES
+                        ):
+                            raise ValueError(
+                                f"Refusing to delete {resolved}: outside expected Xcode directories"
+                            )
+                        shutil.rmtree(item.path)
+                else:
+                    raise ValueError("Item has no path or item_id")
+                results.append(DeletionResult(item=item, success=True))
+            except Exception as exc:
+                results.append(
+                    DeletionResult(item=item, success=False, error=str(exc))
+                )
+            progress.advance(task)
+
+    return results

xcode_cleaner-0.1.0/src/xcode_cleaner/cli.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import click
+from rich.console import Console
+
+from xcode_cleaner import __version__
+from xcode_cleaner.cleaner import confirm_deletion, delete_items
+from xcode_cleaner.display import (
+    display_deletion_summary,
+    display_dry_run,
+    display_scan_result,
+)
+from xcode_cleaner.interactive import prompt_selection
+from xcode_cleaner.scanner import scan_all
+
+console = Console()
+
+
+def _run_scan():
+    """Run a full scan with a spinner and return the result."""
+    with console.status("[bold cyan]Scanning for Xcode files...[/bold cyan]"):
+        result = scan_all()
+    return result
+
+
+@click.group()
+@click.version_option(version=__version__)
+def main():
+    """Reclaim disk space from Xcode build artifacts, caches, and simulators."""
+
+
+@main.command()
+def scan():
+    """Scan and display Xcode disk usage report."""
+    result = _run_scan()
+    display_scan_result(result)
+
+
+@main.command()
+@click.option("--dry-run", is_flag=True, help="Show what would be deleted without deleting.")
+def clean(dry_run: bool):
+    """Interactively select and delete Xcode files to free disk space."""
+    result = _run_scan()
+
+    if result.grand_total == 0:
+        console.print("[green]Nothing to clean — all categories are empty.[/green]")
+        return
+
+    display_scan_result(result)
+
+    selected = prompt_selection(result)
+    if not selected:
+        console.print("No items selected.")
+        return
+
+    if dry_run:
+        display_dry_run(selected)
+        return
+
+    if not confirm_deletion(selected):
+        console.print("Cancelled.")
+        return
+
+    results = delete_items(selected)
+    display_deletion_summary(results)

xcode_cleaner-0.1.0/src/xcode_cleaner/constants.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+
+
+class Category(Enum):
+    DERIVED_DATA = "Derived Data"
+    ARCHIVES = "Archives"
+    DEVICE_SUPPORT = "Device Support"
+    SIMULATORS = "Simulators"
+    SIMULATOR_RUNTIMES = "Simulator Runtimes"
+    CACHES = "Xcode Caches"
+
+
+XCODE_BASE = Path.home() / "Library" / "Developer" / "Xcode"
+
+CATEGORY_PATHS: dict[Category, Path] = {
+    Category.DERIVED_DATA: XCODE_BASE / "DerivedData",
+    Category.ARCHIVES: XCODE_BASE / "Archives",
+    Category.CACHES: Path.home() / "Library" / "Caches" / "com.apple.dt.Xcode",
+}
+
+DEVICE_SUPPORT_PATHS: list[Path] = [
+    XCODE_BASE / "iOS DeviceSupport",
+    XCODE_BASE / "watchOS DeviceSupport",
+    XCODE_BASE / "tvOS DeviceSupport",
+]

xcode_cleaner-0.1.0/src/xcode_cleaner/display.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from xcode_cleaner.constants import Category
+from xcode_cleaner.models import DeletionResult, ScanResult
+from xcode_cleaner.sizes import format_size
+
+console = Console()
+
+
+def display_scan_result(result: ScanResult) -> None:
+    """Display the scan result as Rich tables grouped by category."""
+    for scan_cat in result.categories:
+        if not scan_cat.items:
+            console.print(f"[bold cyan]{scan_cat.category.value}[/bold cyan]")
+            if not scan_cat.found:
+                if scan_cat.category in (Category.SIMULATORS, Category.SIMULATOR_RUNTIMES):
+                    console.print("  [dim]Could not list (xcrun unavailable)[/dim]")
+                else:
+                    console.print("  [dim]Directory not found — skipped[/dim]")
+            else:
+                console.print("  [dim]Empty — nothing to clean[/dim]")
+            console.print()
+            continue
+
+        table = Table(
+            title=f"{scan_cat.category.value}",
+            title_style="bold cyan",
+            show_lines=False,
+        )
+        table.add_column("Name", style="white", no_wrap=False, ratio=3)
+        table.add_column("Size", style="green", justify="right", ratio=1)
+
+        for item in scan_cat.items:
+            table.add_row(item.name, format_size(item.size_bytes))
+
+        table.add_section()
+        table.add_row(
+            f"[bold]{scan_cat.item_count} items[/bold]",
+            f"[bold]{format_size(scan_cat.total_size)}[/bold]",
+        )
+
+        console.print(table)
+        console.print()
+
+    console.print(
+        Panel(
+            f"[bold]Total reclaimable space: {format_size(result.grand_total)}[/bold]",
+            style="green",
+        )
+    )
+
+
+def display_deletion_summary(results: list[DeletionResult]) -> None:
+    """Display summary of deletion results."""
+    succeeded = [r for r in results if r.success]
+    failed = [r for r in results if not r.success]
+    freed = sum(r.item.size_bytes for r in succeeded)
+
+    console.print()
+    if succeeded:
+        console.print(
+            f"[green]Deleted {len(succeeded)} item(s), freed {format_size(freed)}[/green]"
+        )
+    if failed:
+        console.print(f"[red]Failed to delete {len(failed)} item(s):[/red]")
+        for r in failed:
+            console.print(f"  [red]• {r.item.name}: {r.error}[/red]")
+
+
+def display_dry_run(items: list) -> None:
+    """Display what would be deleted in dry-run mode."""
+    from xcode_cleaner.models import ScanItem
+
+    total = sum(item.size_bytes for item in items)
+    console.print(
+        Panel("[bold yellow]Dry run — nothing will be deleted[/bold yellow]")
+    )
+    for item in items:
+        console.print(f"  Would delete: {item.name} ({format_size(item.size_bytes)})")
+    console.print(
+        f"\n[bold]Would free {format_size(total)} across {len(items)} item(s)[/bold]"
+    )

xcode_cleaner-0.1.0/src/xcode_cleaner/interactive.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+from InquirerPy.separator import Separator
+
+from xcode_cleaner.models import ScanItem, ScanResult
+from xcode_cleaner.sizes import format_size
+
+
+def prompt_selection(result: ScanResult) -> list[ScanItem]:
+    """Show an interactive checkbox prompt grouped by category. Returns selected items."""
+    choices: list[Choice | Separator] = []
+    items_by_index: dict[int, ScanItem] = {}
+    index = 0
+
+    for scan_cat in result.categories:
+        if not scan_cat.items:
+            continue
+
+        choices.append(
+            Separator(
+                f"── {scan_cat.category.value} ({scan_cat.item_count} items, {format_size(scan_cat.total_size)}) ──"
+            )
+        )
+
+        # Compute column widths for alignment within this category
+        name_width = 0
+        state_width = 0
+        size_width = 0
+        for item in scan_cat.items:
+            name_width = max(name_width, len(item.name))
+            state = item.metadata.get("state", "")
+            if state:
+                state_width = max(state_width, len(f"[{state}]"))
+            size_width = max(size_width, len(format_size(item.size_bytes)))
+
+        for item in scan_cat.items:
+            items_by_index[index] = item
+            state = item.metadata.get("state", "")
+            state_str = f"[{state}]" if state else ""
+            size_str = format_size(item.size_bytes)
+
+            name_col = item.name.ljust(name_width)
+            state_col = state_str.ljust(state_width) if state_width else ""
+            size_col = size_str.rjust(size_width)
+
+            parts = [name_col]
+            if state_width:
+                parts.append(state_col)
+            parts.append(size_col)
+
+            choices.append(
+                Choice(
+                    value=index,
+                    name="  ".join(parts),
+                    enabled=False,
+                )
+            )
+            index += 1
+
+    if not choices:
+        return []
+
+    selected = inquirer.checkbox(
+        message="Select items to delete (Space to toggle, Enter to confirm):",
+        choices=choices,
+        cycle=True,
+        instruction="(↑/↓ navigate, Space toggle, Enter confirm)",
+    ).execute()
+
+    if not selected:
+        return []
+
+    return [items_by_index[i] for i in selected]

xcode_cleaner-0.1.0/src/xcode_cleaner/models.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from xcode_cleaner.constants import Category
+
+
+@dataclass
+class ScanItem:
+    name: str
+    size_bytes: int
+    category: Category
+    path: Path | None = None
+    item_id: str | None = None  # UDID for simulators
+    metadata: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class ScanCategory:
+    category: Category
+    items: list[ScanItem] = field(default_factory=list)
+    found: bool = True  # Whether the source directory/data was found
+
+    @property
+    def total_size(self) -> int:
+        return sum(item.size_bytes for item in self.items)
+
+    @property
+    def item_count(self) -> int:
+        return len(self.items)
+
+
+@dataclass
+class ScanResult:
+    categories: list[ScanCategory] = field(default_factory=list)
+
+    @property
+    def grand_total(self) -> int:
+        return sum(cat.total_size for cat in self.categories)
+
+
+@dataclass
+class DeletionResult:
+    item: ScanItem
+    success: bool
+    error: str | None = None

xcode_cleaner-0.1.0/src/xcode_cleaner/scanner.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from xcode_cleaner.constants import CATEGORY_PATHS, DEVICE_SUPPORT_PATHS, Category
+from xcode_cleaner.models import ScanCategory, ScanItem, ScanResult
+from xcode_cleaner.simulators import list_runtimes, list_simulators
+from xcode_cleaner.sizes import dir_size
+
+
+def _scan_flat(category: Category, base: Path) -> list[ScanItem]:
+    """Scan a directory where each subdirectory is one item."""
+    if not base.is_dir():
+        return []
+    items: list[ScanItem] = []
+    try:
+        for entry in sorted(base.iterdir()):
+            if entry.is_dir() and not entry.is_symlink():
+                size = dir_size(entry)
+                items.append(
+                    ScanItem(
+                        name=entry.name,
+                        size_bytes=size,
+                        category=category,
+                        path=entry,
+                    )
+                )
+    except PermissionError:
+        pass
+    return items
+
+
+def _scan_archives(base: Path) -> list[ScanItem]:
+    """Scan Archives — date folders containing .xcarchive bundles."""
+    if not base.is_dir():
+        return []
+    items: list[ScanItem] = []
+    try:
+        for date_folder in sorted(base.iterdir()):
+            if not date_folder.is_dir() or date_folder.is_symlink():
+                continue
+            for archive in sorted(date_folder.iterdir()):
+                if archive.is_dir() and not archive.is_symlink() and archive.suffix == ".xcarchive":
+                    size = dir_size(archive)
+                    items.append(
+                        ScanItem(
+                            name=archive.name,
+                            size_bytes=size,
+                            category=Category.ARCHIVES,
+                            path=archive,
+                            metadata={"date_folder": date_folder.name},
+                        )
+                    )
+    except PermissionError:
+        pass
+    return items
+
+
+def scan_category(category: Category) -> ScanCategory:
+    """Scan a single category and return results."""
+    if category == Category.SIMULATORS:
+        items, found = list_simulators()
+    elif category == Category.SIMULATOR_RUNTIMES:
+        items, found = list_runtimes()
+    elif category == Category.DEVICE_SUPPORT:
+        items = []
+        found = False
+        for base in DEVICE_SUPPORT_PATHS:
+            if base.is_dir():
+                found = True
+                items.extend(_scan_flat(category, base))
+    elif category == Category.ARCHIVES:
+        base = CATEGORY_PATHS[Category.ARCHIVES]
+        found = base.is_dir()
+        items = _scan_archives(base)
+    else:
+        base = CATEGORY_PATHS[category]
+        found = base.is_dir()
+        items = _scan_flat(category, base)
+
+    # Sort by size descending
+    items.sort(key=lambda x: x.size_bytes, reverse=True)
+    return ScanCategory(category=category, items=items, found=found)
+
+
+def scan_all() -> ScanResult:
+    """Scan all categories and return a full result."""
+    categories = [scan_category(cat) for cat in Category]
+    return ScanResult(categories=categories)

xcode_cleaner-0.1.0/src/xcode_cleaner/simulators.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import json
+import subprocess
+
+from xcode_cleaner.constants import Category
+from xcode_cleaner.models import ScanItem
+
+
+def list_simulators() -> tuple[list[ScanItem], bool]:
+    """List all simulators via xcrun simctl and return (items, success).
+
+    The bool indicates whether the scan succeeded. False means xcrun was
+    unavailable or timed out — callers can distinguish "no simulators"
+    from "couldn't check."
+    """
+    try:
+        result = subprocess.run(
+            ["xcrun", "simctl", "list", "devices", "--json"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+    except FileNotFoundError:
+        return [], False
+    except subprocess.TimeoutExpired:
+        return [], False
+
+    if result.returncode != 0:
+        return [], False
+
+    try:
+        data = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return [], False
+
+    items: list[ScanItem] = []
+    for runtime, devices in data.get("devices", {}).items():
+        # runtime looks like "com.apple.CoreSimulator.SimRuntime.iOS-17-5"
+        runtime_name = runtime.rsplit(".", 1)[-1].replace("-", " ")
+        for device in devices:
+            udid = device.get("udid", "")
+            if not udid:
+                continue
+            name = device.get("name", "Unknown")
+            state = device.get("state", "Unknown")
+            size_bytes = device.get("dataPathSize", 0) or 0
+
+            items.append(
+                ScanItem(
+                    name=f"{name} ({runtime_name})",
+                    size_bytes=size_bytes,
+                    category=Category.SIMULATORS,
+                    item_id=udid,
+                    metadata={"state": state, "runtime": runtime_name},
+                )
+            )
+    return items, True
+
+
+def list_runtimes() -> tuple[list[ScanItem], bool]:
+    """List installed simulator runtimes via xcrun simctl and return (items, success).
+
+    The bool indicates whether the scan succeeded. False means xcrun was
+    unavailable or timed out.
+    """
+    try:
+        result = subprocess.run(
+            ["xcrun", "simctl", "runtime", "list", "-j"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+    except FileNotFoundError:
+        return [], False
+    except subprocess.TimeoutExpired:
+        return [], False
+
+    if result.returncode != 0:
+        return [], False
+
+    try:
+        data = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return [], False
+
+    items: list[ScanItem] = []
+    entries = data.values() if isinstance(data, dict) else data if isinstance(data, list) else []
+    for entry in entries:
+        identifier = entry.get("identifier")
+        if not identifier:
+            continue
+
+        # Build display name from runtimeIdentifier
+        # e.g. "com.apple.CoreSimulator.SimRuntime.iOS-26-2" -> "iOS 26.2"
+        runtime_id = entry.get("runtimeIdentifier", "")
+        if "." in runtime_id:
+            short = runtime_id.rsplit(".", 1)[-1]
+            parts = short.split("-", 1)
+            if len(parts) == 2:
+                platform = parts[0]
+                version = parts[1].replace("-", ".")
+                display_name = f"{platform} {version}"
+            else:
+                display_name = short.replace("-", " ")
+        else:
+            display_name = runtime_id or identifier
+
+        size_bytes = entry.get("sizeBytes", 0) or 0
+
+        items.append(
+            ScanItem(
+                name=display_name,
+                size_bytes=size_bytes,
+                category=Category.SIMULATOR_RUNTIMES,
+                item_id=identifier,
+                metadata={
+                    "state": entry.get("state", "Unknown"),
+                    "build": entry.get("build", ""),
+                    "kind": entry.get("kind", ""),
+                    "deletable": entry.get("deletable", False),
+                },
+            )
+        )
+    return items, True
+
+
+def delete_simulator(udid: str) -> None:
+    """Delete a simulator by UDID via xcrun simctl."""
+    subprocess.run(
+        ["xcrun", "simctl", "delete", udid],
+        capture_output=True,
+        text=True,
+        timeout=60,
+        check=True,
+    )
+
+
+def delete_runtime(identifier: str) -> None:
+    """Delete a simulator runtime by identifier via xcrun simctl."""
+    subprocess.run(
+        ["xcrun", "simctl", "runtime", "delete", identifier],
+        capture_output=True,
+        text=True,
+        timeout=120,
+        check=True,
+    )

xcode_cleaner-0.1.0/src/xcode_cleaner/sizes.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def dir_size(path: Path) -> int:
+    """Calculate total size of a directory using os.scandir for performance."""
+    total = 0
+    try:
+        with os.scandir(path) as entries:
+            for entry in entries:
+                try:
+                    if entry.is_file(follow_symlinks=False):
+                        total += entry.stat(follow_symlinks=False).st_size
+                    elif entry.is_dir(follow_symlinks=False):
+                        total += dir_size(Path(entry.path))
+                except (PermissionError, OSError):
+                    continue
+    except (PermissionError, OSError):
+        pass
+    return total
+
+
+def format_size(size_bytes: int) -> str:
+    """Format byte count as human-readable string."""
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    for unit in ("KB", "MB", "GB", "TB"):
+        size_bytes /= 1024
+        if size_bytes < 1024 or unit == "TB":
+            return f"{size_bytes:.1f} {unit}"
+    return f"{size_bytes:.1f} TB"  # unreachable but satisfies type checker

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

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: xcode-cleaner
+Version: 0.1.0
+Summary: CLI tool to reclaim disk space from Xcode build artifacts, caches, and simulators
+Author: cdunkel
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/cdunkel/xcode-cleaner
+Project-URL: Repository, https://github.com/cdunkel/xcode-cleaner
+Project-URL: Issues, https://github.com/cdunkel/xcode-cleaner/issues
+Keywords: xcode,macos,disk-space,cleanup,cli,simulators,derived-data
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Filesystems
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=13.0
+Requires-Dist: InquirerPy>=0.3.4
+Dynamic: license-file
+
+# xcode-cleaner
+
+A CLI tool to reclaim disk space from Xcode build artifacts, caches, and simulators.
+
+## What It Scans
+
+| Category | Path |
+|----------|------|
+| Derived Data | `~/Library/Developer/Xcode/DerivedData` |
+| Archives | `~/Library/Developer/Xcode/Archives` |
+| iOS Device Support | `~/Library/Developer/Xcode/iOS DeviceSupport` |
+| watchOS Device Support | `~/Library/Developer/Xcode/watchOS DeviceSupport` |
+| tvOS Device Support | `~/Library/Developer/Xcode/tvOS DeviceSupport` |
+| Simulators | Managed via `xcrun simctl` |
+| Xcode Caches | `~/Library/Caches/com.apple.dt.Xcode` |
+
+## Installation
+
+From PyPI:
+
+```
+pip install xcode-cleaner
+```
+
+From source:
+
+```
+git clone https://github.com/cdunkel/xcode-cleaner.git
+cd xcode-cleaner
+pip install .
+```
+
+## Usage
+
+**Scan and display a disk usage report:**
+
+```
+xcode-cleaner scan
+```
+
+**Interactively select and delete items to free space:**
+
+```
+xcode-cleaner clean
+```
+
+**Preview what would be deleted without actually deleting:**
+
+```
+xcode-cleaner clean --dry-run
+```
+
+## Requirements
+
+- macOS
+- Python 3.9+
+- Xcode (for simulator management)
+
+## License
+
+MIT

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

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+src/xcode_cleaner/__init__.py
+src/xcode_cleaner/__main__.py
+src/xcode_cleaner/cleaner.py
+src/xcode_cleaner/cli.py
+src/xcode_cleaner/constants.py
+src/xcode_cleaner/display.py
+src/xcode_cleaner/interactive.py
+src/xcode_cleaner/models.py
+src/xcode_cleaner/scanner.py
+src/xcode_cleaner/simulators.py
+src/xcode_cleaner/sizes.py
+src/xcode_cleaner.egg-info/PKG-INFO
+src/xcode_cleaner.egg-info/SOURCES.txt
+src/xcode_cleaner.egg-info/dependency_links.txt
+src/xcode_cleaner.egg-info/entry_points.txt
+src/xcode_cleaner.egg-info/requires.txt
+src/xcode_cleaner.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+xcode-cleaner = xcode_cleaner.cli:main

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

@@ -0,0 +1,3 @@
+click>=8.0
+rich>=13.0
+InquirerPy>=0.3.4

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

@@ -0,0 +1 @@
+xcode_cleaner