diffctx 1.8.1__cp310-abi3-win_amd64.whl

diffctx/__init__.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import io
+import logging
+from pathlib import Path
+from typing import Any
+
+from .diffctx import build_diff_context
+from .ignore import get_ignore_specs, get_whitelist_spec
+from .main import run
+from .tree import TreeBuildContext, build_tree
+from .version import __version__
+from .writer import write_tree_json, write_tree_markdown, write_tree_text, write_tree_yaml
+
+logging.getLogger("diffctx").addHandler(logging.NullHandler())
+
+__all__ = [
+    "__version__",
+    "build_diff_context",
+    "map_directory",
+    "run",
+    "to_json",
+    "to_markdown",
+    "to_text",
+    "to_yaml",
+]
+
+
+def _root_display_name(user_path: str | Path, resolved: Path) -> str:
+    original_name = Path(user_path).name
+    if original_name:
+        return original_name
+    return str(resolved)
+
+
+def _resolve_path_if_exists(path: str | Path | None, label: str) -> Path | None:
+    if path is None:
+        return None
+    resolved = Path(path).resolve()
+    if not resolved.is_file():
+        raise FileNotFoundError(f"{label} '{path}' does not exist")
+    return resolved
+
+
+def map_directory(
+    path: str | Path,
+    *,
+    max_depth: int | None = None,
+    no_content: bool = False,
+    max_file_bytes: int | None = None,
+    ignore_file: str | Path | None = None,
+    no_default_ignores: bool = False,
+    whitelist_file: str | Path | None = None,
+) -> dict[str, Any]:
+    root_dir = Path(path).resolve()
+    if not root_dir.is_dir():
+        raise ValueError(f"'{path}' is not a directory")
+
+    ignore_path = _resolve_path_if_exists(ignore_file, "Ignore file")
+    whitelist_path = _resolve_path_if_exists(whitelist_file, "Whitelist file")
+
+    ctx = TreeBuildContext(
+        base_dir=root_dir,
+        combined_spec=get_ignore_specs(root_dir, ignore_path, no_default_ignores, None),
+        output_file=None,
+        max_depth=max_depth,
+        no_content=no_content,
+        max_file_bytes=max_file_bytes,
+        whitelist_spec=get_whitelist_spec(whitelist_path, root_dir),
+    )
+
+    return {
+        "name": _root_display_name(path, root_dir),
+        "type": "directory",
+        "children": build_tree(root_dir, ctx),
+    }
+
+
+def to_yaml(tree: dict[str, Any]) -> str:
+    buf = io.StringIO()
+    write_tree_yaml(buf, tree)
+    return buf.getvalue()
+
+
+def to_json(tree: dict[str, Any]) -> str:
+    buf = io.StringIO()
+    write_tree_json(buf, tree)
+    return buf.getvalue()
+
+
+def to_text(tree: dict[str, Any]) -> str:
+    buf = io.StringIO()
+    write_tree_text(buf, tree)
+    return buf.getvalue()
+
+
+def to_markdown(tree: dict[str, Any]) -> str:
+    buf = io.StringIO()
+    write_tree_markdown(buf, tree)
+    return buf.getvalue()

diffctx/__main__.py

@@ -0,0 +1,17 @@
+import logging
+import sys
+
+# Initialize logging early to avoid Python 3.13 issues with argparse
+# This ensures logging's internal state is fully set up before argparse runs
+try:
+    logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.ERROR)
+    # Force initialization of logging internals
+    logging.getLogger()
+except (OSError, ValueError) as e:
+    # If logging initialization fails, warn but continue
+    print(f"Warning: logging init failed: {e}", file=sys.stderr)
+
+from diffctx.main import main
+
+if __name__ == "__main__":
+    main()

diffctx/cli.py

