dark-matter-cli 0.1.0__py3-none-any.whl

dark_matter_cli/__init__.py

@@ -0,0 +1,35 @@
+"""A programmatic pipeline for recursive storage profiling."""
+
+import contextlib
+import importlib.metadata
+
+__version__ = "unknown"
+with contextlib.suppress(importlib.metadata.PackageNotFoundError):
+    __version__ = importlib.metadata.version("dark-matter-cli")
+
+from .core import (
+    build_analysis_dataframe,
+    build_compare_analysis_dataframe,
+    build_compare_theoretical_dataframe,
+    build_explain_analysis_dataframe,
+    build_explain_theoretical_dataframe,
+    build_targeted_analysis_dataframe,
+    build_targeted_theoretical_dataframe,
+    build_theoretical_dataframe,
+)
+from .homebrew import get_brew_metadata, get_brew_prefix, get_theoretical_catalog
+
+__all__ = [
+    "__version__",
+    "build_analysis_dataframe",
+    "build_compare_analysis_dataframe",
+    "build_compare_theoretical_dataframe",
+    "build_explain_analysis_dataframe",
+    "build_explain_theoretical_dataframe",
+    "build_targeted_analysis_dataframe",
+    "build_targeted_theoretical_dataframe",
+    "build_theoretical_dataframe",
+    "get_brew_metadata",
+    "get_brew_prefix",
+    "get_theoretical_catalog",
+]

dark_matter_cli/cli.py

