onepaste 1.3.0__py3-none-any.whl

codecollector/gitignore.py

@@ -0,0 +1,160 @@
+"""Git-aware ignore checking for filter mode."""
+
+import fnmatch
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Set, Tuple
+
+
+class GitignoreMatcher:
+    """Match paths against .gitignore rules (fallback when git is unavailable)."""
+
+    def __init__(self, root: Path):
+        self.root = root.resolve()
+        self._rules: List[Tuple[str, bool, bool]] = []  # pattern, negation, dir_only
+
+    def load_all(self) -> None:
+        """Load the root .gitignore and nested ones (skipping .git)."""
+        root_gitignore = self.root / ".gitignore"
+        if root_gitignore.is_file():
+            self._load_file(root_gitignore)
+
+        for gitignore in self.root.rglob(".gitignore"):
+            if gitignore == root_gitignore:
+                continue
+            try:
+                if ".git" in gitignore.relative_to(self.root).parts:
+                    continue
+            except ValueError:
+                continue
+            self._load_file(gitignore)
+
+    def _load_file(self, gitignore_path: Path) -> None:
+        try:
+            rel_base = gitignore_path.parent.relative_to(self.root)
+            prefix = "" if rel_base == Path(".") else rel_base.as_posix() + "/"
+        except ValueError:
+            return
+
+        try:
+            lines = gitignore_path.read_text(encoding="utf-8", errors="replace").splitlines()
+        except OSError:
+            return
+
+        for raw_line in lines:
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+
+            negation = line.startswith("!")
+            if negation:
+                line = line[1:].strip()
+                if not line:
+                    continue
+
+            dir_only = line.endswith("/")
+            if dir_only:
+                line = line.rstrip("/")
+
+            if line.startswith("/"):
+                pattern = prefix + line.lstrip("/")
+            elif "/" in line:
+                pattern = prefix + line
+            else:
+                # gitignore: pattern without slash matches in any directory
+                pattern = prefix + "**/" + line if prefix else "**/" + line
+
+            self._rules.append((pattern, negation, dir_only))
+
+    def is_ignored(self, path: Path, is_dir: bool = False) -> bool:
+        try:
+            rel = path.resolve().relative_to(self.root).as_posix()
+        except ValueError:
+            return False
+
+        if not rel or rel == ".":
+            return False
+
+        name = path.name
+        ignored = False
+
+        for pattern, negation, dir_only in self._rules:
+            if dir_only and not is_dir:
+                continue
+            if self._matches(pattern, rel, name):
+                ignored = not negation
+
+        return ignored
+
+    @staticmethod
+    def _matches(pattern: str, rel_path: str, name: str) -> bool:
+        candidates = {rel_path, name}
+
+        # "**/foo" also matches top-level "foo"
+        if pattern.startswith("**/"):
+            candidates.add(pattern[3:])
+            bare = pattern[3:]
+            if fnmatch.fnmatch(name, bare) or fnmatch.fnmatch(rel_path, bare):
+                return True
+            if fnmatch.fnmatch(rel_path, pattern):
+                return True
+            # match in nested path segments
+            parts = rel_path.split("/")
+            for i in range(len(parts)):
+                sub = "/".join(parts[i:])
+                if fnmatch.fnmatch(sub, bare) or fnmatch.fnmatch(parts[i], bare):
+                    return True
+            return False
+
+        for target in candidates:
+            if fnmatch.fnmatch(target, pattern):
+                return True
+
+        return False
+
+
+def is_inside_git_work_tree(root: Path) -> bool:
+    """Return True if root is inside a git working tree.
+
+    Fast probe used for the default-on .gitignore behaviour. Returns False
+    when git is unavailable or root is not inside a work tree.
+    """
+    root = root.resolve()
+    try:
+        probe = subprocess.run(
+            ["git", "-C", str(root), "rev-parse", "--is-inside-work-tree"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except FileNotFoundError:
+        return False
+
+    return probe.returncode == 0 and probe.stdout.strip() == "true"
+
+
+def list_git_visible_files(root: Path) -> Optional[Set[Path]]:
+    """Return files that are tracked or untracked-but-not-ignored.
+
+    Uses `git ls-files -co --exclude-standard`. Returns None if git is
+    unavailable or root is not inside a git work tree.
+    """
+    root = root.resolve()
+    if not is_inside_git_work_tree(root):
+        return None
+
+    result = subprocess.run(
+        ["git", "-C", str(root), "ls-files", "-co", "--exclude-standard", "-z"],
+        capture_output=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        return None
+
+    files: Set[Path] = set()
+    for raw in result.stdout.split(b"\0"):
+        if not raw:
+            continue
+        rel = raw.decode("utf-8", errors="replace")
+        files.add((root / rel).resolve())
+    return files

codecollector/output.py

@@ -0,0 +1,61 @@
+"""Output path resolution and manifest generation."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import List
+
+
+def output_files_exist(output_dir: Path, base_filename: str) -> bool:
+    """Check if a collection output (single or split) already exists."""
+    if (output_dir / base_filename).exists():
+        return True
+
+    stem = Path(base_filename).stem
+    suffix = Path(base_filename).suffix
+    return any(output_dir.glob(f"{stem}.part*{suffix}"))
+
+
+def resolve_unique_filename(
+    output_dir: Path,
+    base_filename: str,
+    force: bool = False,
+) -> str:
+    """Return a filename that won't overwrite existing collection output."""
+    if force or not output_files_exist(output_dir, base_filename):
+        return base_filename
+
+    stem = Path(base_filename).stem
+    suffix = Path(base_filename).suffix
+    counter = 1
+
+    while True:
+        candidate = f"{stem}_{counter}{suffix}"
+        if not output_files_exist(output_dir, candidate):
+            return candidate
+        counter += 1
+
+
+def write_manifest(
+    output_dir: Path,
+    base_filename: str,
+    output_paths: List[Path],
+    root_path: Path,
+    files_collected: int,
+) -> Path:
+    """Write a manifest JSON describing the collection output."""
+    stem = Path(base_filename).stem
+    manifest_path = output_dir / f"{stem}.manifest.json"
+    manifest = {
+        "generated": datetime.now().isoformat(timespec="seconds"),
+        "root": str(root_path.absolute()),
+        "base_filename": base_filename,
+        "total_parts": len(output_paths),
+        "files_collected": files_collected,
+        "parts": [p.name for p in output_paths],
+    }
+
+    with open(manifest_path, "w", encoding="utf-8") as f:
+        json.dump(manifest, f, indent=2, ensure_ascii=False)
+
+    return manifest_path

codecollector/selector.py

@@ -0,0 +1,115 @@
+"""Interactive directory selector module."""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.theme import Theme
+
+custom_theme = Theme({
+    "info": "cyan",
+    "warning": "yellow",
+    "error": "red bold",
+    "success": "green bold",
+    "path": "blue",
+})
+
+console = Console(theme=custom_theme)
+
+custom_style = questionary.Style([
+    ("qmark", "fg:#673ab7 bold"),
+    ("question", "bold"),
+    ("answer", "fg:#f44336 bold"),
+    ("pointer", "fg:#673ab7 bold"),
+    ("highlighted", "fg:#673ab7 bold"),
+    ("selected", "fg:#cc5454"),
+    ("separator", "fg:#cc5454"),
+    ("disabled", "fg:#858585 italic"),
+])
+
+
+class InteractiveSelector:
+    """Interactive directory selector with keyboard navigation."""
+
+    @staticmethod
+    def select_directory(start_path: Optional[Path] = None) -> Optional[Path]:
+        """Interactively select a directory to collect."""
+        if start_path is None:
+            start_path = Path.cwd()
+
+        current_path = start_path.resolve()
+
+        while True:
+            os.system("clear" if os.name != "nt" else "cls")
+
+            console.print()
+            console.print(Panel.fit(
+                "[bold cyan]CodeCollector[/bold cyan] [dim]- Select directory, press Enter to collect[/dim]",
+                border_style="cyan",
+            ))
+
+            path_text = Text()
+            path_text.append("Directory: ", style="bold white")
+            path_text.append(str(current_path), style="blue")
+            console.print(path_text)
+            console.print("─" * 60)
+
+            try:
+                items = sorted(current_path.iterdir())
+                dirs = [item for item in items if item.is_dir() and not item.name.startswith(".")]
+
+                choices = []
+
+                choices.append(questionary.Separator("─" * 28 + " Collect " + "─" * 28))
+                choices.append({
+                    "name": "  ✅  Collect this directory",
+                    "value": ".",
+                })
+
+                choices.append(questionary.Separator("─" * 28 + " Navigate " + "─" * 28))
+                if current_path != current_path.parent:
+                    choices.append({"name": "  ⬆️  .. (parent directory)", "value": ".."})
+
+                for d in dirs:
+                    choices.append({"name": f"  📁  {d.name}/", "value": d.name})
+
+                choices.append(questionary.Separator("─" * 60))
+                choices.append({"name": "  Exit", "value": "quit"})
+
+                selected = questionary.select(
+                    "Select:",
+                    choices=choices,
+                    style=custom_style,
+                    use_indicator=True,
+                    qmark="👉",
+                    pointer="❯",
+                ).ask()
+
+                if selected is None or selected == "quit":
+                    return None
+                elif selected == "..":
+                    current_path = current_path.parent
+                elif selected == ".":
+                    return current_path
+                else:
+                    new_path = current_path / selected
+                    if new_path.is_dir():
+                        current_path = new_path
+                    else:
+                        console.print(f"\n[error]Cannot enter: {selected}[/error]")
+                        console.input("[dim]Press Enter to continue...[/dim]")
+
+            except PermissionError:
+                console.print("\n[error]Permission denied[/error]")
+                console.input("[dim]Press Enter to continue...[/dim]")
+                if current_path != current_path.parent:
+                    current_path = current_path.parent
+                else:
+                    return None
+            except KeyboardInterrupt:
+                console.print("\n\n[yellow]Cancelled[/yellow]")
+                return None

codecollector/splitter.py

@@ -0,0 +1,142 @@
+"""Output file splitting for large collections."""
+
+from pathlib import Path
+from typing import List, Tuple
+
+from codecollector.config import CollectorConfig
+from codecollector.output import resolve_unique_filename
+
+HEADER_SIZE_BUFFER = 512
+ESTIMATED_PART_HEADER = (
+    "# CodeCollector - Part 999 of 999\n\n"
+    f"- **Root:** `{'x' * 60}`\n"
+    "- **Files in this part:** 999\n"
+    + "\n".join(f"  - `{'x' * 60}`" for _ in range(10))
+    + "\n\n---\n\n"
+)
+
+
+def byte_size(text: str) -> int:
+    return len(text.encode("utf-8"))
+
+
+def make_part_filename(base_filename: str, part: int) -> str:
+    path = Path(base_filename)
+    return f"{path.stem}.part{part}{path.suffix}"
+
+
+def format_part_header(
+    part: int,
+    total: int,
+    config: CollectorConfig,
+    files_in_part: List[Path],
+) -> str:
+    """Format the header for a split output file."""
+    lines = [
+        f"# CodeCollector - Part {part} of {total}",
+        "",
+    ]
+
+    if part > 1:
+        lines.append(f"- **Root:** `{config.root_path.absolute()}`")
+        lines.append(f"- **Files in this part:** {len(files_in_part)}")
+        lines.append("")
+        for fp in files_in_part:
+            try:
+                lines.append(f"  - `{fp.relative_to(config.root_path)}`")
+            except ValueError:
+                lines.append(f"  - `{fp}`")
+        lines.append("")
+        lines.append("---")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def plan_parts(
+    chunks: List[str],
+    first_part_prefix: str,
+    max_bytes: int,
+) -> List[List[int]]:
+    """Plan which chunk indices belong in each output part."""
+    if max_bytes <= 0:
+        return [list(range(len(chunks)))]
+
+    parts: List[List[int]] = []
+    current: List[int] = []
+    current_size = 0
+    part_num = 1
+    header_overhead = byte_size(ESTIMATED_PART_HEADER) + HEADER_SIZE_BUFFER
+
+    for idx, chunk in enumerate(chunks):
+        chunk_size = byte_size(chunk)
+        overhead = header_overhead
+
+        if part_num == 1:
+            overhead += byte_size(first_part_prefix)
+
+        budget = max_bytes - overhead
+
+        if current and current_size + chunk_size > budget:
+            parts.append(current)
+            current = [idx]
+            current_size = chunk_size
+            part_num += 1
+        else:
+            current.append(idx)
+            current_size += chunk_size
+
+    if current:
+        parts.append(current)
+
+    return parts
+
+
+def write_collection_output(
+    output_dir: Path,
+    base_filename: str,
+    summary: str,
+    collected_files: List[Path],
+    file_contents: List[str],
+    config: CollectorConfig,
+    force: bool = False,
+) -> Tuple[List[Path], str]:
+    """Write collection output, splitting into multiple files when needed.
+
+    Returns (output_paths, resolved_base_filename).
+    """
+    resolved_name = base_filename
+    if config.auto_increment_output:
+        resolved_name = resolve_unique_filename(output_dir, base_filename, force=force)
+
+    max_bytes = int(config.max_output_size_mb * 1024 * 1024)
+    output_path = output_dir / resolved_name
+
+    part_indices = plan_parts(file_contents, summary, max_bytes)
+
+    if len(part_indices) <= 1:
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(summary)
+            for content in file_contents:
+                f.write(content)
+        return [output_path], resolved_name
+
+    total_parts = len(part_indices)
+    output_paths: List[Path] = []
+
+    for part_num, indices in enumerate(part_indices, start=1):
+        part_filename = make_part_filename(resolved_name, part_num)
+        part_path = output_dir / part_filename
+        files_in_part = [collected_files[i] for i in indices]
+        header = format_part_header(part_num, total_parts, config, files_in_part)
+
+        with open(part_path, "w", encoding="utf-8") as f:
+            f.write(header)
+            if part_num == 1:
+                f.write(summary)
+            for i in indices:
+                f.write(file_contents[i])
+
+        output_paths.append(part_path)
+
+    return output_paths, resolved_name

codecollector/tokens.py

@@ -0,0 +1,56 @@
+"""Token counting with graceful degradation.
+
+Uses tiktoken (o200k_base) when available for exact counts; falls back to a
+characters/4 estimate when the optional dependency is missing or the encoding
+cannot be loaded (e.g. offline first run).
+"""
+
+from typing import Any, Optional
+
+try:
+    import tiktoken as _tiktoken
+except ImportError:  # pragma: no cover - exercised via fallback tests
+    _tiktoken = None  # type: ignore[assignment]
+
+CHARS_PER_TOKEN_ESTIMATE = 4
+_ENCODING_NAME = "o200k_base"
+
+_encoding: Optional[Any] = None
+_encoding_failed = False
+
+
+def _get_encoding() -> Optional[Any]:
+    global _encoding, _encoding_failed
+    if _encoding is not None or _encoding_failed:
+        return _encoding
+    if _tiktoken is None:
+        _encoding_failed = True
+        return None
+    try:
+        _encoding = _tiktoken.get_encoding(_ENCODING_NAME)
+    except Exception:
+        _encoding_failed = True
+    return _encoding
+
+
+def is_exact() -> bool:
+    """True when counts come from tiktoken rather than the estimator."""
+    return _get_encoding() is not None
+
+
+def method_label() -> str:
+    """Human-readable label describing the counting method."""
+    if is_exact():
+        return f"tiktoken {_ENCODING_NAME}"
+    return f"estimate (~{CHARS_PER_TOKEN_ESTIMATE} chars/token)"
+
+
+def count_tokens(text: str) -> int:
+    """Count tokens in text, degrading to an estimate when needed."""
+    encoding = _get_encoding()
+    if encoding is not None:
+        try:
+            return len(encoding.encode(text))
+        except Exception:
+            pass
+    return max(1, (len(text) + CHARS_PER_TOKEN_ESTIMATE - 1) // CHARS_PER_TOKEN_ESTIMATE)

codecollector/uninstall.py

@@ -0,0 +1,118 @@
+"""Uninstall helpers for development and updates."""
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from codecollector.config import CONFIG_DIR
+
+PACKAGE_NAME = "codecollector"
+
+
+def _run(cmd: List[str]) -> Tuple[int, str]:
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except FileNotFoundError:
+        return 127, f"command not found: {cmd[0]}"
+    output = (result.stdout or "") + (result.stderr or "")
+    return result.returncode, output.strip()
+
+
+def _has_command(name: str) -> bool:
+    return shutil.which(name) is not None
+
+
+def _pipx_has_package() -> bool:
+    code, output = _run(["pipx", "list", "--short"])
+    if code != 0:
+        return False
+    return any(line.split()[0] == PACKAGE_NAME for line in output.splitlines() if line.strip())
+
+
+def _pip_has_package() -> bool:
+    code, _ = _run([sys.executable, "-m", "pip", "show", PACKAGE_NAME])
+    return code == 0
+
+
+def detect_install_methods() -> List[str]:
+    """Return known install methods currently present."""
+    methods: List[str] = []
+    if _has_command("pipx") and _pipx_has_package():
+        methods.append("pipx")
+    if _pip_has_package():
+        methods.append("pip")
+    return methods
+
+
+def remove_config_dir() -> Optional[Path]:
+    """Remove the user config directory if it exists."""
+    if not CONFIG_DIR.exists():
+        return None
+    shutil.rmtree(CONFIG_DIR)
+    return CONFIG_DIR
+
+
+def uninstall_package(purge_config: bool = False) -> Tuple[bool, List[str]]:
+    """Uninstall codecollector via pipx and/or pip.
+
+    Returns (success, messages).
+    """
+    messages: List[str] = []
+    methods = detect_install_methods()
+
+    if not methods:
+        messages.append(
+            f"No installed `{PACKAGE_NAME}` found via pipx or pip.\n"
+            "If you run from source with PYTHONPATH, just stop using that path."
+        )
+        if purge_config:
+            removed = remove_config_dir()
+            if removed:
+                messages.append(f"Removed config: {removed}")
+            else:
+                messages.append(f"No config directory to remove: {CONFIG_DIR}")
+        return False, messages
+
+    success = True
+
+    if "pipx" in methods:
+        code, output = _run(["pipx", "uninstall", PACKAGE_NAME])
+        if code == 0:
+            messages.append(f"Uninstalled via pipx: {PACKAGE_NAME}")
+        else:
+            success = False
+            messages.append(f"pipx uninstall failed:\n{output or '(no output)'}")
+
+    if "pip" in methods:
+        code, output = _run(
+            [sys.executable, "-m", "pip", "uninstall", "-y", PACKAGE_NAME]
+        )
+        if code == 0:
+            messages.append(f"Uninstalled via pip: {PACKAGE_NAME}")
+        else:
+            success = False
+            messages.append(f"pip uninstall failed:\n{output or '(no output)'}")
+
+    if purge_config:
+        removed = remove_config_dir()
+        if removed:
+            messages.append(f"Removed config: {removed}")
+        else:
+            messages.append(f"No config directory to remove: {CONFIG_DIR}")
+
+    if success:
+        messages.append(
+            "Reinstall from source with:\n"
+            f"  pipx install -e {Path.cwd()}\n"
+            "or:\n"
+            "  pip install -e ."
+        )
+
+    return success, messages