@@ -0,0 +1,491 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import NoReturn
+
+from .version import __version__
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MAX_FILE_BYTES = 256 * 1024  # 256 KB
+_DEFAULT_ALPHA = 0.60
+_DEFAULT_TAU = 0.08
+
+
+class _Unset:
+    def __repr__(self) -> str:
+        return "<unset>"
+
+
+_UNSET: _Unset = _Unset()
+_DIFF_SENTINEL = "__DIFFCTX_DIFF_BARE__"
+
+
+def _exit_error(message: str) -> NoReturn:
+    print(f"Error: {message}", file=sys.stderr)
+    sys.exit(1)
+
+
+def _validate_max_depth(max_depth: int | None) -> None:
+    if max_depth is not None and max_depth < 0:
+        _exit_error(f"--max-depth must be non-negative, got {max_depth}")
+    if max_depth == 0:
+        print("Warning: --max-depth 0 produces empty tree (root only, no children)", file=sys.stderr)
+
+
+def _validate_max_file_bytes(max_file_bytes: int, no_file_size_limit: bool) -> int | None:
+    if no_file_size_limit:
+        return None
+    if max_file_bytes < 0:
+        _exit_error(f"--max-file-bytes must be non-negative, got {max_file_bytes}")
+    if max_file_bytes == 0:
+        _exit_error("--max-file-bytes 0 is ambiguous. Use --no-file-size-limit to include all files regardless of size")
+    return max_file_bytes
+
+
+def _validate_budget(budget: int | None) -> None:
+    if budget is not None and budget < -1:
+        _exit_error(f"--budget must be >= -1 (0=auto, -1=unlimited), got {budget}")
+
+
+def _validate_alpha(alpha: float) -> None:
+    if not (0 < alpha < 1):
+        _exit_error(f"--alpha must be between 0 and 1 (exclusive), got {alpha}")
+
+
+def _validate_tau(tau: float) -> None:
+    if tau < 0:
+        _exit_error(f"--tau must be non-negative, got {tau}")
+
+
+def _resolve_root_dir(directory: str) -> Path:
+    try:
+        root_dir = Path(directory).resolve(strict=True)
+        if not root_dir.is_dir():
+            _exit_error(f"'{root_dir}' is not a directory")
+        return root_dir
+    except FileNotFoundError:
+        _exit_error(f"Directory '{directory}' does not exist")
+    except OSError as e:
+        _exit_error(f"Cannot access '{directory}': {e}")
+
+
+def _resolve_glob_pattern(pattern: str) -> list[str]:
+    import glob as globmod
+
+    matches = sorted(globmod.glob(pattern, recursive=True))
+    if matches:
+        return matches
+    try:
+        p = Path(pattern).resolve(strict=True)
+    except FileNotFoundError:
+        _exit_error(f"No matches for '{pattern}'")
+    except OSError as e:
+        _exit_error(f"Cannot access '{pattern}': {e}")
+    return [str(p)]
+
+
+def _classify_resolved(resolved: Path, dirs: list[Path], files: list[Path]) -> None:
+    if resolved.is_dir():
+        dirs.append(resolved)
+    elif resolved.is_file():
+        files.append(resolved)
+
+
+def _expand_paths(raw_paths: list[str]) -> tuple[list[Path], list[Path]]:
+    dirs: list[Path] = []
+    files: list[Path] = []
+    seen: set[Path] = set()
+    for pattern in raw_paths:
+        for m in _resolve_glob_pattern(pattern):
+            try:
+                resolved = Path(m).resolve()
+            except OSError as e:
+                _exit_error(f"Cannot access '{m}': {e}")
+            if resolved in seen:
+                continue
+            seen.add(resolved)
+            _classify_resolved(resolved, dirs, files)
+    return dirs, files
+
+
+def _resolve_output_file(output_file_arg: str | None, save: bool, output_format: str) -> tuple[Path | None, bool]:
+    if save and output_file_arg is not None:
+        _exit_error("--save and -o/--output-file are mutually exclusive")
+
+    if save:
+        ext = "yaml" if output_format == "yaml" else output_format
+        return Path(f"tree.{ext}").resolve(), False
+
+    if output_file_arg is None:
+        return None, False
+    if output_file_arg == "-":
+        return None, True
+
+    output_file = Path(output_file_arg).resolve()
+    if output_file.is_dir():
+        _exit_error(f"'{output_file_arg}' is a directory, not a file")
+    return output_file, False
+
+
+def _find_in_diffctx_dir(arg: str, root_dir: Path, extra_exts: tuple[str, ...]) -> Path | None:
+    if Path(arg).parent != Path("."):
+        return None
+    stem = Path(arg).stem if Path(arg).suffix else arg
+    base = root_dir / ".diffctx"
+    for name in (arg, *(f"{stem}{ext}" for ext in extra_exts if f"{stem}{ext}" != arg)):
+        candidate = base / name
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def _resolve_config_file(file_arg: str | None, root_dir: Path, extensions: tuple[str, ...], label: str) -> Path | None:
+    if not file_arg:
+        return None
+    found = _find_in_diffctx_dir(file_arg, root_dir, extensions)
+    if found:
+        return found
+    resolved = Path(file_arg).resolve()
+    if not resolved.is_file():
+        _exit_error(f"{label} file '{file_arg}' does not exist")
+    return resolved
+
+
+def _resolve_ignore_file(ignore_file_arg: str | None, root_dir: Path) -> Path | None:
+    return _resolve_config_file(ignore_file_arg, root_dir, (".ignore", ".txt"), "Ignore")
+
+
+def _resolve_whitelist_file(whitelist_file_arg: str | None, root_dir: Path) -> Path | None:
+    return _resolve_config_file(whitelist_file_arg, root_dir, (".whitelist", ".txt"), "Whitelist")
+
+
+@dataclass
+class GraphArgs:
+    format: str = "mermaid"
+    summary: bool = False
+    level: str = "directory"
+
+
+@dataclass
+class ParsedArgs:
+    root_dir: Path
+    ignore_file: Path | None
+    whitelist_file: Path | None
+    output_file: Path | None
+    no_default_ignores: bool
+    verbosity: int | str
+    output_format: str
+    max_depth: int | None
+    no_content: bool
+    max_file_bytes: int | None
+    copy: bool
+    force_stdout: bool
+    quiet: bool = False
+    diff_range: str | None = None
+    budget: int | None = None
+    alpha: float = _DEFAULT_ALPHA
+    tau: float = _DEFAULT_TAU
+    scoring: str = "ego"
+    full_diff: bool = False
+    command: str | None = None
+    graph: GraphArgs | None = None
+    extra_dirs: list[Path] | None = None
+    extra_files: list[Path] | None = None
+
+
+DEFAULT_IGNORES_HELP = """
+Default ignored patterns (use --no-default-ignores to disable built-in patterns;
+project-level .gitignore and .diffctx/ignore still apply):
+  .git/, .svn/, .hg/    Version control directories
+  __pycache__/, *.py[cod], *.so, venv/, .venv/, .tox/, .nox/  Python
+  node_modules/, .npm/  JavaScript/Node
+  package-lock.json, yarn.lock, pnpm-lock.yaml  JS lock files
+  Pipfile.lock, poetry.lock, Cargo.lock, Gemfile.lock  Other lock files
+  target/, .gradle/     Java/Maven/Gradle
+  bin/, obj/            .NET
+  vendor/               Go/PHP
+  dist/, build/, out/   Generic build output
+  .*_cache/             All cache dirs (.pytest_cache, .mypy_cache, etc.)
+  .idea/, .vscode/      IDE configurations
+  .DS_Store, Thumbs.db  OS-specific files
+  tree.{yaml,json,md,txt}  Default output files (auto-ignored)
+
+Ignore files (hierarchical, like git):
+  .gitignore            Standard git ignore patterns
+  .diffctx/ignore    diffctx-specific patterns
+
+Whitelist files (auto-discovered):
+  .diffctx/whitelist  Include-only filter
+
+Examples:
+  diffctx .                    Map current directory to YAML
+  diffctx /path/to/project     Map a specific directory
+  diffctx . -f json            Output as JSON
+  diffctx . -f md --save       Save as tree.md
+  diffctx . --diff HEAD~1      Show context for last commit
+  diffctx . -c                 Copy output to clipboard
+  diffctx . --no-content       Structure only, no file contents
+
+Output routing:
+  Default:      stdout
+  -o FILE:      write to FILE
+  --save:       write to tree.{ext} (e.g., tree.yaml)
+  -c:           copy to clipboard, suppress stdout
+  -c -o FILE:   copy to clipboard AND write to FILE
+"""
+
+
+def _build_shared_parser() -> argparse.ArgumentParser:
+    shared = argparse.ArgumentParser(add_help=False)
+    shared.add_argument("-o", "--output-file", default=None, help="Write output to FILE")
+    shared.add_argument("-i", "--ignore", default=None, help="Path to custom ignore file")
+    shared.add_argument("-w", "--whitelist", default=None, help="Path to whitelist file (only matching files are included)")
+    shared.add_argument(
+        "--no-default-ignores",
+        action="store_true",
+        help="Disable built-in ignore patterns (project .gitignore and .diffctx/ignore still apply)",
+    )
+    shared.add_argument("-c", "--copy", action="store_true", help="Copy to clipboard")
+    shared.add_argument("-q", "--quiet", action="store_true", help="Suppress all non-error output")
+    shared.add_argument(
+        "--log-level",
+        choices=["error", "warning", "info", "debug"],
+        default="error",
+        help="Log level (default: error)",
+    )
+    return shared
+
+
+def _build_graph_parser(prog: str = "diffctx graph") -> argparse.ArgumentParser:
+    graph_parser = argparse.ArgumentParser(
+        prog=prog,
+        description="Build and analyze the project dependency graph",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        parents=[_build_shared_parser()],
+    )
+    graph_parser.add_argument("directory", nargs="?", default=".", help="The directory to analyze")
+    graph_parser.add_argument(
+        "-f",
+        "--format",
+        choices=["mermaid", "json", "graphml"],
+        default="mermaid",
+        help="Graph output format (default: mermaid)",
+    )
+    graph_parser.add_argument(
+        "--summary", action="store_true", help="Print graph statistics (cycles, hotspots, coupling metrics)"
+    )
+    graph_parser.add_argument(
+        "--level",
+        choices=["fragment", "file", "directory"],
+        default="directory",
+        help="Granularity level for graph operations (default: directory)",
+    )
+    return graph_parser
+
+
+def _build_main_parser(prog: str = "diffctx", version: str = __version__) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog=prog,
+        description=(
+            "Generate a structured representation of a directory tree (YAML, JSON, text, or Markdown). "
+            "Supports diff context mode (--diff) for intelligent code change analysis.\n\n"
+            "Subcommands:\n"
+            "  graph    Build and analyze the project dependency graph"
+        ),
+        epilog=DEFAULT_IGNORES_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        parents=[_build_shared_parser()],
+    )
+
+    parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {version}")
+    parser.add_argument("paths", nargs="*", default=["."], help="Directories, files, or glob patterns to analyze")
+    parser.add_argument(
+        "-f",
+        "--format",
+        choices=["yaml", "json", "txt", "md"],
+        default="yaml",
+        help="Output format (default: yaml)",
+    )
+    parser.add_argument(
+        "--save",
+        action="store_true",
+        help="Save output to tree.{ext} (e.g., tree.yaml, tree.json)",
+    )
+    parser.add_argument("--max-depth", type=int, default=None, metavar="N", help="Maximum traversal depth")
+    parser.add_argument("--no-content", action="store_true", help="Skip file contents (structure only)")
+    parser.add_argument(
+        "--max-file-bytes",
+        type=int,
+        default=DEFAULT_MAX_FILE_BYTES,
+        metavar="N",
+        help=f"Truncate per-file content at N bytes (default: {DEFAULT_MAX_FILE_BYTES // 1024} KB). Use --no-file-size-limit to disable.",
+    )
+    parser.add_argument(
+        "--no-file-size-limit",
+        action="store_true",
+        help="Include all files regardless of size",
+    )
+
+    diff_group = parser.add_argument_group("diff context mode")
+    diff_group.add_argument(
+        "--diff",
+        dest="diff_range",
+        nargs="?",
+        const=_DIFF_SENTINEL,
+        default=None,
+        metavar="RANGE",
+        help="Git diff range (e.g., HEAD~1..HEAD, main..feature). Bare --diff defaults to HEAD.",
+    )
+    diff_group.add_argument(
+        "--budget",
+        type=int,
+        default=_UNSET,
+        metavar="N",
+        help="Token budget: 0=auto (default), -1=unlimited, N=fixed budget",
+    )
+    diff_group.add_argument(
+        "--alpha",
+        type=float,
+        default=_UNSET,
+        metavar="F",
+        help="How tightly context clusters around changes, 0-1 (default: 0.60, higher = more focused)",
+    )
+    diff_group.add_argument(
+        "--tau",
+        type=float,
+        default=_UNSET,
+        metavar="F",
+        help="Minimum relevance to include a fragment (default: 0.08, lower = more context)",
+    )
+    diff_group.add_argument(
+        "--scoring",
+        choices=["ppr", "ego", "bm25"],
+        default=_UNSET,
+        help="Scoring mode: ego (bounded ego-network expansion, default), ppr (Personalized PageRank), bm25 (lexical fragment retrieval)",
+    )
+    diff_group.add_argument(
+        "--full",
+        action="store_true",
+        default=False,
+        help="Include all changed code (skip smart selection algorithm)",
+    )
+    return parser
+
+
+def _warn_diff_only_flags(args: argparse.Namespace) -> None:
+    if args.diff_range:
+        return
+    used = []
+    if args.budget is not _UNSET:
+        used.append("--budget")
+    if args.alpha is not _UNSET:
+        used.append("--alpha")
+    if args.tau is not _UNSET:
+        used.append("--tau")
+    if args.full:
+        used.append("--full")
+    if args.scoring is not _UNSET:
+        used.append("--scoring")
+    if used:
+        flags = ", ".join(used)
+        print(f"Warning: diff-mode flags ignored without --diff: {flags}", file=sys.stderr)
+
+
+def _build_graph_parsed_args(args: argparse.Namespace) -> ParsedArgs:
+    root_dir = _resolve_root_dir(args.directory)
+    output_file_path = Path(args.output_file).resolve() if args.output_file else None
+    ignore_file = _resolve_ignore_file(args.ignore, root_dir)
+    whitelist_file = _resolve_whitelist_file(args.whitelist, root_dir)
+    verbosity = "error" if args.quiet else args.log_level
+
+    return ParsedArgs(
+        root_dir=root_dir,
+        ignore_file=ignore_file,
+        whitelist_file=whitelist_file,
+        output_file=output_file_path,
+        no_default_ignores=args.no_default_ignores,
+        verbosity=verbosity,
+        output_format="yaml",
+        max_depth=None,
+        no_content=False,
+        max_file_bytes=None,
+        copy=args.copy,
+        force_stdout=False,
+        quiet=args.quiet,
+        command="graph",
+        graph=GraphArgs(
+            format=args.format,
+            summary=args.summary,
+            level=args.level,
+        ),
+    )
+
+
+def _build_tree_parsed_args(args: argparse.Namespace) -> ParsedArgs:
+    _validate_max_depth(args.max_depth)
+    max_file_bytes = _validate_max_file_bytes(args.max_file_bytes, args.no_file_size_limit)
+
+    budget = None if args.budget is _UNSET else args.budget
+    alpha = _DEFAULT_ALPHA if args.alpha is _UNSET else args.alpha
+    tau = _DEFAULT_TAU if args.tau is _UNSET else args.tau
+    scoring = "ego" if args.scoring is _UNSET else args.scoring
+
+    _validate_budget(budget)
+    _validate_alpha(alpha)
+    _validate_tau(tau)
+    _warn_diff_only_flags(args)
+
+    diff_range = args.diff_range
+    if diff_range == _DIFF_SENTINEL:
+        diff_range = "HEAD"
+
+    dirs, files = _expand_paths(args.paths)
+    root_dir = dirs[0] if dirs else Path(".").resolve()
+    extra_dirs = dirs or None
+    extra_files = files or None
+
+    output_format = args.format
+    output_file, force_stdout = _resolve_output_file(args.output_file, args.save, output_format)
+    ignore_file = _resolve_ignore_file(args.ignore, root_dir)
+    whitelist_file = _resolve_whitelist_file(args.whitelist, root_dir)
+    verbosity = "error" if args.quiet else args.log_level
+
+    return ParsedArgs(
+        root_dir=root_dir,
+        ignore_file=ignore_file,
+        whitelist_file=whitelist_file,
+        output_file=output_file,
+        no_default_ignores=args.no_default_ignores,
+        verbosity=verbosity,
+        output_format=output_format,
+        max_depth=args.max_depth,
+        no_content=args.no_content,
+        max_file_bytes=max_file_bytes,
+        copy=args.copy,
+        force_stdout=force_stdout,
+        quiet=args.quiet,
+        diff_range=diff_range,
+        budget=budget,
+        alpha=alpha,
+        tau=tau,
+        scoring=scoring,
+        full_diff=args.full,
+        extra_dirs=extra_dirs,
+        extra_files=extra_files,
+    )
+
+
+def parse_args(argv: list[str] | None = None, *, prog: str = "diffctx", version: str = __version__) -> ParsedArgs:
+    raw_args = sys.argv[1:] if argv is None else argv
+
+    if raw_args and raw_args[0] == "graph":
+        args = _build_graph_parser(prog=f"{prog} graph").parse_args(raw_args[1:])
+        return _build_graph_parsed_args(args)
+
+    args = _build_main_parser(prog=prog, version=version).parse_args(raw_args)
+    return _build_tree_parsed_args(args)