@@ -0,0 +1,295 @@
+import contextlib
+import sys
+from collections.abc import Iterator
+from enum import StrEnum
+from pathlib import Path
+from typing import Any
+
+import typer
+from rich.console import Console
+
+from dark_matter_cli import (
+    __version__,
+    build_analysis_dataframe,
+    build_compare_analysis_dataframe,
+    build_compare_theoretical_dataframe,
+    build_explain_analysis_dataframe,
+    build_explain_theoretical_dataframe,
+    build_targeted_analysis_dataframe,
+    build_targeted_theoretical_dataframe,
+    build_theoretical_dataframe,
+    display,
+    get_brew_metadata,
+    get_brew_prefix,
+    get_theoretical_catalog,
+)
+
+app = typer.Typer(
+    help="Analyze dependency bloat and storage mass of macOS Homebrew installations.",
+    add_completion=False,
+)
+console = Console()
+
+state = {"verbose": False}
+
+
+class ExportFormat(StrEnum):
+    """Supported serialized output formats for the export command."""
+
+    csv = "csv"
+    json = "json"
+
+
+class ExportSource(StrEnum):
+    """Supported theoretical or physical data sources for the export command."""
+
+    installed = "installed"
+    catalog = "catalog"
+
+
+@contextlib.contextmanager
+def handle_pipeline_errors(active_console: Console = console) -> Iterator[None]:
+    """Centralize exception catching and CLI exit codes."""
+    try:
+        yield
+    except (RuntimeError, ValueError) as e:
+        active_console.print(f"[bold red]Pipeline Error:[/bold red] {e}")
+        raise typer.Exit(code=1) from e
+
+
+def load_ecosystem_context(
+    source: ExportSource, active_console: Console, target_msg: str | None = None
+) -> tuple[Path, dict[str, Any], bool]:
+    """Resolve the prefix and ingest the metadata payload while managing UI state."""
+    prefix = get_brew_prefix()
+    is_theoretical = source == ExportSource.catalog
+
+    if not is_theoretical:
+        msg = target_msg or "[yellow]Scanning physical disk footprint...[/yellow]"
+        with active_console.status(msg):
+            metadata = get_brew_metadata()
+    else:
+        msg = target_msg or "[yellow]Computing theoretical ecosystem DAG...[/yellow]"
+        with active_console.status(msg):
+            metadata = get_theoretical_catalog(prefix)
+
+    return prefix, metadata, is_theoretical
+
+
+def version_callback(value: bool) -> None:
+    """Print the version and exit eagerly."""
+    if value:
+        console.print(f"dark-matter version [bold cyan]{__version__}[/bold cyan]")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose logging."
+    ),
+    version: bool = typer.Option(
+        None,
+        "--version",
+        help="Show the application version and exit.",
+        callback=version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """Configure global CLI state."""
+    state["verbose"] = verbose
+
+
+@app.command()
+def analyze(
+    sort_by: str = typer.Option("ratio", "--sort", "-s", help="Sorting metric."),
+    top_n: int = typer.Option(20, "--top", "-n", help="Number of packages to display."),
+    fractional: bool = typer.Option(True, "--fractional/--standard"),
+) -> None:
+    """Execute the storage bloat analysis pipeline."""
+    console.print("[bold cyan]Initializing Dark Matter pipeline...[/bold cyan]")
+
+    with handle_pipeline_errors():
+        prefix, metadata, _ = load_ecosystem_context(ExportSource.installed, console)
+
+        formulae_count = len(metadata.get("formulae", []))
+        casks_count = len(metadata.get("casks", []))
+        console.print(
+            f"Successfully parsed [bold]{formulae_count}[/bold] formulae and [bold]{casks_count}[/bold] casks."
+        )
+
+        with console.status("[yellow]Computing fractional attribution DAG...[/yellow]"):
+            df = build_analysis_dataframe(metadata, prefix)
+
+        display.render_bloat_table(
+            df, sort_by=sort_by, top_n=top_n, fractional=fractional
+        )
+
+
+@app.command()
+def leaderboard(
+    sort_by: str = typer.Option("ratio", "--sort", "-s", help="Sorting metric."),
+    top_n: int = typer.Option(20, "--top", "-n", help="Number of packages to display."),
+    arch: str = typer.Option(
+        "arm64_tahoe", "--arch", "-a", help="Target architecture."
+    ),
+) -> None:
+    """Evaluate the complete theoretical ecosystem leaderboard."""
+    console.print("[bold cyan]Accessing local ecosystem cache...[/bold cyan]")
+
+    with handle_pipeline_errors():
+        _, metadata, _ = load_ecosystem_context(ExportSource.catalog, console)
+
+        with console.status("[yellow]Processing massive theoretical DAG...[/yellow]"):
+            df = build_theoretical_dataframe(metadata, arch=arch)
+
+        display.render_bloat_table(
+            df, sort_by=sort_by, top_n=top_n, fractional=True, is_theoretical=True
+        )
+
+
+@app.command()
+def inspect(
+    package: str = typer.Argument(..., help="The specific package to analyze."),
+    source: ExportSource = typer.Option(ExportSource.installed, "--source", "-s"),
+    arch: str = typer.Option("arm64_tahoe", "--arch", "-a"),
+) -> None:
+    """Evaluate the bloat of a single target package."""
+    console.print(f"[bold cyan]Inspecting bloat for '{package}'...[/bold cyan]")
+
+    with handle_pipeline_errors():
+        prefix, metadata, is_theoretical = load_ecosystem_context(
+            source,
+            console,
+            target_msg=f"[yellow]Resolving data for {package}...[/yellow]",
+        )
+
+        if is_theoretical:
+            df = build_targeted_theoretical_dataframe(
+                metadata, target=package, arch=arch
+            )
+        else:
+            df = build_targeted_analysis_dataframe(metadata, prefix, target=package)
+
+        display.render_bloat_table(
+            df, sort_by="ratio", top_n=1, fractional=True, is_theoretical=is_theoretical
+        )
+
+
+@app.command()
+def compare(
+    packages: list[str] = typer.Argument(..., help="The specific packages to compare."),
+    sort_by: str = typer.Option("ratio", "--sort", "-s"),
+    source: ExportSource = typer.Option(ExportSource.installed, "--source", "-s"),
+    arch: str = typer.Option("arm64_tahoe", "--arch", "-a"),
+) -> None:
+    """Evaluate and compare the bloat of multiple packages."""
+    pkg_list_str = ", ".join(packages)
+    console.print(f"[bold cyan]Comparing bloat for: {pkg_list_str}[/bold cyan]")
+
+    with handle_pipeline_errors():
+        prefix, metadata, is_theoretical = load_ecosystem_context(
+            source, console, target_msg="[yellow]Resolving data for targets...[/yellow]"
+        )
+
+        if is_theoretical:
+            df = build_compare_theoretical_dataframe(
+                metadata, targets=packages, arch=arch
+            )
+        else:
+            df = build_compare_analysis_dataframe(metadata, prefix, targets=packages)
+
+        display.render_bloat_table(
+            df,
+            sort_by=sort_by,
+            top_n=len(packages),
+            fractional=True,
+            is_theoretical=is_theoretical,
+        )
+
+
+@app.command()
+def export(
+    source: ExportSource = typer.Option(ExportSource.installed, "--source", "-s"),
+    export_format: ExportFormat = typer.Option(ExportFormat.csv, "--format", "-f"),
+    arch: str = typer.Option("arm64_tahoe", "--arch", "-a"),
+) -> None:
+    """Export the computed bloat analysis dataframe for external pipelines."""
+    err_console = Console(stderr=True)
+
+    with handle_pipeline_errors(err_console):
+        prefix, metadata, is_theoretical = load_ecosystem_context(source, err_console)
+
+        with err_console.status(
+            "[yellow]Computing fractional attribution DAG...[/yellow]"
+        ):
+            if is_theoretical:
+                df = build_theoretical_dataframe(metadata, arch=arch)
+            else:
+                df = build_analysis_dataframe(metadata, prefix)
+
+        if export_format == ExportFormat.csv:
+            sys.stdout.write(df.to_csv(index=False))
+        else:
+            sys.stdout.write(df.to_json(orient="records", indent=2))
+            sys.stdout.write("\n")
+
+
+@app.command()
+def explain(
+    package: str = typer.Argument(..., help="The specific package to analyze."),
+    source: ExportSource = typer.Option(ExportSource.installed, "--source", "-s"),
+    arch: str = typer.Option("arm64_tahoe", "--arch", "-a"),
+) -> None:
+    """Break down the bloat of a package by its dependencies."""
+    console.print(
+        f"[bold cyan]Explaining fractional dependencies for '{package}'...[/bold cyan]"
+    )
+
+    with handle_pipeline_errors():
+        prefix, metadata, is_theoretical = load_ecosystem_context(
+            source,
+            console,
+            target_msg=f"[yellow]Resolving data for {package}...[/yellow]",
+        )
+
+        try:
+            if is_theoretical:
+                df = build_explain_theoretical_dataframe(
+                    metadata, target=package, arch=arch
+                )
+            else:
+                df = build_explain_analysis_dataframe(metadata, prefix, target=package)
+
+        except ValueError as e:
+            # Intercept the specific missing package error for physical installations
+            if not is_theoretical and "not found in the local installation" in str(e):
+                # Suspend the pipeline and prompt for state pivot
+                fallback = typer.confirm(
+                    f"\nPackage '{package}' is not installed. Fall back to the theoretical catalog?",
+                    default=True,
+                )
+
+                if not fallback:
+                    raise typer.Exit(code=1) from None
+
+                # Mutate state to theoretical and fetch the full catalog metadata
+                is_theoretical = True
+                _, metadata, _ = load_ecosystem_context(
+                    ExportSource.catalog,
+                    console,
+                    target_msg="[yellow]Loading theoretical catalog...[/yellow]",
+                )
+
+                df = build_explain_theoretical_dataframe(
+                    metadata, target=package, arch=arch
+                )
+            else:
+                # Bubble up unrelated ValueErrors to the context manager
+                raise
+
+        display.render_explain_table(df, target=package, is_theoretical=is_theoretical)
+
+
+if __name__ == "__main__":
+    app()

dark_matter_cli/core.py

@@ -0,0 +1,304 @@
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+from dark_matter_cli import homebrew
+
+
+def _build_global_topology(
+    metadata: dict[str, Any],
+) -> tuple[dict[str, list[str]], dict[str, set[str]], dict[str, int], dict[str, Any]]:
+    """Parse metadata and pre-compute the immutable DAG properties."""
+    packages = metadata.get("formulae", []) + metadata.get("casks", [])
+
+    dependency_graph = {}
+    pkg_data_map = {}
+
+    for pkg in packages:
+        name = pkg["name"][0] if isinstance(pkg["name"], list) else pkg["name"]
+        dependency_graph[name] = pkg.get("dependencies", [])
+        pkg_data_map[name] = pkg
+
+    package_transitive_deps = {
+        pkg: get_all_dependencies(pkg, dependency_graph) for pkg in dependency_graph
+    }
+
+    # Initialize with 0 for known packages, but handle missing edge nodes dynamically
+    dependency_parent_count = dict.fromkeys(dependency_graph, 0)
+    for deps in package_transitive_deps.values():
+        for dep in deps:
+            dependency_parent_count[dep] = dependency_parent_count.get(dep, 0) + 1
+
+    return (
+        dependency_graph,
+        package_transitive_deps,
+        dependency_parent_count,
+        pkg_data_map,
+    )
+
+
+def _resolve_physical_sizes(
+    dependency_graph: dict[str, list[str]], prefix: Path
+) -> dict[str, int]:
+    """Calculate disk footprint for installed packages."""
+    size_map = {}
+    for name in dependency_graph:
+        cellar_path = prefix / "Cellar" / name
+        cask_path = prefix / "Caskroom" / name
+
+        if cellar_path.exists():
+            size_map[name] = homebrew.get_directory_size(cellar_path)
+        elif cask_path.exists():
+            size_map[name] = homebrew.get_directory_size(cask_path)
+        else:
+            size_map[name] = 0
+    return size_map
+
+
+def _resolve_theoretical_sizes(
+    resolution_set: set[str], pkg_data_map: dict[str, Any], arch: str
+) -> dict[str, int]:
+    """Resolve compressed bottle sizes via ghcr.io for a specific subset of packages."""
+    package_digest = {}
+    bottles = {}
+
+    for name in resolution_set:
+        pkg = pkg_data_map.get(name, {})
+        files = pkg.get("bottle", {}).get("stable", {}).get("files", {})
+        file_info = files.get(arch) or next(iter(files.values()), None)
+
+        if file_info is not None:
+            digest = file_info.get("sha256", "")
+            url = file_info.get("url", "")
+            if digest and url:
+                package_digest[name] = digest
+                bottles[digest] = url
+
+    cache = homebrew.load_bottle_size_cache()
+    resolved_sizes = homebrew.resolve_bottle_sizes(bottles, cache)
+    homebrew.save_bottle_size_cache(cache)
+
+    return {
+        name: resolved_sizes.get(digest, 0) for name, digest in package_digest.items()
+    }
+
+
+def _compute_bloat_metrics(
+    targets: list[str],
+    size_map: dict[str, int],
+    package_transitive_deps: dict[str, set[str]],
+    dependency_parent_count: dict[str, int],
+) -> pd.DataFrame:
+    """Execute the fractional attribution math and compile the DataFrame."""
+    results = []
+    for target in targets:
+        core_size = size_map.get(target, 0)
+        target_deps = package_transitive_deps.get(target, set())
+
+        standard_recursive_size = core_size + sum(
+            size_map.get(d, 0) for d in target_deps
+        )
+        fractional_dep_size = sum(
+            size_map.get(d, 0) / dependency_parent_count.get(d, 1) for d in target_deps
+        )
+
+        weighted_recursive_size = core_size + fractional_dep_size
+        ratio = (weighted_recursive_size / core_size) if core_size > 0 else 1.0
+
+        results.append(
+            {
+                "Package": target,
+                "Core_Bytes": core_size,
+                "Standard_Bytes": standard_recursive_size,
+                "Weighted_Bytes": weighted_recursive_size,
+                "Bloat_Ratio": ratio,
+                "Dep_Count": len(target_deps),
+                "Is_Leaf": dependency_parent_count.get(target, 0) == 0
+                if len(targets) > 1
+                else True,
+            }
+        )
+
+    return pd.DataFrame(results)
+
+
+def _compute_explain_metrics(
+    target: str,
+    size_map: dict[str, int],
+    package_transitive_deps: dict[str, set[str]],
+    dependency_parent_count: dict[str, int],
+    is_theoretical: bool,
+) -> pd.DataFrame:
+    """Compile the fractional dependency cost breakdown for a target package."""
+    target_deps = package_transitive_deps.get(target, set())
+    results = []
+
+    for dep in target_deps:
+        dep_size = size_map.get(dep, 0)
+        parents = dependency_parent_count.get(dep, 1)
+        attributed_size = dep_size / parents if parents > 0 else float(dep_size)
+
+        row = {
+            "Dependency": dep,
+            "Shared_By": parents,
+            "Attributed_Bytes": attributed_size,
+        }
+
+        if is_theoretical:
+            row["Archive_Bytes"] = dep_size
+        else:
+            row["Core_Bytes"] = dep_size
+
+        results.append(row)
+
+    df = pd.DataFrame(results)
+    if not df.empty:
+        df = df.sort_values(by="Attributed_Bytes", ascending=False)
+
+    return df
+
+
+def get_all_dependencies(
+    pkg: str, graph: dict[str, list[str]], visited: set[str] | None = None
+) -> set[str]:
+    """Recursively traverse the DAG to extract all transitive dependencies.
+
+    Args:
+        pkg: The target package identifier.
+        graph: The complete directed acyclic graph of explicitly declared dependencies.
+        visited: The mathematical set of dependencies already encountered.
+
+    Returns:
+        set[str]: A set containing all deeply nested transitive dependencies.
+    """
+    if visited is None:
+        visited = set()
+
+    if pkg not in graph:
+        return visited
+
+    for dep in graph[pkg]:
+        if dep not in visited:
+            visited.add(dep)
+            get_all_dependencies(dep, graph, visited)
+
+    return visited
+
+
+def build_analysis_dataframe(metadata: dict[str, Any], prefix: Path) -> pd.DataFrame:
+    """Construct the primary DataFrame utilizing physical disk metrics."""
+    graph, trans_deps, in_degrees, _ = _build_global_topology(metadata)
+    size_map = _resolve_physical_sizes(graph, prefix)
+    targets = list(graph.keys())
+
+    return _compute_bloat_metrics(targets, size_map, trans_deps, in_degrees)
+
+
+def build_targeted_analysis_dataframe(
+    metadata: dict[str, Any], prefix: Path, target: str
+) -> pd.DataFrame:
+    """Constructs a DataFrame for a single installed target."""
+    graph, trans_deps, in_degrees, _ = _build_global_topology(metadata)
+
+    if target not in graph:
+        raise ValueError(f"Package '{target}' not found in the local installation.")
+
+    size_map = _resolve_physical_sizes(graph, prefix)
+    return _compute_bloat_metrics([target], size_map, trans_deps, in_degrees)
+
+
+def build_compare_analysis_dataframe(
+    metadata: dict[str, Any], prefix: Path, targets: list[str]
+) -> pd.DataFrame:
+    """Constructs a DataFrame for comparing multiple installed targets."""
+    graph, trans_deps, in_degrees, _ = _build_global_topology(metadata)
+
+    valid_targets = [t for t in targets if t in graph]
+    if not valid_targets:
+        raise ValueError(
+            "None of the specified packages were found in the local installation."
+        )
+
+    size_map = _resolve_physical_sizes(graph, prefix)
+    return _compute_bloat_metrics(valid_targets, size_map, trans_deps, in_degrees)
+
+
+def build_explain_analysis_dataframe(
+    metadata: dict[str, Any], prefix: Path, target: str
+) -> pd.DataFrame:
+    """Constructs a dependency breakdown DataFrame for a physical target."""
+    graph, trans_deps, in_degrees, _ = _build_global_topology(metadata)
+
+    if target not in graph:
+        raise ValueError(f"Package '{target}' not found in the local installation.")
+
+    size_map = _resolve_physical_sizes(graph, prefix)
+    return _compute_explain_metrics(
+        target, size_map, trans_deps, in_degrees, is_theoretical=False
+    )
+
+
+def build_theoretical_dataframe(
+    metadata: dict[str, Any], arch: str = "arm64_tahoe"
+) -> pd.DataFrame:
+    """Constructs the ecosystem-wide theoretical leaderboard."""
+    graph, trans_deps, in_degrees, pkg_map = _build_global_topology(metadata)
+
+    resolution_set = set(graph.keys())
+    size_map = _resolve_theoretical_sizes(resolution_set, pkg_map, arch)
+    targets = list(graph.keys())
+
+    return _compute_bloat_metrics(targets, size_map, trans_deps, in_degrees)
+
+
+def build_targeted_theoretical_dataframe(
+    metadata: dict[str, Any], target: str, arch: str = "arm64_tahoe"
+) -> pd.DataFrame:
+    """Constructs a DataFrame for a single target, minimizing network resolution."""
+    graph, trans_deps, in_degrees, pkg_map = _build_global_topology(metadata)
+
+    if target not in graph:
+        raise ValueError(f"Package '{target}' not found in the catalog.")
+
+    # Isolate strictly to the target's closure to prevent O(N) network lookups
+    resolution_set = {target} | trans_deps[target]
+    size_map = _resolve_theoretical_sizes(resolution_set, pkg_map, arch)
+
+    return _compute_bloat_metrics([target], size_map, trans_deps, in_degrees)
+
+
+def build_compare_theoretical_dataframe(
+    metadata: dict[str, Any], targets: list[str], arch: str = "arm64_tahoe"
+) -> pd.DataFrame:
+    """Constructs a DataFrame for multiple targets by resolving their unioned closure."""
+    graph, trans_deps, in_degrees, pkg_map = _build_global_topology(metadata)
+
+    valid_targets = [t for t in targets if t in graph]
+    if not valid_targets:
+        raise ValueError("None of the specified packages were found in the catalog.")
+
+    # Generate the union of all target transitive dependencies
+    resolution_set = set(valid_targets)
+    for t in valid_targets:
+        resolution_set.update(trans_deps[t])
+
+    size_map = _resolve_theoretical_sizes(resolution_set, pkg_map, arch)
+    return _compute_bloat_metrics(valid_targets, size_map, trans_deps, in_degrees)
+
+
+def build_explain_theoretical_dataframe(
+    metadata: dict[str, Any], target: str, arch: str = "arm64_tahoe"
+) -> pd.DataFrame:
+    """Constructs a dependency breakdown DataFrame using theoretical metrics."""
+    graph, trans_deps, in_degrees, pkg_map = _build_global_topology(metadata)
+
+    if target not in graph:
+        raise ValueError(f"Package '{target}' not found in the catalog.")
+
+    resolution_set = {target} | trans_deps[target]
+    size_map = _resolve_theoretical_sizes(resolution_set, pkg_map, arch)
+
+    return _compute_explain_metrics(
+        target, size_map, trans_deps, in_degrees, is_theoretical=True
+    )

dark_matter_cli/display.py

@@ -0,0 +1,131 @@
+import pandas as pd
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def format_bytes(size: float) -> str:
+    """Dynamically format byte sizes into human-readable strings."""
+    if size < 1024:
+        return f"{size:.0f} B"
+    if size < 1024**2:
+        return f"{size / 1024:.1f} KB"
+    if size < 999 * (1024**2):
+        return f"{size / (1024**2):.1f} MB"
+    return f"{size / (1024**3):.2f} GB"
+
+
+def render_bloat_table(
+    df: pd.DataFrame,
+    sort_by: str = "ratio",
+    top_n: int = 20,
+    fractional: bool = True,
+    is_theoretical: bool = False,
+) -> None:
+    """Render the mathematical analysis as a formatted terminal table.
+
+    Args:
+        df: The fully processed pandas DataFrame containing bloat metrics.
+        sort_by: The column criteria utilized for descending sort operations.
+        top_n: The maximum number of rows to print to standard output.
+        fractional: Boolean flag to display the Fractional Attribution Model data.
+        is_theoretical: Boolean flag to indicate if the data is from theoretical analysis.
+    """
+    if df.empty or "Is_Leaf" not in df.columns:
+        console.print("[bold red]No package data available to render.[/bold red]")
+        return
+
+    # Filter explicitly for root invocations (leaves)
+    df = df[df["Is_Leaf"]]
+
+    # Map the CLI flag to the corresponding DataFrame column
+    sort_map = {
+        "ratio": "Bloat_Ratio",
+        "core": "Core_Bytes",
+        "recursive": "Weighted_Bytes" if fractional else "Standard_Bytes",
+    }
+    sort_col = sort_map.get(sort_by, "Bloat_Ratio")
+
+    df = df.sort_values(by=sort_col, ascending=False).head(top_n)
+
+    table = Table(
+        title="[bold]Dark Matter: Homebrew Bloat Analysis[/bold]",
+        show_header=True,
+        header_style="bold cyan",
+    )
+
+    table.add_column("Package", style="white", no_wrap=True)
+
+    # Adjust headers based on the measurement type
+    core_label = "Archive Size" if is_theoretical else "Core Size"
+    table.add_column(core_label, justify="right", style="dim")
+
+    if fractional:
+        rec_label = "Theoretical Rec. Size" if is_theoretical else "Weighted Rec. Size"
+        table.add_column(rec_label, justify="right", style="magenta")
+    else:
+        rec_label = "Theoretical Std. Size" if is_theoretical else "Standard Rec. Size"
+        table.add_column(rec_label, justify="right", style="magenta")
+
+    table.add_column("Bloat Ratio", justify="right")
+    table.add_column("Deps", justify="right", style="dim")
+
+    for _, row in df.iterrows():
+        # Pass raw byte values to the dynamic formatter
+        core_bytes = row["Core_Bytes"]
+        rec_bytes = row["Weighted_Bytes"] if fractional else row["Standard_Bytes"]
+
+        ratio = row["Bloat_Ratio"]
+        deps = int(row["Dep_Count"])
+
+        # Color code the bloat severity
+        if ratio >= 10.0:
+            ratio_str = f"[bold red]{ratio:.1f}x[/bold red]"
+        elif ratio >= 3.0:
+            ratio_str = f"[bold yellow]{ratio:.1f}x[/bold yellow]"
+        else:
+            ratio_str = f"[green]{ratio:.1f}x[/green]"
+
+        table.add_row(
+            str(row["Package"]),
+            format_bytes(core_bytes),
+            format_bytes(rec_bytes),
+            ratio_str,
+            str(deps),
+        )
+
+    console.print(table)
+
+
+def render_explain_table(
+    df: pd.DataFrame, target: str, is_theoretical: bool = False
+) -> None:
+    """Render the dependency breakdown table for a specific package."""
+    if df.empty:
+        console.print(f"[green]'{target}' has no transitive dependencies.[/green]")
+        return
+
+    table = Table(
+        title=f"[bold]Dependency Breakdown: {target}[/bold]",
+        show_header=True,
+        header_style="bold cyan",
+    )
+
+    size_col = "Archive_Bytes" if is_theoretical else "Core_Bytes"
+    size_label = "Archive Size" if is_theoretical else "Core Size"
+
+    table.add_column("Dependency", style="white", no_wrap=True)
+    table.add_column(size_label, justify="right", style="dim")
+    table.add_column("Shared By", justify="right", style="dim")
+    table.add_column("Attributed Size", justify="right", style="magenta")
+
+    for _, row in df.iterrows():
+        table.add_row(
+            str(row["Dependency"]),
+            format_bytes(row[size_col]),
+            str(int(row["Shared_By"])),
+            format_bytes(row["Attributed_Bytes"]),
+        )
+
+    console.print(table)

dark_matter_cli/homebrew.py

@@ -0,0 +1,320 @@
+import json
+import logging
+import os
+import re
+import subprocess
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any
+
+import requests
+
+logger = logging.getLogger("dark_matter_cli")
+
+
+def get_brew_prefix() -> Path:
+    """Retrieve the local Homebrew installation prefix.
+
+    Returns:
+        Path: The absolute path to the Homebrew prefix (e.g., /opt/homebrew).
+
+    Raises:
+        RuntimeError: If the brew prefix command fails.
+    """
+    try:
+        result = subprocess.run(
+            ["brew", "--prefix"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return Path(result.stdout.strip())
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Failed to resolve Homebrew prefix: {e.stderr}") from e
+
+
+def get_brew_metadata() -> dict[str, Any]:
+    """Execute the brew info API to extract installed package metadata.
+
+    Returns:
+        dict[str, Any]: The parsed JSON payload containing formulae and casks.
+
+    Raises:
+        RuntimeError: If the brew info command fails or returns invalid JSON.
+    """
+    try:
+        result = subprocess.run(
+            ["brew", "info", "--json=v2", "--installed"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        data: dict[str, Any] = json.loads(result.stdout)
+        return data
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Failed to execute brew API: {e.stderr}") from e
+    except json.JSONDecodeError as e:
+        raise RuntimeError("Failed to parse Homebrew JSON output.") from e
+
+
+def get_directory_size(path: Path) -> int:
+    """Recursively calculate the aggregate physical byte size of a directory.
+
+    Utilizes os.scandir for highly optimized filesystem traversal.
+
+    Args:
+        path: The directory path to calculate.
+
+    Returns:
+        int: The total size in bytes. Returns 0 if the path does not exist.
+    """
+    if not path.exists() or not path.is_dir():
+        return 0
+
+    total_size = 0
+    try:
+        with os.scandir(path) as it:
+            for entry in it:
+                if entry.is_file(follow_symlinks=False):
+                    total_size += entry.stat().st_size
+                elif entry.is_dir(follow_symlinks=False):
+                    total_size += get_directory_size(Path(entry.path))
+    except PermissionError:
+        # Silently ignore unreadable directories to prevent pipeline termination
+        pass
+
+    return total_size
+
+
+def _load_api_cache(json_path: Path, jws_path: Path) -> list[dict[str, Any]]:
+    if jws_path.exists():
+        with open(jws_path, encoding="utf-8") as f:
+            jws_data = json.load(f)
+
+        payload = jws_data.get("payload", "")
+
+        if not isinstance(payload, str):
+            logger.error("JWS payload is not a string!")
+            return []
+
+        try:
+            data = json.loads(payload)
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse JWS payload: {e}")
+            return []
+
+        if not isinstance(data, list):
+            logger.error("API payload is not a list.")
+            return []
+
+        return data
+
+    if json_path.exists():
+        with open(json_path, encoding="utf-8") as f:
+            data = json.load(f)
+
+        if not isinstance(data, list):
+            logger.error("API cache is not a list.")
+            return []
+
+        return data
+
+    return []
+
+
+def get_theoretical_catalog(prefix: Path) -> dict[str, list[dict[str, Any]]]:
+    """Directly ingests Homebrew's local API JSON caches, bypassing the CLI entirely.
+
+    Args:
+        prefix: The base physical installation path for Homebrew.
+
+    Returns:
+        dict: A dictionary containing 'formulae' and 'casks' lists.
+    """
+    # Standard location where Homebrew mirrors its online API cache locally
+    cache_dir = Path.home() / "Library/Caches/Homebrew/api"
+
+    formula_api_path = cache_dir / "formula.json"
+    formula_jws_path = cache_dir / "formula.jws.json"
+
+    cask_api_path = cache_dir / "cask.json"
+    cask_jws_path = cache_dir / "cask.jws.json"
+
+    # Fallback to internal cellar var paths if user settings vary
+    if not formula_jws_path.exists() and not formula_api_path.exists():
+        formula_api_path = prefix / "var/homebrew/api/formula.json"
+        formula_jws_path = prefix / "var/homebrew/api/formula.jws.json"
+        cask_api_path = prefix / "var/homebrew/api/cask.json"
+        cask_jws_path = prefix / "var/homebrew/api/cask.jws.json"
+
+    if not formula_jws_path.exists() and not formula_api_path.exists():
+        raise RuntimeError(
+            "Local Homebrew API cache not found. Please run `brew update` first."
+        )
+
+    formulae = _load_api_cache(formula_api_path, formula_jws_path)
+    casks = _load_api_cache(cask_api_path, cask_jws_path)
+
+    return {"formulae": formulae, "casks": casks}
+
+
+_GHCR_TOKEN_URL = "https://ghcr.io/token"  # noqa: S105
+_BLOB_URL_PATTERN = re.compile(r"^https://ghcr\.io/v2/(?P<repo>.+)/blobs/sha256:")
+_BOTTLE_SIZE_CACHE_PATH = Path.home() / ".cache" / "dark-matter" / "bottle_sizes.json"
+
+
+def _parse_repository(url: str) -> str | None:
+    """Extract the ghcr.io repository path from a bottle blob URL.
+
+    Args:
+        url: The full blob URL, e.g.
+            'https://ghcr.io/v2/homebrew/core/wget/blobs/sha256:...'.
+
+    Returns:
+        str | None: The repository path (e.g. 'homebrew/core/wget'), or None
+            if the URL does not match the expected ghcr.io blob format.
+    """
+    match = _BLOB_URL_PATTERN.match(url)
+    return match.group("repo") if match else None
+
+
+def _fetch_ghcr_token(repository: str, timeout: float) -> str | None:
+    """Request an anonymous pull token scoped to a single ghcr.io repository.
+
+    Args:
+        repository: The repository path (e.g. 'homebrew/core/wget').
+        timeout: Per-request timeout in seconds.
+
+    Returns:
+        str | None: A bearer token, or None if the request failed.
+    """
+    params = {"service": "ghcr.io", "scope": f"repository:{repository}:pull"}
+    try:
+        resp = requests.get(_GHCR_TOKEN_URL, params=params, timeout=timeout)
+        resp.raise_for_status()
+        token = resp.json().get("token")
+    except requests.RequestException:
+        return None
+
+    return token if isinstance(token, str) else None
+
+
+def _fetch_blob_size(url: str, token: str, timeout: float) -> int:
+    """Resolve the compressed size of an OCI blob via a HEAD request.
+
+    Args:
+        url: The full blob URL.
+        token: A bearer token scoped to the blob's repository.
+        timeout: Per-request timeout in seconds.
+
+    Returns:
+        int: The size in bytes, or 0 if the size could not be determined.
+    """
+    headers = {"Authorization": f"Bearer {token}"}
+    try:
+        resp = requests.head(
+            url, headers=headers, timeout=timeout, allow_redirects=True
+        )
+        resp.raise_for_status()
+        return int(resp.headers.get("Content-Length", "0"))
+    except (requests.RequestException, ValueError):
+        return 0
+
+
+def _fetch_bottle_size(url: str, timeout: float = 5.0) -> int:
+    """Resolve a single bottle's compressed byte size from ghcr.io.
+
+    Args:
+        url: The full blob URL for the bottle.
+        timeout: Per-request timeout in seconds.
+
+    Returns:
+        int: The size in bytes, or 0 if any stage of the lookup failed.
+    """
+    repository = _parse_repository(url)
+    if repository is None:
+        return 0
+
+    token = _fetch_ghcr_token(repository, timeout)
+    if token is None:
+        return 0
+
+    return _fetch_blob_size(url, token, timeout)
+
+
+def load_bottle_size_cache() -> dict[str, int]:
+    """Load the persisted sha256-to-size cache from disk.
+
+    Returns:
+        dict[str, int]: A mapping of bottle sha256 digests to byte sizes.
+            Returns an empty dict if no cache exists or it cannot be parsed.
+    """
+    if not _BOTTLE_SIZE_CACHE_PATH.exists():
+        return {}
+
+    try:
+        with open(_BOTTLE_SIZE_CACHE_PATH, encoding="utf-8") as f:
+            data: dict[str, int] = json.load(f)
+        return data
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def save_bottle_size_cache(cache: dict[str, int]) -> None:
+    """Persist the sha256-to-size cache to disk.
+
+    Args:
+        cache: A mapping of bottle sha256 digests to byte sizes.
+    """
+    _BOTTLE_SIZE_CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(_BOTTLE_SIZE_CACHE_PATH, "w", encoding="utf-8") as f:
+        json.dump(cache, f)
+
+
+def resolve_bottle_sizes(
+    bottles: dict[str, str],
+    cache: dict[str, int],
+    max_workers: int = 16,
+    timeout: float = 5.0,
+) -> dict[str, int]:
+    """Resolve compressed bottle sizes for a batch of sha256-keyed blob URLs.
+
+    Cached digests are returned immediately without touching the network.
+    Uncached digests are resolved concurrently via ghcr.io HEAD requests, and
+    `cache` is updated in place with any newly-resolved sizes so the caller
+    can persist it afterward.
+
+    Args:
+        bottles: A mapping of bottle sha256 digest to its blob URL.
+        cache: The sha256-to-size cache, updated in place with new results.
+        max_workers: The maximum number of concurrent network requests.
+        timeout: Per-request timeout in seconds.
+
+    Returns:
+        dict[str, int]: A mapping of sha256 digest to resolved byte size,
+            covering every digest present in `bottles`.
+    """
+    resolved: dict[str, int] = {}
+    pending: dict[str, str] = {}
+
+    for digest, url in bottles.items():
+        if digest in cache:
+            resolved[digest] = cache[digest]
+        else:
+            pending[digest] = url
+
+    if not pending:
+        return resolved
+
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        future_to_digest = {
+            executor.submit(_fetch_bottle_size, url, timeout): digest
+            for digest, url in pending.items()
+        }
+        for future in as_completed(future_to_digest):
+            digest = future_to_digest[future]
+            size = future.result()
+            resolved[digest] = size
+            cache[digest] = size
+
+    return resolved

dark_matter_cli/logger.py

@@ -0,0 +1,21 @@
+import logging
+import sys
+
+
+def get_logger(name: str, verbose: bool = False) -> logging.Logger:
+    """Create and configure a logger for the application.
+
+    Args:
+        name: Logger name.
+        verbose: Whether DEBUG logging should be enabled.
+
+    Returns:
+        A configured logger instance.
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.DEBUG if verbose else logging.INFO)
+    handler = logging.StreamHandler(sys.stderr)
+    formatter = logging.Formatter("%(levelname)s: %(message)s")
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    return logger

dark_matter_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,200 @@
+Metadata-Version: 2.5
+Name: dark-matter-cli
+Version: 0.1.0
+Summary: A dependency-graph-aware storage profiler for Homebrew.
+Project-URL: Repository, https://github.com/jacksonfergusondev/dark-matter
+Project-URL: Issues, https://github.com/jacksonfergusondev/dark-matter/issues
+Project-URL: PyPI, https://pypi.org/project/dark-matter-cli/
+Author-email: Jackson Ferguson <jackson.ferguson0@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Jackson Ferguson
+        
+        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.
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Requires-Dist: pandas>=3.0.3
+Requires-Dist: requests>=2.34.0
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.25.1
+Description-Content-Type: text/markdown
+
+<!-- rumdl-disable-file first-line-heading -->
+<div align="center">
+
+# Dark Matter
+
+**A dependency-graph-aware storage profiler for Homebrew.**
+
+[![CI](https://img.shields.io/github/actions/workflow/status/JacksonFergusonDev/dark-matter/ci.yml?style=flat-square&color=white&labelColor=0A0A0A&label=CI)](https://github.com/JacksonFergusonDev/dark-matter/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.12+-white?style=flat-square&labelColor=0A0A0A)](https://www.python.org/downloads/)
+[![Ruff](https://img.shields.io/badge/style-ruff-white?style=flat-square&labelColor=0A0A0A)](https://github.com/astral-sh/ruff)
+[![Mypy](https://img.shields.io/badge/mypy-checked-white?style=flat-square&labelColor=0A0A0A)](https://mypy-lang.org/)
+[![prek](https://img.shields.io/badge/prek-enabled-white?style=flat-square&labelColor=black)](https://github.com/j178/prek)
+[![License](https://img.shields.io/badge/license-MIT-white?style=flat-square&labelColor=0A0A0A)](LICENSE)
+
+</div>
+
+## Why
+
+Homebrew flattens every dependency into a single `Cellar` directory. Tools like `du` or `ncdu` can tell you a formula takes up 500 MB, but they have no concept of *why* — whether that mass belongs to the formula itself or to a shared runtime pulled in by five other packages you installed for unrelated reasons.
+
+Dark Matter reconstructs the dependency graph Homebrew already knows about and uses it to answer a more useful question: for each package you explicitly installed, how much disk space does it actually cost you, once shared dependencies are fairly split across everything that depends on them?
+
+## How it works
+
+Dark Matter parses Homebrew's own JSON metadata (via `brew info --json=v2` or its local API cache), rebuilds the dependency DAG, and walks it to compute two figures per package:
+
+- **Core size** — the package's own on-disk footprint (or, in theoretical mode, its compressed bottle archive).
+- **Weighted recursive size** — the core size plus a *fair share* of every transitive dependency, where each shared dependency's cost is divided evenly across all the packages that depend on it.
+
+The ratio between the two — the **Bloat Ratio** — is the headline number. A low ratio means a package is mostly self-contained; a high ratio means most of its footprint belongs to shared infrastructure it happens to require.
+
+## Features
+
+- **Comprehensive analysis suite**
+  - `analyze` — measures what's actually on disk, using `brew info --json=v2 --installed` and direct filesystem traversal (`os.scandir`) for exact byte counts.
+  - `leaderboard` — a theoretical mode that ranks Homebrew's *entire* formula and cask catalog from the local API cache, without requiring anything to be installed.
+  - `inspect` & `compare` — targeted O(1) theoretical resolution for individual or grouped packages without resolving the entire ecosystem payload.
+  - `explain` — breaks down a target package's bloat by attributing fractional byte costs to each of its transitive dependencies.
+  - `export` — streams the underlying DataFrames to CSV or JSON for integration into external data pipelines.
+- **Fractional Attribution Model** — shared dependencies (`openssl`, `python`, etc.) are divided proportionally across all parent packages instead of being double-counted, giving an honest per-package cost.
+- **Daemon-free** — no background indexing, no persistent database. Every run is a fresh, on-demand computation.
+- **Typed and tested** — fully type-annotated (strict `mypy`), linted with `ruff`, and covered by a `pytest` suite exercising the DAG traversal, fractional math, and network resolution logic. CI runs the full suite on macOS and Ubuntu across Python 3.12 and 3.14.
+
+## A note on theoretical measurements
+
+`leaderboard`, `inspect`, `compare`, and `explain` rely on `Content-Length` headers from `ghcr.io` blob storage, which report *compressed* archive size, not the size a package occupies once unpacked to disk. The absolute numbers they report will therefore run lower than `analyze`'s physical measurements.
+
+The Bloat Ratio, however, stays meaningful. Since most bottles compress with similar algorithms (gzip or zstd), the compression factor $c$ appears in both the numerator and denominator and cancels out:
+
+$$R \approx \frac{c \cdot m_{recursive}}{c \cdot m_{core}} \approx \frac{m_{recursive}}{m_{core}}$$
+
+So while theoretical modes shouldn't be read as precise disk-space forecasts, they are a reliable way to evaluate relative bloat without installing anything.
+
+## Installation
+
+```bash
+git clone https://github.com/jacksonfergusondev/dark-matter.git
+cd dark-matter
+uv tool install --editable .
+```
+
+## Usage
+
+```bash
+# Analyze what's actually installed
+dark-matter analyze
+
+# Rank the entire Homebrew catalog by theoretical bloat
+dark-matter leaderboard
+
+# Evaluate a specific formula instantly
+dark-matter inspect uv
+
+# Break down the dependency bloat of a specific package
+dark-matter explain uv
+
+# Compare multiple packages side-by-side
+dark-matter compare uv poetry pdm
+
+# Export the entire graph to JSON for external analysis
+dark-matter export --format json > homebrew_bloat.json
+```
+
+All commands accept the global `--verbose` / `-v` flag for debug logging, and `--version` to print the installed version.
+
+### `analyze`
+
+| Flag | Default | Description |
+| --- | --- | --- |
+| `--sort` / `-s` | `ratio` | Sort by `ratio`, `core`, or `recursive` |
+| `--top` / `-n` | `20` | Number of packages to display |
+| `--fractional` / `--standard` | `--fractional` | Toggle the Fractional Attribution Model |
+
+### `leaderboard`
+
+| Flag | Default | Description |
+| --- | --- | --- |
+| `--sort` / `-s` | `ratio` | Sort by `ratio`, `core`, or `recursive` |
+| `--top` / `-n` | `20` | Number of packages to display |
+| `--arch` / `-a` | `arm64_tahoe` | Target bottle architecture |
+
+### `inspect`
+
+| Argument/Flag | Default | Description |
+| --- | --- | --- |
+| `[PACKAGE]` | **Required** | The target package to analyze |
+| `--source` / `-s` | `installed` | Data source to compute: `installed` or `catalog` |
+| `--arch` / `-a` | `arm64_tahoe` | Target bottle architecture |
+
+### `compare`
+
+| Argument/Flag | Default | Description |
+| --- | --- | --- |
+| `[PACKAGES]...` | **Required** | A space-separated list of packages to compare |
+| `--sort` / `-s` | `ratio` | Sort by `ratio`, `core`, or `recursive` |
+| `--source` / `-s` | `installed` | Data source to compute: `installed` or `catalog` |
+| `--arch` / `-a` | `arm64_tahoe` | Target bottle architecture |
+
+### `explain`
+
+| Argument/Flag | Default | Description |
+| --- | --- | --- |
+| `[PACKAGE]` | **Required** | The specific package to analyze |
+| `--source` / `-s` | `installed` | Data source to compute: `installed` or `catalog` |
+| `--arch` / `-a` | `arm64_tahoe` | Target bottle architecture |
+
+### `export`
+
+| Flag | Default | Description |
+| --- | --- | --- |
+| `--source` / `-s` | `installed` | Data source to compute: `installed` or `catalog` |
+| `--format` / `-f` | `csv` | Output format: `csv` or `json` |
+| `--arch` / `-a` | `arm64_tahoe` | Target bottle architecture (for `catalog` source) |
+
+## Development
+
+The project uses [`just`](https://github.com/casey/just) to wrap common tasks:
+
+```bash
+just format       # ruff format + fix
+just lint         # ruff + rumdl
+just typecheck    # mypy
+just test         # pytest
+just test-cov     # pytest with coverage report
+just ci           # the full pipeline CI runs, locally
+```
+
+## 📧 Contact
+
+[![GitHub](https://img.shields.io/badge/GitHub-100000?style=for-the-badge&logo=github&logoColor=white)](https://github.com/JacksonFergusonDev)
+[![LinkedIn](https://img.shields.io/badge/LinkedIn-0077B5?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/jackson--ferguson/)
+[![Email](https://img.shields.io/badge/Email-D14836?style=for-the-badge&logo=gmail&logoColor=white)](mailto:jackson.ferguson0@gmail.com)
+
+## 📄 License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

dark_matter_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+dark_matter_cli/__init__.py,sha256=cEVTCS2UBX0W5UrBSvWx1aXPjSQy2nHpAyC_DPzILpw,1102
+dark_matter_cli/cli.py,sha256=zGIW0HV9DWY-1GrpMQQDswevtQCumBkEJrTo_2222Q8,10213
+dark_matter_cli/core.py,sha256=lEBLpvwmHU-0jd9XpOtXbDhbWBjTrkcxdyEHqs7rfeU,10548
+dark_matter_cli/display.py,sha256=YGxoGlufYlqafaFz3zp7v2Jx8R9drZj9-z8k-v0qIq8,4415
+dark_matter_cli/homebrew.py,sha256=_SXlrm9HPk4hsmMt_vNkkuawmrB4OWTXunuarECYYxQ,10210
+dark_matter_cli/logger.py,sha256=SoT7nkCRmkwh3m32dJoZ-j-RzSKgZAt1736_J2bldb0,608
+dark_matter_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dark_matter_cli-0.1.0.dist-info/METADATA,sha256=paJ-SCRJP-390dVQ7P0uzMDqKo1hAdcnO19T-18KMpg,10199
+dark_matter_cli-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+dark_matter_cli-0.1.0.dist-info/entry_points.txt,sha256=Yb1raHKzJMhV0GTzZaGfoW7ORqADVIlHXJ0mB_dn8Hk,56
+dark_matter_cli-0.1.0.dist-info/licenses/LICENSE,sha256=29F5Dm0FvGigEbT-pzbDtV9PFLKUvQhIxmvGaRnsS74,1073
+dark_matter_cli-0.1.0.dist-info/RECORD,,

dark_matter_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

dark_matter_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dark-matter = dark_matter_cli.cli:app

dark_matter_cli-0.1.0.dist-info/licenses/LICENSE

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