{
  "meta": {
    "tool": "paleae",
    "version": "1.0.0",
    "license": "MIT",
    "website": "https://paleae.com",
    "source": "https://github.com/PaulTiffany/paleae",
    "timestamp": "2025-09-22T23:36:01Z",
    "root_directory": "C:\\Users\\paulc\\projects\\paleae",
    "ignore_file": {
      "file": ".paleaeignore",
      "present": true,
      "patterns": 35,
      "negations": 0
    },
    "summary": {
      "total_files": 22,
      "total_chars": 75345,
      "estimated_tokens": 18827
    }
  },
  "files": [
    {
      "path": ".github/workflows/ci.yml",
      "content": "name: Python CI\n\non:\n  push:\n    branches: [ main ]\n  pull_request:\n    branches: [ main ]\n\njobs:\n  build:\n    runs-on: ubuntu-latest\n\n    steps:\n    - uses: actions/checkout@v4\n\n    - name: Set up Python 3.11\n      uses: actions/setup-python@v5\n      with:\n        python-version: '3.11'\n\n    - name: Cache Python dependencies\n      uses: actions/cache@v4\n      with:\n        path: |-\n          ~/.cache/pip\n          .venv\n        key: ${{ runner.os }}-python-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('./paleae/pyproject.toml') }}\n        restore-keys: |-\n          ${{ runner.os }}-python-${{ steps.setup-python.outputs.python-version }}-\n          ${{ runner.os }}-python-\n\n    - name: Install dependencies\n      run: |\n        python -m pip install --upgrade pip\n        pip install -e .[dev]\n\n    - name: Security scan with bandit\n      run: |\n        bandit -r paleae.py\n\n    - name: Check code formatting with ruff\n      run: |\n        ruff format --check .\n\n    - name: Lint with ruff\n      run: |\n        ruff check .\n\n    - name: Type check with mypy\n      run: |\n        mypy .\n\n    - name: Check docstrings with pydocstyle\n      run: |\n        pydocstyle paleae.py\n\n    - name: Test with pytest and coverage\n      run: |\n        pytest --cov=paleae --cov-report=xml --cov-report=term-missing\n        pytest --cov=paleae --cov-fail-under=100\n\n    - name: Upload coverage to Codecov\n      uses: codecov/codecov-action@v4\n      with:\n        token: ${{ secrets.CODECOV_TOKEN }}\n        slug: PaulTiffany/paleae\n",
      "size_chars": 1543,
      "sha256": "b41a35decdcb85a74786a9a38a6ee96f80759c243ad57b9a91544eeb14b9e9c9",
      "estimated_tokens": 385
    },
    {
      "path": ".github/workflows/release.yml",
      "content": "name: Release to PyPI\n\non:\n  workflow_dispatch: # Allows manual triggering from GitHub UI\n  push:\n    tags:\n      - 'v*.*.*' # Triggers on pushes to tags like v1.0.0\n\njobs:\n  release:\n    runs-on: ubuntu-latest\n\n    steps:\n    - name: Checkout code\n      uses: actions/checkout@v4\n\n    - name: Set up Python\n      uses: actions/setup-python@v5\n      with:\n        python-version: '3.x' # Use latest Python 3\n\n    - name: Install build and publish dependencies\n      run: |\n        python -m pip install --upgrade pip\n        pip install build twine\n\n    - name: Build package\n      run: python -m build\n\n    - name: Publish to PyPI\n      env:\n        TWINE_USERNAME: __token__\n        TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}\n      run: twine upload dist/*\n\n    - name: Create GitHub Release\n      uses: softprops/action-gh-release@v1\n      if: startsWith(github.ref, 'refs/tags/')\n      with:\n        tag_name: ${{ github.ref_name }}\n        name: Release ${{ github.ref_name }}\n        body: |-\n          See the [CHANGELOG.md](https://github.com/PaulTiffany/paleae/blob/${{ github.ref_name }}/CHANGELOG.md) for details.\n          \n          Full Source: [${{ github.ref_name }}.zip](https://github.com/PaulTiffany/paleae/archive/refs/tags/${{ github.ref_name }}.zip)\n        draft: false\n        prerelease: false\n",
      "size_chars": 1322,
      "sha256": "a336ee36a2377310953e0a8cf49fdaab547ab89eb1df4c76323d9cbfc776c227",
      "estimated_tokens": 330
    },
    {
      "path": ".ruff.toml",
      "content": "line-length = 100\n[lint]\nselect = [\"E\",\"F\",\"B\",\"I\",\"UP\",\"PL\"]\n",
      "size_chars": 62,
      "sha256": "0aca6dbe26e1ab772650c1b2ecc4983c3c294b9dabff6c622279bb4553aacfa5",
      "estimated_tokens": 15
    },
    {
      "path": "ACCESSIBILITY.md",
      "content": "# Accessibility Statement and Guidelines for Paleae\n\nPaleae is committed to building and maintaining an inclusive and accessible tool. We believe that software should be usable by everyone, regardless of their abilities or the assistive technologies they use.\n\nThis document outlines our commitment to accessibility and provides guidelines for contributors to ensure that all changes maintain or improve the accessibility of Paleae and its related assets (like the website and documentation).\n\n## Our Commitment\n\nWe strive to adhere to the Web Content Accessibility Guidelines (WCAG) 2.1 Level AA standards for our website and documentation. For the `paleae.py` tool itself, our focus is on ensuring its output is machine-readable and compatible with various parsing and analysis tools, including those used by assistive technologies.\n\n## Guidelines for Contributors\n\nWhen contributing to Paleae, please keep accessibility in mind:\n\n### Code Contributions (`paleae.py`)\n\n*   **Output Clarity:** Ensure any new output or changes to existing output are clear, concise, and structured. Avoid ambiguous or overly complex text that might be difficult for screen readers or other assistive tools to parse.\n*   **Error Messages:** Make error messages informative and actionable. They should clearly explain what went wrong and, if possible, how to resolve it.\n*   **CLI Usability:** Consider keyboard navigation and screen reader compatibility for any interactive CLI elements (though Paleae is primarily a non-interactive tool).\n\n### Website (`index.html`)\n\n*   **Semantic HTML:** Use HTML elements for their intended purpose (e.g., `<button>` for buttons, `<h1>` for main headings). This provides a logical structure for assistive technologies.\n*   **Color Contrast:** Ensure all text and interactive elements have sufficient color contrast against their background. We aim for WCAG 2.1 AA standards (minimum 4.5:1 for normal text, 3:1 for large text).\n*   **Alternative Text:** Provide meaningful `alt` text for all images (`<img alt=\"...\">`). If an image is purely decorative, use `alt=\"\"` or `aria-hidden=\"true\"`.\n*   **Keyboard Navigation:** Ensure all interactive elements (buttons, links, form fields) are reachable and operable using only the keyboard (Tab, Enter, Spacebar).\n*   **ARIA Attributes:** Use ARIA attributes (`aria-label`, `aria-labelledby`, `role`, `aria-hidden`) judiciously to enhance semantics where native HTML is insufficient.\n*   **Responsive Design:** Ensure the website is usable and readable across various screen sizes and devices.\n\n### Documentation (Wiki, `README.md`, etc.)\n\n*   **Clear Language:** Write clearly and concisely. Avoid jargon where possible, or explain it.\n*   **Headings:** Use proper heading hierarchy (`#`, `##`, `###`) to structure content logically.\n*   **Link Text:** Make link text descriptive (e.g., \"Read our Contributing Guide\" instead of \"Click here\").\n*   **Code Blocks:** Ensure code blocks are readable and can be easily copied.\n\n## Reporting Accessibility Issues\n\nIf you encounter any accessibility barriers while using Paleae, its website, or documentation, please report them via [GitHub Issues](https://github.com/PaulTiffany/paleae/issues). We take all feedback seriously and are committed to continuous improvement.\n\nThank you for helping us make Paleae accessible to everyone!",
      "size_chars": 3341,
      "sha256": "3e6f705c13628976bc98e1d97e02e70f641697f0bd4461742a979603f46b7df1",
      "estimated_tokens": 835
    },
    {
      "path": "CNAME",
      "content": "paleae.com",
      "size_chars": 10,
      "sha256": "981bbbb3c32b6f04e284634450781ec63f81234964692b5011250100a159abed",
      "estimated_tokens": 2
    },
    {
      "path": "CODE_OF_CONDUCT.md",
      "content": "# Code of Conduct\n\n## Our Commitment\n\nWe are committed to providing a welcoming and constructive environment for all contributors to the Paleae project, regardless of experience level, background, or identity. This commitment extends to ensuring our tools and resources are accessible to everyone. Please refer to our [[ACCESSIBILITY.md]](./ACCESSIBILITY.md) for more details on our accessibility guidelines.\n\n## Expected Behavior\n\n* Be respectful in discussions and code reviews\n* Focus on technical merit and project goals\n* Provide constructive feedback with specific suggestions\n* Acknowledge different perspectives and expertise levels\n* Help newcomers get started and learn\n\n## Unacceptable Behavior\n\n* Personal attacks or inflammatory language\n* Harassment in any form\n* Publishing private information without consent\n* Off-topic discussions that derail technical conversations\n* Behavior that creates an unwelcoming environment for others\n\n## Project Focus\n\nPaleae is a technical tool with a specific purpose. Discussions should center on:\n* Code quality and functionality\n* User experience improvements  \n* Bug reports and feature requests\n* Development process and tooling\n\n## Enforcement\n\nInstances of unacceptable behavior may be reported by opening an issue or contacting the project maintainers. All reports will be reviewed and may result in:\n\n* Warning and request to modify behavior\n* Temporary restriction from project participation  \n* Permanent removal from the project\n\n## Scope\n\nThis code of conduct applies within all project spaces including GitHub repositories, issue trackers, discussions, and any other forums where the project is represented.\n\n## Attribution\n\nThis Code of Conduct is adapted from community standards for open source technical projects.",
      "size_chars": 1780,
      "sha256": "074b8e23cb92e048735fbbfba3a83552a5a730eb2a7153e7001969a8f09db12c",
      "estimated_tokens": 445
    },
    {
      "path": "CONTRIBUTING.md",
      "content": "# Contributing to Paleae\n\nThank you for your interest in contributing to Paleae! This project aims to make repository snapshots for AI analysis as simple and reliable as possible.\n\n## Quick Start\n\n1. **Fork and clone** the [repository](https://github.com/PaulTiffany/paleae)\n2. **Install dev dependencies**: `pip install -e .[dev]` (see [`pyproject.toml`](./pyproject.toml) for details)\n3. **Run tests**: `pytest` (should achieve 100% coverage, enforced by [`pytest-cov`](https://pytest-cov.readthedocs.io/))\n4. **Check code quality**: `ruff check .` ([Ruff](https://docs.astral.sh/ruff/)), `mypy .` ([MyPy](https://mypy.readthedocs.io/)), `pydocstyle paleae.py` ([Pydocstyle](https://pydocstyle.readthedocs.io/))\n\n## Development Philosophy\n\nPaleae follows these core principles:\n\n- **Single file, zero runtime dependencies** - Keep [`paleae.py`](./paleae.py) self-contained\n- **Local-first** - No network calls, no external services\n- **Predictable behavior** - Deterministic output, clear error messages\n- **Comprehensive testing** - Property-based tests with [Hypothesis](https://hypothesis.readthedocs.io/), 100% coverage\n\n## Types of Contributions\n\n### Bug Reports\n- Use GitHub Issues with clear reproduction steps\n- Include your OS, Python version, and example repository structure\n- Attach the problematic snapshot output if relevant\n\n### Feature Requests\n- Check existing issues first to avoid duplicates\n- Explain the use case and why it benefits AI analysis workflows\n- Consider if the feature aligns with the \"lean but powerful\" philosophy\n\n### Code Contributions\n- All changes require tests with full coverage maintained\n- Follow the existing code style (enforced by [Ruff](https://docs.astral.sh/ruff/))\n- Update documentation for user-facing changes\n\n## Development Setup\n\n```bash\n# Clone your fork\ngit clone https://github.com/YOUR-USERNAME/paleae.git\ncd paleae\n\n# Install in development mode\npip install -e .[dev]\n\n# Run the full test suite\npytest --cov=paleae --cov-branch --cov-report=term-missing\n\n# Check code quality\nruff check .\nmypy .\npydocstyle paleae.py\nbandit -r paleae.py # Security scan with [Bandit](https://bandit.readthedocs.io/)\n```\n\n## Testing Guidelines\n\n- **Unit tests**: Test individual functions with clear inputs/outputs\n- **Property-based tests**: Use Hypothesis for edge cases and invariants\n- **Integration tests**: Test complete workflows with temporary directories\n- **Coverage requirement**: 100% line and branch coverage (enforced by [`pytest-cov`](https://pytest-cov.readthedocs.io/))\n\nExample test pattern:\n```python\ndef test_feature_basic_case():\n    \"\"\"Test the happy path.\"\"\"\n    # Arrange, Act, Assert\n\n@given(st.text())\ndef test_feature_property(input_text):\n    \"\"\"Property-based test for edge cases.\"\"\"\n    # Test invariants that should always hold\n```\n\n## Code Style\n\n- **Line length**: 100 characters (configured in [`./.ruff.toml`](./.ruff.toml))\n- **Type hints**: Required for all function signatures (see [Python Typing](https://docs.python.org/3/library/typing.html))\n- **Docstrings**: Required for public functions (checked by [Pydocstyle](https://pydocstyle.readthedocs.io/))\n- **Error handling**: Use specific exceptions, avoid bare `except:`\n\n## Making Changes\n\n1. **Create a feature branch**: `git checkout -b feature/your-feature-name`\n2. **Write tests first** (TDD approach preferred)\n3. **Implement the change** while maintaining coverage\n4. **Update documentation** if user-facing behavior changes\n5. **Run the full test suite** before submitting\n\n## Pull Request Process\n\n1. **Run all checks locally**: The same checks run automatically on every pull request. You can view the full workflow definition [here](.github/workflows/ci.yml).\n   ```bash\n   pytest --cov=paleae --cov-branch\n   ruff check .\n   mypy .\n   pydocstyle paleae.py\n   bandit -r paleae.py # Security scan\n   ```\n\n2. **Update the version** in `paleae.py` and `pyproject.toml` if appropriate\n3. **Write a clear PR description** explaining the change and motivation\n4. **Link to related issues** using GitHub keywords (`fixes #123`)\n\n## Release Process\n\nReleases are handled by maintainers:\n1. Version bump in `paleae.py` and `pyproject.toml`\n2. Update changelog/release notes\n3. Tag release and publish to PyPI\n4. Update website if needed\n\n## Questions?\n\n- **General discussion**: GitHub Discussions\n- **Bug reports**: GitHub Issues  \n- **Quick questions**: Open an issue with the \"question\" label\n\n## License\n\nBy contributing, you agree that your contributions will be licensed under the same [MIT license](./LICENSE) that covers the project.\n",
      "size_chars": 4579,
      "sha256": "c1acaf6da8ad1eec880acab1587006872614554accdeee55e3c51504e9222a9f",
      "estimated_tokens": 1144
    },
    {
      "path": "LICENSE",
      "content": "MIT License\n\nCopyright (c) 2025 PaulTiffany\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n",
      "size_chars": 1068,
      "sha256": "6bccd79fe55795f20a65aa183865774720a217e153032fc3948d9c53d9da3fe9",
      "estimated_tokens": 267
    },
    {
      "path": "PHILOSOPHY.md",
      "content": "# Philosophy\n\nPaleae embodies a simple conviction: **good tools should be predictable, transparent, and trustworthy**.\n\nThis document outlines the core principles of the project. For detailed usage and configuration, please see the [Paleae Wiki](paleae.wiki/Home.md).\n\n## Core Principles\n\n### Single File, Zero Dependencies\n\nOne file. One purpose. No hidden complexity.\n\nWhen you download `paleae.py`, you get the entire tool. No package managers, no dependency trees, no version conflicts. You can read every line of code, understand exactly what it does, and trust that it will work the same way tomorrow as it does today.\n\nThis isn't a limitation—it's a feature. Constraints breed clarity.\n\n### Local-First\n\nYour code never leaves your machine during scanning. No network calls, no telemetry, no \"phone home\" behavior. Paleae runs where you run it, processes what you tell it to process, and writes output where you specify.\n\nIn an era of cloud-everything and data collection, this is a deliberate choice. Your repositories contain your ideas, your competitive advantages, your mistakes, and your breakthroughs. They shouldn't require an internet connection to analyze.\n\n### Predictable by Design\n\nPaleae produces deterministic output. The same codebase scanned twice will generate identical snapshots (modulo timestamps). File traversal follows consistent patterns. Error messages are clear and actionable.\n\nSurprises are bugs, not features.\n\n### Lean but Powerful\n\nEvery feature must justify its existence. Every line of code must serve a purpose. We resist feature creep not out of laziness, but out of respect for the core mission.\n\nThe goal isn't to build the most feature-rich repository scanner. The goal is to build the most trustworthy one.\n\n## Design Decisions\n\n### Why JSON/JSONL?\n\nStructured data beats clever formatting. JSON is universal, parseable, and future-proof. JSONL handles large repositories gracefully and streams naturally. Both formats work everywhere, with everything.\n\nHuman-readable is important, but machine-parseable is essential. See the [Output Format](paleae.wiki/Output-Format.md) guide for details.\n\n### Why Regex Patterns Instead of Globs?\n\nPower users need precision. While `.paleaeignore` uses familiar glob syntax, the CLI accepts regex patterns for maximum flexibility. This dual approach serves both casual users and power users without compromise. This is explained in the [Configuration](paleae.wiki/Configuration.md) guide.\n\n### Why SHA-256 Hashes?\n\nTrust requires verification. Every file in the snapshot includes its SHA-256 hash, enabling you to verify the integrity of the data and detect changes over time. This isn't paranoia—it's engineering rigor.\n\n### Why No Configuration Files?\n\nConfiguration files create state. State creates complexity. Complexity breaks predictability.\n\nPaleae takes its instructions from [command-line arguments](paleae.wiki/Usage-Guide.md) and [`.paleaeignore` files](paleae.wiki/Configuration.md) that live alongside your code. Everything else is convention and sensible defaults.\n\n## What Paleae Is Not\n\n- **Not a code analysis tool.** It snapshots, it doesn't analyze.\n- **Not a backup solution.** It captures text content, not complete repository state.\n- **Not a deployment tool.** It creates data for other systems to consume.\n- **Not a cloud service.** It's a local utility that respects local control.\n\n## The Grain Metaphor\n\n\"Paleae\" refers to the chaff that surrounds grain—the protective husks that must be separated to reveal the valuable core.\n\nA codebase is the same. It contains signal (source code, key configurations) and noise (build artifacts, logs, binaries). For a Large Language Model, this noise is detrimental. It consumes precious context window space, introduces irrelevant information, and degrades the quality of analysis.\n\nPaleae is the winnowing fan for your code. It helps you separate the grain from the chaff, creating clean, dense, signal-rich snapshots that are perfectly optimized for AI consumption. Like traditional winnowing, this process requires judgment. That's why Paleae gives you precise [filtering control](paleae.wiki/Configuration.md) over what gets included and what gets filtered out.\n\n## Long-term Thinking\n\nSoftware tools often grow until they collapse under their own weight. Paleae chooses a different path: **sustainable minimalism**.\n\nWe will:\n- Resist feature requests that compromise core principles\n- Maintain backward compatibility aggressively\n- Keep the single-file constraint inviolate\n- Prioritize reliability over novelty\n\nThe best tools become invisible infrastructure. They work so consistently that you stop thinking about them and focus on your actual work instead.\n\nThat's the goal.\n",
      "size_chars": 4734,
      "sha256": "7752fbc08d60824971e1dd66b3c1ff698d2783bf84aac0c209ca99682ea04daa",
      "estimated_tokens": 1183
    },
    {
      "path": "README.md",
      "content": "<p align=\"center\">\n  <picture>\n    <source media=\"(prefers-color-scheme: dark)\" srcset=\"./assets/paleae-badge-dark.svg\">\n    <img alt=\"Paleae — Ship your repo to your AI\" src=\"./assets/paleae-badge-light.svg\" width=\"230\">\n  </picture>\n</p>\n\n<p align=\"center\">\n  <strong>Snapshot your codebase into compact JSON/JSONL — perfect for LLMs.</strong>\n  <br>\n  Single file. Zero dependencies. No install.\n</p>\n\n<p align=\"center\">\n  <a href=\"https://github.com/PaulTiffany/paleae/actions/workflows/ci.yml\">\n    <img src=\"https://github.com/PaulTiffany/paleae/actions/workflows/ci.yml/badge.svg\" alt=\"CI Status\">\n  </a>\n  <a href=\"https://pypi.org/project/paleae/\">\n    <img src=\"https://img.shields.io/pypi/v/paleae.svg?color=5EE1A0&label=pypi%20package\" alt=\"PyPI version\">\n  </a>\n  <a href=\"https://pypi.org/project/paleae/\">\n    <img src=\"https://img.shields.io/pypi/pyversions/paleae.svg\" alt=\"Python versions\">\n  </a>\n  <a href=\"./LICENSE\">\n    <img src=\"https://img.shields.io/badge/license-MIT-informational.svg\" alt=\"MIT License\">\n  </a>\n</p>\n\n---\n\n`paleae` is a single-file, zero-dependency utility that scans your repository and creates a structured snapshot optimized for AI analysis. It's designed to be simple, transparent, and trustworthy.\n\n## Key Features\n\n*   **Single File, Zero Deps:** Drop `paleae.py` into any project. It runs anywhere Python runs, with no `pip install` required.\n*   **Local-First:** Scans files on your machine. No code is ever sent over the network.\n*   **AI-Ready Output:** Generates clean `JSON` or `JSONL` designed for machine consumption. The structured format is perfect for populating LLM context windows, building Retrieval-Augmented Generation (RAG) systems, or creating training datasets.\n*   **Configurable:** Use powerful include/exclude regex patterns and a `.paleaeignore` file (with `!` negation) to precisely control what gets included.\n*   **Rigorously Tested:** 100% line and branch coverage, fully type-checked with MyPy, linted with Ruff, and hardened with Hypothesis property-based tests and `pydocstyle` compliance.\n\n## Quick Start\n\nNo installation needed. Just download and run.\n\n```bash\n# Download the script\ncurl -fsSL https://raw.githubusercontent.com/PaulTiffany/paleae/main/paleae.py -o paleae.py\n\n# Snapshot the current directory\npython paleae.py\n```\n\nThis will create a `repo_snapshot.json` file in your current directory.\n\n## Usage with AI Assistants\n\nIf you are using an AI assistant, it can leverage `paleae` to help you more effectively. Your assistant can:\n1.  **Suggest snapshot commands** tailored to your project to get the best context for analysis.\n2.  **Generate custom `.paleaeignore` files** to exclude noise and focus on the most relevant code.\n\nSee the [project Cookbook](https://github.com/PaulTiffany/paleae/wiki/Cookbook) for detailed recipes and examples.\n\n## Contributing\n\nWe welcome contributions! If you're interested in helping improve Paleae, please read our comprehensive [Contributing Guide](./CONTRIBUTING.md) for details on setting up your development environment, running tests, and submitting pull requests.\n\n### Privacy & Safety (30s)\n- Runs locally in read-only mode. No execution. No network.\n- Skips binaries, huge files (>10 MB), VCS/caches, and `.env` by default.\n- Add a `.paleaeignore` to exclude anything sensitive.\n- You are responsible for what you share—review the JSON before uploading.\n\n## Usage\n\n```\nusage: paleae [-h] [-o OUT] [-f {json,jsonl}] [--profile {minimal,ai_optimized}]\n              [--include INCLUDE] [--exclude EXCLUDE] [--version] [--about]\n              [directory]\n\nCreate JSON/JSONL snapshot of your repo for LLMs\n\npositional arguments:\n  directory             Directory to snapshot (default: .)\n\noptions:\n  -h, --help            show this help message and exit\n  -o, --out OUT         Output file (auto-named if not specified)\n  -f, --format {json,jsonl}\n                        Output format\n  --profile {minimal,ai_optimized}\n                        File inclusion profile\n  --include INCLUDE     Extra include regex (repeatable)\n  --exclude EXCLUDE     Extra exclude regex (repeatable)\n  --version             show program's version number and exit\n  --about               Show project info and exit\n```\n\n### Examples\n\n**Snapshot to a specific JSONL file:**\n```bash\npython paleae.py -f jsonl -o my_project.jsonl\n```\n\n**Use the `ai_optimized` profile to include only core source and config files:**\n```bash\npython paleae.py --profile ai_optimized\n```\n\n**Add a specific directory to the snapshot using a regex:**\n```bash\npython paleae.py --include \"^(docs|examples)/\"\n```\n\n## Configuration (`.paleaeignore`)\n\nCreate a `.paleaeignore` file in your project's root directory to exclude files and directories. The syntax is similar to `.gitignore`.\n\n```\n# .paleaeignore\n\n# Ignore build artifacts and logs\nbuild/\ndist/\n*.log\n\n# But force-include an important log file\n!important.log\n```\n\n## Output Format\n\nThe snapshot contains metadata and a list of file objects.\n\n```json\n{\n  \"meta\": {\n    \"tool\": \"paleae\",\n    \"version\": \"1.0.0\",\n    \"timestamp\": \"2025-09-16T20:00:00Z\",\n    \"root_directory\": \"/path/to/your/project\",\n    \"summary\": {\n      \"total_files\": 42,\n      \"total_chars\": 123456,\n      \"estimated_tokens\": 30864\n    }\n  },\n  \"files\": [\n    {\n      \"path\": \"src/main.py\",\n      \"content\": \"print('hello')\",\n      \"size_chars\": 14,\n      \"sha256\": \"b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9\",\n      \"estimated_tokens\": 3\n    }\n  ]\n}\n```\n\n## License\n\nThis project is licensed under the [MIT License](./LICENSE).\n\nThe brand assets (`assets/*.svg`) are dedicated to the public domain under [CC0 1.0 Universal](./assets/LICENSE.txt).\nE.txt).\n",
      "size_chars": 5695,
      "sha256": "7f9b014d968efa344db596fb08a9e46303191771c305c7e6da7a8a1825996381",
      "estimated_tokens": 1423
    },
    {
      "path": "SECURITY.md",
      "content": "# Security Policy\n\n## Our Pledge: Your Code is Yours\n\nPaleae is designed with a simple security pledge: **Your code is yours. It never leaves your machine.**\n\n-   **Local-First:** The tool runs entirely on your machine.\n-   **No Network Calls:** It does not and will not make network requests.\n-   **Zero Dependencies:** It has no runtime dependencies, minimizing supply chain risk.\n-   **Full Transparency:** It is a single script you can read and verify.\n\nYou have full control and visibility over the data it produces.\n\n---\n\n## Security for AI Workflows & LLMs\n\nThe most critical security consideration when using Paleae is ensuring that the snapshots you generate do not contain sensitive information **before you share them with an AI or any third party.**\n\nWhile Paleae itself is secure and local, the snapshot it creates is a new file containing your code. You are responsible for its contents.\n\n**Before sharing a snapshot:**\n1.  **Review the output JSON/JSONL file** to ensure it doesn't contain API keys, passwords, or other secrets.\n2.  **Use a `.paleaeignore` file** to exclude sensitive files and directories. Common patterns to add include:\n    ```\n    # Common secrets and config\n    .env\n    *.pem\n    *.key\n    credentials.json\n    settings.local.py\n    ```\n3.  **Ask your AI assistant for help.** An AI can help you craft a robust `.paleaeignore` file tailored to your project's framework (e.g., Django, Rails, Node.js).\n\n---\n\n## Supported Versions\n\nWe accept security reports for:\n- The latest release tag on GitHub\n- The `main` branch (HEAD) as published in this repository\n\nOlder releases are generally unsupported unless the issue is severe and broadly impactful.\n\n---\n\n## Reporting a Vulnerability\n\n**Preferred:** Use GitHub’s **Private Vulnerability Reporting** (Security → “Report a vulnerability”) on this repo.  \n**Fallback:** Email **<paulctiffany@gmail.com>** with the details.\n\n*Note: While email is provided as a fallback, we strongly prefer using GitHub's Private Vulnerability Reporting for enhanced security and tracking. For future consideration, a dedicated security email alias (e.g., `security@yourdomain.com`) is recommended to manage reports and reduce spam.*\n\nPlease include:\n- Clear reproduction steps (commands, flags, input files if possible)\n- Impact and likelihood\n- A minimal proof-of-concept (no destructive payloads)\n- Your preferred credit name/handle\n\nWe aim to acknowledge within **48 hours** and provide a remediation plan or fix within **7–14 days** for high-severity issues.\n\n---\n\n## Coordinated Disclosure\n\nWe follow coordinated disclosure:\n1. We confirm and triage the report.\n2. We prepare a fix and security advisory.\n3. We publish a new release and advisory notes.\n4. We credit reporters who request attribution.\n\nIf your report reveals active exploitation or widespread risk, we may accelerate timelines and/or release a temporary mitigation.\n\n---\n\n## In Scope\n\nBecause Paleae is a local CLI that **reads files and writes snapshots**:\n- Path traversal or file read beyond the selected scope (e.g., bypassing includes/excludes/.paleaeignore)\n- Determinism or hashing flaws that could **silently** corrupt or misrepresent snapshot contents\n- Logic that causes **unexpected network activity** (none should exist)\n- Unsanitized execution of external inputs (none should exist)\n- Resource exhaustion that leads to **unbounded memory/CPU** usage despite caps\n\n---\n\n## Out of Scope\n\n- General usability issues, performance tuning, or feature requests (please open a normal issue/PR)\n- Impacts that require users to ignore documented flags, bypass `.paleaeignore`, or modify the code\n- Scenarios that rely on malicious modification of the Paleae script **after** download (supply chain is handled by release integrity below)\n\n---\n\n## Handling Sensitive Data in Snapshots\n\nPaleae intentionally **does not upload or transmit** data. Users are responsible for:\n- Adding patterns to `.paleaeignore` (supports `!negation` to re-include)\n- Verifying output before sharing snapshots publicly\n\nIf your report concerns accidental capture of secrets with default profiles, include a minimal example and we will consider safer defaults.\n\n---\n\n## Release Integrity & Verification\n\nTo reduce supply-chain risk:\n- Always download from the official GitHub releases or repo.\n- Verify the **SHA-256** of `paleae.py` against the value posted in the release notes (when provided).\n- Avoid third-party mirrors.\n\n---\n\n## Development & Dependencies\n\n- Single file, Python standard library only (no runtime dependencies).\n- No telemetry; no auto-update; no network calls.\n- Deterministic traversal and hashing intended for reproducibility.\n\nIf you discover behavior that contradicts the above guarantees, please report it as a security issue.\n\n---\n\n## Responsible Research\n\nWe appreciate good-faith testing that avoids disrupting others. Please do not publicly disclose details before a fix is available. \nWe are happy to discuss embargo timing if needed.\n\n---\n\n## Contact & Keys\n\n- Security contact: **<paulctiffany@gmail.com>**\n- PGP key (optional): publish a fingerprint here if you require encrypted reports.\n",
      "size_chars": 5143,
      "sha256": "8b85422d1236dec8fbcf74fb8e1dec8c7057546030010962650a64b772d65848",
      "estimated_tokens": 1285
    },
    {
      "path": "cosmic-ray.toml",
      "content": "[cosmic-ray]\nmodule-path = \"paleae\"\ntest-command = \"pytest\"\ntimeout = 30.0\n\n[cosmic-ray.distributor]\nname = \"local\"\n",
      "size_chars": 116,
      "sha256": "8d9299bfef0c18f7548ffeae6c79b493893c57f83156bf1605864dd5de713035",
      "estimated_tokens": 29
    },
    {
      "path": "cr.toml",
      "content": "[cosmic-ray]\n# Mutate ONLY the importable module \"paleae\" (i.e., paleae.py at repo root)\nmodule = \"paleae\"\nmodule-path = \".\"\ntimeout = 10.0\n\n# Never mutate tests or docs\nexcluded-modules = [\"tests/*\", \"docs/*\"]\n\n# Use a lighter Hypothesis profile for mutation runs and fail fast on first failing test\n# (Windows syntax). If you're on macOS/Linux, see the comment below.\ntest-command = \"cmd /c \\\"set HYPOTHESIS_PROFILE=mutation && pytest -q --maxfail=1 --no-header --no-summary -p no:warnings\\\"\"\n\n# On macOS/Linux, swap the line above for:\n# test-command = \"HYPOTHESIS_PROFILE=mutation pytest -q --maxfail=1 --no-header --no-summary -p no:warnings\"\n\n[execution]\nengine = \"local\"\n\n[cosmic-ray.distributor]\nname = \"local\"",
      "size_chars": 718,
      "sha256": "3336aae81fb138a301ab27e0cfd0c020f33143a0b6db975053329f3d91eaf53c",
      "estimated_tokens": 179
    },
    {
      "path": "paleae.egg-info/PKG-INFO",
      "content": "Metadata-Version: 2.4\nName: paleae\nVersion: 1.2.0\nSummary: Lightweight snapshot tool for codebases. Harvest → Husk → Seed AI.\nAuthor: Paul Tiffany\nLicense: MIT\nProject-URL: Homepage, https://paleae.com\nProject-URL: Repository, https://github.com/PaulTiffany/paleae\nProject-URL: Issues, https://github.com/PaulTiffany/paleae/issues\nProject-URL: Documentation, https://paleae.com\nKeywords: snapshot,LLM,AI,JSON,repository,developer-tools,metadata,packaging,utilities\nClassifier: Development Status :: 4 - Beta\nClassifier: Environment :: Console\nClassifier: Intended Audience :: Developers\nClassifier: License :: OSI Approved :: MIT License\nClassifier: Operating System :: OS Independent\nClassifier: Programming Language :: Python :: 3\nClassifier: Programming Language :: Python :: 3.9\nClassifier: Programming Language :: Python :: 3.10\nClassifier: Programming Language :: Python :: 3.11\nClassifier: Programming Language :: Python :: 3.12\nClassifier: Programming Language :: Python :: 3.13\nClassifier: Topic :: Software Development :: Build Tools\nClassifier: Topic :: Utilities\nRequires-Python: >=3.9\nDescription-Content-Type: text/markdown\nLicense-File: LICENSE\nProvides-Extra: dev\nRequires-Dist: pytest>=8; extra == \"dev\"\nRequires-Dist: mypy>=1.10; extra == \"dev\"\nRequires-Dist: ruff>=0.5; extra == \"dev\"\nRequires-Dist: hypothesis>=6; extra == \"dev\"\nRequires-Dist: pydocstyle>=6.3; extra == \"dev\"\nRequires-Dist: cosmic-ray>=8; extra == \"dev\"\nRequires-Dist: build>=1.2.1; extra == \"dev\"\nRequires-Dist: twine>=5.1.1; extra == \"dev\"\nRequires-Dist: sphinx>=7.0; extra == \"dev\"\nRequires-Dist: myst-parser>=2.0; extra == \"dev\"\nRequires-Dist: sphinxcontrib-mermaid; extra == \"dev\"\nDynamic: license-file\n\n<p align=\"center\">\n  <picture>\n    <source media=\"(prefers-color-scheme: dark)\" srcset=\"./assets/paleae-badge-dark.svg\">\n    <img alt=\"Paleae — Ship your repo to your AI\" src=\"./assets/paleae-badge-light.svg\" width=\"230\">\n  </picture>\n</p>\n\n<p align=\"center\">\n  <strong>Snapshot your codebase into compact JSON/JSONL — perfect for LLMs.</strong>\n  <br>\n  Single file. Zero dependencies. No install.\n</p>\n\n<p align=\"center\">\n  <a href=\"https://github.com/PaulTiffany/paleae/actions/workflows/ci.yml\">\n    <img src=\"https://github.com/PaulTiffany/paleae/actions/workflows/ci.yml/badge.svg\" alt=\"CI Status\">\n  </a>\n  <a href=\"https://pypi.org/project/paleae/\">\n    <img src=\"https://img.shields.io/pypi/v/paleae.svg?color=5EE1A0&label=pypi%20package\" alt=\"PyPI version\">\n  </a>\n  <a href=\"https://pypi.org/project/paleae/\">\n    <img src=\"https://img.shields.io/pypi/pyversions/paleae.svg\" alt=\"Python versions\">\n  </a>\n  <a href=\"./LICENSE\">\n    <img src=\"https://img.shields.io/badge/license-MIT-informational.svg\" alt=\"MIT License\">\n  </a>\n</p>\n\n---\n\n`paleae` is a single-file, zero-dependency utility that scans your repository and creates a structured snapshot optimized for AI analysis. It's designed to be simple, transparent, and trustworthy.\n\n## Key Features\n\n*   **Single File, Zero Deps:** Drop `paleae.py` into any project. It runs anywhere Python runs, with no `pip install` required.\n*   **Local-First:** Scans files on your machine. No code is ever sent over the network.\n*   **Structured Output:** Generates clean `JSON` or `JSONL`, including file paths, content, and SHA-256 hashes.\n*   **Configurable:** Use powerful include/exclude regex patterns and a `.paleaeignore` file (with `!` negation) to precisely control what gets included.\n*   **Rigorously Tested:** 100% line and branch coverage, fully type-checked with MyPy, linted with Ruff, and hardened with Hypothesis property-based tests and `pydocstyle` compliance.\n\n## Quick Start\n\nNo installation needed. Just download and run.\n\n```bash\n# Download the script\ncurl -fsSL https://raw.githubusercontent.com/PaulTiffany/paleae/main/paleae.py -o paleae.py\n\n# Snapshot the current directory\npython paleae.py\n```\n\nThis will create a `repo_snapshot.json` file in your current directory.\n\n## Contributing\n\nWe welcome contributions! If you're interested in helping improve Paleae, please read our comprehensive [Contributing Guide](./CONTRIBUTING.md) for details on setting up your development environment, running tests, and submitting pull requests.\n\n## Usage\n\n```\nusage: paleae [-h] [-o OUT] [-f {json,jsonl}] [--profile {minimal,ai_optimized}]\n              [--include INCLUDE] [--exclude EXCLUDE] [--version] [--about]\n              [directory]\n\nCreate JSON/JSONL snapshot of your repo for LLMs\n\npositional arguments:\n  directory             Directory to snapshot (default: .)\n\noptions:\n  -h, --help            show this help message and exit\n  -o, --out OUT         Output file (auto-named if not specified)\n  -f, --format {json,jsonl}\n                        Output format\n  --profile {minimal,ai_optimized}\n                        File inclusion profile\n  --include INCLUDE     Extra include regex (repeatable)\n  --exclude EXCLUDE     Extra exclude regex (repeatable)\n  --version             show program's version number and exit\n  --about               Show project info and exit\n```\n\n### Examples\n\n**Snapshot to a specific JSONL file:**\n```bash\npython paleae.py -f jsonl -o my_project.jsonl\n```\n\n**Use the `ai_optimized` profile to include only core source and config files:**\n```bash\npython paleae.py --profile ai_optimized\n```\n\n**Add a specific directory to the snapshot using a regex:**\n```bash\npython paleae.py --include \"^(docs|examples)/\"\n```\n\n## Configuration (`.paleaeignore`)\n\nCreate a `.paleaeignore` file in your project's root directory to exclude files and directories. The syntax is similar to `.gitignore`.\n\n```\n# .paleaeignore\n\n# Ignore build artifacts and logs\nbuild/\ndist/\n*.log\n\n# But force-include an important log file\n!important.log\n```\n\n## Output Format\n\nThe snapshot contains metadata and a list of file objects.\n\n```json\n{\n  \"meta\": {\n    \"tool\": \"paleae\",\n    \"version\": \"1.2.0\",\n    \"timestamp\": \"2025-09-16T20:00:00Z\",\n    \"root_directory\": \"/path/to/your/project\",\n    \"summary\": {\n      \"total_files\": 42,\n      \"total_chars\": 123456,\n      \"estimated_tokens\": 30864\n    }\n  },\n  \"files\": [\n    {\n      \"path\": \"src/main.py\",\n      \"content\": \"print('hello')\",\n      \"size_chars\": 14,\n      \"sha256\": \"b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9\",\n      \"estimated_tokens\": 3\n    }\n  ]\n}\n```\n\n## License\n\nThis project is licensed under the [MIT License](./LICENSE).\n\nThe brand assets (`assets/*.svg`) are dedicated to the public domain under [CC0 1.0 Universal](./assets/LICENSE.txt).\n",
      "size_chars": 6504,
      "sha256": "0472adbcf8f5800767a4af7e868a855b151158a891c97bfbb6c87ba580b69efd",
      "estimated_tokens": 1626
    },
    {
      "path": "paleae.egg-info/SOURCES.txt",
      "content": "LICENSE\nREADME.md\npaleae.py\npyproject.toml\npaleae.egg-info/PKG-INFO\npaleae.egg-info/SOURCES.txt\npaleae.egg-info/dependency_links.txt\npaleae.egg-info/entry_points.txt\npaleae.egg-info/requires.txt\npaleae.egg-info/top_level.txt\ntests/test_paleae.py",
      "size_chars": 245,
      "sha256": "a8ea59cff7a53c848af5c1bc9ebddc73bdba0965df928590c10cdaaf98e1fa96",
      "estimated_tokens": 61
    },
    {
      "path": "paleae.egg-info/entry_points.txt",
      "content": "[console_scripts]\npaleae = paleae:cli_entrypoint\n",
      "size_chars": 49,
      "sha256": "33157084de302622bf19f0f7b934270af2e4b069da0fcb0c989ce6e95f06150f",
      "estimated_tokens": 12
    },
    {
      "path": "paleae.egg-info/requires.txt",
      "content": "\n[dev]\npytest>=8\nmypy>=1.10\nruff>=0.5\nhypothesis>=6\npydocstyle>=6.3\ncosmic-ray>=8\nbuild>=1.2.1\ntwine>=5.1.1\nsphinx>=7.0\nmyst-parser>=2.0\nsphinxcontrib-mermaid\n",
      "size_chars": 159,
      "sha256": "52fc645e2f3931e59913b327ee3679509636a5e22010e0d3686c16c03e5a9bd9",
      "estimated_tokens": 39
    },
    {
      "path": "paleae.egg-info/top_level.txt",
      "content": "paleae\n",
      "size_chars": 7,
      "sha256": "0bd9b9fb64410b8ce10609102e93ee64cca3dbd9bd0472dc41ecbedbea31f59d",
      "estimated_tokens": 1
    },
    {
      "path": "paleae.py",
      "content": "#!/usr/bin/env python3\n# SPDX-License-Identifier: MIT\n# Copyright (c) 2025 Paul Tiffany\n# Project: paleae - Snapshot your repo for LLMs\n# Website: https://paleae.com\n# Source:  https://github.com/PaulTiffany/paleae\n\n\"\"\"\npaleae - Create JSON/JSONL snapshots of your repository for LLMs.\n\nA single-file, zero-dependency tool that scans your codebase and creates\nstructured snapshots optimized for AI analysis and processing.\n\"\"\"\n\nimport argparse\nimport fnmatch\nimport hashlib\nimport json\nimport re\nimport sys\nimport time\nfrom pathlib import Path\nfrom typing import Any, Optional\n\n# Project metadata (also embedded in output)\n__version__ = \"1.0.0\"\n__license__ = \"MIT\"\n__website__ = \"https://paleae.com\"\n__source__ = \"https://github.com/PaulTiffany/paleae\"\n\n# --- Configuration ---\nMAX_SIZE = 10 * 1024 * 1024  # 10MB\nPALEAEIGNORE = \".paleaeignore\"\n\nTEXT_EXTS = {\n    \".py\",\n    \".md\",\n    \".rst\",\n    \".txt\",\n    \".json\",\n    \".yaml\",\n    \".yml\",\n    \".toml\",\n    \".ini\",\n    \".cfg\",\n    \".xml\",\n    \".csv\",\n    \".tsv\",\n    \".html\",\n    \".css\",\n    \".js\",\n    \".ts\",\n    \".tsx\",\n    \".c\",\n    \".h\",\n    \".cpp\",\n    \".hpp\",\n    \".java\",\n    \".kt\",\n    \".go\",\n    \".rs\",\n    \".rb\",\n    \".php\",\n    \".sh\",\n    \".ps1\",\n}\n\nDEFAULT_SKIP = [\n    r\"(^|/)\\.(git|hg|svn)($|/)\",\n    r\"(^|/)__pycache__($|/)\",\n    r\"(^|/)\\.(pytest|mypy|ruff)_cache($|/)\",\n    r\"(^|/)(\\.?venv|env)($|/)\",\n    r\"(^|/)node_modules($|/)\",\n    r\"(^|/)(build|dist)($|/)\",\n    r\"(^|/)coverage($|/)\",\n    r\"(^|/)htmlcov($|/)\",\n    r\"(^|/)\\.coverage($|/)?\",\n    r\"(^|/)\\.env($|/)\",\n    r\"(^|/)\" + re.escape(PALEAEIGNORE) + r\"($|/)?\",  # Ignore our own config file\n]\n\nPROFILES = {\n    \"minimal\": {\"include\": [r\".*\"], \"exclude\": DEFAULT_SKIP},\n    \"ai_optimized\": {\n        \"include\": [\n            r\"^(src|tests)(/.*)?$\",\n            r\"^pyproject\\.toml$\",\n            r\"^README(\\.md|\\.rst)?$\",\n            r\"^(ROADMAP|CHANGELOG)\\.md$\",\n        ],\n        \"exclude\": DEFAULT_SKIP + [r\"(^|/)docs/\"],\n    },\n}\n\n# --- Core Logic ---\n\n\nclass PaleaeError(Exception):\n    \"\"\"Base exception for paleae operations.\"\"\"\n\n\ndef token_estimate(text: str) -> int:\n    \"\"\"Estimate tokens using 4-char heuristic.\"\"\"\n    return max(1, len(text) // 4) if text else 0\n\n\ndef is_text_file(path: Path) -> bool:\n    \"\"\"Check if file should be treated as text.\"\"\"\n    if not path.is_file():\n        return False\n    try:\n        size = path.stat().st_size\n        if size == 0:\n            return path.suffix.lower() in TEXT_EXTS or path.suffix == \"\"\n        if size > MAX_SIZE:\n            return False\n        with path.open(\"rb\") as f:\n            chunk = f.read(min(1024, size))\n        if b\"\\x00\" in chunk:\n            return False\n        chunk.decode(\"utf-8\")\n        return True\n    except (OSError, UnicodeDecodeError, PermissionError):\n        return False\n\n\ndef _translate_globs_to_regex(globs: list[str]) -> list[str]:\n    \"\"\"Translate shell globs to regex strings with normalization.\"\"\"\n    regex_list: list[str] = []\n    for glob_pattern in globs:\n        line = glob_pattern.strip()\n        if not line or line.startswith(\"#\"):\n            continue\n        # fnmatch.translate handles **, *, ?, and char classes\n        regex_list.append(fnmatch.translate(line))\n    return regex_list\n\n\ndef read_paleaeignore(root: Path) -> tuple[list[str], list[str]]:\n    \"\"\"Return (positive_globs, negative_globs) from .paleaeignore.\"\"\"\n    pos: list[str] = []\n    neg: list[str] = []\n    path = root / PALEAEIGNORE\n    if not path.is_file():\n        return pos, neg\n    try:\n        lines = path.read_text(encoding=\"utf-8\", errors=\"ignore\").splitlines()\n        for line_item in lines:\n            line = line_item.strip()\n            if not line or line.startswith(\"#\"):\n                continue\n            if line.startswith(\"!\"):\n                neg.append(line[1:].strip())\n            else:\n                pos.append(line)\n    except (OSError, PermissionError):\n        print(f\"Warning: Could not read {PALEAEIGNORE}\", file=sys.stderr)\n    return pos, neg\n\n\ndef compile_patterns(patterns: Optional[list[str]]) -> list[re.Pattern[str]]:\n    \"\"\"Compile regex patterns with error handling.\"\"\"\n    if not patterns:\n        return []\n    compiled = []\n    for pattern in patterns:\n        try:\n            compiled.append(re.compile(pattern))\n        except re.error as e:\n            raise PaleaeError(f\"Invalid regex '{pattern}': {e}\") from e\n    return compiled\n\n\ndef matches_any(text: str, patterns: list[re.Pattern[str]]) -> bool:\n    \"\"\"Check if text matches any pattern.\"\"\"\n    return any(p.search(text) for p in patterns)\n\n\ndef collect_files(\n    root: Path,\n    inc_patterns: list[re.Pattern[str]],\n    exc_patterns: list[re.Pattern[str]],\n    ign_pos_patterns: list[re.Pattern[str]],\n    ign_neg_patterns: list[re.Pattern[str]],\n) -> list[str]:\n    \"\"\"Collect files matching all filter criteria.\"\"\"\n    if not root.is_dir():\n        raise PaleaeError(f\"Directory not found: {root}\")\n\n    files = []\n    try:\n        for path in root.rglob(\"*\"):\n            if not path.is_file():\n                continue\n            try:\n                rel_path = path.relative_to(root).as_posix()\n            except ValueError:\n                continue\n\n            # Step 1: Check if the path is excluded by default, CLI, or .paleaeignore\n            is_excluded = matches_any(rel_path, exc_patterns) or matches_any(\n                rel_path, ign_pos_patterns\n            )\n\n            # Step 2: A negative pattern (!) in .paleaeignore overrides any exclusion\n            if is_excluded and matches_any(rel_path, ign_neg_patterns):\n                is_excluded = False\n\n            if is_excluded:\n                continue\n\n            # Step 3: Check if the path meets the inclusion criteria\n            if inc_patterns and not matches_any(rel_path, inc_patterns):\n                continue\n\n            if is_text_file(path):\n                files.append(rel_path)\n    except (OSError, PermissionError) as e:\n        raise PaleaeError(f\"Error traversing {root}: {e}\") from e\n    return sorted(files)\n\n\ndef build_snapshot(root: Path, rel_files: list[str], ignore_meta: dict[str, Any]) -> dict[str, Any]:\n    \"\"\"Build complete snapshot data, including metadata.\"\"\"\n    files_data, total_chars, total_tokens = [], 0, 0\n    for rel_path in rel_files:\n        full_path = root / rel_path\n        try:\n            content = full_path.read_text(encoding=\"utf-8\", errors=\"ignore\")\n            if not content.strip():\n                continue\n        except (OSError, PermissionError, UnicodeDecodeError):\n            continue\n\n        chars = len(content)\n        tokens = token_estimate(content)\n        files_data.append(\n            {\n                \"path\": rel_path,\n                \"content\": content,\n                \"size_chars\": chars,\n                \"sha256\": hashlib.sha256(content.encode(\"utf-8\", errors=\"ignore\")).hexdigest(),\n                \"estimated_tokens\": tokens,\n            }\n        )\n        total_chars += chars\n        total_tokens += tokens\n\n    return {\n        \"meta\": {\n            \"tool\": \"paleae\",\n            \"version\": __version__,\n            \"license\": __license__,\n            \"website\": __website__,\n            \"source\": __source__,\n            \"timestamp\": time.strftime(\"%Y-%m-%dT%H:%M:%SZ\", time.gmtime()),\n            \"root_directory\": str(root),\n            \"ignore_file\": ignore_meta,\n            \"summary\": {\n                \"total_files\": len(files_data),\n                \"total_chars\": total_chars,\n                \"estimated_tokens\": total_tokens,\n            },\n        },\n        \"files\": files_data,\n    }\n\n\ndef write_output(path: Path, data: dict[str, Any], format: str) -> None:\n    \"\"\"Write data as JSON or JSONL file.\"\"\"\n    try:\n        path.parent.mkdir(parents=True, exist_ok=True)\n        if format == \"json\":\n            content = json.dumps(data, indent=2, ensure_ascii=False)\n            path.write_text(content, encoding=\"utf-8\")\n        else:  # jsonl\n            with path.open(\"w\", encoding=\"utf-8\") as f:\n                f.write(json.dumps({\"type\": \"meta\", **data[\"meta\"]}, ensure_ascii=False) + \"\\n\")\n                for row in data[\"files\"]:\n                    f.write(json.dumps({\"type\": \"file\", **row}, ensure_ascii=False) + \"\\n\")\n    except (OSError, PermissionError) as e:\n        raise PaleaeError(f\"Error writing {path}: {e}\") from e\n\n\n# --- CLI and Main Execution ---\n\n\ndef create_parser() -> argparse.ArgumentParser:\n    \"\"\"Create CLI argument parser.\"\"\"\n    parser = argparse.ArgumentParser(description=\"Create JSON/JSONL snapshot of your repo for LLMs\")\n    parser.add_argument(\n        \"directory\", nargs=\"?\", default=\".\", help=\"Directory to snapshot (default: .)\"\n    )\n    parser.add_argument(\"-o\", \"--out\", help=\"Output file (auto-named if not specified)\")\n    parser.add_argument(\n        \"-f\", \"--format\", choices=[\"json\", \"jsonl\"], default=\"json\", help=\"Output format\"\n    )\n    parser.add_argument(\n        \"--profile\", choices=list(PROFILES.keys()), default=\"minimal\", help=\"File inclusion profile\"\n    )\n    parser.add_argument(\"--include\", action=\"append\", help=\"Extra include regex (repeatable)\")\n    parser.add_argument(\"--exclude\", action=\"append\", help=\"Extra exclude regex (repeatable)\")\n    parser.add_argument(\"--version\", action=\"version\", version=f\"paleae {__version__}\")\n    parser.add_argument(\"--about\", action=\"store_true\", help=\"Show project info and exit\")\n    return parser\n\n\ndef main() -> int:  # noqa: PLR0911\n    \"\"\"Run the main entry point.\"\"\"\n    parser = create_parser()\n    args = parser.parse_args()\n\n    if args.about:\n        print(\n            f\"paleae {__version__} ({__license__})\\nWebsite: {__website__}\\nSource:  {__source__}\"\n        )\n        return 0\n\n    try:\n        # --- Setup ---\n        root = Path(args.directory).resolve()\n        if not root.is_dir():\n            print(f\"Error: '{args.directory}' is not a directory\", file=sys.stderr)\n            return 1\n\n        # --- Pattern Compilation ---\n        profile = PROFILES.get(args.profile, PROFILES[\"minimal\"])\n        inc_cli = compile_patterns((args.include or []) + profile[\"include\"])\n        exc_cli = compile_patterns((args.exclude or []) + profile[\"exclude\"])\n\n        pos_globs, neg_globs = read_paleaeignore(root)\n        ign_pos_rx = compile_patterns(_translate_globs_to_regex(pos_globs))\n        ign_neg_rx = compile_patterns(_translate_globs_to_regex(neg_globs))\n        ignore_meta = {\n            \"file\": PALEAEIGNORE,\n            \"present\": bool(pos_globs or neg_globs),\n            \"patterns\": len(pos_globs),\n            \"negations\": len(neg_globs),\n        }\n\n        # --- File Collection ---\n        files = collect_files(root, inc_cli, exc_cli, ign_pos_rx, ign_neg_rx)\n        if not files:\n            print(\"No text files found matching criteria.\", file=sys.stderr)\n            return 1\n\n        # --- Snapshot Generation & Output ---\n        data = build_snapshot(root, files, ignore_meta)\n        out_path = Path(args.out) if args.out else Path(f\"repo_snapshot.{args.format}\")\n        write_output(out_path, data, args.format)\n\n        # --- Summary ---\n        s = data[\"meta\"][\"summary\"]\n        print(f\"✓ Snapshot saved to {out_path}\")\n        print(\n            f\"  Files: {s['total_files']}  \"\n            f\"Characters: {s['total_chars']:,}  \"\n            f\"Tokens: {s['estimated_tokens']:,}\"\n        )\n        return 0\n\n    except PaleaeError as e:\n        print(f\"Error: {e}\", file=sys.stderr)\n        return 1\n    except KeyboardInterrupt:\n        print(\"\\nCancelled by user\", file=sys.stderr)\n        return 1\n    except Exception as e:\n        print(f\"Unexpected error: {e}\", file=sys.stderr)\n        return 1\n\n\ndef cli_entrypoint() -> None:\n    \"\"\"Console entry point (kept tiny so tests can patch sys.exit).\"\"\"\n    sys.exit(main())\n\n\nif __name__ == \"__main__\":\n    cli_entrypoint()\n",
      "size_chars": 11833,
      "sha256": "791a58139ccde003b8ca957dfcf5cde63859c532243b0e7cbcd3732a4a57ca03",
      "estimated_tokens": 2958
    },
    {
      "path": "pyproject.toml",
      "content": "[build-system]\nrequires = [\"setuptools>=69\", \"wheel\"]\nbuild-backend = \"setuptools.build_meta\"\n\n[project]\nname = \"paleae\"\ndynamic = [\"version\"]\ndescription = \"Lightweight snapshot tool for codebases. Harvest → Husk → Seed AI.\"\nreadme = \"README.md\"\nrequires-python = \">=3.9\"\nlicense = { text = \"MIT\" }\nauthors = [{ name = \"Paul Tiffany\" }]\nkeywords = [\n  \"ai\",\n  \"llm\",\n  \"rag\",\n  \"snapshot\",\n  \"codebase\",\n  \"repository\",\n  \"json\",\n  \"jsonl\",\n  \"context-window\",\n  \"prompt-engineering\",\n  \"fine-tuning\",\n  \"code-analysis\",\n  \"developer-tools\",\n  \"utilities\",\n]\nclassifiers = [\n  \"Development Status :: 5 - Production/Stable\",\n  \"Environment :: Console\",\n  \"Intended Audience :: Developers\",\n  \"License :: OSI Approved :: MIT License\",\n  \"Operating System :: OS Independent\",\n  \"Programming Language :: Python :: 3\",\n  \"Programming Language :: Python :: 3.9\",\n  \"Programming Language :: Python :: 3.10\",\n  \"Programming Language :: Python :: 3.11\",\n  \"Programming Language :: Python :: 3.12\",\n  \"Programming Language :: Python :: 3.13\",\n  \"Topic :: Software Development :: Build Tools\",\n  \"Topic :: Utilities\"\n]\n# Paleae is zero-dependency at runtime; declare when/if that changes.\ndependencies = []\n\n[project.urls]\nHomepage = \"https://paleae.com\"\nRepository = \"https://github.com/PaulTiffany/paleae\"\nIssues = \"https://github.com/PaulTiffany/paleae/issues\"\nDocumentation = \"https://paleae.com\"\n\n# Console script wired to the single-file module's CLI entrypoint.\n[project.scripts]\npaleae = \"paleae:cli_entrypoint\"\n\n# Single-module layout (picks up paleae.py)\n[tool.setuptools]\npy-modules = [\"paleae\"]\n\n# Keep version single-sourced from paleae.__version__\n[tool.setuptools.dynamic]\nversion = \"1.0.0\"\n\n# Dev toolchain for CI and local hacking\n[project.optional-dependencies]\ndev = [\n  \"pytest>=8\",\n  \"mypy>=1.10\",\n  \"ruff>=0.5\",\n  \"hypothesis>=6\",\n  \"pydocstyle>=6.3\",\n  \"cosmic-ray>=8\",\n  \"build>=1.2.1\",\n  \"twine>=5.1.1\",\n  \"sphinx>=7.0\",\n  \"myst-parser>=2.0\",\n  \"sphinxcontrib-mermaid\"\n]",
      "size_chars": 1985,
      "sha256": "1fd194c5a6d5066b811508781725187dc632e3214cff928dda55b035118a8714",
      "estimated_tokens": 496
    },
    {
      "path": "tests/conftest.py",
      "content": "import os\n\nfrom hypothesis import HealthCheck, settings\n\n# Strict CI profile: heavy exploration for regression/CI\nsettings.register_profile(\n    \"ci\",\n    max_examples=200,\n    deadline=200,\n    suppress_health_check=[HealthCheck.too_slow],\n    derandomize=False,\n    print_blob=True,\n)\n\n# Light profile for mutation testing: faster per-mutant; still meaningful\nsettings.register_profile(\n    \"mutation\",\n    max_examples=25,          # 25–50 is a good band; raise if needed\n    deadline=100,\n    suppress_health_check=[HealthCheck.too_slow],\n    derandomize=True,         # stable example sequence for reproducibility\n)\n\n# Default to CI unless caller overrides with HYPOTHESIS_PROFILE\nsettings.load_profile(os.getenv(\"HYPOTHESIS_PROFILE\", \"ci\"))",
      "size_chars": 746,
      "sha256": "dbb87bb1cf77f009ef0f3939e22427c8b81bf72a8ccc1d418a9938884f0a6e8d",
      "estimated_tokens": 186
    },
    {
      "path": "tests/test_paleae.py",
      "content": "# SPDX-License-Identifier: MIT\n# Copyright (c) 2025 Paul Tiffany\n# Project: paleae - Snapshot your repo for LLMs\n\n\"\"\"\nUnit and property-based tests for paleae.py.\n\nThis test suite ensures the reliability and determinism of paleae, a tool designed\nto create clean, structured, and AI-optimized snapshots of code repositories. The\ntests cover everything from file parsing and filtering to the integrity of the final\nJSON/JSONL output.\n\nThe core principle tested here is that paleae must be a trustworthy preprocessor\nfor AI analysis. A high-quality, predictable snapshot is the foundation for any\nmeaningful interaction between a Large Language Model and a codebase. These tests\nvalidate that foundation.\n\"\"\"\n\nimport argparse\nimport fnmatch\nimport importlib.util\nimport json\nimport re\nimport runpy\nimport subprocess\nimport sys\nfrom pathlib import Path\nfrom unittest.mock import patch\n\nimport pytest\nfrom hypothesis import HealthCheck, given, settings\nfrom hypothesis import strategies as st\n\n\ndef load_paleae_module():\n    \"\"\"Load the paleae.py script as a module.\"\"\"\n    script_path = Path(__file__).parent.parent / \"paleae.py\"\n    spec = importlib.util.spec_from_file_location(\"paleae\", script_path)\n    if not (spec and spec.loader):\n        raise ImportError(f\"Could not load spec for module paleae from {script_path}\")\n    paleae = importlib.util.module_from_spec(spec)\n    spec.loader.exec_module(paleae)\n    sys.modules[\"paleae\"] = paleae\n    return paleae\n\n\npaleae = load_paleae_module()\n\n\n# --- Fixtures ---\n\n\n@pytest.fixture\ndef temp_repo(tmp_path: Path):\n    \"\"\"Create a temporary directory structure for testing.\"\"\"\n    repo = tmp_path / \"repo\"\n    repo.mkdir()\n    (repo / \"src\").mkdir()\n    (repo / \"tests\").mkdir()\n    (repo / \".git\").mkdir()\n    (repo / \"venv\").mkdir()\n    (repo / \"__pycache__\").mkdir()\n    (repo / \".paleaeignore\").write_text(\n        \"\"\"# Ignore logs\n*.log\n\n!important.log\ndist/\n\"\"\"\n    )\n    (repo / \"src\" / \"main.py\").write_text(\"print('hello')\")\n    (repo / \"src\" / \"utils.py\").write_text(\"def helper(): pass\")\n    (repo / \"README.md\").write_text(\"# My Project\")\n    (repo / \"data.bin\").write_bytes(b\"\\x00\\x01\\x02\")\n    (repo / \"empty.txt\").touch()\n    (repo / \"app.log\").write_text(\"Log entry\")\n    (repo / \"important.log\").write_text(\"Important log\")\n    (repo / \"dist\").mkdir()\n    (repo / \"dist\" / \"package.tar.gz\").touch()\n    (repo / \"tests\" / \"test_main.py\").write_text(\"assert True\")\n\n    # Create a file with unicode errors\n    (repo / \"bad_encoding.txt\").write_bytes(b\"\\xff\\xfe\")\n\n    # Create a file that is too large\n    large_file = repo / \"large_file.txt\"\n    with large_file.open(\"wb\") as f:\n        f.seek(paleae.MAX_SIZE + 1)\n        f.write(b\"\\0\")\n\n    return repo\n\n\n# --- Unit Tests for Core Logic ---\n\n\ndef test_importer_failure():\n    \"\"\"Test the script importer fails gracefully.\"\"\"\n    with patch(\"importlib.util.spec_from_file_location\", return_value=None):\n        with pytest.raises(ImportError):\n            load_paleae_module()\n\n\ndef test_token_estimate():\n    assert paleae.token_estimate(\"\") == 0\n    assert paleae.token_estimate(\"a\") == 1\n    assert paleae.token_estimate(\"abc\") == 1\n    assert paleae.token_estimate(\"abcd\") == 1\n    assert paleae.token_estimate(\"abcde\") == 1\n    long_text = \"long text for estimation\"\n    assert paleae.token_estimate(long_text) == len(long_text) // 4\n    assert paleae.token_estimate(None) == 0\n\n\n@given(st.text())\ndef test_token_estimate_hypothesis(s):\n    \"\"\"Property-based test for token_estimate.\"\"\"\n    estimate = paleae.token_estimate(s)\n    assert isinstance(estimate, int)\n    assert estimate >= 0\n    if s:\n        assert estimate > 0\n        assert estimate >= len(s) // 4\n    else:\n        assert estimate == 0\n\n\ndef test_is_text_file(temp_repo):\n    assert paleae.is_text_file(temp_repo / \"src\" / \"main.py\") is True\n    assert paleae.is_text_file(temp_repo / \"README.md\") is True\n    assert paleae.is_text_file(temp_repo / \"data.bin\") is False\n    assert paleae.is_text_file(temp_repo / \"empty.txt\") is True\n    (temp_repo / \"empty_no_ext\").touch()\n    assert paleae.is_text_file(temp_repo / \"empty_no_ext\") is True\n    assert paleae.is_text_file(temp_repo / \"non_existent_file.txt\") is False\n    assert paleae.is_text_file(temp_repo / \"bad_encoding.txt\") is False\n    assert paleae.is_text_file(temp_repo / \"large_file.txt\") is False\n    # Test a file with a non-text extension but text content\n    (temp_repo / \"custom.ext\").write_text(\"text content\")\n    assert paleae.is_text_file(temp_repo / \"custom.ext\") is True\n    # Test directory\n    assert paleae.is_text_file(temp_repo / \"src\") is False\n    # Test permission error on read\n    with patch.object(Path, \"open\", side_effect=PermissionError):\n        assert paleae.is_text_file(temp_repo / \"src\" / \"main.py\") is False\n\n\n# Strategy for content that is likely not UTF-8\ninvalid_utf8_content = st.text(min_size=1).map(lambda s: s.encode(\"utf-16\"))\n\n\n@settings(suppress_health_check=[HealthCheck.function_scoped_fixture])\n@given(content=invalid_utf8_content)\ndef test_is_text_file_invalid_utf8_hypothesis(tmp_path, content):\n    # Ensure we don't have null bytes, to isolate the unicode error\n    content = content.replace(b\"\\x00\", b\"\")\n    if not content:\n        return  # Skip if the content becomes empty after removing nulls\n\n    path = tmp_path / \"invalid_utf8.txt\"\n    path.write_bytes(content)\n\n    # is_text_file should return False because of UnicodeDecodeError\n    assert not paleae.is_text_file(path)\n\n\ndef test_translate_globs_to_regex():\n    globs = [\"*.py\", \"src/\", \"# comment\", \"\", \"data[0-9].bin\"]\n    expected = [\n        fnmatch.translate(\"*.py\"),\n        fnmatch.translate(\"src/\"),\n        fnmatch.translate(\"data[0-9].bin\"),\n    ]\n    assert paleae._translate_globs_to_regex(globs) == expected\n\n\n# Characters that have special meaning in globs but not always in regex\nst_glob_chars = st.sampled_from(\"*?[]!\")\n\n# Strategy for generating a simple glob pattern component\nst_glob_part = st.text(\n    st.characters(max_codepoint=127, blacklist_characters=\"*?[]!/\\\\\"),\n    min_size=1,\n)\n\n\n# Strategy for generating a full glob pattern\nst_glob_pattern = st.lists(st.one_of(st_glob_part, st_glob_chars), min_size=1, max_size=10).map(\n    \"\".join\n)\n\n\n@given(pattern=st_glob_pattern, text=st.text(max_size=100))\ndef test_translate_globs_to_regex_hypothesis(pattern, text):\n    \"\"\"Check that translated glob regex behaves like fnmatch.\"\"\"\n    # The core invariant: if fnmatch.fnmatch matches, so should the regex.\n    # Note: The reverse is not always true due to how fnmatch translates '**' etc.\n    # We are testing for basic consistency.\n    try:\n        regex_str = fnmatch.translate(pattern)\n        # On Windows, fnmatch is case-insensitive by default.\n        flags = re.IGNORECASE if sys.platform == \"win32\" else 0\n        compiled_regex = re.compile(regex_str, flags)\n\n        matches_glob = fnmatch.fnmatch(text, pattern)\n        matches_regex = compiled_regex.match(text) is not None\n\n        if matches_glob:\n            assert matches_regex, (\n                f\"Glob '{pattern}' matched '{text}', but regex '{regex_str}' did not.\"\n            )\n\n    except re.error:\n        # Some generated patterns might be invalid for fnmatch, which is fine.\n        # We are interested in the behavior of valid patterns.\n        pass\n\n\ndef test_read_paleaeignore(temp_repo):\n    pos, neg = paleae.read_paleaeignore(temp_repo)\n    assert pos == [\"*.log\", \"dist/\"]\n    assert neg == [\"important.log\"]\n\n\ndef test_read_paleaeignore_not_found(tmp_path):\n    pos, neg = paleae.read_paleaeignore(tmp_path)\n    assert pos == []\n    assert neg == []\n\n\ndef test_read_paleaeignore_permission_error(temp_repo, capsys):\n    with patch.object(Path, \"read_text\", side_effect=PermissionError(\"Permission denied\")):\n        pos, neg = paleae.read_paleaeignore(temp_repo)\n        assert pos == []\n        assert neg == []\n        captured = capsys.readouterr()\n        assert f\"Warning: Could not read {paleae.PALEAEIGNORE}\" in captured.err\n\n\n@settings(suppress_health_check=[HealthCheck.function_scoped_fixture])\n@given(\n    lines=st.lists(\n        st.one_of(\n            st.just(\"\"),  # Empty lines\n            st.just(\"# comment\"),  # Comments\n            st.just(\"!negated\"),  # Negated pattern\n            st.just(\"  ! spaced_negated  \"),  # Spaced negated\n            st.just(\"positive\"),  # Positive pattern\n            st.just(\"  spaced_positive  \"),  # Spaced positive\n        )\n    )\n)\ndef test_read_paleaeignore_hypothesis(tmp_path, lines):\n    \"\"\"Test parsing of .paleaeignore with varied content.\"\"\"\n    content = \"\\n\".join(lines)\n    ignore_file = tmp_path / paleae.PALEAEIGNORE\n    ignore_file.write_text(content)\n\n    pos, neg = paleae.read_paleaeignore(tmp_path)\n\n    expected_pos = []\n    expected_neg = []\n    for line in lines:\n        stripped = line.strip()\n        if not stripped or stripped.startswith(\"#\"):\n            continue\n        if stripped.startswith(\"!\"):\n            expected_neg.append(stripped[1:].strip())\n        else:\n            expected_pos.append(stripped)\n\n    assert sorted(pos) == sorted(expected_pos)\n    assert sorted(neg) == sorted(expected_neg)\n\n\ndef test_compile_patterns():\n    patterns = [\"^src/\", r\"\\.py$\"]\n    compiled = paleae.compile_patterns(patterns)\n    assert len(compiled) == len(patterns)\n    assert compiled[0].pattern == \"^src/\"\n    assert compiled[1].pattern == r\"\\.py$\"\n    assert paleae.compile_patterns(None) == []\n\n\ndef test_compile_patterns_invalid_regex():\n    with pytest.raises(paleae.PaleaeError, match=\"unterminated character set\"):\n        paleae.compile_patterns([\"[\"])\n\n\ndef test_matches_any():\n    patterns = [re.compile(r\"^src/\"), re.compile(r\"\\.md$\")]\n    assert paleae.matches_any(\"src/main.py\", patterns) is True\n    assert paleae.matches_any(\"README.md\", patterns) is True\n    assert paleae.matches_any(\"tests/test.py\", patterns) is False\n\n\n@given(\n    text=st.text(max_size=100),\n    patterns_str=st.lists(st.sampled_from([r\"^a\", r\"b$\", r\"c\\d\"]), min_size=0, max_size=5),\n)\ndef test_matches_any_hypothesis(text, patterns_str):\n    \"\"\"Test matches_any logic against a manual check.\"\"\"\n    patterns = [re.compile(p) for p in patterns_str]\n\n    result = paleae.matches_any(text, patterns)\n\n    manual_check = any(re.search(p, text) for p in patterns_str)\n\n    assert result == manual_check\n\n\n# --- Integration-like Tests for File Collection ---\n\n\ndef test_collect_files_default_skip(temp_repo):\n    all_files = [p.relative_to(temp_repo).as_posix() for p in temp_repo.rglob(\"*\") if p.is_file()]\n    exc_patterns = paleae.compile_patterns(paleae.DEFAULT_SKIP)\n    expected = [\n        f\n        for f in all_files\n        if not paleae.matches_any(f, exc_patterns) and paleae.is_text_file(temp_repo / f)\n    ]\n    files = paleae.collect_files(temp_repo, [], exc_patterns, [], [])\n    assert sorted(files) == sorted(expected)\n\n\ndef test_collect_files_with_paleaeignore(temp_repo):\n    pos_globs, neg_globs = paleae.read_paleaeignore(temp_repo)\n    ign_pos_rx = paleae.compile_patterns(paleae._translate_globs_to_regex(pos_globs))\n    ign_neg_rx = paleae.compile_patterns(paleae._translate_globs_to_regex(neg_globs))\n    files = paleae.collect_files(\n        temp_repo,\n        [],\n        paleae.compile_patterns(paleae.DEFAULT_SKIP),\n        ign_pos_rx,\n        ign_neg_rx,\n    )\n    assert \"app.log\" not in files\n    assert not any(f.startswith(\"dist/\") for f in files)\n    assert \"important.log\" in files\n    assert \"src/main.py\" in files\n\n\ndef test_collect_files_with_cli_include_exclude(temp_repo):\n    inc = paleae.compile_patterns([r\"^src/\"])\n    exc = paleae.compile_patterns([r\"\\.py$\"])\n    files = paleae.collect_files(temp_repo, inc, exc, [], [])\n    assert files == []\n    inc = paleae.compile_patterns([r\"^src/\"])\n    exc = paleae.compile_patterns([r\"utils\"])\n    files = paleae.collect_files(temp_repo, inc, exc, [], [])\n    assert files == [\"src/main.py\"]\n\n\ndef test_collect_files_non_existent_dir():\n    with pytest.raises(paleae.PaleaeError, match=\"Directory not found\"):\n        paleae.collect_files(Path(\"nonexistent\"), [], [], [], [])\n\n\ndef test_collect_files_permission_error(temp_repo):\n    with patch.object(Path, \"rglob\", side_effect=PermissionError(\"Access denied\")):\n        with pytest.raises(paleae.PaleaeError, match=\"Error traversing\"):\n            paleae.collect_files(temp_repo, [], [], [], [])\n\n\ndef test_collect_files_value_error_on_relative_to(temp_repo):\n    with patch.object(Path, \"relative_to\", side_effect=ValueError):\n        files = paleae.collect_files(temp_repo, [], [], [], [])\n        assert files is not None\n\n\n# --- Tests for Snapshot Building and Writing ---\n\n\ndef test_build_snapshot(temp_repo):\n    files = [\"src/main.py\", \"README.md\", \"non_existent.txt\"]\n    ignore_meta = {\"file\": \".paleaeignore\", \"present\": True, \"patterns\": 2, \"negations\": 1}\n    with patch(\"time.strftime\", return_value=\"2025-09-14T12:00:00Z\"):\n        data = paleae.build_snapshot(temp_repo, files, ignore_meta)\n\n    assert data[\"meta\"][\"tool\"] == \"paleae\"\n    assert data[\"meta\"][\"version\"] == paleae.__version__\n    assert data[\"meta\"][\"timestamp\"] == \"2025-09-14T12:00:00Z\"\n    assert data[\"meta\"][\"root_directory\"] == str(temp_repo)\n    assert data[\"meta\"][\"ignore_file\"] == ignore_meta\n\n    expected_file_count = 2\n    assert len(data[\"files\"]) == expected_file_count\n\n    main_py_data = next(f for f in data[\"files\"] if f[\"path\"] == \"src/main.py\")\n    readme_data = next(f for f in data[\"files\"] if f[\"path\"] == \"README.md\")\n    content = \"print('hello')\"\n    assert main_py_data[\"content\"] == content\n    assert main_py_data[\"size_chars\"] == len(content)\n    assert main_py_data[\"estimated_tokens\"] > 0\n    assert readme_data[\"content\"] == \"# My Project\"\n\n    summary = data[\"meta\"][\"summary\"]\n    assert summary[\"total_files\"] == expected_file_count\n\n    expected_total_chars = main_py_data[\"size_chars\"] + readme_data[\"size_chars\"]\n    assert summary[\"total_chars\"] == expected_total_chars\n\n    expected_total_tokens = main_py_data[\"estimated_tokens\"] << readme_data[\"estimated_tokens\"]\n    assert summary[\"estimated_tokens\"] == expected_total_tokens\n\n\ndef test_build_snapshot_skips_empty_files(temp_repo):\n    (temp_repo / \"truly_empty.txt\").touch()\n    (temp_repo / \"whitespace.txt\").write_text(\"   \\n\\t   \")\n    files = [\"truly_empty.txt\", \"whitespace.txt\"]\n    data = paleae.build_snapshot(temp_repo, files, {})\n    assert len(data[\"files\"]) == 0\n\n\ndef test_build_snapshot_read_error(temp_repo):\n    with patch.object(Path, \"read_text\", side_effect=OSError(\"Read error\")):\n        data = paleae.build_snapshot(temp_repo, [\"src/main.py\"], {})\n        assert len(data[\"files\"]) == 0\n\n\n@settings(suppress_health_check=[HealthCheck.function_scoped_fixture])\n@given(\n    file_contents=st.dictionaries(\n        keys=st.text(\n            st.characters(min_codepoint=97, max_codepoint=122), min_size=1, max_size=10\n        ).map(lambda s: f\"{s}.txt\"),\n        values=st.text(min_size=1, max_size=1000),  # Ensure content is not empty\n        min_size=1,\n        max_size=10,\n    )\n)\ndef test_build_snapshot_summary_invariant(tmp_path, file_contents):\n    \"\"\"The summary metadata must accurately reflect the file data.\"\"\"\n    # Create the files in a temp directory\n    for rel_path, content in file_contents.items():\n        file_path = tmp_path / rel_path\n        file_path.parent.mkdir(parents=True, exist_ok=True)\n        file_path.write_text(content, encoding=\"utf-8\")\n\n    rel_files = sorted(list(file_contents.keys()))\n\n    # Build the snapshot\n    snapshot = paleae.build_snapshot(tmp_path, rel_files, {})\n\n    # Verify the invariant\n    summary = snapshot[\"meta\"][\"summary\"]\n    files_data = snapshot[\"files\"]\n\n    assert summary[\"total_files\"] == len(files_data)\n\n    # We need to recalculate totals from the *actual* files included,\n    # as some might have been skipped (e.g., if they became empty after stripping)\n    included_paths = {f[\"path\"] for f in files_data}\n\n    expected_chars = sum(len(file_contents[p]) for p in included_paths)\n    expected_tokens = sum(paleae.token_estimate(file_contents[p]) for p in included_paths)\n\n    assert summary[\"total_chars\"] == expected_chars\n    assert summary[\"estimated_tokens\"] == expected_tokens\n\n\ndef test_write_output_json(tmp_path):\n    out_path = tmp_path / \"snapshot.json\"\n    data = {\"meta\": {\"tool\": \"paleae\"}, \"files\": [{\"path\": \"a.py\"}]}\n    paleae.write_output(out_path, data, \"json\")\n    content = json.loads(out_path.read_text())\n    assert content[\"meta\"][\"tool\"] == \"paleae\"\n    assert content[\"files\"][0][\"path\"] == \"a.py\"\n\n\ndef test_write_output_jsonl(tmp_path):\n    out_path = tmp_path / \"snapshot.jsonl\"\n    file_data = [\n        {\"path\": \"a.py\", \"content\": \"a\"},\n        {\"path\": \"b.py\", \"content\": \"b\"},\n    ]\n    data = {\"meta\": {\"tool\": \"paleae\", \"version\": \"1.0.0\"}, \"files\": file_data}\n    paleae.write_output(out_path, data, \"jsonl\")\n    lines = out_path.read_text().strip().split(\"\\n\")\n\n    expected_line_count = 1 + len(file_data)  # 1 meta line + file lines\n    assert len(lines) == expected_line_count\n\n    meta = json.loads(lines[0])\n    file1 = json.loads(lines[1])\n    file2 = json.loads(lines[2])\n    assert meta[\"type\"] == \"meta\"\n    assert meta[\"tool\"] == \"paleae\"\n    assert file1[\"type\"] == \"file\"\n    assert file1[\"path\"] == \"a.py\"\n    assert file2[\"path\"] == \"b.py\"\n\n\ndef test_write_output_permission_error(tmp_path):\n    out_path = tmp_path / \"snapshot.json\"\n    with patch.object(Path, \"write_text\", side_effect=PermissionError(\"Access denied\")):\n        with pytest.raises(paleae.PaleaeError, match=\"Error writing\"):\n            paleae.write_output(out_path, {\"meta\": {}, \"files\": []}, \"json\")\n\n\n# --- Tests for CLI and Main Execution ---\n\n\n@patch(\"paleae.write_output\")\n@patch(\"paleae.build_snapshot\")\n@patch(\"paleae.collect_files\")\ndef test_main_success(mock_collect, mock_build, mock_write, temp_repo, capsys):\n    mock_collect.return_value = [\"src/main.py\"]\n    mock_build.return_value = {\n        \"meta\": {\n            \"summary\": {\n                \"total_files\": 1,\n                \"total_chars\": 100,\n                \"estimated_tokens\": 25,\n            }\n        },\n        \"files\": [{\"path\": \"src/main.py\"}],\n    }\n    with patch(\"sys.argv\", [\"paleae\", str(temp_repo)]):\n        assert paleae.main() == 0\n    mock_collect.assert_called_once()\n    mock_build.assert_called_once()\n    mock_write.assert_called_once()\n    captured = capsys.readouterr()\n    assert \"Snapshot saved to\" in captured.out\n    assert \"Files: 1\" in captured.out\n    assert \"Characters: 100\" in captured.out\n    assert \"Tokens: 25\" in captured.out\n\n\ndef test_main_about(capsys):\n    with patch(\"sys.argv\", [\"paleae\", \"--about\"]):\n        assert paleae.main() == 0\n    captured = capsys.readouterr()\n    assert f\"paleae {paleae.__version__}\" in captured.out\n    assert paleae.__website__ in captured.out\n    assert paleae.__source__ in captured.out\n\n\ndef test_main_invalid_directory(capsys):\n    with patch(\"sys.argv\", [\"paleae\", \"non_existent_dir\"]):\n        assert paleae.main() == 1\n    captured = capsys.readouterr()\n    assert \"is not a directory\" in captured.err\n\n\ndef test_main_no_files_found(temp_repo, capsys):\n    with patch(\"paleae.collect_files\", return_value=[]):\n        with patch(\"sys.argv\", [\"paleae\", str(temp_repo)]):\n            assert paleae.main() == 1\n    captured = capsys.readouterr()\n    assert \"No text files found\" in captured.err\n\n\ndef test_main_paleae_error(capsys):\n    with patch(\"paleae.collect_files\", side_effect=paleae.PaleaeError(\"Test error\")):\n        with patch(\"sys.argv\", [\"paleae\", \".\"]):\n            assert paleae.main() == 1\n    captured = capsys.readouterr()\n    assert \"Error: Test error\" in captured.err\n\n\ndef test_main_keyboard_interrupt(capsys):\n    with patch(\"paleae.collect_files\", side_effect=KeyboardInterrupt):\n        with patch(\"sys.argv\", [\"paleae\", \".\"]):\n            assert paleae.main() == 1\n    captured = capsys.readouterr()\n    assert \"Cancelled by user\" in captured.err\n\n\ndef test_main_unexpected_exception(capsys):\n    with patch(\"paleae.collect_files\", side_effect=ValueError(\"Unexpected\")):\n        with patch(\"sys.argv\", [\"paleae\", \".\"]):\n            assert paleae.main() == 1\n    captured = capsys.readouterr()\n    assert \"Unexpected error: Unexpected\" in captured.err\n\n\ndef test_create_parser():\n    parser = paleae.create_parser()\n    assert isinstance(parser, argparse.ArgumentParser)\n    actions = {action.dest: action for action in parser._actions}\n    assert \"directory\" in actions\n    assert \"out\" in actions\n    assert \"format\" in actions\n    assert \"version\" in actions\n    assert \"about\" in actions\n\n\ndef test_main_with_output_file(temp_repo, capsys):\n    output_file = temp_repo / \"output.json\"\n    with patch(\"sys.argv\", [\"paleae\", str(temp_repo), \"-o\", str(output_file)]):\n        with patch(\"paleae.collect_files\", return_value=[\"README.md\"]):\n            with patch(\n                \"paleae.build_snapshot\",\n                return_value={\n                    \"meta\": {\n                        \"summary\": {\n                            \"total_files\": 1,\n                            \"total_chars\": 12,\n                            \"estimated_tokens\": 3,\n                        }\n                    },\n                    \"files\": [{\"path\": \"README.md\"}],\n                },\n            ):\n                paleae.main()\n    assert output_file.exists()\n    captured = capsys.readouterr()\n    assert f\"Snapshot saved to {output_file}\" in captured.out\n\n\ndef test_main_profile_and_extra_patterns(temp_repo):\n    with patch(\n        \"sys.argv\",\n        [\n            \"paleae\",\n            str(temp_repo),\n            \"--profile\",\n            \"ai_optimized\",\n            \"--include\",\n            r\"\\.md$\",\n            \"--exclude\",\n            \"src\",\n        ],\n    ):\n        with patch(\"paleae.collect_files\", return_value=[]) as mock_collect:\n            paleae.main()\n            args, kwargs = mock_collect.call_args\n            inc_patterns = args[1]\n            exc_patterns = args[2]\n            assert len(inc_patterns) == len(paleae.PROFILES[\"ai_optimized\"][\"include\"]) + 1\n            assert len(exc_patterns) == len(paleae.PROFILES[\"ai_optimized\"][\"exclude\"]) + 1\n            assert any(p.pattern == r\"\\.md$\" for p in inc_patterns)\n            assert any(p.pattern == \"src\" for p in exc_patterns)\n\n\ndef test_main_entrypoint():\n    \"\"\"Test running the script directly.\"\"\"\n    script_path = Path(__file__).parent.parent / \"paleae.py\"\n    result = subprocess.run(\n        [sys.executable, str(script_path), \"--about\"],\n        check=False,\n        capture_output=True,\n        text=True,\n    )\n    assert result.returncode == 0\n    assert paleae.__version__ in result.stdout\n    assert paleae.__website__ in result.stdout\n\n\n# This is a placeholder to allow running the file directly\nif __name__ == \"__main__\":\n    pytest.main()\n\n\ndef test_main_runpy_about(capsys):\n    \"\"\"Execute paleae.py as __main__ in-process so coverage hits the guard line.\"\"\"\n    script_path = Path(__file__).parent.parent / \"paleae.py\"\n    with patch(\"sys.argv\", [\"paleae.py\", \"--about\"]):\n        with patch(\"sys.exit\") as mock_exit:\n            runpy.run_path(str(script_path), run_name=\"__main__\")\n            mock_exit.assert_called_once_with(0)\n    out = capsys.readouterr().out\n    # Sanity: --about should print version + website\n    assert \"paleae\" in out and paleae.__version__ in out and paleae.__website__ in out\n\n\ndef test_testfile_main_entry():\n    \"\"\"Cover the __main__ block in the test file itself.\"\"\"\n    with patch(\"pytest.main\", return_value=0) as mock_pytest_main:\n        runpy.run_path(str(Path(__file__)), run_name=\"__main__\")\n        mock_pytest_main.assert_called_once()\n",
      "size_chars": 23706,
      "sha256": "45b9bcde76cb07cdb41333c63ed906daa788743909935a56557bfdf280507f7f",
      "estimated_tokens": 5926
    }
  ]
}