pilepack 0.1.0__py3-none-any.whl

pilepack/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == '__main__':
+    main()

pilepack/cli.py

@@ -0,0 +1,103 @@
+import argparse
+import sys
+from pathlib import Path
+
+from .collector import collect_files, build_tree
+from .reader import read_file
+from .formatter import render
+
+
+def _generate_report(root_path: Path, include_content=True, mask_secrets=False, follow_gitignore=True, fmt="txt"):
+    print("Scanning files...", file=sys.stderr, flush=True)
+    files = collect_files(root_path, follow_gitignore=follow_gitignore)
+    tree = build_tree(files)
+
+    files_content = []
+    if include_content:
+        total = len(files)
+        print(f"Reading {total} files...", file=sys.stderr, flush=True)
+        for rel_path in files:
+            abs_path = root_path / rel_path
+            content = read_file(abs_path, mask_secrets=mask_secrets)
+            files_content.append((rel_path, content))
+        print(f"Done. Read {total} files.", file=sys.stderr, flush=True)
+    else:
+        files_content = []
+
+    root_name = root_path.name or str(root_path)
+    report = render(root_name, tree, files_content, fmt=fmt)
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Pack your codebase into a single file for AI analysis"
+    )
+    parser.add_argument(
+        "root",
+        nargs="?",
+        default=".",
+        help="Root directory to scan (default: current directory)",
+    )
+    parser.add_argument(
+        "--no-content",
+        dest="include_content",
+        action="store_false",
+        help="Do not include file contents (only show tree structure)"
+    )
+    parser.add_argument(
+        "--mask-secrets",
+        action="store_true",
+        help="Mask sensitive information like passwords, tokens, etc."
+    )
+    parser.add_argument(
+        "-o", "--output",
+        type=Path,
+        help="Write output to a file instead of stdout"
+    )
+    parser.add_argument(
+        "--no-gitignore",
+        dest="follow_gitignore",
+        action="store_false",
+        help="Do NOT respect .gitignore rules (include all files)"
+    )
+    parser.add_argument(
+        "-f", "--format",
+        choices=["txt", "md"],
+        default="txt",
+        help="Output format: txt (default) or md",
+        metavar='FMT'
+    )
+
+    args = parser.parse_args()
+
+    root_path = Path(args.root).resolve()
+    if not root_path.is_dir():
+        print(f"Error: '{root_path}' is not a valid directory.", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        report = _generate_report(
+            root_path,
+            include_content=args.include_content,
+            mask_secrets=args.mask_secrets,
+            follow_gitignore=args.follow_gitignore,
+            fmt=args.format,
+        )
+    except Exception as e:
+        print(f"Error generating report: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if args.output:
+        try:
+            args.output.write_text(report, encoding='utf-8')
+            print(f"Report written to {args.output}")
+        except IOError as e:
+            print(f"Error writing to file: {e}", file=sys.stderr)
+            sys.exit(1)
+    else:
+        print(report)
+
+
+if __name__ == "__main__":
+    main()

pilepack/collector.py

@@ -0,0 +1,37 @@
+from .ignorer import load_gitignore, is_ignored
+from pathlib import Path
+from typing import Dict, List
+
+
+def collect_files(root_path: Path, follow_gitignore: bool = True) -> list[Path]:
+    if not root_path.is_dir():
+        raise NotADirectoryError(f"{root_path} does not exist or is not a directory")
+
+    if follow_gitignore:
+        spec = load_gitignore(root_path)
+    else:
+        spec = None
+    collected = []
+
+    for item in root_path.rglob('*'):
+        if item.name == '.gitignore':
+            continue
+        if '.git' in item.parts:
+            continue
+        if spec and is_ignored(item, root_path, spec):
+            continue
+        if item.is_file():
+            rel = item.relative_to(root_path)
+            collected.append(rel)
+    return collected
+
+
+def build_tree(files: List[Path]) -> Dict:
+    tree = {}
+    for path in files:
+        parts = path.parts
+        current = tree
+        for part in parts[:-1]:
+            current = current.setdefault(part, {})
+        current[parts[-1]] = None
+    return tree

pilepack/formatter.py

@@ -0,0 +1,68 @@
+from typing import Dict, List, Optional, Tuple
+from pathlib import Path
+
+
+def _format_tree(tree: Dict, prefix: str = '', is_last: bool = True) -> str:
+    lines = []
+    items = sorted(tree.items(), key=lambda x: (isinstance(x[1], dict), x[0].lower()), reverse=True)
+
+    for i, (name, subtree) in enumerate(items):
+        is_last_item = (i == len(items) - 1)
+        connector = '└── ' if is_last_item else '├── '
+        display_name = name + '/' if isinstance(subtree, dict) else name
+        lines.append(prefix + connector + display_name)
+
+        if isinstance(subtree, dict):
+            new_prefix = prefix + ('    ' if is_last_item else '│   ')
+            lines.append(_format_tree(subtree, new_prefix, is_last_item))
+    return '\n'.join(lines)
+
+
+def _render_txt(root_name: str, tree: Dict, files_content: List[Tuple[Path, Optional[str]]]) -> str:
+    tree_str = _format_tree(tree)
+    output = [f"{root_name}\n{tree_str}"]
+
+    if files_content:
+        output.append("\n" + "=" * 80 + "\n")
+
+        for rel_path, content in files_content:
+
+            if content is not None:
+                output.append(f"--- FILE: {rel_path} ---")
+                output.append(content)
+                output.append("")
+            else:
+                output.append(f"--- FILE: {rel_path} [BINARY OR UNREADABLE] ---\n")
+    return "\n".join(output)
+
+
+def _render_md(root_name: str, tree: Dict, files_content: List[Tuple[Path, Optional[str]]]) -> str:
+    tree_str = _format_tree(tree)
+    output = [f"# {root_name}\n```\n{tree_str}\n```"]
+
+    if files_content:
+        output.append("\n---\n")
+
+        for rel_path, content in files_content:
+            
+            if content is not None:
+                ext = rel_path.suffix.lower()
+                lang = {
+                    '.py': 'python', '.js': 'javascript', '.ts': 'typescript',
+                    '.html': 'html', '.css': 'css', '.json': 'json',
+                    '.md': 'markdown', '.yaml': 'yaml', '.yml': 'yaml',
+                    '.sh': 'bash', '.txt': 'text'
+                }.get(ext, 'text')
+                output.append(f"## `{rel_path}`\n```{lang}\n{content}\n```\n")
+            else:
+                output.append(f"## `{rel_path}`\n*[BINARY OR UNREADABLE]*\n")
+    return '\n'.join(output)
+
+
+def render(root_name: str, tree: Dict, files_content: List[Tuple[Path, Optional[str]]], fmt: str = "txt") -> str:
+    if fmt == "txt":
+        return _render_txt(root_name, tree, files_content)
+    elif fmt == "md":
+        return _render_md(root_name, tree, files_content)
+    else:
+        raise ValueError(f"Unsupported format: {fmt}. Supported: 'txt', 'md'")

pilepack/ignorer.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+from pathspec import PathSpec
+
+
+def load_gitignore(root_path: Path) -> PathSpec:
+    gitignore_path = root_path / '.gitignore'
+    if not gitignore_path.exists():
+        return PathSpec.from_lines('gitignore', [])
+    with open(gitignore_path, 'r', encoding='utf-8') as file:
+        return PathSpec.from_lines('gitignore', file)
+
+
+def is_ignored(path, root: Path, spec: PathSpec) -> bool:
+    original = str(path)
+    path_obj = Path(original)
+
+    if not path_obj.is_absolute():
+        path_obj = root / path_obj
+
+    try:
+        rel_path = path_obj.relative_to(root)
+    except ValueError:
+        return False
+    rel_str = rel_path.as_posix()
+
+    if original.endswith(('/', '\\')) or (path_obj.exists() and path_obj.is_dir()):
+        rel_str += '/'
+    return spec.match_file(rel_str)

pilepack/reader.py

@@ -0,0 +1,46 @@
+import re
+from pathlib import Path
+from typing import Optional
+
+SECRET_PATTERNS = [
+    (r'(password|passwd|pwd)\s*[=:]\s*["\']?([^"\'\s]+)["\']?', r'\1="***"'),
+    (r'(api_key|apikey)\s*[=:]\s*["\']?([^"\'\s]+)["\']?', r'\1="***"'),
+    (r'(token|access_token)\s*[=:]\s*["\']?([^"\'\s]+)["\']?', r'\1="***"'),
+    (r'(secret|private_key)\s*[=:]\s*["\']?([^"\'\s]+)["\']?', r'\1="***"'),
+    (r'(?:\\b[A-Za-z0-9+/]{40,}\\b)', '***'),
+    (r'(?:\\b[0-9a-f]{32,}\\b)', '***')
+]
+
+def _mask_secrets_in_text(text: str) -> str:
+    for pattern, replacement in SECRET_PATTERNS:
+        text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
+    return text
+
+def read_file(file_path: Path, mask_secrets: bool = False) -> Optional[str]:
+    try:
+        raw_data = file_path.read_bytes()
+    except (OSError, IOError) as e:
+        print(f"Failed to read {file_path}: {e}")
+        return None
+
+    if b'\x00' in raw_data:
+        return None
+    try:
+        text = raw_data.decode('utf-8-sig')
+    except UnicodeDecodeError:
+        for enc in ('utf-8', 'cp1251', 'latin1'):
+            try:
+                text = raw_data.decode(enc)
+                break
+            except UnicodeDecodeError:
+                continue
+        else:
+            return None
+
+    if text.startswith('\ufeff'):
+        text = text[1:]
+
+    if mask_secrets:
+        text = _mask_secrets_in_text(text)
+
+    return text

pilepack-0.1.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: pilepack
+Version: 0.1.0
+Summary: Pack your codebase into a single file for AI analysis
+Author-email: "Vasili S. Pribylov" <dartmew@yandex.com>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pathspec>=0.10.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# PilePack
+
+[![Python Version](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![PyPI version](https://img.shields.io/pypi/v/pilepack)](https://pypi.org/project/pilepack/)
+[![Tests](https://img.shields.io/badge/tests-20%20passed-brightgreen)](tests/)
+[![Coverage](https://img.shields.io/badge/coverage-84%25-yellowgreen)](tests/)
+[![CLI](https://img.shields.io/badge/CLI-ready-blue)]()
+
+**Pack your codebase into a single file for AI analysis**  
+Combine all your project files into one text file — perfect for sending to LLMs (ChatGPT, Claude, Copilot, Deepseek, etc.).
+
+---
+
+## ✨ Features
+
+- 📁 **Recursive scanning** – walks through all files in a directory.
+- 🚫 **Respects .gitignore** – optionally disable with `--no-gitignore`.
+- 🌳 **Tree structure** – displays project hierarchy.
+- 📄 **Embedded content** – each file is shown with its path header.
+- 🔐 **Secrets masking** – hides passwords, tokens, keys (`--mask-secrets`).
+- 🖨️ **Two output formats** – plain text (`txt`) or Markdown (`md`).
+- 💾 **Save to file** – use `-o output.txt`.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install pilepack
+```
+From source:
+
+```bash
+git clone https://github.com/dartmew/pilepack.git
+cd pilepack
+pip install -e .
+```
+
+## 🚀 Usage
+Basic command – pass a path to your project:
+```bash
+pilepack /path/to/your/project
+```
+Redirect output to a file:
+```bash
+pilepack . > report.txt
+```
+Example output (txt)
+```text
+myproject
+├── main.py
+├── utils/
+│   ├── helpers.py
+│   └── __init__.py
+└── README.md
+
+================================================================================
+
+--- FILE: main.py ---
+import utils.helpers
+
+def main():
+    print("Hello")
+
+--- FILE: utils/helpers.py ---
+def greet(name):
+    return f"Hi {name}"
+```
+Markdown format
+```bash
+pilepack . -f md -o report.md
+```
+Produces a Markdown file with syntax highlighting.
+
+Show only structure (no file contents)
+```bash
+pilepack . --no-content
+```
+Mask secrets
+```bash
+pilepack . --mask-secrets
+```
+Replaces values of password=, api_key=, token=, and long strings (base64/hex) with ***.
+
+Disable .gitignore
+```bash
+pilepack . --no-gitignore
+```
+## 📋 CLI Options
+| Option | Description |
+|--------|-------------|
+| `root` | Directory to scan (default: current directory) |
+| `--no-content` | Show tree structure only, skip file contents |
+| `--mask-secrets` | Mask passwords, tokens, API keys |
+| `-o, --output` | Write report to a file instead of stdout |
+| `--no-gitignore` | Do not respect `.gitignore` (include all files) |
+| `-f, --format` | Output format: `txt` (default) or `md` |
+
+## 🧪 Testing
+Install test dependencies and run:
+
+```bash
+pip install -e .[test]
+pytest
+```
+With coverage:
+```bash
+pytest --cov=pilepack
+```
+Current coverage: 84% (20 tests, all passing).
+```bash
+Name                    Stmts   Miss  Cover
+-------------------------------------------
+pilepack\__init__.py        0      0   100%
+pilepack\__main__.py        3      3     0%
+pilepack\cli.py            51      7    86%
+pilepack\collector.py      30      1    97%
+pilepack\formatter.py      44      3    93%
+pilepack\ignorer.py        21      3    86%
+pilepack\reader.py         31     12    61%
+-------------------------------------------
+TOTAL                     180     29    84%
+```
+
+## 📄 License
+[MIT](LICENSE) © 2026 Vasili S. Pribylov
+
+## 🤝 Contributing
+Issues and pull requests are welcome! For major changes, please open an issue first to discuss.
+
+## 🙏 Acknowledgements
+Inspired by the need to easily feed code into large language models.

pilepack-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pilepack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilepack/__main__.py,sha256=hgA7I86RlZPQ28yoxwUz5uOhsxK8fzYfaJ6XYkq2nQ4,65
+pilepack/cli.py,sha256=nRrDwnU6D0KnwEOO_k2rnb7HqL0T0CzFsGHy2-yfYuI,3174
+pilepack/collector.py,sha256=3uMoW68mjIFF-eaa3qUAS7CcSd1RMWX_VFAOTjPOdnM,1077
+pilepack/formatter.py,sha256=sBv312kZjz-3etlIUOqxzj0698LTLMLZZbHrhMrRK84,2723
+pilepack/ignorer.py,sha256=PMzl_Dx8gWUYxQHvccIBw-OAdYPn-ihbFcmTzYGkXpY,848
+pilepack/reader.py,sha256=QEUPmCj8h_Po4Zzt0Yz6qdRyfBdK8-m6hxTzf0j19D4,1447
+pilepack-0.1.0.dist-info/licenses/LICENSE,sha256=U6IZ7mLlAQFo7cMcX0eqWuPtgiP2RRAWfnYdfVmEc30,1079
+pilepack-0.1.0.dist-info/METADATA,sha256=97DTfm7WtQuOSbFEtYgJznhjcEjqH7xB4lbNitv2Cd4,4282
+pilepack-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pilepack-0.1.0.dist-info/entry_points.txt,sha256=ywLekmCJYvrm_uymq5cWDu3GJXZVDUULh-q14QNRLN4,47
+pilepack-0.1.0.dist-info/top_level.txt,sha256=PBbRF3bR-s_sO1hbRtLORxUipnbLHUytM7Lh6ecgbuI,9
+pilepack-0.1.0.dist-info/RECORD,,

pilepack-0.1.0.dist-info/WHEEL

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

pilepack-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pilepack = pilepack.cli:main

pilepack-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Vasili S. Pribylov
+
+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.

pilepack-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pilepack