diffctx/clipboard.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import subprocess
+
+
+class ClipboardError(Exception):
+    pass
+
+
+def _detect_darwin_clipboard() -> list[str] | None:
+    return ["pbcopy"] if shutil.which("pbcopy") else None
+
+
+def _detect_windows_clipboard() -> list[str] | None:
+    return ["clip"] if shutil.which("clip") else None
+
+
+def _detect_linux_clipboard() -> list[str] | None:
+    if os.environ.get("WAYLAND_DISPLAY") and shutil.which("wl-copy"):
+        return ["wl-copy", "--type", "text/plain"]
+    if os.environ.get("DISPLAY"):
+        if shutil.which("xclip"):
+            return ["xclip", "-selection", "clipboard"]
+        if shutil.which("xsel"):
+            return ["xsel", "--clipboard", "--input"]
+    return None
+
+
+_CLIPBOARD_DETECTORS = {
+    "Darwin": _detect_darwin_clipboard,
+    "Windows": _detect_windows_clipboard,
+    "Linux": _detect_linux_clipboard,
+    "FreeBSD": _detect_linux_clipboard,
+}
+
+_INSTALL_HINTS = {
+    "Darwin": "pbcopy should be available by default on macOS",
+    "Windows": "clip.exe should be available by default on Windows",
+    "Linux": "Install wl-copy (Wayland) or xclip/xsel (X11): sudo apt install wl-clipboard or sudo apt install xclip",
+    "FreeBSD": "Install xclip or xsel: pkg install xclip",
+}
+
+
+def detect_clipboard_command() -> list[str] | None:
+    detector = _CLIPBOARD_DETECTORS.get(platform.system())
+    return detector() if detector else None
+
+
+def copy_to_clipboard(text: str) -> None:
+    cmd = detect_clipboard_command()
+    if cmd is None:
+        system = platform.system()
+        hint = _INSTALL_HINTS.get(system, f"No clipboard support for {system}")
+        raise ClipboardError(f"No clipboard tool found. {hint}")
+
+    encoding = "utf-16le" if platform.system() == "Windows" else "utf-8"
+    encoded = text.encode(encoding)
+
+    try:
+        subprocess.run(
+            cmd,
+            input=encoded,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+            timeout=5,
+            check=True,
+        )
+    except subprocess.TimeoutExpired as e:
+        raise ClipboardError("Clipboard operation timed out") from e
+    except subprocess.CalledProcessError as e:
+        stderr_msg = e.stderr.decode(errors="replace").strip() if e.stderr else ""
+        raise ClipboardError(stderr_msg or f"Command failed with code {e.returncode}") from e
+    except OSError as e:
+        raise ClipboardError(f"Failed to execute clipboard command: {e}") from e
+
+
+def clipboard_available() -> bool:
+    return detect_clipboard_command() is not None

diffctx/diffctx/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from diffctx._diffctx import GitError
+
+from .pipeline import build_diff_context, compute_scored_state, select_with_params
+
+__all__ = ["GitError", "build_diff_context", "compute_scored_state", "select_with_params"]