[
{
"path": ".assets/flow_diagram.md",
"content": "---\nconfig:\n flowchart:\n nodeSpacing: 15\n rankSpacing: 50\n curve: monotoneX\n layout: fixed\n---\nflowchart LR\n subgraph S1[\"1. Input Source\"]\n A[(\"📂 Codebase & Git\")]\n end\n subgraph S2[\"2. Code2Prompt Core\"]\n direction LR\n B{\"🔍 Filtrage & Config\"}\n C[\"🧠 Smart Processing\n(Parse CSV, Notebooks, JSONL)\"]\n D[\"🎨 Templating Layer\n(Handlebars + Token Count)\"]\n end\n subgraph S3[\"3. Delivery Interfaces\"]\n direction TB\n E[\"💻 CLI / TUI\"]\n F[\"🐍 Python SDK\"]\n G[\"🔌 MCP Server\"]\n end\n A --> B\n B --> C\n C --> D\n D --> E & F & G\n E --> H(\"🤖 LLM / AI Model\")\n F --> H\n G --> H\n H -. 📝 Generate &
Integrate Code .-> A\n\n A:::input\n B:::core\n C:::core\n D:::core\n E:::delivery\n F:::delivery\n G:::delivery\n H:::ai\n classDef input fill:#e1f5fe,stroke:#01579b,stroke-width:2px\n classDef core fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px\n classDef delivery fill:#fff3e0,stroke:#ef6c00,stroke-width:2px\n classDef ai fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px\n classDef loop fill:#ffffff,stroke:#333,stroke-width:1px,stroke-dasharray: 5 5"
},
{
"path": ".c2pconfig",
"content": "default_output = \"clipboard\"\ninclude_patterns = [\"*.rs\"]\nexclude_patterns = [\"**/test*\"]\nline_numbers = false\nabsolute_path = true\n\n[user_variables]\nproject = \"code2prompt\"\n"
},
{
"path": ".github/dependabot.yml",
"content": "# https://docs.github.com/en/code-security/dependabot/working-with-dependabot/dependabot-options-reference#package-ecosystem-\n\nversion: 2\nupdates:\n - package-ecosystem: \"github-actions\" # .github/workflows/*.yml\n target-branch: \"main\"\n directory: \"/\"\n schedule:\n interval: \"weekly\"\n - package-ecosystem: \"cargo\" # Cargo.lock\n target-branch: \"main\"\n directory: \"/\"\n schedule:\n interval: \"weekly\"\n - package-ecosystem: \"cargo\" # Cargo.lock\n target-branch: \"main\"\n directory: \"/crates/code2prompt-core\"\n schedule:\n interval: \"weekly\"\n - package-ecosystem: \"pip\" # pyproject.toml\n target-branch: \"main\"\n directory: \"/crates/code2prompt-python\"\n schedule:\n interval: \"weekly\"\n - package-ecosystem: \"uv\" # requirements.lock\n target-branch: \"main\"\n directory: \"/crates/code2prompt-python\"\n schedule:\n interval: \"weekly\"\n - package-ecosystem: \"npm\" # package.json and yarn.lock\n target-branch: \"main\"\n directory: \"/website\"\n schedule:\n interval: \"weekly\"\n"
},
{
"path": ".github/workflows/ci.yml",
"content": "# Run tests for code2prompt\nname: Code2prompt Continuous Integration\n\non:\n push:\n branches: [ \"main\" ]\n pull_request:\n branches: [ \"main\" ]\n\nenv:\n CARGO_TERM_COLOR: always\n\njobs:\n build:\n\n runs-on: ubuntu-latest\n\n steps:\n - uses: actions/checkout@v6\n - name: Run tests\n run: cargo test --verbose\n"
},
{
"path": ".github/workflows/release.yml",
"content": "# Build and publish release on tags push\n\nname: Code2prompt Release\n\non:\n push:\n tags:\n - 'v[0-9]*.[0-9]*.[0-9]*'\n\njobs:\n build:\n strategy:\n matrix:\n include:\n - os: ubuntu-latest\n target: x86_64-unknown-linux-gnu\n - os: macos-latest\n target: x86_64-apple-darwin\n - os: macos-latest\n target: aarch64-apple-darwin\n - os: windows-latest\n target: x86_64-pc-windows-msvc\n runs-on: ${{ matrix.os }}\n outputs:\n asset-path: ${{ steps.set_asset.outputs.asset-path }}\n steps:\n - name: Checkout code\n uses: actions/checkout@v6\n\n - name: Set up Rust toolchain\n uses: actions-rs/toolchain@v1\n with:\n toolchain: stable\n target: ${{ matrix.target }}\n override: true\n\n - name: Cache Rust dependencies\n uses: actions/cache@v5\n with:\n path: |\n ~/.cargo/bin/\n ~/.cargo/registry/index/\n ~/.cargo/registry/cache/\n ~/.cargo/git/db/\n target/\n key: ${{ runner.os }}-${{ matrix.target }}-cargo-${{ hashFiles('**/Cargo.lock') }}\n restore-keys: |\n ${{ runner.os }}-${{ matrix.target }}-cargo-\n\n - name: Install extra dependencies on Ubuntu\n if: runner.os == 'Linux'\n run: |\n if [ \"${{ matrix.target }}\" = \"aarch64-unknown-linux-gnu\" ]; then\n sudo apt-get update && sudo apt-get install -y gcc-aarch64-linux-gnu\n fi\n\n - name: Cache LLVM on Windows\n if: runner.os == 'Windows'\n id: cache-llvm\n uses: actions/cache@v5\n with:\n path: C:\\Program Files\\LLVM\n key: windows-llvm-latest\n \n - name: Install LLVM on Windows\n if: runner.os == 'Windows' && steps.cache-llvm.outputs.cache-hit != 'true'\n run: |\n choco install llvm\n\n - name: Build\n run: cargo build --release --target ${{ matrix.target }}\n\n # Packaging for Windows (PowerShell)\n - name: Package Binary (Windows)\n if: runner.os == 'Windows'\n id: package_windows\n shell: pwsh\n run: |\n $BIN_DIR = \"target/${{ matrix.target }}/release\"\n $BIN_NAME = \"code2prompt\"\n New-Item -ItemType Directory -Force -Path release | Out-Null\n Copy-Item \"$BIN_DIR\\$BIN_NAME.exe\" \"release/${BIN_NAME}-${{ matrix.target }}.exe\"\n # Enregistrer le chemin de l'artefact dans un fichier\n Set-Content -Path asset_windows.txt -Value \"release/${BIN_NAME}-${{ matrix.target }}.exe\"\n\n # Packaging for Linux/macOS (bash)\n - name: Package Binary (Unix)\n if: runner.os != 'Windows'\n id: package_unix\n shell: bash\n run: |\n BIN_DIR=target/${{ matrix.target }}/release\n BIN_NAME=code2prompt\n mkdir -p release\n cp \"$BIN_DIR/$BIN_NAME\" \"release/${BIN_NAME}-${{ matrix.target }}\"\n echo \"release/${BIN_NAME}-${{ matrix.target }}\" > asset_unix.txt\n\n # Get Artifact's path according to OS and defines it as output\n - name: Set asset output\n id: set_asset\n shell: bash\n run: |\n if [ -f asset_windows.txt ]; then\n ASSET_PATH=$(cat asset_windows.txt)\n else\n ASSET_PATH=$(cat asset_unix.txt)\n fi\n echo \"Asset path: $ASSET_PATH\"\n echo \"::set-output name=asset-path::$ASSET_PATH\"\n\n - name: Upload Artifact\n uses: actions/upload-artifact@v6\n with:\n name: asset-${{ matrix.target }}\n path: ${{ steps.set_asset.outputs.asset-path }}\n\n release:\n needs: build\n runs-on: ubuntu-latest\n steps:\n - name: Download artifacts\n uses: actions/download-artifact@v7\n with:\n path: artifacts\n\n - name: Create GitHub Release and upload assets\n if: startsWith(github.ref, 'refs/tags/')\n uses: softprops/action-gh-release@v2\n with:\n tag_name: ${{ github.ref }}\n name: Release ${{ github.ref }}\n body: \"Automatically generated release for ${{ github.ref }}\"\n files: |\n artifacts/**\n env:\n GITHUB_TOKEN: ${{ secrets.C2P_RELEASE_TOKEN }}\n"
},
{
"path": ".github/workflows/website.yml",
"content": "name: Code2prompt Website\n\non:\n # Trigger the workflow every time you push to the `main` branch\n # Using a different branch name? Replace `main` with your branch’s name\n push:\n branches: [main]\n # Allows you to run this workflow manually from the Actions tab on GitHub.\n workflow_dispatch:\n\n# Allow this job to clone the repo and create a page deployment\npermissions:\n contents: read\n pages: write\n id-token: write\n\njobs:\n build:\n runs-on: ubuntu-latest\n steps:\n - name: Checkout your repository using git\n uses: actions/checkout@v6\n - name: Install, build, and upload your site\n uses: withastro/action@v5\n with:\n path: website # The root location of your Astro project inside the repository. (optional)\n # node-version: 20 # The specific version of Node that should be used to build your site. Defaults to 20. (optional)\n package-manager: pnpm # The Node package manager that should be used to install dependencies and build your site. Automatically detected based on your lockfile. (optional)\n\n deploy:\n needs: build\n runs-on: ubuntu-latest\n environment:\n name: github-pages\n url: ${{ steps.deployment.outputs.page_url }}\n steps:\n - name: Deploy to GitHub Pages\n id: deployment\n uses: actions/deploy-pages@v4\n"
},
{
"path": ".gitignore",
"content": "# Generated by Cargo\n# will have compiled files and executables\ndebug/\ntarget/\n\n# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries\n# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html\n# Cargo.lock\n\n# These are backup files generated by rustfmt\n**/*.rs.bk\n\n# MSVC Windows builds of rustc generate these, which store debugging information\n*.pdb\n\n### Linux ###\n*~\n\n# temporary files which can be created if a process still has a handle open of a deleted file\n.fuse_hidden*\n\n# KDE directory preferences\n.directory\n\n# Linux trash folder which might appear on any partition or disk\n.Trash-*\n\n# .nfs files are created when an open file is removed but is still being accessed\n.nfs*\n\n### macOS ###\n# General\n.DS_Store\n.AppleDouble\n.LSOverride\n\n# Icon must end with two \\r\nIcon\n\n\n# Thumbnails\n._*\n\n# Files that might appear in the root of a volume\n.DocumentRevisions-V100\n.fseventsd\n.Spotlight-V100\n.TemporaryItems\n.Trashes\n.VolumeIcon.icns\n.com.apple.timemachine.donotpresent\n\n# Directories potentially created on remote AFP share\n.AppleDB\n.AppleDesktop\nNetwork Trash Folder\nTemporary Items\n.apdisk\n\n### macOS Patch ###\n# iCloud generated files\n*.icloud\n\n### Windows ###\n# Windows thumbnail cache files\nThumbs.db\nThumbs.db:encryptable\nehthumbs.db\nehthumbs_vista.db\n\n# Dump file\n*.stackdump\n\n# Folder config file\n[Dd]esktop.ini\n\n# Recycle Bin used on file shares\n$RECYCLE.BIN/\n\n# Windows Installer files\n*.cab\n*.msi\n*.msix\n*.msm\n*.msp\n\n# Windows shortcuts\n*.lnk\n\n# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\n# Distribution / packaging\n.Python\nbuild/\ndevelop-eggs/\ndist/\ndownloads/\neggs/\n.eggs/\nlib/\nlib64/\nparts/\nsdist/\nvar/\nwheels/\nshare/python-wheels/\n*.egg-info/\n.installed.cfg\n*.egg\nMANIFEST\n\n# PyInstaller\n# Usually these files are written by a python script from a template\n# before PyInstaller builds the exe, so as to inject date/other infos into it.\n*.manifest\n*.spec\n\n# Installer logs\npip-log.txt\npip-delete-this-directory.txt\n\n# Unit test / coverage reports\nhtmlcov/\n.tox/\n.nox/\n.coverage\n.coverage.*\n.cache\nnosetests.xml\ncoverage.xml\n*.cover\n*.py,cover\n.hypothesis/\n.pytest_cache/\ncover/\n\n# Translations\n*.mo\n*.pot\n\n# Django stuff:\n*.log\nlocal_settings.py\ndb.sqlite3\ndb.sqlite3-journal\n\n# Flask stuff:\ninstance/\n.webassets-cache\n\n# Scrapy stuff:\n.scrapy\n\n# Sphinx documentation\ndocs/_build/\n\n# PyBuilder\n.pybuilder/\ntarget/\n\n# Jupyter Notebook\n.ipynb_checkpoints\n\n# IPython\nprofile_default/\nipython_config.py\n\n# pyenv\n# For a library or package, you might want to ignore these files since the code is\n# intended to run in multiple environments; otherwise, check them in:\n# .python-version\n\n# pipenv\n# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.\n# However, in case of collaboration, if having platform-specific dependencies or dependencies\n# having no cross-platform support, pipenv may install dependencies that don't work, or not\n# install all needed dependencies.\n#Pipfile.lock\n\n# UV\n# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.\n# This is especially recommended for binary packages to ensure reproducibility, and is more\n# commonly ignored for libraries.\n#uv.lock\n\n# poetry\n# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.\n# This is especially recommended for binary packages to ensure reproducibility, and is more\n# commonly ignored for libraries.\n# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control\n#poetry.lock\n\n# pdm\n# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.\n#pdm.lock\n# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it\n# in version control.\n# https://pdm.fming.dev/latest/usage/project/#working-with-version-control\n.pdm.toml\n.pdm-python\n.pdm-build/\n\n# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm\n__pypackages__/\n\n# Celery stuff\ncelerybeat-schedule\ncelerybeat.pid\n\n# SageMath parsed files\n*.sage.py\n\n# Environments\n.env\n.venv\nenv/\nvenv/\nENV/\nenv.bak/\nvenv.bak/\n\n# Spyder project settings\n.spyderproject\n.spyproject\n\n# Rope project settings\n.ropeproject\n\n# mkdocs documentation\n/site\n\n# mypy\n.mypy_cache/\n.dmypy.json\ndmypy.json\n\n# Pyre type checker\n.pyre/\n\n# pytype static type analyzer\n.pytype/\n\n# Cython debug symbols\ncython_debug/\n\n# PyCharm\n# JetBrains specific template is maintained in a separate JetBrains.gitignore that can\n# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore\n# and can be added to the global gitignore or merged into this file. For a more nuclear\n# option (not recommended) you can uncomment the following to ignore the entire idea folder.\n#.idea/\n\n# PyPI configuration file\n.pypirc\n\n.claude\nCLAUDE\n"
},
{
"path": "Cargo.toml",
"content": "[workspace]\nresolver = \"2\"\nmembers = [\n \"crates/code2prompt-core\",\n \"crates/code2prompt\",\n \"crates/code2prompt-python\",\n]\ndefault-members = [\"crates/code2prompt-core\", \"crates/code2prompt\"]\n\n[profile.release]\nlto = \"thin\"\npanic = 'abort'\ncodegen-units = 1\n\n[workspace.dependencies]\nanyhow = \"1.0.98\"\nansi_term = \"0.12.1\"\narboard = { version = \"3.6.0\" }\nbracoxide = \"0.1.8\"\ncolored = \"3.0.0\"\ncsv = \"1.4.0\"\nchrono = { version = \"0.4\", features = [\"serde\"] }\nchardetng = { version = \"0.1.17\" }\nclap = { version = \"4.5\", features = [\"derive\"] }\ncontent_inspector = \"0.2.4\"\ncrossterm = \"0.29.0\"\ndirs = \"6.0.0\"\nderive_builder = { version = \"0.20.2\" }\nenv_logger = { version = \"0.11.3\" }\nencoding_rs = { version = \"0.8.35\" }\nindicatif = \"0.18.0\"\ninquire = \"0.9.1\"\nlog = \"0.4\"\nlscolors = { version = \"0.21.0\", features = [\"ansi_term\"] }\nignore = \"0.4.25\"\ngit2 = { version = \"0.20.2\", default-features = false, features = [\n \"https\",\n \"vendored-libgit2\",\n \"vendored-openssl\",\n] }\nglobset = \"0.4.15\"\nhandlebars = \"6.4.0\"\nonce_cell = \"1.19.0\"\npyo3 = { version = \"0.27\", features = [\"extension-module\", \"abi3-py312\"] }\nratatui = \"0.29.0\"\nregex = \"1.10.3\"\nrayon = \"1.11.0\"\nserde = { version = \"1.0\", features = [\"derive\"] }\nserde_json = \"1.0.148\"\ntermtree = \"0.5\"\ntiktoken-rs = \"0.9.1\"\nterminal_size = \"0.4.3\"\ntokio = { version = \"1.49.0\", features = [\"full\"] }\ntoml = \"0.9.10\"\ntui-tree-widget = \"0.23.0\"\ntui-textarea = \"0.7\"\nunicode-width = \"0.2.0\"\nwalkdir = \"2.4.0\"\nwinapi = { version = \"0.3.9\", features = [\"errhandlingapi\"] }\n"
},
{
"path": "LICENSE",
"content": "MIT License\n\nCopyright (c) 2024 Mufeed VH\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"
},
{
"path": "README.md",
"content": "\n
\n ![\"Code2prompt\"/](\"https://github.com/mufeedvh/code2prompt/blob/main/.assets/logo_dark_v0.0.2.svg?raw=true\")
\n \n
\n
Convert your codebase into a single LLM prompt.
\n
\n Website •\n Documentation •\n Discord\n
\n\n\n\n[](https://github.com/mufeedvh/code2prompt/blob/master/LICENSE)\n[](https://crates.io/crates/code2prompt)\n[](https://pypi.org/project/code2prompt-rs/)\n[](https://github.com/mufeedvh/code2prompt/actions)\n[](https://discord.com/invite/ZZyBbsHTwH)\n[](https://docs.rs/code2prompt-core)\n[](https://crates.io/crates/code2prompt)\n[](https://github.com/mufeedvh/code2prompt)\n\n
\n\n---\n\n\n ![\"code2prompt](\"https://github.com/mufeedvh/code2prompt/blob/main/.assets/demo.gif?raw=true\")
\n
\n\n\n\n**Code2Prompt** is a powerful context engineering tool designed to ingest codebases and format them for Large Language Models. Whether you are manually copying context for ChatGPT, building AI agents via Python, or running a MCP server, Code2Prompt streamlines the context preparation process.\n\n## ⚡ Quick Install\n\n### Cargo\n\n```bash\ncargo install code2prompt \n```\n\nTo enable optional Wayland support (e.g., for clipboard integration on Wayland-based systems), use the `wayland` feature flag:\n\n```bash\ncargo install --features wayland code2prompt\n```\n\n### Homebrew\n\n```bash\nbrew install code2prompt\n```\n\n### SDK with pip 🐍\n\n```bash\npip install code2prompt-rs\n```\n\n## 🚀 Quick Start\n\nOnce installed, generating a prompt from your codebase is as simple as pointing the tool to your directory.\n\n**Basic Usage**: Generate a prompt from the current directory and copy it to the clipboard.\n\n```sh\ncode2prompt .\n```\n\n**Save to file**:\n\n```sh\ncode2prompt path/to/project --output-file prompt.txt\n```\n\n## 🌐 Ecosystem\n\nCode2Prompt is more than just a CLI tool. It is a complete ecosystem for codebase context.\n\n| 🧱 Core Library
![\"Rust](\"https://img.shields.io/badge/Rust-FF6700?style=for-the-badge&logo=rust&logoColor=white\")
| 💻 CLI Tool
![\"CLI](\"https://img.shields.io/badge/Terminal-2C3E50?style=for-the-badge&logo=gnu-bash&logoColor=white\")
| 🐍 Python SDK
![\"Python](\"https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white\")
| 🤖 MCP Server ![\"MCP](\"https://img.shields.io/badge/Agentic%20Flow-7E57C2?style=for-the-badge&logo=server&logoColor=white\")
|\n| :---: | :---: | :---: | :---: |\n| The internal, high-speed library responsible for secure file traversal, respecting `.gitignore` rules, and structuring Git metadata. | Designed for humans, featuring both a minimal CLI and an interactive TUI. Generate formatted prompts, track token usage, and outputs the result to your clipboard or stdout. | Provides fast Python bindings to the Rust Core. Ideal for AI Agents, automation scripts, or deep integration into RAG pipelines. Available on PyPI. | Run Code2Prompt as a local service, enabling agentic applications to read your local codebase efficiently without bloating your context window. |\n\n## 📚 Documentation\n\nCheck our online [documentation](https://code2prompt.dev/docs/welcome/) for detailed instructions\n\n## ✨ Features\n\nCode2Prompt transforms your entire codebase into a well-structured prompt for large language models. Key features include:\n\n- **Terminal User Interface (TUI)**: Interactive terminal interface for configuring and generating prompts\n- **Smart Filtering**: Include/exclude files using glob patterns and respect `.gitignore` rules\n- **Flexible Templating**: Customize prompts with Handlebars templates for different use cases\n- **Automatic Code Processing**: Convert codebases of any size into readable, formatted prompts\n- **Token Tracking**: Track token usage to stay within LLM context limits\n- **Smart File Reading**: Simplify reading various file formats for LLMs (CSV, Notebooks, JSONL, etc.)\n- **Git Integration**: Include diffs, logs, and branch comparisons in your prompts\n- **Blazing Fast**: Built in Rust for high performance and low resource usage\n\nStop manually copying files and formatting code for LLMs. Code2Prompt handles the tedious work so you can focus on getting insights and solutions from AI models.\n\n## Alternative Installation\n\nRefer to the [documentation](https://code2prompt.dev/docs/how_to/install/) for detailed installation instructions.\n\n### Binary releases\n\nDownload the latest binary for your OS from [Releases](https://github.com/mufeedvh/code2prompt/releases).\n\n### Source build\n\nRequires:\n\n- [Git](https://git-scm.org/downloads), [Rust](https://rust-lang.org/tools/install) and `Cargo`.\n\n```sh\ngit clone https://github.com/mufeedvh/code2prompt.git\ncd code2prompt/\ncargo install --path crates/code2prompt\n```\n\n## ⭐ Star Gazing\n\n[](https://star-history.com/#mufeedvh/code2prompt&Date)\n\n## 📜 License\n\nLicensed under the MIT License, see LICENSE for more information.\n\n## Liked the project?\n\nIf you liked the project and found it useful, please give it a :star: !\n\n## 👥 Contribution\n\nWays to contribute:\n\n- Suggest a feature\n- Report a bug\n- Fix something and open a pull request\n- Help me document the code\n- Spread the word\n"
},
{
"path": "README_ES.md",
"content": "# code2prompt\n\n[](https://crates.io/crates/code2prompt)\n[](https://github.com/mufeedvh/code2prompt/blob/master/LICENSE)\n\n\n ![\"code2prompt\"](\".assets/code2prompt-screenshot.png\")
\n
\n\n`code2prompt` es una herramienta de línea de comandos (CLI) que convierte tu base de código en un único prompt para LLM, incluyendo un árbol de archivos fuente, plantillas de prompts y conteo de tokens.\n\n## Tabla de Contenidos\n\n- [Características](#features)\n- [Instalación](#installation)\n- [Uso](#usage)\n- [Plantillas](#templates)\n- [Variables Definidas por el Usuario](#user-defined-variables)\n- [Tokenizadores](#tokenizers)\n- [Contribución](#contribution)\n- [Licencia](#license)\n- [Apoya al Autor](#support-the-author)\n\n## Características\n\nPuedes ejecutar esta herramienta en un directorio completo, y generará un prompt bien formateado en Markdown que detalla la estructura del árbol de archivos fuente y todo el código. Luego puedes cargar este documento en modelos como GPT o Claude con ventanas de contexto amplias y pedirles que:\n\n- Generen prompts para LLM rápidamente a partir de bases de código de cualquier tamaño.\n- Personalicen la generación de prompts usando plantillas de Handlebars (ver la [plantilla predeterminada](src/default_template.hbs))\n- Respete los archivos `.gitignore`.\n- Filtren y excluyan archivos utilizando patrones glob.\n- Muestren el conteo de tokens del prompt generado (Ver [Tokenizadores](#tokenizers) para más detalles).\n- Incluyan opcionalmente salidas de `git diff` (archivos en estado staged) en el prompt generado.\n- Copien automáticamente el prompt generado al portapapeles.\n- Guarden el prompt generado en un archivo de salida.\n- Excluyan archivos y carpetas por nombre o ruta.\n- Añadan números de línea a los bloques de código fuente.\n\nPuedes personalizar las plantillas de prompts para lograr cualquier caso de uso deseado. Básicamente, recorre una base de código y crea un prompt con todos los archivos fuente combinados. En resumen, automatiza la tarea de copiar y formatear múltiples archivos fuente en un único prompt y te informa cuántos tokens consume.\n\n## Instalación\n\n### Lanzamiento de binarios\nDescarga el binario más reciente para tu sistema operativo desde [Releases](https://github.com/mufeedvh/code2prompt/releases).\n\n### Construcción desde código fuente\nRequisitos:\n\n- [Git](https://git-scm.org/downloads), [Rust](https://rust-lang.org/tools/install) y Cargo.\n\n```sh\ngit clone https://github.com/mufeedvh/code2prompt.git\ncd code2prompt/\ncargo build --release\n```\n\n## cargo\n\n```bash\n# Cargo\n$ cargo install code2prompt\n\n# Homebrew\n$ brew install code2prompt\n```\n\nPara versiones no publicadas:\n\n```sh\ncargo install --git https://github.com/mufeedvh/code2prompt\n```\n\n### AUR\n`code2prompt` está disponible en [`AUR`](https://aur.archlinux.org/packages?O=0&K=code2prompt). Instálalo usando cualquier gestor AUR.\n\n```sh\nparu/yay -S code2prompt\n```\n\n### Nix\nSi utilizas Nix, puedes instalarlo con `nix-env` o `profile`:\n\n```sh\n# Sin flakes:\nnix-env -iA nixpkgs.code2prompt\n# Con flakes:\nnix profile install nixpkgs#code2prompt\n```\n\n## Uso\n\nGenera un prompt desde un directorio de código:\n\n```sh\ncode2prompt path/to/codebase\n```\n\nUsa un archivo de plantilla Handlebars personalizado:\n\n```sh\ncode2prompt path/to/codebase -t path/to/template.hbs\n```\n\nFiltrar archivos usando patrones glob:\n\n```sh\ncode2prompt path/to/codebase --include=\"*.rs,*.toml\"\n```\n\nExcluir archivos usando patrones glob:\n\n```sh\ncode2prompt path/to/codebase --exclude=\"*.txt,*.md\"\n```\n\nExcluir archivos/carpetas del árbol de origen basándose en patrones de exclusión:\n\n```sh\ncode2prompt path/to/codebase --exclude=\"*.npy,*.wav\" --exclude-from-tree\n```\n\nMostrar el conteo de tokens del prompt generado:\n\n```sh\ncode2prompt path/to/codebase --tokens\n```\n\nEspecificar un tokenizador para el conteo de tokens:\n\n```sh\ncode2prompt path/to/codebase --tokens --encoding=p50k\n```\n\nTokenizadores soportados: `cl100k`, `p50k`, `p50k_edit`, `r50k_bas`.\n> [!NOTE] \n> Ver [Tokenizadores](#tokenizers) para más detalles.\n\nGuardar el prompt generado en un archivo de salida:\n\n```sh\ncode2prompt path/to/codebase --output=output.txt\n```\n\nImprimir salida como JSON:\n\n```sh\ncode2prompt path/to/codebase --json\n```\n\nLa salida JSON tendrá la siguiente estructura:\n\n```json\n{\n \"prompt\": \"\", \n \"directory_name\": \"codebase\",\n \"token_count\": 1234,\n \"model_info\": \"Modelos de ChatGPT, text-embedding-ada-002\",\n \"files\": []\n}\n```\n\nGenerar un mensaje de commit de Git (para archivos en estado staged):\n\n```sh\ncode2prompt path/to/codebase --diff -t templates/write-git-commit.hbs\n```\n\nGenerar una Pull Request comparando ramas (para archivos en estado staged):\n\n```sh\ncode2prompt path/to/codebase --git-diff-branch 'main, development' --git-log-branch 'main, development' -t templates/write-github-pull-request.hbs\n```\n\nAñadir números de línea a los bloques de código fuente:\n\n```sh\ncode2prompt path/to/codebase --line-number\n```\n\nDesactivar el envoltorio de código dentro de bloques de código markdown:\n\n```sh\ncode2prompt path/to/codebase --no-codeblock\n```\n\n- Reescribir el código a otro idioma.\n- Encontrar errores/vulnerabilidades de seguridad.\n- Documentar el código.\n- Implementar nuevas características.\n\n> Inicialmente escribí esto para uso personal para utilizar la ventana de contexto de 200K de Claude 3.0 y ha resultado ser bastante útil, ¡así que decidí hacerlo de código abierto!\n\n## Plantillas\n\n`code2prompt` viene con un conjunto de plantillas integradas para casos de uso comunes. Puedes encontrarlas en el directorio [`templates`](templates).\n\n### [`document-the-code.hbs`](templates/document-the-code.hbs)\n\nUsa esta plantilla para generar prompts para documentar el código. Añadirá comentarios de documentación a todas las funciones, métodos, clases y módulos públicos en la base de código.\n\n### [`find-security-vulnerabilities.hbs`](templates/find-security-vulnerabilities.hbs)\n\nUsa esta plantilla para generar prompts para encontrar posibles vulnerabilidades de seguridad en la base de código. Buscará problemas de seguridad comunes y proporcionará recomendaciones sobre cómo solucionarlos o mitigarlos.\n\n### [`clean-up-code.hbs`](templates/clean-up-code.hbs)\n\nUsa esta plantilla para generar prompts para limpiar y mejorar la calidad del código. Buscará oportunidades para mejorar la legibilidad, adherencia a las mejores prácticas, eficiencia, manejo de errores, y más.\n\n### [`fix-bugs.hbs`](templates/fix-bugs.hbs)\n\nUsa esta plantilla para generar prompts para corregir errores en la base de código. Ayudará a diagnosticar problemas, proporcionar sugerencias de corrección y actualizar el código con las correcciones propuestas.\n\n### [`write-github-pull-request.hbs`](templates/write-github-pull-request.hbs)\n\nUsa esta plantilla para crear una descripción de Pull Request de GitHub en markdown comparando el git diff y el git log de dos ramas.\n\n### [`write-github-readme.hbs`](templates/write-github-readme.hbs)\n\nUsa esta plantilla para generar un archivo README de alta calidad para el proyecto, adecuado para alojar en GitHub. Analizará la base de código para entender su propósito y funcionalidad, y generará el contenido del README en formato Markdown.\n\n### [`write-git-commit.hbs`](templates/write-git-commit.hbs)\n\nUsa esta plantilla para generar commits de git a partir de los archivos en estado staged en tu directorio git. Analizará la base de código para entender su propósito y funcionalidad, y generará el contenido del mensaje de commit de git en formato Markdown.\n\n### [`improve-performance.hbs`](templates/improve-performance.hbs)\n\nUsa esta plantilla para generar prompts para mejorar el rendimiento de la base de código. Buscará oportunidades de optimización, proporcionará sugerencias específicas y actualizará el código con los cambios.\n\nPuedes usar estas plantillas pasando el flag `-t` seguido de la ruta al archivo de plantilla. Por ejemplo:\n\n```sh\ncode2prompt path/to/codebase -t templates/document-the-code.hbs\n```\n\n## Variables Definidas por el Usuario\n\n`code2prompt` soporta el uso de variables definidas por el usuario en las plantillas de Handlebars. Cualquier variable en la plantilla que no sea parte del contexto predeterminado (`absolute_code_path`, `source_tree`, `files`) será tratada como una variable definida por el usuario.\n\nDurante la generación del prompt, `code2prompt` solicitará al usuario que ingrese valores para estas variables definidas por el usuario. Esto permite una mayor personalización de los prompts generados basados en la entrada del usuario.\n\nPor ejemplo, si tu plantilla incluye `{{challenge_name}}` y `{{challenge_description}}`, se te pedirá que ingreses valores para estas variables al ejecutar `code2prompt`.\n\nEsta característica permite crear plantillas reutilizables que pueden adaptarse a diferentes escenarios basados en la información proporcionada por el usuario.\n\n## Tokenizadores\n\nLa tokenización se implementa usando [`tiktoken-rs`](https://github.com/zurawiki/tiktoken-rs). `tiktoken` soporta estas codificaciones utilizadas por los modelos de OpenAI:\n\n| Nombre de codificación | Modelos de OpenAI |\n| ----------------------- | ------------------------------------------------------------------------- |\n| `cl100k_base` | Modelos de ChatGPT, `text-embedding-ada-002` |\n| `p50k_base` | Modelos de código, `text-davinci-002`, `text-davinci-003` |\n| `p50k_edit` | Usar para modelos de edición como `text-davinci-edit-001`, `code-davinci-edit-001` |\n| `r50k_base` (o `gpt2`) | Modelos GPT-3 como `davinci` |\n| `o200k_base` | Modelos GPT-4o |\n\nPara más contexto sobre los diferentes tokenizadores, ver el [OpenAI Cookbook](https://github.com/openai/openai-cookbook/blob/66b988407d8d13cad5060a881dc8c892141f2d5c/examples/How_to_count_tokens_with_tiktoken.ipynb)\n\n## ¿Cómo es útil?\n\n`code2prompt` facilita la generación de prompts para LLMs desde tu base de código. Recorre el directorio, construye una estructura de árbol y recopila información sobre cada archivo. Puedes personalizar la generación de prompts usando plantillas de Handlebars. El prompt generado se copia automáticamente en tu portapapeles y también se puede guardar en un archivo de salida. `code2prompt` ayuda a agilizar el proceso de creación de prompts para análisis de código, generación y otras tareas.\n\n## Contribución\n\nFormas de contribuir:\n\n- Sugerir una característica\n- Reportar un error \n- Arreglar algo y abrir un pull request\n- Ayudarme a documentar el código\n- Difundir la palabra\n\n## Licencia\n\nLicenciado bajo la Licencia MIT, ver LICENSE para más información.\n\n## ¿Te gustó el proyecto?\n\nSi te gustó el proyecto y lo encontraste útil, por favor dale una :star: y considera apoyar a los autores!\n"
},
{
"path": "crates/code2prompt/Cargo.toml",
"content": "[package]\nname = \"code2prompt\"\nversion = \"4.2.0\"\nedition = \"2024\"\ndescription = \"Command-line interface for code2prompt\"\nlicense = \"MIT\"\nrepository = \"https://github.com/mufeedvh/code2prompt\"\nreadme = \"../../README.md\"\n\n[features]\nwayland = [\"arboard/wayland-data-control\"]\n\n[dependencies]\ncode2prompt_core = { path = \"../code2prompt-core\", version = \"4.2.0\" }\nclap = { workspace = true }\nenv_logger = { workspace = true }\narboard = { workspace = true }\nanyhow = { workspace = true }\ncolored = { workspace = true }\nindicatif = { workspace = true }\nlog = { workspace = true }\nserde = { workspace = true }\nserde_json = { workspace = true }\ntoml = { workspace = true }\ninquire = { workspace = true }\nterminal_size = { workspace = true }\nlscolors = { workspace = true }\nansi_term = { workspace = true }\nratatui = { workspace = true }\ncrossterm = { workspace = true }\ntokio = { workspace = true }\ntui-tree-widget = { workspace = true }\ntui-textarea = { workspace = true }\nwalkdir = { workspace = true }\nunicode-width = { workspace = true }\nbracoxide = { workspace = true }\ngit2 = { workspace = true }\nchrono = { workspace = true }\ndirs = { workspace = true }\nregex = { workspace = true }\nhandlebars = { workspace = true }\nignore = { workspace = true }\ntiktoken-rs = { workspace = true }\n\n[target.'cfg(windows)'.dependencies]\nwinapi = { workspace = true }\n\n[[bin]]\nname = \"code2prompt\"\npath = \"src/main.rs\"\n\n[dev-dependencies]\ntempfile = \"3.24\"\nassert_cmd = \"2.1.1\"\npredicates = \"3.1\"\nenv_logger = \"0.11.3\"\nrstest = \"0.26\"\n"
},
{
"path": "crates/code2prompt/src/args.rs",
"content": "//! Command-line argument parsing and validation.\n//!\n//! This module defines the CLI structure using clap for parsing command-line arguments\n//! and options for the code2prompt tool. It supports both TUI and CLI modes with\n//! comprehensive configuration options for file selection, output formatting,\n//! tokenization, and git integration.\nuse anyhow::{Result, anyhow};\nuse clap::{Parser, builder::ValueParser};\nuse code2prompt_core::{\n sort::FileSortMethod, template::OutputFormat, tokenizer::TokenFormat, tokenizer::TokenizerType,\n};\nuse serde::de::DeserializeOwned;\nuse std::path::PathBuf;\n\n// ~~~ CLI Arguments ~~~\n#[derive(Parser, Debug)]\n#[clap(\n name = env!(\"CARGO_PKG_NAME\"),\n version = env!(\"CARGO_PKG_VERSION\"),\n author = env!(\"CARGO_PKG_AUTHORS\")\n)]\n#[command(arg_required_else_help = true)]\npub struct Cli {\n /// Path to the codebase directory\n #[arg(value_name = \"PATH_TO_ANALYZE\", default_value = \".\")]\n pub path: PathBuf,\n\n /// Optional output file (use \"-\" for stdout)\n #[arg(short = 'O', long = \"output-file\", value_name = \"FILE\")]\n pub output_file: Option,\n\n /// Launch the Terminal User Interface\n #[clap(long)]\n pub tui: bool,\n\n /// Patterns to include\n #[clap(short = 'i', long = \"include\")]\n pub include: Vec,\n\n /// Patterns to exclude\n #[clap(short = 'e', long = \"exclude\")]\n pub exclude: Vec,\n\n /// Output format\n #[clap(\n short = 'F',\n long = \"output-format\",\n value_name = \"markdown, json, xml\",\n value_parser = ValueParser::new(parse_serde::)\n )]\n pub output_format: Option,\n\n /// Optional Path to a custom Handlebars template\n #[clap(short, long, value_name = \"TEMPLATE\")]\n pub template: Option,\n\n /// List the full directory tree\n #[clap(long)]\n pub full_directory_tree: bool,\n\n /// Token encoding to use for token count\n #[clap(\n long,\n value_name = \"cl100k, p50k, p50k_edit, r50k\",\n value_parser = ValueParser::new(parse_serde::),\n )]\n pub encoding: Option,\n\n /// Display the token count of the generated prompt. Accepts a format: \"raw\" (machine parsable) or \"format\" (human readable)\n #[clap(\n long,\n value_name = \"raw,format\",\n value_parser = ValueParser::new(parse_serde::),\n )]\n pub token_format: Option,\n\n /// Include git diff\n #[clap(short, long)]\n pub diff: bool,\n\n /// Generate git diff between two branches\n #[clap(long, value_name = \"BRANCHES\", num_args = 2, value_delimiter = ',')]\n pub git_diff_branch: Option>,\n\n /// Retrieve git log between two branches\n #[clap(long, value_name = \"BRANCHES\", num_args = 2, value_delimiter = ',')]\n pub git_log_branch: Option>,\n\n /// Add line numbers to the source code\n #[clap(short, long)]\n pub line_numbers: bool,\n\n /// If true, paths in the output will be absolute instead of relative.\n #[clap(long)]\n pub absolute_paths: bool,\n\n /// Follow symlinks\n #[clap(short = 'L', long)]\n pub follow_symlinks: bool,\n\n /// Include hidden directories and files\n #[clap(long)]\n pub hidden: bool,\n\n /// Disable wrapping code inside markdown code blocks\n #[clap(long)]\n pub no_codeblock: bool,\n\n /// Copy output to clipboard\n #[clap(short = 'c', long)]\n pub clipboard: bool,\n\n /// Optional Disable copying to clipboard (deprecated, use default behavior)\n #[clap(long, hide = true)]\n pub no_clipboard: bool,\n\n /// Skip .gitignore rules\n #[clap(long)]\n pub no_ignore: bool,\n\n /// Sort order for files\n #[clap(\n long,\n value_name = \"name_asc, name_desc, date_asc, date_desc\",\n value_parser = ValueParser::new(parse_serde::),\n )]\n pub sort: Option,\n\n /// Suppress progress and success messages\n #[clap(short = 'q', long)]\n pub quiet: bool,\n\n /// Display a visual token map of files (similar to disk usage tools)\n #[clap(long)]\n pub token_map: bool,\n\n /// Maximum number of lines to display in token map (default: terminal height - 10)\n #[clap(long, value_name = \"NUMBER\")]\n pub token_map_lines: Option,\n\n /// Minimum percentage of tokens to display in token map (default: 0.1%)\n #[clap(long, value_name = \"PERCENT\")]\n pub token_map_min_percent: Option,\n\n /// Start with all files deselected\n #[clap(long)]\n pub deselected: bool,\n\n #[arg(long, hide = true)]\n pub clipboard_daemon: bool,\n}\n\n/// Helper function to parse serde deserializable enum from string inputs.\nfn parse_serde(s: &str) -> Result {\n serde_json::from_value(serde_json::Value::String(s.to_string()))\n .map_err(|e| anyhow!(\"Failed to parse value: {}\", e))\n}\n"
},
{
"path": "crates/code2prompt/src/clipboard.rs",
"content": "use anyhow::{Context, Result};\n\n#[cfg(not(target_os = \"linux\"))]\n/// Copies the provided text to the system clipboard.\n///\n/// This is a simple, one-shot copy operation suitable for non-Linux platforms\n/// or scenarios where maintaining the clipboard content is not required.\n///\n/// # Arguments\n///\n/// * `text` - The text content to be copied.\n///\n/// # Returns\n///\n/// * `Result<()>` - Returns Ok on success, or an error if the clipboard could not be accessed.\npub fn copy_text_to_clipboard(text: &str) -> Result<()> {\n use arboard::Clipboard;\n match Clipboard::new() {\n Ok(mut clipboard) => {\n clipboard\n .set_text(text.to_string())\n .context(\"Failed to copy to clipboard\")?;\n Ok(())\n }\n Err(e) => Err(anyhow::anyhow!(\"Failed to initialize clipboard: {}\", e)),\n }\n}\n\n#[cfg(target_os = \"linux\")]\n/// Entry point for the clipboard daemon process on Linux.\n///\n/// This function reads clipboard content from its standard input, sets it as the system clipboard,\n/// and then waits to serve clipboard requests. This ensures that the clipboard content remains available\n/// even after the main application exits. The daemon will exit automatically once the clipboard is overwritten.\n///\n/// # Returns\n///\n/// * `Result<()>` - Returns Ok on success or an error if clipboard operations fail.\npub fn serve_clipboard_daemon() -> Result<()> {\n use arboard::{Clipboard, LinuxClipboardKind, SetExtLinux};\n use std::io::Read;\n\n // Read content from stdin\n let mut content_from_stdin = String::new();\n std::io::stdin()\n .read_to_string(&mut content_from_stdin)\n .context(\"Failed to read from stdin\")?;\n\n // Initialize the clipboard\n let mut clipboard = Clipboard::new().context(\"Failed to initialize clipboard\")?;\n\n // Explicitly set the clipboard selection to Clipboard (not Primary)\n clipboard\n .set()\n .clipboard(LinuxClipboardKind::Clipboard)\n .wait()\n .text(content_from_stdin)\n .context(\"Failed to set clipboard content\")?;\n Ok(())\n}\n\n#[cfg(target_os = \"linux\")]\n/// Spawns a daemon process to maintain clipboard content on Linux.\n///\n/// On Linux (Wayland/X11), the clipboard content is owned by the process that defined it.\n/// If the main application exits, the clipboard would be cleared.\n/// To avoid this, this function spawns a new process that will run in the background\n/// (daemon) and maintain the clipboard content until it is overwritten by a new copy.\n///\n/// # Arguments\n///\n/// * `text` - The text to be served by the daemon process.\n///\n/// # Returns\n///\n/// * `Result<()>` - Returns Ok if the daemon process was spawned and the content was sent successfully,\n/// or an error if the process could not be launched or written to.\npub fn spawn_clipboard_daemon(content: &str) -> Result<()> {\n use std::process::{Command, Stdio};\n use log::info;\n\n // ~~~ Setting up the command to run the daemon ~~~\n let current_exe: std::path::PathBuf =\n std::env::current_exe().context(\"Failed to get current executable path\")?;\n let mut args: Vec = std::env::args().collect();\n args.push(\"--clipboard-daemon\".to_string());\n\n // ~~~ Spawn the clipboard daemon process ~~~\n let mut child = Command::new(current_exe)\n .args(&args[1..])\n .stdin(Stdio::piped())\n .stdout(Stdio::null())\n .stderr(Stdio::null())\n .spawn()\n .context(\"Failed to launch clipboard daemon process\")?;\n\n // ~~~ Write the content to the daemon's standard input ~~~\n use std::io::Write;\n let mut stdin = child\n .stdin\n .take()\n .context(\"Failed to acquire stdin pipe for clipboard daemon process\")?;\n stdin\n .write_all(content.as_bytes())\n .context(\"Failed to write content to clipboard daemon process\")?;\n info!(\"Clipboard daemon launched successfully\");\n\n Ok(())\n}\n\n/// Copy text to clipboard\npub fn copy_to_clipboard(text: &str) -> Result<()> {\n #[cfg(target_os = \"linux\")]\n {\n spawn_clipboard_daemon(text)\n }\n #[cfg(not(target_os = \"linux\"))]\n {\n copy_text_to_clipboard(text)\n }\n}\n"
},
{
"path": "crates/code2prompt/src/config.rs",
"content": "//! Configuration parsing and session creation utilities.\n//!\n//! This module handles the conversion of command-line arguments into\n//! Code2PromptSession instances, consolidating all configuration parsing\n//! logic in one place for better maintainability and separation of concerns.\n\nuse anyhow::{Context, Result};\nuse code2prompt_core::{\n configuration::Code2PromptConfig,\n session::Code2PromptSession,\n sort::FileSortMethod,\n template::{OutputFormat, extract_undefined_variables},\n tokenizer::TokenizerType,\n};\nuse inquire::Text;\nuse log::error;\nuse std::path::PathBuf;\n\nuse crate::{args::Cli, config_loader::ConfigSource};\n\n/// Unified session builder that merges configuration layering in one place\n/// - base: Some(&ConfigSource) to use loaded config as defaults; None to use CLI defaults\n/// - args: CLI arguments\n/// - tui_mode: whether running in TUI mode (enables token map by default)\npub fn build_session(\n base: Option<&ConfigSource>,\n args: &Cli,\n tui_mode: bool,\n) -> Result {\n let mut configuration = Code2PromptConfig::builder();\n\n let cfg = base.map(|b| &b.config);\n\n // Path: config path takes precedence if provided, otherwise CLI path\n if let Some(c) = cfg {\n if let Some(path) = &c.path {\n configuration.path(PathBuf::from(path));\n } else {\n configuration.path(args.path.clone());\n }\n } else {\n configuration.path(args.path.clone());\n }\n\n // Include/Exclude patterns:\n // If CLI provides any patterns, they override config patterns completely (to avoid conflicts)\n let use_cli_patterns = !args.include.is_empty() || !args.exclude.is_empty();\n let (include_patterns, exclude_patterns) = if use_cli_patterns {\n (\n expand_comma_separated_patterns(&args.include),\n expand_comma_separated_patterns(&args.exclude),\n )\n } else if let Some(c) = cfg {\n (c.include_patterns.clone(), c.exclude_patterns.clone())\n } else {\n (\n expand_comma_separated_patterns(&args.include),\n expand_comma_separated_patterns(&args.exclude),\n )\n };\n configuration\n .include_patterns(include_patterns)\n .exclude_patterns(exclude_patterns);\n\n // Display options: CLI overrides config (logical-or semantics for booleans)\n let cfg_line_numbers = cfg.map(|c| c.line_numbers).unwrap_or(false);\n let cfg_absolute = cfg.map(|c| c.absolute_path).unwrap_or(false);\n let cfg_full_tree = cfg.map(|c| c.full_directory_tree).unwrap_or(false);\n configuration\n .line_numbers(args.line_numbers || cfg_line_numbers)\n .absolute_path(args.absolute_paths || cfg_absolute)\n .full_directory_tree(args.full_directory_tree || cfg_full_tree);\n\n // Output format: CLI overrides config\n let output_format = if let Some(output_format_str) = args.output_format {\n output_format_str\n } else if let Some(c) = cfg {\n c.output_format.unwrap_or(OutputFormat::Markdown)\n } else {\n OutputFormat::Markdown\n };\n configuration.output_format(output_format);\n\n // Sort method: CLI overrides config\n let sort_method = if let Some(sort_str) = args.sort {\n sort_str\n } else if let Some(c) = cfg {\n c.sort_method.unwrap_or(FileSortMethod::NameAsc)\n } else {\n FileSortMethod::NameAsc\n };\n configuration.sort_method(sort_method);\n\n // Tokenizer settings: CLI overrides config\n let tokenizer_type = if let Some(encoding) = args.encoding {\n encoding\n } else if let Some(c) = cfg {\n c.encoding.unwrap_or(TokenizerType::Cl100kBase)\n } else {\n TokenizerType::Cl100kBase\n };\n\n // Token format: CLI overrides config\n let token_format = if let Some(format) = args.token_format {\n format\n } else if let Some(c) = cfg {\n c.token_format\n .unwrap_or(code2prompt_core::tokenizer::TokenFormat::Format)\n } else {\n code2prompt_core::tokenizer::TokenFormat::Format\n };\n\n configuration\n .encoding(tokenizer_type)\n .token_format(token_format);\n\n // Template: CLI overrides config\n let (template_str, template_name) = if args.template.is_some() {\n parse_template(&args.template).map_err(|e| {\n error!(\"Failed to parse template: {}\", e);\n e\n })?\n } else if let Some(c) = cfg {\n (\n c.template_str.clone().unwrap_or_default(),\n c.template_name\n .clone()\n .unwrap_or_else(|| \"default\".to_string()),\n )\n } else {\n (\"\".to_string(), \"default\".to_string())\n };\n\n configuration\n .template_str(template_str)\n .template_name(template_name);\n\n // Git options: CLI overrides config\n let diff_branches = parse_branch_argument(&args.git_diff_branch).or_else(|| {\n cfg.and_then(|c| {\n c.diff_branches.as_ref().and_then(|branches| {\n if branches.len() == 2 {\n Some((branches[0].clone(), branches[1].clone()))\n } else {\n None\n }\n })\n })\n });\n\n let log_branches = parse_branch_argument(&args.git_log_branch).or_else(|| {\n cfg.and_then(|c| {\n c.log_branches.as_ref().and_then(|branches| {\n if branches.len() == 2 {\n Some((branches[0].clone(), branches[1].clone()))\n } else {\n None\n }\n })\n })\n });\n\n let cfg_diff_enabled = cfg.map(|c| c.diff_enabled).unwrap_or(false);\n let cfg_token_map_enabled = cfg.map(|c| c.token_map_enabled).unwrap_or(false);\n let cfg_deselected = cfg.map(|c| c.deselected).unwrap_or(false);\n\n configuration\n .diff_enabled(args.diff || cfg_diff_enabled)\n .diff_branches(diff_branches)\n .log_branches(log_branches)\n .no_ignore(args.no_ignore)\n .hidden(args.hidden)\n .no_codeblock(args.no_codeblock)\n .follow_symlinks(args.follow_symlinks)\n .token_map_enabled(args.token_map || cfg_token_map_enabled || tui_mode)\n .deselected(args.deselected || cfg_deselected);\n\n // User variables from config (if available)\n if let Some(c) = cfg {\n configuration.user_variables(c.user_variables.clone());\n }\n\n let session = Code2PromptSession::new(configuration.build()?);\n Ok(session)\n}\n\n/// Parses the branch argument from command line options.\n///\n/// Takes an optional vector of strings and converts it to a tuple of two branch names\n/// if exactly two branches are provided.\n///\n/// # Arguments\n///\n/// * `branch_arg` - An optional vector containing branch names\n///\n/// # Returns\n///\n/// * `Option<(String, String)>` - A tuple of (from_branch, to_branch) if two branches were provided, None otherwise\npub fn parse_branch_argument(branch_arg: &Option>) -> Option<(String, String)> {\n match branch_arg {\n Some(branches) if branches.len() == 2 => Some((branches[0].clone(), branches[1].clone())),\n _ => None,\n }\n}\n\n/// Loads a template from a file path or returns default values.\n///\n/// # Arguments\n///\n/// * `template_arg` - An optional path to a template file\n///\n/// # Returns\n///\n/// * `Result<(String, String)>` - A tuple containing (template_content, template_name)\n/// where template_name is \"custom\" for user-provided templates or \"default\" otherwise\npub fn parse_template(template_arg: &Option) -> Result<(String, String)> {\n match template_arg {\n Some(path) => {\n let template_str =\n std::fs::read_to_string(path).context(\"Failed to load custom template file\")?;\n Ok((template_str, \"custom\".to_string()))\n }\n None => Ok((\"\".to_string(), \"default\".to_string())),\n }\n}\n\n/// Handles user-defined variables in the template and adds them to the session.\n///\n/// This function extracts undefined variables from the template and prompts\n/// the user to provide values for them through interactive input.\n///\n/// # Arguments\n///\n/// * `session` - The Code2PromptSession to modify\n/// * `template_content` - The template content string to analyze\n///\n/// # Returns\n///\n/// * `Result<()>` - An empty result indicating success or an error\npub fn handle_undefined_variables(\n session: &mut Code2PromptSession,\n template_content: &str,\n) -> Result<()> {\n let undefined_variables = extract_undefined_variables(template_content);\n\n for var in undefined_variables.iter() {\n // Check if variable is already defined in user_variables\n if !session.config.user_variables.contains_key(var) {\n let prompt = format!(\"Enter value for '{}': \", var);\n let answer = Text::new(&prompt)\n .with_help_message(\"Fill user defined variable in template\")\n .prompt()\n .unwrap_or_default();\n session.config.user_variables.insert(var.clone(), answer);\n }\n }\n\n Ok(())\n}\n\n/// Expands comma-separated patterns while preserving brace expansion patterns\n///\n/// This function handles the expansion of comma-separated include/exclude patterns\n/// while being careful not to split patterns that contain brace expansion syntax.\n///\n/// # Arguments\n///\n/// * `patterns` - A vector of pattern strings that may contain comma-separated values\n///\n/// # Returns\n///\n/// * `Vec` - A vector of individual patterns\nfn expand_comma_separated_patterns(patterns: &[String]) -> Vec {\n let mut expanded = Vec::new();\n\n for pattern in patterns {\n // If the pattern contains braces, don't split on commas (preserve brace expansion)\n if pattern.contains('{') && pattern.contains('}') {\n expanded.push(pattern.clone());\n } else {\n // Split on commas for regular patterns\n for part in pattern.split(',') {\n let trimmed = part.trim();\n if !trimmed.is_empty() {\n expanded.push(trimmed.to_string());\n }\n }\n }\n }\n\n expanded\n}\n"
},
{
"path": "crates/code2prompt/src/config_loader.rs",
"content": "//! Configuration file loading and management.\n//!\n//! This module handles loading TOML configuration files from multiple locations\n//! with proper priority handling and informational messages.\n\nuse anyhow::{Context, Result};\nuse code2prompt_core::configuration::{OutputDestination, TomlConfig};\nuse colored::*;\nuse log::{debug, info};\nuse std::path::Path;\n\n/// Configuration source information\n#[derive(Debug, Clone)]\npub struct ConfigSource {\n pub config: TomlConfig,\n}\n\n/// Load configuration with proper priority handling\npub fn load_config(quiet: bool) -> Result {\n // Check for local config first (.c2pconfig in current directory)\n let local_config_path = std::env::current_dir()?.join(\".c2pconfig\");\n if local_config_path.exists() {\n match load_config_from_file(&local_config_path) {\n Ok(config) => {\n if !quiet {\n eprintln!(\n \"{}{}{} Using config from: {}\",\n \"[\".bold().white(),\n \"i\".bold().blue(),\n \"]\".bold().white(),\n local_config_path.display()\n );\n }\n info!(\"Loaded local config from: {}\", local_config_path.display());\n return Ok(ConfigSource { config });\n }\n Err(e) => {\n debug!(\"Failed to load local config: {}\", e);\n }\n }\n }\n\n // Check for global config (~/.config/code2prompt/.c2pconfig)\n if let Some(config_dir) = dirs::config_dir() {\n let global_config_path = config_dir.join(\"code2prompt\").join(\".c2pconfig\");\n if global_config_path.exists() {\n match load_config_from_file(&global_config_path) {\n Ok(config) => {\n if !quiet {\n eprintln!(\n \"{}{}{} Using config from: {}\",\n \"[\".bold().white(),\n \"i\".bold().blue(),\n \"]\".bold().white(),\n global_config_path.display()\n );\n }\n info!(\n \"Loaded global config from: {}\",\n global_config_path.display()\n );\n return Ok(ConfigSource { config });\n }\n Err(e) => {\n debug!(\"Failed to load global config: {}\", e);\n }\n }\n }\n }\n\n // Use default configuration\n if !quiet {\n eprintln!(\n \"{}{}{} Using default configuration\",\n \"[\".bold().white(),\n \"i\".bold().blue(),\n \"]\".bold().white(),\n );\n }\n info!(\"Using default configuration\");\n\n Ok(ConfigSource {\n config: TomlConfig::default(),\n })\n}\n\n/// Load TOML configuration from a file\nfn load_config_from_file(path: &Path) -> Result {\n let content = std::fs::read_to_string(path)\n .with_context(|| format!(\"Failed to read config file: {}\", path.display()))?;\n\n TomlConfig::from_toml_str(&content)\n .with_context(|| format!(\"Failed to parse TOML config file: {}\", path.display()))\n}\n\n/// Get the default output destination from config\npub fn get_default_output_destination(config_source: &ConfigSource) -> OutputDestination {\n config_source.config.default_output.clone()\n}\n"
},
{
"path": "crates/code2prompt/src/main.rs",
"content": "//! code2prompt is a command-line tool to generate an LLM prompt from a codebase directory.\n//!\n//! Authors: Olivier D'Ancona (@ODAncona), Mufeed VH (@mufeedvh)\nmod args;\nmod clipboard;\nmod config;\nmod config_loader;\nmod model;\nmod token_map;\nmod tui;\nmod utils;\nmod view;\nmod widgets;\n\nuse crate::utils::format_number;\nuse anyhow::{Context, Result};\nuse args::Cli;\nuse clap::Parser;\nuse code2prompt_core::template::write_to_file;\nuse colored::*;\nuse indicatif::{ProgressBar, ProgressStyle};\nuse log::{debug, error, info};\nuse std::io::Write;\nuse tui::run_tui;\n\n#[tokio::main]\nasync fn main() -> Result<()> {\n env_logger::init();\n info! {\"Args: {:?}\", std::env::args().collect::>()};\n\n let args: Cli = Cli::parse();\n\n // ~~~ Clipboard Daemon ~~~\n #[cfg(target_os = \"linux\")]\n {\n use clipboard::serve_clipboard_daemon;\n if args.clipboard_daemon {\n info! {\"Serving clipboard daemon...\"};\n serve_clipboard_daemon()?;\n info! {\"Shutting down gracefully...\"};\n return Ok(());\n }\n }\n\n // ~~~ TUI or CLI Mode ~~~\n if args.tui {\n // ~~~ Build Session for TUI ~~~\n let session = config::build_session(None, &args, args.tui).unwrap_or_else(|e| {\n error!(\"Failed to create session: {}\", e);\n std::process::exit(1);\n });\n run_tui(session).await\n } else {\n run_cli_mode_with_args(args).await\n }\n}\n\n/// Run the CLI mode with parsed arguments\nasync fn run_cli_mode_with_args(args: Cli) -> Result<()> {\n use code2prompt_core::configuration::OutputDestination;\n use config_loader::{get_default_output_destination, load_config};\n\n let quiet_mode = args.quiet;\n\n // ~~~ Load Configuration ~~~\n let config_source = load_config(quiet_mode)?; // load config files first (local > global), then apply CLI args on top\n\n // ~~~ Build Session with config + CLI args ~~~\n let mut session = config::build_session(Some(&config_source), &args, false)?;\n\n // ~~~ Determine Output Behavior ~~~\n let default_output = get_default_output_destination(&config_source);\n\n // Determine final output destinations (Solution B: Unix-style behavior)\n let output_to_clipboard = if args.clipboard {\n // Explicit clipboard flag - ONLY clipboard, no stdout\n true\n } else if args.output_file.is_some() {\n // Output file specified, don't use clipboard unless explicitly requested\n false\n } else {\n // Use config default\n matches!(default_output, OutputDestination::Clipboard)\n };\n\n let output_to_stdout = if args.clipboard {\n false\n } else if let Some(ref output_file) = args.output_file {\n output_file == \"-\"\n } else {\n match default_output {\n OutputDestination::Stdout => true,\n OutputDestination::Clipboard => false,\n OutputDestination::File => false,\n }\n };\n\n // ~~~ Create Session ~~~\n let spinner = if !quiet_mode {\n Some(setup_spinner(\"Traversing directory and building tree...\"))\n } else {\n None\n };\n\n // ~~~ Gather Repository Data ~~~\n session.load_codebase().map_err(|e| {\n if let Some(s) = spinner.as_ref() {\n s.finish_with_message(\"Failed!\".red().to_string())\n }\n error!(\"Failed to build directory tree: \\n{}\", e);\n anyhow::anyhow!(\"Failed to build directory tree: {}\", e)\n })?;\n if let Some(s) = spinner.as_ref() {\n s.set_message(\"Proceeding…\")\n }\n\n // ~~~ Git Related ~~~\n // Git Diff\n if session.config.diff_enabled {\n if let Some(s) = spinner.as_ref() {\n s.set_message(\"Generating git diff...\")\n }\n session.load_git_diff().unwrap_or_else(|e| {\n if let Some(s) = spinner.as_ref() {\n s.finish_with_message(\"Failed!\".red().to_string())\n }\n error!(\"Failed to generate git diff: {}\", e);\n std::process::exit(1);\n });\n }\n\n // Load Git diff between branches if provided\n if session.config.diff_branches.is_some() {\n if let Some(s) = spinner.as_ref() {\n s.set_message(\"Generating git diff between two branches...\")\n }\n session\n .load_git_diff_between_branches()\n .unwrap_or_else(|e| {\n if let Some(s) = spinner.as_ref() {\n s.finish_with_message(\"Failed!\".red().to_string())\n }\n error!(\"Failed to generate git diff: {}\", e);\n std::process::exit(1);\n });\n }\n\n // Load Git log between branches if provided\n if session.config.log_branches.is_some() {\n if let Some(ref s) = spinner {\n s.set_message(\"Generating git log between two branches...\");\n }\n session.load_git_log_between_branches().unwrap_or_else(|e| {\n if let Some(ref s) = spinner {\n s.finish_with_message(\"Failed!\".red().to_string());\n }\n error!(\"Failed to generate git log: {}\", e);\n std::process::exit(1);\n });\n }\n\n // ~~~ Template ~~~\n\n // Handle undefined variables (modifies session.config.user_variables)\n let template_str_clone = session.config.template_str.clone();\n config::handle_undefined_variables(&mut session, &template_str_clone)?;\n\n // Data - now build after handling undefined variables\n let data = session.build_template_data();\n debug!(\n \"Template Context: absolute_code_path={}, files_count={}, has_user_vars={}\",\n data.absolute_code_path,\n data.files.map(|f| f.len()).unwrap_or(0),\n !session.config.user_variables.is_empty()\n );\n\n // Render\n let rendered = session.render_prompt(&data).unwrap_or_else(|e| {\n error!(\"Failed to render prompt: {}\", e);\n std::process::exit(1);\n });\n\n if let Some(ref s) = spinner {\n s.finish_with_message(\"Codebase Traversal Done!\".green().to_string());\n }\n\n // ~~~ Token Count ~~~\n let token_count = rendered.token_count;\n let formatted_token_count = format_number(token_count, &session.config.token_format);\n let model_info = rendered.model_info;\n\n if !quiet_mode {\n eprintln!(\n \"{}{}{} Token count: {}, Model info: {}\",\n \"[\".bold().white(),\n \"i\".bold().blue(),\n \"]\".bold().white(),\n formatted_token_count,\n model_info\n );\n }\n\n // ~~~ Token Map Display ~~~\n if args.token_map {\n use crate::token_map::{display_token_map, generate_token_map_with_limit};\n\n if let Some(files) = session.data.files.as_ref() {\n // Calculate total tokens from individual file counts\n let total_from_files: usize = files.iter().map(|f| f.token_count).sum();\n\n // Get max lines from command line or calculate from terminal height\n let max_lines = args.token_map_lines.unwrap_or_else(|| {\n terminal_size::terminal_size()\n .map(|(_, terminal_size::Height(h))| {\n let height = h as usize;\n // Ensure minimum of 10 lines, subtract 10 for other output\n if height > 20 { height - 10 } else { 10 }\n })\n .unwrap_or(20) // Default to 20 lines if terminal size detection fails\n });\n\n // Use the sum of individual file tokens for the map with line limit\n let entries = generate_token_map_with_limit(\n files,\n total_from_files,\n Some(max_lines),\n args.token_map_min_percent,\n );\n display_token_map(&entries, total_from_files);\n }\n }\n\n // ~~~ Output to Stdout ~~~\n if output_to_stdout {\n print!(\"{}\", &rendered.prompt);\n std::io::stdout()\n .flush()\n .context(\"Failed to flush stdout\")?;\n }\n\n // ~~~ Copy to Clipboard ~~~\n if output_to_clipboard {\n use crate::clipboard::copy_to_clipboard;\n match copy_to_clipboard(&rendered.prompt) {\n Ok(_) => {\n if !quiet_mode {\n eprintln!(\n \"{}{}{} {}\",\n \"[\".bold().white(),\n \"✓\".bold().green(),\n \"]\".bold().white(),\n \"Copied to clipboard successfully.\".green()\n );\n }\n }\n Err(e) => {\n if !quiet_mode {\n eprintln!(\n \"{}{}{} {}\",\n \"[\".bold().white(),\n \"!\".bold().red(),\n \"]\".bold().white(),\n format!(\"Failed to copy to clipboard: {}\", e).red()\n );\n }\n }\n }\n }\n\n // ~~~ Output File ~~~\n if let Some(ref output_file) = args.output_file\n && output_file != \"-\"\n {\n output_prompt(\n Some(std::path::Path::new(output_file)),\n &rendered.prompt,\n quiet_mode,\n )?;\n }\n\n Ok(())\n}\n\n/// Sets up a progress spinner with a given message\n///\n/// # Arguments\n///\n/// * `message` - A message to display with the spinner\n///\n/// # Returns\n///\n/// * `ProgressBar` - The configured progress spinner\nfn setup_spinner(message: &str) -> ProgressBar {\n let spinner = ProgressBar::new_spinner();\n spinner.enable_steady_tick(std::time::Duration::from_millis(220));\n let done_symbol = format!(\n \"{}{}{}\",\n \"[\".bold().white(),\n \"✓\".bold().green(),\n \"]\".bold().white()\n );\n spinner.set_style(\n ProgressStyle::default_spinner()\n .tick_strings(&[\n \"▹▹▹▹▹\",\n \"▸▹▹▹▹\",\n \"▹▸▹▹▹\",\n \"▹▹▸▹▹\",\n \"▹▹▹▸▹\",\n \"▹▹▹▹▸\",\n &done_symbol,\n ])\n .template(\"{spinner:.blue} {msg}\")\n .unwrap(),\n );\n spinner.set_message(message.to_string());\n spinner\n}\n\n// ~~~ Output to file or stdout ~~~\nfn output_prompt(\n effective_output: Option<&std::path::Path>,\n rendered: &str,\n quiet: bool,\n) -> Result<()> {\n let output_path = match effective_output {\n Some(path) => path,\n None => return Ok(()), // nothing to do\n };\n\n let path_str = output_path.to_string_lossy();\n if path_str == \"-\" {\n // stdout\n print!(\"{}\", rendered);\n std::io::stdout()\n .flush()\n .context(\"Failed to flush stdout\")?;\n } else {\n // file\n write_to_file(&path_str, rendered)\n .context(format!(\"Failed to write to file: {}\", path_str))?;\n\n if !quiet {\n eprintln!(\n \"{}{}{} {}\",\n \"[\".bold().white(),\n \"✓\".bold().green(),\n \"]\".bold().white(),\n format!(\"Prompt written to file: {}\", path_str).green()\n );\n }\n }\n\n Ok(())\n}\n"
},
{
"path": "crates/code2prompt/src/model/commands.rs",
"content": "//! Command system for handling side effects in the Model-View-Update architecture.\n//!\n//! This module implements the Cmd pattern from Elm/Redux, allowing the Model::update()\n//! function to remain pure while still triggering side effects like async operations,\n//! file I/O, and clipboard operations.\n\nuse std::collections::HashMap;\n\n/// Commands represent side effects that should be executed after model updates.\n/// This allows Model::update() to remain pure while still triggering necessary\n/// side effects like async operations, file I/O, etc.\n#[derive(Debug, Clone)]\npub enum Cmd {\n /// No command - pure state update only\n None,\n\n /// Run analysis in background\n RunAnalysis {\n template_content: String,\n user_variables: HashMap,\n },\n\n /// Copy text to clipboard\n CopyToClipboard(String),\n\n /// Save text to file\n SaveToFile { filename: String, content: String },\n\n /// Save template to custom directory\n SaveTemplate { filename: String, content: String },\n\n /// Refresh file tree from session\n RefreshFileTree,\n}\n"
},
{
"path": "crates/code2prompt/src/model/mod.rs",
"content": "//! Data structures and application state management for the TUI.\n//!\n//! This module contains the core data structures that represent the application state,\n//! including the main Model struct, tab definitions, message types for event handling,\n//! and all state management submodules. It serves as the central state container\n//! for the terminal user interface.\n\npub mod commands;\npub mod prompt_output;\npub mod settings;\npub mod statistics;\npub mod template;\n\npub use commands::*;\npub use prompt_output::*;\npub use settings::*;\npub use statistics::*;\npub use template::*;\n\nuse crate::utils::directory_contains_selected_files;\nuse code2prompt_core::session::Code2PromptSession;\n\n/// The five main tabs of the TUI\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\npub enum Tab {\n FileTree,\n Settings,\n Statistics,\n Template,\n PromptOutput,\n}\n\n/// Input mode for the FileTree tab\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\npub enum FileTreeInputMode {\n Normal,\n Search,\n}\n\n/// Hierarchical file node for TUI display with proper parent-child relationships\n#[derive(Debug, Clone)]\npub struct DisplayFileNode {\n pub path: std::path::PathBuf,\n pub name: String,\n pub is_directory: bool,\n pub is_expanded: bool,\n pub level: usize,\n pub children_loaded: bool,\n pub children: Vec,\n}\n\nimpl DisplayFileNode {\n pub fn new(path: std::path::PathBuf, level: usize) -> Self {\n let name = path\n .file_name()\n .map(|n| n.to_string_lossy().to_string())\n .unwrap_or_else(|| path.to_string_lossy().to_string());\n\n let is_directory = path.is_dir();\n\n Self {\n path,\n name,\n is_directory,\n is_expanded: false,\n level,\n children_loaded: false,\n children: Vec::new(),\n }\n }\n\n /// Find a node by path in the tree (recursive)\n pub fn find_node_mut(&mut self, target_path: &std::path::Path) -> Option<&mut DisplayFileNode> {\n if self.path == target_path {\n return Some(self);\n }\n\n for child in &mut self.children {\n if let Some(found) = child.find_node_mut(target_path) {\n return Some(found);\n }\n }\n\n None\n }\n\n /// Load children for this directory node\n pub fn load_children(\n &mut self,\n session: &mut code2prompt_core::session::Code2PromptSession,\n ) -> Result<(), Box> {\n if !self.is_directory || self.children_loaded {\n return Ok(());\n }\n\n self.children.clear();\n\n // Use ignore crate to respect gitignore\n use ignore::WalkBuilder;\n let walker = WalkBuilder::new(&self.path).max_depth(Some(1)).build();\n\n for entry in walker {\n let entry = entry?;\n let path = entry.path();\n\n if path == self.path {\n continue; // Skip self\n }\n\n let mut child = DisplayFileNode::new(path.to_path_buf(), self.level + 1);\n\n // Auto-expand if contains selected files\n if child.is_directory && directory_contains_selected_files(&child.path, session) {\n child.is_expanded = true;\n }\n\n self.children.push(child);\n }\n\n // Sort children: directories first, then alphabetically\n self.children\n .sort_by(|a, b| match (a.is_directory, b.is_directory) {\n (true, false) => std::cmp::Ordering::Less,\n (false, true) => std::cmp::Ordering::Greater,\n _ => a.name.cmp(&b.name),\n });\n\n self.children_loaded = true;\n Ok(())\n }\n}\n\n/// Messages for updating the model\n#[derive(Debug, Clone)]\npub enum Message {\n SwitchTab(Tab),\n Quit,\n\n UpdateSearchQuery(String),\n ToggleFileSelection(usize),\n ExpandDirectory(usize),\n CollapseDirectory(usize),\n MoveTreeCursor(i32),\n RefreshFileTree,\n\n EnterSearchMode,\n ExitSearchMode,\n\n MoveSettingsCursor(i32),\n ToggleSetting(usize),\n CycleSetting(usize),\n\n RunAnalysis,\n AnalysisComplete(AnalysisResults),\n AnalysisError(String),\n\n CopyToClipboard,\n SaveToFile(String),\n ScrollOutput(i16),\n\n CycleStatisticsView(i8),\n ScrollStatistics(i16),\n\n SaveTemplate(String),\n ReloadTemplate,\n LoadTemplate,\n RefreshTemplates,\n\n SetTemplateFocus(TemplateFocus, FocusMode),\n SetTemplateFocusMode(FocusMode),\n TemplateEditorInput(ratatui::crossterm::event::KeyEvent),\n TemplatePickerMove(i32),\n\n VariableStartEditing(String),\n VariableInputChar(char),\n VariableInputBackspace,\n VariableInputEnter,\n VariableInputCancel,\n VariableNavigateUp,\n VariableNavigateDown,\n}\n\n/// Represents the overall state of the TUI application.\n#[derive(Debug, Clone)]\npub struct Model {\n pub session: Code2PromptSession,\n pub current_tab: Tab,\n pub should_quit: bool,\n pub file_tree_input_mode: FileTreeInputMode,\n pub file_tree_nodes: Vec,\n pub search_query: String,\n pub tree_cursor: usize,\n pub file_tree_scroll: u16,\n pub settings: SettingsState,\n pub statistics: StatisticsState,\n pub template: TemplateState,\n pub prompt_output: PromptOutputState,\n pub status_message: String,\n}\n\nimpl Default for Model {\n fn default() -> Self {\n let config = code2prompt_core::configuration::Code2PromptConfig::default();\n let session = Code2PromptSession::new(config);\n\n Model {\n session,\n current_tab: Tab::FileTree,\n should_quit: false,\n file_tree_input_mode: FileTreeInputMode::Normal,\n file_tree_nodes: Vec::new(),\n search_query: String::new(),\n tree_cursor: 0,\n file_tree_scroll: 0,\n settings: SettingsState::default(),\n statistics: StatisticsState::default(),\n template: TemplateState::default(),\n prompt_output: PromptOutputState::default(),\n status_message: String::new(),\n }\n }\n}\n\nimpl Model {\n pub fn new(session: Code2PromptSession) -> Self {\n Model {\n session,\n current_tab: Tab::FileTree,\n should_quit: false,\n file_tree_input_mode: FileTreeInputMode::Normal,\n file_tree_nodes: Vec::new(),\n search_query: String::new(),\n tree_cursor: 0,\n file_tree_scroll: 0,\n settings: SettingsState::default(),\n statistics: StatisticsState::default(),\n template: TemplateState::default(),\n prompt_output: PromptOutputState::default(),\n status_message: String::new(),\n }\n }\n\n /// Get grouped settings for display\n pub fn get_settings_groups(&self) -> Vec {\n crate::view::format_settings_groups(&self.session)\n }\n\n pub fn update(&self, message: Message) -> (Self, Cmd) {\n let mut new_model = self.clone();\n\n match message {\n Message::Quit => {\n new_model.should_quit = true;\n new_model.status_message = \"Goodbye!\".to_string();\n (new_model, Cmd::None)\n }\n\n Message::SwitchTab(tab) => {\n new_model.current_tab = tab;\n new_model.status_message = format!(\"Switched to {:?} tab\", tab);\n (new_model, Cmd::None)\n }\n\n Message::RefreshFileTree => {\n new_model.status_message = \"Refreshing file tree...\".to_string();\n (new_model, Cmd::RefreshFileTree)\n }\n\n Message::UpdateSearchQuery(query) => {\n new_model.search_query = query;\n new_model.tree_cursor = 0; // Reset cursor when search changes\n new_model.file_tree_scroll = 0; // Reset scroll when search changes\n (new_model, Cmd::None)\n }\n\n Message::EnterSearchMode => {\n new_model.file_tree_input_mode = FileTreeInputMode::Search;\n new_model.status_message = \"Search mode - Type to search, Esc to exit\".to_string();\n (new_model, Cmd::None)\n }\n\n Message::ExitSearchMode => {\n new_model.file_tree_input_mode = FileTreeInputMode::Normal;\n new_model.status_message = \"Exited search mode\".to_string();\n (new_model, Cmd::None)\n }\n\n Message::MoveTreeCursor(delta) => {\n let visible_nodes = crate::utils::get_visible_nodes(\n &new_model.file_tree_nodes,\n &new_model.search_query,\n &mut new_model.session,\n );\n let visible_count = visible_nodes.len();\n\n if visible_count > 0 {\n let new_cursor = if delta > 0 {\n (new_model.tree_cursor + delta as usize).min(visible_count - 1)\n } else {\n new_model.tree_cursor.saturating_sub((-delta) as usize)\n };\n new_model.tree_cursor = new_cursor;\n }\n (new_model, Cmd::None)\n }\n\n Message::MoveSettingsCursor(delta) => {\n let settings_count = new_model\n .settings\n .get_settings_items(&new_model.session)\n .len();\n if settings_count > 0 {\n let new_cursor = if delta > 0 {\n (new_model.settings.settings_cursor + delta as usize)\n .min(settings_count - 1)\n } else {\n new_model\n .settings\n .settings_cursor\n .saturating_sub((-delta) as usize)\n };\n new_model.settings.settings_cursor = new_cursor;\n }\n (new_model, Cmd::None)\n }\n\n Message::ToggleFileSelection(index) => {\n let visible_nodes = crate::utils::get_visible_nodes(\n &new_model.file_tree_nodes,\n &new_model.search_query,\n &mut new_model.session,\n );\n\n if let Some(display_node) = visible_nodes.get(index) {\n let node_path = display_node.node.path.clone();\n let name = display_node.node.name.clone();\n let is_directory = display_node.node.is_directory;\n let current = display_node.is_selected;\n\n // Convert to relative path for session\n let relative_path =\n if let Ok(rel) = node_path.strip_prefix(&new_model.session.config.path) {\n rel.to_path_buf()\n } else {\n node_path.clone()\n };\n\n // Update session selection state (single source of truth)\n new_model.session.toggle_file_selection(relative_path);\n\n let action = if current { \"Deselected\" } else { \"Selected\" };\n let extra = if is_directory { \" (and contents)\" } else { \"\" };\n new_model.status_message = format!(\"{} {}{}\", action, name, extra);\n }\n (new_model, Cmd::None)\n }\n\n Message::ExpandDirectory(index) => {\n let visible_nodes = crate::utils::get_visible_nodes(\n &new_model.file_tree_nodes,\n &new_model.search_query,\n &mut new_model.session,\n );\n\n if let Some(display_node) = visible_nodes.get(index)\n && display_node.node.is_directory\n {\n let node_path = display_node.node.path.clone();\n let name = display_node.node.name.clone();\n\n // Ensure the path exists in the tree first\n if let Err(e) = crate::utils::ensure_path_exists_in_tree(\n &mut new_model.file_tree_nodes,\n &node_path,\n &mut new_model.session,\n ) {\n new_model.status_message =\n format!(\"Failed to ensure path exists for {}: {}\", name, e);\n return (new_model, Cmd::None);\n }\n\n // Find and expand the node in the tree\n let mut found = false;\n for root_node in &mut new_model.file_tree_nodes {\n if let Some(node) = root_node.find_node_mut(&node_path) {\n if !node.is_expanded {\n node.is_expanded = true;\n // Load children if not already loaded\n if !node.children_loaded\n && let Err(e) = node.load_children(&mut new_model.session)\n {\n new_model.status_message =\n format!(\"Failed to load children for {}: {}\", name, e);\n return (new_model, Cmd::None);\n }\n new_model.status_message = format!(\"Expanded {}\", name);\n } else {\n new_model.status_message = format!(\"{} is already expanded\", name);\n }\n found = true;\n break;\n }\n }\n\n if !found {\n new_model.status_message = format!(\"Could not find directory {}\", name);\n }\n }\n (new_model, Cmd::None)\n }\n\n Message::CollapseDirectory(index) => {\n let visible_nodes = crate::utils::get_visible_nodes(\n &new_model.file_tree_nodes,\n &new_model.search_query,\n &mut new_model.session,\n );\n\n if let Some(display_node) = visible_nodes.get(index)\n && display_node.node.is_directory\n {\n let node_path = display_node.node.path.clone();\n let name = display_node.node.name.clone();\n\n // Find and collapse the node in the tree\n let mut found = false;\n for root_node in &mut new_model.file_tree_nodes {\n if let Some(node) = root_node.find_node_mut(&node_path)\n && node.is_expanded\n {\n node.is_expanded = false;\n new_model.status_message = format!(\"Collapsed {}\", name);\n found = true;\n break;\n }\n }\n\n if !found {\n new_model.status_message = format!(\"Could not find directory {}\", name);\n }\n }\n (new_model, Cmd::None)\n }\n\n Message::ToggleSetting(index) => {\n let items = new_model.settings.get_settings_items(&new_model.session);\n if let Some(item) = items.get(index) {\n let setting_name = new_model.settings.update_setting_by_key(\n &mut new_model.session,\n item.key,\n SettingAction::Toggle,\n );\n new_model.status_message = format!(\"Toggled {}\", setting_name);\n } else {\n new_model.status_message = format!(\"Invalid setting index: {}\", index);\n }\n (new_model, Cmd::None)\n }\n\n Message::CycleSetting(index) => {\n let items = new_model.settings.get_settings_items(&new_model.session);\n if let Some(item) = items.get(index) {\n let setting_name = new_model.settings.update_setting_by_key(\n &mut new_model.session,\n item.key,\n SettingAction::Cycle,\n );\n new_model.status_message = format!(\"Cycled {}\", setting_name);\n } else {\n new_model.status_message = format!(\"Invalid setting index: {}\", index);\n }\n (new_model, Cmd::None)\n }\n\n Message::RunAnalysis => {\n if !new_model.prompt_output.analysis_in_progress {\n new_model.prompt_output.analysis_in_progress = true;\n new_model.prompt_output.analysis_error = None;\n new_model.status_message = \"Running analysis...\".to_string();\n new_model.current_tab = Tab::PromptOutput; // Switch to output tab\n\n let cmd = Cmd::RunAnalysis {\n template_content: new_model.template.get_template_content().to_string(),\n user_variables: new_model.template.variables.user_variables.clone(),\n };\n (new_model, cmd)\n } else {\n new_model.status_message = \"Analysis already in progress...\".to_string();\n (new_model, Cmd::None)\n }\n }\n\n Message::AnalysisComplete(results) => {\n new_model.prompt_output.analysis_in_progress = false;\n new_model.prompt_output.generated_prompt = Some(results.generated_prompt);\n new_model.prompt_output.token_count = results.token_count;\n new_model.prompt_output.file_count = results.file_count;\n // Reset output scroll so the new content starts at the top.\n new_model.prompt_output.output_scroll = 0;\n new_model.statistics.token_map_entries = results.token_map_entries;\n let tokens = results.token_count.unwrap_or(0);\n new_model.status_message = format!(\n \"Analysis complete! {} tokens, {} files\",\n tokens, results.file_count\n );\n (new_model, Cmd::None)\n }\n\n Message::AnalysisError(error) => {\n new_model.prompt_output.analysis_in_progress = false;\n new_model.prompt_output.analysis_error = Some(error.clone());\n new_model.status_message = format!(\"Analysis failed: {}\", error);\n (new_model, Cmd::None)\n }\n\n Message::CopyToClipboard => {\n if let Some(prompt) = &new_model.prompt_output.generated_prompt {\n let cmd = Cmd::CopyToClipboard(prompt.clone());\n (new_model, cmd)\n } else {\n new_model.status_message = \"No prompt to copy\".to_string();\n (new_model, Cmd::None)\n }\n }\n\n Message::SaveToFile(filename) => {\n if let Some(prompt) = &new_model.prompt_output.generated_prompt {\n let cmd = Cmd::SaveToFile {\n filename,\n content: prompt.clone(),\n };\n (new_model, cmd)\n } else {\n new_model.status_message = \"No prompt to save\".to_string();\n (new_model, Cmd::None)\n }\n }\n\n Message::ScrollOutput(delta) => {\n // Apply delta only; widgets will clamp based on actual viewport.\n let new_scroll = if delta < 0 {\n new_model\n .prompt_output\n .output_scroll\n .saturating_sub((-delta) as u16)\n } else {\n new_model\n .prompt_output\n .output_scroll\n .saturating_add(delta as u16)\n };\n new_model.prompt_output.output_scroll = new_scroll;\n (new_model, Cmd::None)\n }\n\n Message::CycleStatisticsView(direction) => {\n new_model.statistics.view = if direction > 0 {\n new_model.statistics.view.next()\n } else {\n new_model.statistics.view.prev()\n };\n new_model.statistics.scroll = 0;\n new_model.status_message =\n format!(\"Switched to {} view\", new_model.statistics.view.as_str());\n (new_model, Cmd::None)\n }\n\n Message::ScrollStatistics(delta) => {\n let new_scroll = if delta < 0 {\n new_model.statistics.scroll.saturating_sub((-delta) as u16)\n } else {\n new_model.statistics.scroll.saturating_add(delta as u16)\n };\n new_model.statistics.scroll = new_scroll;\n (new_model, Cmd::None)\n }\n\n Message::SaveTemplate(filename) => {\n let content = new_model.template.get_template_content().to_string();\n let cmd = Cmd::SaveTemplate {\n filename: filename.clone(),\n content,\n };\n new_model.status_message = \"Saving template...\".to_string();\n (new_model, cmd)\n }\n\n Message::ReloadTemplate => {\n new_model.template.editor = crate::model::template::EditorState::default();\n new_model.template.sync_variables_with_template();\n new_model.status_message = \"Reloaded template\".to_string();\n (new_model, Cmd::None)\n }\n\n Message::LoadTemplate => {\n let result = new_model.template.load_selected_template();\n match result {\n Ok(template_name) => {\n new_model.template.sync_variables_with_template();\n new_model.status_message = format!(\"Loaded template: {}\", template_name);\n }\n Err(e) => {\n new_model.status_message = format!(\"Failed to load template: {}\", e);\n }\n }\n (new_model, Cmd::None)\n }\n\n Message::RefreshTemplates => {\n new_model.template.picker.refresh();\n new_model.status_message = \"Templates refreshed\".to_string();\n (new_model, Cmd::None)\n }\n\n Message::SetTemplateFocus(focus, mode) => {\n new_model.template.set_focus(focus);\n new_model.template.set_focus_mode(mode);\n if mode == crate::model::template::FocusMode::EditingVariable {\n new_model\n .template\n .variables\n .move_to_first_missing_variable();\n }\n new_model.status_message = format!(\"Template focus: {:?} ({:?})\", focus, mode);\n (new_model, Cmd::None)\n }\n\n Message::SetTemplateFocusMode(mode) => {\n new_model.template.set_focus_mode(mode);\n new_model.status_message = format!(\"Template mode: {:?}\", mode);\n (new_model, Cmd::None)\n }\n\n Message::TemplateEditorInput(key) => {\n new_model.template.editor.editor.input(key);\n new_model.template.editor.sync_content_from_textarea();\n new_model.template.editor.validate_template();\n new_model.template.sync_variables_with_template();\n (new_model, Cmd::None)\n }\n\n Message::TemplatePickerMove(delta) => {\n if delta > 0 {\n new_model.template.picker.move_cursor_down();\n } else {\n new_model.template.picker.move_cursor_up();\n }\n (new_model, Cmd::None)\n }\n\n Message::VariableStartEditing(var_name) => {\n new_model.template.variables.editing_variable = Some(var_name.clone());\n new_model.template.variables.show_variable_input = true;\n new_model.template.variables.variable_input_content.clear();\n new_model.status_message = format!(\"Editing variable: {}\", var_name);\n (new_model, Cmd::None)\n }\n\n Message::VariableInputChar(c) => {\n new_model.template.variables.add_char_to_input(c);\n (new_model, Cmd::None)\n }\n\n Message::VariableInputBackspace => {\n new_model.template.variables.remove_char_from_input();\n (new_model, Cmd::None)\n }\n\n Message::VariableInputEnter => {\n if let Some((var_name, value)) = new_model.template.variables.finish_editing() {\n new_model.status_message = format!(\"Set {} = {}\", var_name, value);\n new_model.template.sync_variables_with_template();\n }\n (new_model, Cmd::None)\n }\n\n Message::VariableInputCancel => {\n new_model.template.variables.cancel_editing();\n new_model.status_message = \"Cancelled variable editing\".to_string();\n (new_model, Cmd::None)\n }\n\n Message::VariableNavigateUp => {\n if new_model.template.variables.cursor > 0 {\n new_model.template.variables.cursor -= 1;\n }\n (new_model, Cmd::None)\n }\n\n Message::VariableNavigateDown => {\n let variables = new_model.template.get_organized_variables();\n if new_model.template.variables.cursor < variables.len().saturating_sub(1) {\n new_model.template.variables.cursor += 1;\n }\n (new_model, Cmd::None)\n }\n }\n }\n}\n"
},
{
"path": "crates/code2prompt/src/model/prompt_output.rs",
"content": "//! Prompt output state management for the TUI application.\n//!\n//! This module contains the prompt output state and related functionality\n//! for managing generated prompts and analysis results in the TUI.\n\n/// Prompt output state containing all prompt output related data\n#[derive(Debug, Default, Clone)]\npub struct PromptOutputState {\n pub generated_prompt: Option,\n pub token_count: Option,\n pub file_count: usize,\n pub analysis_in_progress: bool,\n pub analysis_error: Option,\n pub output_scroll: u16,\n}\n\n/// Results from code2prompt analysis\n#[derive(Debug, Clone)]\npub struct AnalysisResults {\n pub file_count: usize,\n pub token_count: Option,\n pub generated_prompt: String,\n pub token_map_entries: Vec,\n}\n"
},
{
"path": "crates/code2prompt/src/model/settings.rs",
"content": "//! Settings state management for the TUI application.\n//!\n//! This module contains the settings state, settings groups, and related\n//! functionality for managing configuration options in the TUI.\n\nuse code2prompt_core::session::Code2PromptSession;\nuse code2prompt_core::template::OutputFormat;\nuse code2prompt_core::tokenizer::TokenFormat;\n\n/// Settings state containing cursor position and related data\n#[derive(Default, Debug, Clone)]\npub struct SettingsState {\n pub settings_cursor: usize,\n}\n\n/// Settings group for organizing settings\n#[derive(Debug, Clone)]\npub struct SettingsGroup {\n pub name: String,\n pub items: Vec,\n}\n\n/// Settings item for display and interaction\n#[derive(Debug, Clone)]\npub struct SettingsItem {\n pub key: SettingKey,\n pub name: String,\n pub description: String,\n pub setting_type: SettingType,\n}\n\n#[derive(Debug, Clone)]\npub enum SettingType {\n Boolean(bool),\n Choice {\n options: Vec,\n selected: usize,\n },\n}\n\n#[derive(Debug, Clone)]\npub enum SettingAction {\n Toggle,\n Cycle,\n}\n\n/// Unique identifier for each setting\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]\npub enum SettingKey {\n LineNumbers,\n AbsolutePaths,\n NoCodeblock,\n OutputFormat,\n TokenFormat,\n FullDirectoryTree,\n SortMethod,\n TokenizerType,\n GitDiff,\n FollowSymlinks,\n HiddenFiles,\n NoIgnore,\n Deselected,\n}\n\nimpl SettingsState {\n /// Get flattened list of settings for display (uses format_settings_groups)\n pub fn get_settings_items(&self, session: &Code2PromptSession) -> Vec {\n crate::view::format_settings_groups(session)\n .into_iter()\n .flat_map(|group| group.items)\n .collect()\n }\n\n /// Update setting based on SettingKey and action\n pub fn update_setting_by_key(\n &self,\n session: &mut Code2PromptSession,\n key: SettingKey,\n action: SettingAction,\n ) -> &'static str {\n match (key, action) {\n (SettingKey::LineNumbers, SettingAction::Toggle | SettingAction::Cycle) => {\n session.config.line_numbers = !session.config.line_numbers;\n \"Line Numbers\"\n }\n (SettingKey::AbsolutePaths, SettingAction::Toggle | SettingAction::Cycle) => {\n session.config.absolute_path = !session.config.absolute_path;\n \"Absolute Paths\"\n }\n (SettingKey::NoCodeblock, SettingAction::Toggle | SettingAction::Cycle) => {\n session.config.no_codeblock = !session.config.no_codeblock;\n \"No Codeblock\"\n }\n (SettingKey::OutputFormat, SettingAction::Cycle) => {\n session.config.output_format = match session.config.output_format {\n OutputFormat::Markdown => OutputFormat::Json,\n OutputFormat::Json => OutputFormat::Xml,\n OutputFormat::Xml => OutputFormat::Markdown,\n };\n \"Output Format\"\n }\n (SettingKey::TokenFormat, SettingAction::Cycle) => {\n session.config.token_format = match session.config.token_format {\n TokenFormat::Raw => TokenFormat::Format,\n TokenFormat::Format => TokenFormat::Raw,\n };\n \"Token Format\"\n }\n (SettingKey::FullDirectoryTree, SettingAction::Toggle | SettingAction::Cycle) => {\n session.config.full_directory_tree = !session.config.full_directory_tree;\n \"Full Directory Tree\"\n }\n (SettingKey::SortMethod, SettingAction::Cycle) => {\n session.config.sort_method = Some(match session.config.sort_method {\n Some(code2prompt_core::sort::FileSortMethod::NameAsc) => {\n code2prompt_core::sort::FileSortMethod::NameDesc\n }\n Some(code2prompt_core::sort::FileSortMethod::NameDesc) => {\n code2prompt_core::sort::FileSortMethod::DateAsc\n }\n Some(code2prompt_core::sort::FileSortMethod::DateAsc) => {\n code2prompt_core::sort::FileSortMethod::DateDesc\n }\n Some(code2prompt_core::sort::FileSortMethod::DateDesc) | None => {\n code2prompt_core::sort::FileSortMethod::NameAsc\n }\n });\n \"Sort Method\"\n }\n (SettingKey::TokenizerType, SettingAction::Cycle) => {\n session.config.encoding = match session.config.encoding {\n code2prompt_core::tokenizer::TokenizerType::Cl100kBase => {\n code2prompt_core::tokenizer::TokenizerType::O200kBase\n }\n code2prompt_core::tokenizer::TokenizerType::O200kBase => {\n code2prompt_core::tokenizer::TokenizerType::P50kBase\n }\n code2prompt_core::tokenizer::TokenizerType::P50kBase => {\n code2prompt_core::tokenizer::TokenizerType::P50kEdit\n }\n code2prompt_core::tokenizer::TokenizerType::P50kEdit => {\n code2prompt_core::tokenizer::TokenizerType::R50kBase\n }\n code2prompt_core::tokenizer::TokenizerType::R50kBase => {\n code2prompt_core::tokenizer::TokenizerType::Cl100kBase\n }\n };\n \"Tokenizer Type\"\n }\n (SettingKey::GitDiff, SettingAction::Toggle | SettingAction::Cycle) => {\n session.config.diff_enabled = !session.config.diff_enabled;\n \"Git Diff\"\n }\n (SettingKey::FollowSymlinks, SettingAction::Toggle | SettingAction::Cycle) => {\n session.config.follow_symlinks = !session.config.follow_symlinks;\n \"Follow Symlinks\"\n }\n (SettingKey::HiddenFiles, SettingAction::Toggle | SettingAction::Cycle) => {\n session.config.hidden = !session.config.hidden;\n \"Hidden Files\"\n }\n (SettingKey::NoIgnore, SettingAction::Toggle | SettingAction::Cycle) => {\n session.config.no_ignore = !session.config.no_ignore;\n \"No Ignore\"\n }\n (SettingKey::Deselected, SettingAction::Toggle | SettingAction::Cycle) => {\n session.set_deselected(!session.config.deselected);\n \"Deselected by Default\"\n }\n _ => \"Unknown Setting\",\n }\n }\n}\n"
},
{
"path": "crates/code2prompt/src/model/statistics/mod.rs",
"content": "//! Statistics state management for the TUI application.\n//!\n//! This module contains the statistics state and related functionality,\n//! including different statistics views and their management.\n\npub mod types;\n\nuse crate::model::DisplayFileNode;\nuse crate::utils::format_number;\npub use types::*;\n\n/// Statistics state containing all statistics-related data\n#[derive(Debug, Clone)]\npub struct StatisticsState {\n pub view: StatisticsView,\n pub scroll: u16,\n pub token_map_entries: Vec,\n}\n\nimpl Default for StatisticsState {\n fn default() -> Self {\n StatisticsState {\n view: StatisticsView::Overview,\n scroll: 0,\n token_map_entries: Vec::new(),\n }\n }\n}\n\nimpl StatisticsState {\n /// Count selected files using session-based approach\n pub fn count_selected_files(\n session: &mut code2prompt_core::session::Code2PromptSession,\n ) -> usize {\n session.get_selected_files().unwrap_or_default().len()\n }\n\n /// Count total files in the tree nodes\n pub fn count_total_files(nodes: &[DisplayFileNode]) -> usize {\n fn rec(n: &DisplayFileNode) -> usize {\n if !n.is_directory {\n 1\n } else {\n n.children.iter().map(rec).sum()\n }\n }\n nodes.iter().map(rec).sum()\n }\n\n /// Format number according to token format setting (moved from widget)\n pub fn format_number(\n num: usize,\n token_format: &code2prompt_core::tokenizer::TokenFormat,\n ) -> String {\n format_number(num, token_format)\n }\n\n /// Aggregate tokens by file extension (moved from widget - business logic belongs in Model)\n pub fn aggregate_by_extension(&self) -> Vec<(String, usize, usize)> {\n let mut extension_stats: std::collections::HashMap =\n std::collections::HashMap::new();\n\n for entry in &self.token_map_entries {\n if !entry.metadata.is_dir {\n let extension = entry\n .name\n .split('.')\n .next_back()\n .map(|ext| format!(\".{}\", ext))\n .unwrap_or_else(|| \"(no extension)\".to_string());\n\n let (tokens, count) = extension_stats.entry(extension).or_insert((0, 0));\n *tokens += entry.tokens;\n *count += 1;\n }\n }\n\n // Convert to sorted vec (by tokens desc)\n let mut ext_vec: Vec<(String, usize, usize)> = extension_stats\n .into_iter()\n .map(|(ext, (tokens, count))| (ext, tokens, count))\n .collect();\n ext_vec.sort_by(|a, b| b.1.cmp(&a.1));\n ext_vec\n }\n}\n"
},
{
"path": "crates/code2prompt/src/model/statistics/types.rs",
"content": "//! Statistics view types and enums.\n//!\n//! This module contains the StatisticsView enum and related types\n//! for managing different statistics views in the TUI.\n\n/// Different views available in the Statistics tab\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\npub enum StatisticsView {\n Overview, // General statistics and summary\n TokenMap, // Token distribution by directory/file\n Extensions, // Token distribution by file extension\n}\n\nimpl StatisticsView {\n pub fn next(&self) -> Self {\n match self {\n StatisticsView::Overview => StatisticsView::TokenMap,\n StatisticsView::TokenMap => StatisticsView::Extensions,\n StatisticsView::Extensions => StatisticsView::Overview,\n }\n }\n\n pub fn prev(&self) -> Self {\n match self {\n StatisticsView::Overview => StatisticsView::Extensions,\n StatisticsView::TokenMap => StatisticsView::Overview,\n StatisticsView::Extensions => StatisticsView::TokenMap,\n }\n }\n\n pub fn as_str(&self) -> &'static str {\n match self {\n StatisticsView::Overview => \"Overview\",\n StatisticsView::TokenMap => \"Token Map\",\n StatisticsView::Extensions => \"Extensions\",\n }\n }\n}\n"
},
{
"path": "crates/code2prompt/src/model/template/editor.rs",
"content": "//! Template editor state management.\n//!\n//! This module contains the state and logic for the template editor component,\n//! including TextArea management, validation, and content synchronization.\n\nuse regex::Regex;\nuse std::collections::HashSet;\nuse tui_textarea::TextArea;\n\n/// State for the template editor component\n#[derive(Debug)]\npub struct EditorState {\n pub content: String,\n pub editor: TextArea<'static>,\n pub current_template_name: String,\n pub is_valid: bool,\n pub validation_message: String,\n pub template_variables: Vec, // Variables found in template\n}\n\nimpl Clone for EditorState {\n fn clone(&self) -> Self {\n let mut new_editor = TextArea::from(self.editor.lines().iter().map(|s| s.as_str()));\n new_editor.move_cursor(tui_textarea::CursorMove::Jump(\n self.editor.cursor().0.try_into().unwrap_or(0),\n self.editor.cursor().1.try_into().unwrap_or(0),\n ));\n\n Self {\n content: self.content.clone(),\n editor: new_editor,\n current_template_name: self.current_template_name.clone(),\n is_valid: self.is_valid,\n validation_message: self.validation_message.clone(),\n template_variables: self.template_variables.clone(),\n }\n }\n}\n\nimpl Default for EditorState {\n fn default() -> Self {\n // Load default markdown template from API\n let content = if let Some(builtin_template) =\n code2prompt_core::builtin_templates::BuiltinTemplates::get_template(\"default-markdown\")\n {\n builtin_template.content\n } else {\n \"# {{project_name}}\\n\\n{{#if files}}\\n{{#each files}}\\n## {{path}}\\n\\n```{{extension}}\\n{{content}}\\n```\\n\\n{{/each}}\\n{{/if}}\"\n };\n\n let editor = TextArea::from(content.lines());\n\n let mut state = Self {\n content: content.to_string(),\n editor,\n current_template_name: \"Default (Markdown)\".to_string(),\n is_valid: true,\n validation_message: String::new(),\n template_variables: Vec::new(),\n };\n\n state.analyze_template_variables();\n state\n }\n}\n\nimpl EditorState {\n /// Update content from TextArea and re-analyze variables\n pub fn sync_content_from_textarea(&mut self) {\n self.content = self.editor.lines().join(\"\\n\");\n self.analyze_template_variables();\n }\n\n /// Parse template content to extract all {{variable}} references\n pub fn analyze_template_variables(&mut self) {\n let re = Regex::new(r\"\\{\\{\\s*([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\}\\}\").unwrap();\n let mut found_vars = HashSet::new();\n\n for cap in re.captures_iter(&self.content) {\n if let Some(var_name) = cap.get(1) {\n found_vars.insert(var_name.as_str().to_string());\n }\n }\n\n self.template_variables = found_vars.into_iter().collect();\n self.template_variables.sort();\n }\n\n /// Get all variables found in the template\n pub fn get_template_variables(&self) -> &[String] {\n &self.template_variables\n }\n\n /// Validate template syntax with enhanced Handlebars checking\n pub fn validate_template(&mut self) {\n // First check for balanced braces\n let open_count = self.content.matches(\"{{\").count();\n let close_count = self.content.matches(\"}}\").count();\n\n if open_count != close_count {\n self.is_valid = false;\n self.validation_message = format!(\n \"Unbalanced braces: {} opening, {} closing\",\n open_count, close_count\n );\n return;\n }\n\n // Try to compile the template with Handlebars\n match self.compile_template() {\n Ok(_) => {\n self.is_valid = true;\n self.validation_message = String::new();\n }\n Err(e) => {\n self.is_valid = false;\n self.validation_message = format!(\"Template syntax error: {}\", e);\n }\n }\n }\n\n /// Attempt to compile the template to check for syntax errors\n fn compile_template(&self) -> Result<(), String> {\n let mut handlebars = handlebars::Handlebars::new();\n\n // Set strict mode to catch undefined variables\n handlebars.set_strict_mode(false); // Allow undefined variables for now\n\n match handlebars.register_template_string(\"test\", &self.content) {\n Ok(_) => Ok(()),\n Err(e) => Err(format!(\"{}\", e)),\n }\n }\n\n /// Get current template content\n pub fn get_content(&self) -> &str {\n &self.content\n }\n}\n"
},
{
"path": "crates/code2prompt/src/model/template/mod.rs",
"content": "//! Template state management module.\n//!\n//! This module coordinates the three template sub-components:\n//! - Editor: Template content editing and validation\n//! - Variable: Variable management and validation\n//! - Picker: Template selection and loading\n\npub mod editor;\npub mod picker;\npub mod variable;\n\npub use editor::EditorState;\npub use picker::{ActiveList, PickerState};\npub use variable::{VariableCategory, VariableInfo, VariableState};\n\n/// Which component is currently focused\n#[derive(Debug, Clone, Copy, PartialEq)]\npub enum TemplateFocus {\n Editor,\n Variables,\n Picker,\n}\n\n/// Focus mode determines interaction behavior\n#[derive(Debug, Clone, Copy, PartialEq)]\npub enum FocusMode {\n Normal, // Can switch between panels with e/v/p\n EditingTemplate, // Locked to editor, ESC to exit\n EditingVariable, // Locked to variables, ESC to exit\n}\n\n/// Coordinated template state containing all sub-components\n#[derive(Debug, Clone)]\npub struct TemplateState {\n pub editor: EditorState,\n pub variables: VariableState,\n pub picker: PickerState,\n pub focus: TemplateFocus,\n pub focus_mode: FocusMode,\n pub status_message: String,\n}\n\nimpl Default for TemplateState {\n fn default() -> Self {\n let mut state = Self {\n editor: EditorState::default(),\n variables: VariableState::default(),\n picker: PickerState::default(),\n focus: TemplateFocus::Editor,\n focus_mode: FocusMode::Normal,\n status_message: String::new(),\n };\n\n // Initialize variable state with template variables\n state.sync_variables_with_template();\n state\n }\n}\n\nimpl TemplateState {\n /// Create template state from model (for TUI integration)\n pub fn from_model(model: &crate::model::Model) -> Self {\n // Create a new state based on the model's template state\n model.template.clone()\n }\n\n /// Synchronize variables with current template content\n pub fn sync_variables_with_template(&mut self) {\n let template_vars = self.editor.get_template_variables();\n self.variables.update_missing_variables(template_vars);\n }\n\n /// Set focus to a specific component\n pub fn set_focus(&mut self, focus: TemplateFocus) {\n self.focus = focus;\n }\n\n /// Get current focus\n pub fn get_focus(&self) -> TemplateFocus {\n self.focus\n }\n\n /// Set focus mode\n pub fn set_focus_mode(&mut self, mode: FocusMode) {\n self.focus_mode = mode;\n }\n\n /// Get current focus mode\n pub fn get_focus_mode(&self) -> FocusMode {\n self.focus_mode\n }\n\n /// Check if currently in an editing mode\n pub fn is_in_editing_mode(&self) -> bool {\n matches!(\n self.focus_mode,\n FocusMode::EditingTemplate | FocusMode::EditingVariable\n )\n }\n\n /// Get organized variables for display\n pub fn get_organized_variables(&self) -> Vec {\n self.variables\n .get_organized_variables(self.editor.get_template_variables())\n }\n\n /// Get current template content for analysis\n pub fn get_template_content(&self) -> &str {\n self.editor.get_content()\n }\n\n /// Get status message\n pub fn get_status(&self) -> &str {\n &self.status_message\n }\n\n /// Load the currently selected template from the picker\n pub fn load_selected_template(&mut self) -> Result {\n let selected_template = self.get_selected_template()?;\n\n // Load template content based on type\n let (content, template_name) = if selected_template\n .path\n .to_string_lossy()\n .starts_with(\"builtin://\")\n {\n // Load built-in template from embedded resources\n let path_str = selected_template.path.to_string_lossy();\n let template_key = path_str.strip_prefix(\"builtin://\").unwrap_or(\"\");\n\n if let Some(builtin_template) =\n code2prompt_core::builtin_templates::BuiltinTemplates::get_template(template_key)\n {\n (\n builtin_template.content.to_string(),\n builtin_template.name.to_string(),\n )\n } else {\n return Err(format!(\"Built-in template '{}' not found\", template_key));\n }\n } else {\n // Load template from file\n let content = std::fs::read_to_string(&selected_template.path)\n .map_err(|e| format!(\"Failed to read template file: {}\", e))?;\n (content, selected_template.name.clone())\n };\n\n // Update editor with new content\n self.editor.content = content.clone();\n self.editor.current_template_name = template_name.clone();\n\n // Create new TextArea with the content\n self.editor.editor = tui_textarea::TextArea::from(content.lines());\n\n // Sync and validate\n self.editor.sync_content_from_textarea();\n self.editor.validate_template();\n\n Ok(template_name)\n }\n\n /// Get the currently selected template from the picker\n fn get_selected_template(&self) -> Result<&picker::TemplateFile, String> {\n match self.picker.active_list {\n ActiveList::Default => self\n .picker\n .default_templates\n .get(self.picker.default_cursor)\n .ok_or_else(|| \"No default template selected\".to_string()),\n ActiveList::Custom => self\n .picker\n .custom_templates\n .get(self.picker.custom_cursor)\n .ok_or_else(|| \"No custom template selected\".to_string()),\n }\n }\n}\n"
},
{
"path": "crates/code2prompt/src/model/template/picker.rs",
"content": "//! Template picker state management.\n//!\n//! This module contains the state and logic for the template picker component,\n//! including loading templates from default and custom directories.\n\nuse std::path::PathBuf;\n\n/// Represents a template file\n#[derive(Debug, Clone)]\npub struct TemplateFile {\n pub name: String,\n pub path: PathBuf,\n}\n\n/// Which list is currently active in the picker\n#[derive(Debug, Clone, Copy, PartialEq)]\npub enum ActiveList {\n Default,\n Custom,\n}\n\n/// State for the template picker component\n#[derive(Debug, Clone)]\npub struct PickerState {\n pub default_templates: Vec,\n pub custom_templates: Vec,\n pub active_list: ActiveList,\n pub default_cursor: usize,\n pub custom_cursor: usize,\n}\n\nimpl Default for PickerState {\n fn default() -> Self {\n let mut state = Self {\n default_templates: Vec::new(),\n custom_templates: Vec::new(),\n active_list: ActiveList::Default,\n default_cursor: 0,\n custom_cursor: 0,\n };\n\n state.load_all_templates();\n state\n }\n}\n\nimpl PickerState {\n /// Load all templates from default and custom directories\n pub fn load_all_templates(&mut self) {\n self.load_default_templates();\n self.load_custom_templates();\n }\n\n /// Load built-in default templates\n fn load_default_templates(&mut self) {\n self.default_templates.clear();\n\n // Load all built-in templates from the core\n let builtin_templates = code2prompt_core::builtin_templates::BuiltinTemplates::get_all();\n\n // Sort templates by name for consistent ordering\n let mut template_entries: Vec<_> = builtin_templates.iter().collect();\n template_entries.sort_by(|a, b| a.1.name.cmp(b.1.name));\n\n for (key, template) in template_entries {\n self.default_templates.push(TemplateFile {\n name: template.name.to_string(),\n path: PathBuf::from(format!(\"builtin://{}\", key)),\n });\n }\n }\n\n /// Load custom templates from user directory\n fn load_custom_templates(&mut self) {\n self.custom_templates.clear();\n\n // Load templates from custom directory using utility function\n if let Ok(all_templates) = crate::utils::load_all_templates() {\n for (name, path) in all_templates {\n // All templates from load_all_templates are custom\n self.custom_templates.push(TemplateFile {\n name,\n path: PathBuf::from(path),\n });\n }\n }\n }\n\n /// Move cursor up in unified list\n pub fn move_cursor_up(&mut self) {\n let total_items = self.get_total_selectable_items();\n if total_items == 0 {\n return;\n }\n\n let current_global = self.get_global_template_index();\n let new_global = if current_global == 0 {\n total_items - 1 // Wrap to bottom\n } else {\n current_global - 1\n };\n\n self.set_cursor_from_global_position(new_global);\n }\n\n /// Move cursor down in unified list\n pub fn move_cursor_down(&mut self) {\n let total_items = self.get_total_selectable_items();\n if total_items == 0 {\n return;\n }\n\n let current_global = self.get_global_template_index();\n let new_global = (current_global + 1) % total_items;\n\n self.set_cursor_from_global_position(new_global);\n }\n\n /// Refresh templates by reloading from directories\n pub fn refresh(&mut self) {\n self.load_all_templates();\n\n // Reset cursors if they're out of bounds\n if self.default_cursor >= self.default_templates.len() {\n self.default_cursor = self.default_templates.len().saturating_sub(1);\n }\n if self.custom_cursor >= self.custom_templates.len() {\n self.custom_cursor = self.custom_templates.len().saturating_sub(1);\n }\n }\n\n /// Get global cursor position for unified list display (for rendering)\n pub fn get_global_cursor_position(&self) -> usize {\n let mut position = 0;\n\n // Count default templates section\n if !self.default_templates.is_empty() {\n position += 1; // Section header\n if self.active_list == ActiveList::Default {\n position += self.default_cursor;\n return position;\n }\n position += self.default_templates.len();\n }\n\n // Count custom templates section\n if !self.custom_templates.is_empty() {\n if !self.default_templates.is_empty() {\n position += 1; // Separator\n }\n position += 1; // Section header\n if self.active_list == ActiveList::Custom {\n position += self.custom_cursor;\n return position;\n }\n }\n\n position\n }\n\n /// Get global template index (for navigation logic)\n fn get_global_template_index(&self) -> usize {\n match self.active_list {\n ActiveList::Default => self.default_cursor,\n ActiveList::Custom => self.default_templates.len() + self.custom_cursor,\n }\n }\n\n /// Get total number of selectable items (templates only, not headers)\n fn get_total_selectable_items(&self) -> usize {\n self.default_templates.len() + self.custom_templates.len()\n }\n\n /// Set cursor position from global position in unified list\n fn set_cursor_from_global_position(&mut self, global_pos: usize) {\n let mut template_index = 0;\n\n // Check if position is in default templates\n if global_pos < self.default_templates.len() {\n self.active_list = ActiveList::Default;\n self.default_cursor = global_pos;\n return;\n }\n template_index += self.default_templates.len();\n\n // Check if position is in custom templates\n if global_pos < template_index + self.custom_templates.len() {\n self.active_list = ActiveList::Custom;\n self.custom_cursor = global_pos - template_index;\n }\n }\n}\n"
},
{
"path": "crates/code2prompt/src/model/template/variable.rs",
"content": "//! Template variable state management.\n//!\n//! This module contains the state and logic for managing template variables,\n//! including system variables, user-defined variables, and missing variables.\n\nuse std::collections::HashMap;\n\n/// Variable categories for display and management\n#[derive(Debug, Clone, PartialEq)]\npub enum VariableCategory {\n System, // From build_template_data\n User, // User-defined\n Missing, // In template but not defined\n}\n\n/// Information about a template variable\n#[derive(Debug, Clone)]\npub struct VariableInfo {\n pub name: String,\n pub value: Option,\n pub category: VariableCategory,\n pub description: Option,\n}\n\n/// State for the template variable component\n#[derive(Debug, Clone)]\npub struct VariableState {\n pub system_variables: HashMap, // System variables with descriptions\n pub user_variables: HashMap, // User-defined variables\n pub missing_variables: Vec, // Variables in template but not defined\n pub cursor: usize, // Current cursor position in variable list\n pub editing_variable: Option, // Currently editing variable name\n pub variable_input_content: String, // Content being typed for variable\n pub show_variable_input: bool, // Show variable input dialog\n}\n\nimpl Default for VariableState {\n fn default() -> Self {\n Self {\n system_variables: Self::get_default_system_variables(),\n user_variables: HashMap::new(),\n missing_variables: Vec::new(),\n cursor: 0,\n editing_variable: None,\n variable_input_content: String::new(),\n show_variable_input: false,\n }\n }\n}\n\nimpl VariableState {\n /// Get default system variables that are available from build_template_data\n fn get_default_system_variables() -> HashMap {\n let mut vars = HashMap::new();\n\n // Main template variables from build_template_data()\n vars.insert(\n \"absolute_code_path\".to_string(),\n \"Path to the codebase directory\".to_string(),\n );\n vars.insert(\n \"source_tree\".to_string(),\n \"Directory tree structure\".to_string(),\n );\n vars.insert(\n \"files\".to_string(),\n \"Array of file objects with content\".to_string(),\n );\n vars.insert(\n \"git_diff\".to_string(),\n \"Git diff output (if enabled)\".to_string(),\n );\n vars.insert(\n \"git_diff_branch\".to_string(),\n \"Git diff between branches\".to_string(),\n );\n vars.insert(\n \"git_log_branch\".to_string(),\n \"Git log between branches\".to_string(),\n );\n\n // File object properties (used within {{#each files}} loops)\n vars.insert(\n \"path\".to_string(),\n \"File path (available in {{#each files}} context)\".to_string(),\n );\n vars.insert(\n \"code\".to_string(),\n \"File content (available in {{#each files}} context)\".to_string(),\n );\n vars.insert(\n \"extension\".to_string(),\n \"File extension (available in {{#each files}} context)\".to_string(),\n );\n vars.insert(\n \"token_count\".to_string(),\n \"Token count for file (available in {{#each files}} context)\".to_string(),\n );\n vars.insert(\n \"metadata\".to_string(),\n \"File metadata (available in {{#each files}} context)\".to_string(),\n );\n vars.insert(\n \"mod_time\".to_string(),\n \"File modification time (available in {{#each files}} context)\".to_string(),\n );\n\n vars\n }\n\n /// Update missing variables based on template variables\n pub fn update_missing_variables(&mut self, template_variables: &[String]) {\n self.missing_variables.clear();\n\n for var in template_variables {\n if !self.system_variables.contains_key(var) && !self.user_variables.contains_key(var) {\n self.missing_variables.push(var.clone());\n }\n }\n\n self.missing_variables.sort();\n }\n\n /// Get all variables organized by category for display\n pub fn get_organized_variables(&self, template_variables: &[String]) -> Vec {\n let mut variables = Vec::new();\n\n // System variables (only those used in template)\n for var in template_variables {\n if let Some(desc) = self.system_variables.get(var) {\n variables.push(VariableInfo {\n name: var.clone(),\n value: Some(\"(system)\".to_string()),\n category: VariableCategory::System,\n description: Some(desc.clone()),\n });\n }\n }\n\n // User variables (only those used in template)\n for var in template_variables {\n if let Some(value) = self.user_variables.get(var) {\n variables.push(VariableInfo {\n name: var.clone(),\n value: Some(value.clone()),\n category: VariableCategory::User,\n description: None,\n });\n }\n }\n\n // Missing variables\n for var in &self.missing_variables {\n variables.push(VariableInfo {\n name: var.clone(),\n value: None,\n category: VariableCategory::Missing,\n description: Some(\"⚠️ Not defined\".to_string()),\n });\n }\n\n variables\n }\n\n /// Set a user variable\n pub fn set_user_variable(&mut self, key: String, value: String) {\n self.user_variables.insert(key, value);\n }\n\n /// Check if there are missing variables\n pub fn has_missing_variables(&self) -> bool {\n !self.missing_variables.is_empty()\n }\n\n /// Cancel variable editing\n pub fn cancel_editing(&mut self) {\n self.editing_variable = None;\n self.variable_input_content.clear();\n self.show_variable_input = false;\n }\n\n /// Finish editing variable and save\n pub fn finish_editing(&mut self) -> Option<(String, String)> {\n if let Some(var_name) = self.editing_variable.take() {\n let value = self.variable_input_content.clone();\n self.set_user_variable(var_name.clone(), value.clone());\n self.variable_input_content.clear();\n self.show_variable_input = false;\n Some((var_name, value))\n } else {\n None\n }\n }\n\n /// Add character to variable input\n pub fn add_char_to_input(&mut self, c: char) {\n self.variable_input_content.push(c);\n }\n\n /// Remove character from variable input\n pub fn remove_char_from_input(&mut self) {\n self.variable_input_content.pop();\n }\n\n /// Get current variable input content\n pub fn get_input_content(&self) -> &str {\n &self.variable_input_content\n }\n\n /// Check if currently editing a variable\n pub fn is_editing(&self) -> bool {\n self.show_variable_input\n }\n\n /// Get currently editing variable name\n pub fn get_editing_variable(&self) -> Option<&String> {\n self.editing_variable.as_ref()\n }\n\n /// Move cursor to first missing/user-defined variable\n pub fn move_to_first_missing_variable(&mut self) {\n // This will be called when entering variable editing mode\n // For now, just reset cursor to 0, but we could enhance this\n // to find the first missing variable in the organized list\n self.cursor = 0;\n }\n}\n"
},
{
"path": "crates/code2prompt/src/token_map.rs",
"content": "//! Token map visualization and analysis.\n//!\n//! This module provides functionality for generating and displaying visual token maps\n//! that show how tokens are distributed across files in a codebase. It creates\n//! hierarchical tree structures with visual bars and colors, similar to disk usage\n//! analyzers but for token consumption.\nuse code2prompt_core::path::FileEntry;\nuse lscolors::{Indicator, LsColors};\nuse serde::Deserialize;\nuse std::cmp::Ordering;\nuse std::collections::{BTreeMap, BinaryHeap, HashMap};\nuse std::path::Path;\nuse unicode_width::UnicodeWidthStr;\n\n/// Color information for TUI rendering\n#[derive(Debug, Clone)]\npub enum TuiColor {\n White,\n Gray,\n Red,\n Green,\n Blue,\n Yellow,\n Cyan,\n Magenta,\n LightRed,\n LightGreen,\n LightBlue,\n LightYellow,\n LightCyan,\n LightMagenta,\n}\n\n/// Formatted line for TUI token map display with separate components\n#[derive(Debug, Clone)]\npub struct TuiTokenMapLine {\n pub tokens_part: String,\n pub prefix_part: String,\n pub name_part: String,\n pub name_color: TuiColor,\n pub bar_part: String,\n pub percentage_part: String,\n}\n\n#[derive(Debug, Clone, Copy, Deserialize)]\npub struct EntryMetadata {\n pub is_dir: bool,\n}\n\n#[derive(Debug, Clone)]\nstruct TreeNode {\n tokens: usize,\n children: BTreeMap,\n path: String,\n metadata: Option,\n}\n\nimpl TreeNode {\n fn with_path(path: String) -> Self {\n TreeNode {\n tokens: 0,\n children: BTreeMap::new(),\n path,\n metadata: None,\n }\n }\n}\n\n// For priority queue ordering\n#[derive(Debug, Clone, Eq, PartialEq)]\nstruct NodePriority {\n tokens: usize,\n path: String,\n depth: usize,\n}\n\nimpl Ord for NodePriority {\n fn cmp(&self, other: &Self) -> Ordering {\n // Order by tokens (descending), then by depth (ascending), then by path\n self.tokens\n .cmp(&other.tokens)\n .then_with(|| other.depth.cmp(&self.depth))\n .then_with(|| self.path.cmp(&other.path))\n }\n}\n\nimpl PartialOrd for NodePriority {\n fn partial_cmp(&self, other: &Self) -> Option {\n Some(self.cmp(other))\n }\n}\n\n/// Generate a hierarchical token map with optional display limits.\n///\n/// Creates a tree structure showing token distribution across files and directories,\n/// with optional limits on the number of entries and minimum percentage thresholds\n/// for inclusion in the output.\n///\n/// # Arguments\n///\n/// * `files` - Array of file metadata from the code2prompt session\n/// * `total_tokens` - Total token count for percentage calculations\n/// * `max_lines` - Maximum number of entries to return (None for unlimited)\n/// * `min_percent` - Minimum percentage threshold for inclusion (None for no limit)\n///\n/// # Returns\n///\n/// * `Vec` - Hierarchical list of token map entries ready for display\npub fn generate_token_map_with_limit(\n files: &[FileEntry],\n total_tokens: usize,\n max_lines: Option,\n min_percent: Option,\n) -> Vec {\n let max_lines = max_lines.unwrap_or(20);\n let min_percent = min_percent.unwrap_or(0.1);\n\n let mut root = TreeNode::with_path(String::new());\n root.tokens = total_tokens;\n\n // Insert all files into the tree\n for file in files {\n let path_str = &file.path;\n let tokens = file.token_count;\n let metadata = EntryMetadata {\n is_dir: file.metadata.is_dir,\n };\n\n let path = Path::new(path_str);\n\n // Skip the root component if it exists\n let components: Vec<_> = path\n .components()\n .filter_map(|c| c.as_os_str().to_str())\n .collect();\n\n insert_path(&mut root, &components, tokens, String::new(), metadata);\n }\n\n // Use priority queue to select most significant entries\n let allowed_nodes = select_nodes_to_display(&root, total_tokens, max_lines, min_percent);\n\n // Convert tree to sorted entries for display\n let mut entries = Vec::new();\n rebuild_filtered_tree(\n &root,\n String::new(),\n &allowed_nodes,\n &mut entries,\n 0,\n total_tokens,\n true,\n );\n\n // Add summary for hidden files if needed\n let displayed_tokens: usize = entries\n .iter()\n .map(|e| {\n if !e.metadata.is_dir {\n e.tokens\n } else {\n // For directories, only count their direct file children to avoid double counting\n 0\n }\n })\n .sum();\n\n let hidden_tokens = calculate_file_tokens(&root) - displayed_tokens;\n if hidden_tokens > 0 {\n entries.push(TokenMapEntry {\n path: \"(other files)\".to_string(),\n name: \"(other files)\".to_string(),\n tokens: hidden_tokens,\n percentage: (hidden_tokens as f64 / total_tokens as f64) * 100.0,\n depth: 0,\n is_last: true,\n metadata: EntryMetadata { is_dir: false },\n });\n }\n\n entries\n}\n\nfn calculate_file_tokens(node: &TreeNode) -> usize {\n if node.metadata.is_some_and(|m| !m.is_dir) {\n node.tokens\n } else {\n node.children.values().map(calculate_file_tokens).sum()\n }\n}\n\nfn insert_path(\n node: &mut TreeNode,\n components: &[&str],\n tokens: usize,\n parent_path: String,\n file_metadata: EntryMetadata,\n) {\n if components.is_empty() {\n return;\n }\n\n if components.len() == 1 {\n // This is a file\n let file_name = components[0].to_string();\n let file_path = if parent_path.is_empty() {\n file_name.clone()\n } else {\n format!(\"{}/{}\", parent_path, file_name)\n };\n let child = node\n .children\n .entry(file_name)\n .or_insert_with(|| TreeNode::with_path(file_path));\n child.tokens = tokens;\n child.metadata = Some(file_metadata);\n } else {\n // This is a directory\n let dir_name = components[0].to_string();\n let dir_path = if parent_path.is_empty() {\n dir_name.clone()\n } else {\n format!(\"{}/{}\", parent_path, dir_name)\n };\n let child = node\n .children\n .entry(dir_name)\n .or_insert_with(|| TreeNode::with_path(dir_path.clone()));\n child.tokens += tokens;\n child.metadata = Some(EntryMetadata { is_dir: true });\n insert_path(child, &components[1..], tokens, dir_path, file_metadata);\n }\n}\n\n#[derive(Debug, Clone)]\npub struct TokenMapEntry {\n pub path: String,\n pub name: String,\n pub tokens: usize,\n pub percentage: f64,\n pub depth: usize,\n pub is_last: bool,\n pub metadata: EntryMetadata,\n}\n\n/// Select nodes to display using priority queue\nfn select_nodes_to_display(\n root: &TreeNode,\n total_tokens: usize,\n max_lines: usize,\n min_percent: f64,\n) -> HashMap {\n let mut heap = BinaryHeap::new();\n let mut allowed_nodes = HashMap::new();\n let min_tokens = (total_tokens as f64 * min_percent / 100.0) as usize;\n\n // Start with root children\n for child in root.children.values() {\n if child.tokens >= min_tokens {\n heap.push(NodePriority {\n tokens: child.tokens,\n path: child.path.clone(),\n depth: 0,\n });\n }\n }\n\n // Process nodes by priority\n while allowed_nodes.len() < max_lines.saturating_sub(1) && !heap.is_empty() {\n if let Some(node_priority) = heap.pop() {\n allowed_nodes.insert(node_priority.path.clone(), node_priority.depth);\n\n // Find the node in the tree and add its children\n if let Some(node) = find_node_by_path(root, &node_priority.path) {\n for child in node.children.values() {\n if child.tokens >= min_tokens && !allowed_nodes.contains_key(&child.path) {\n heap.push(NodePriority {\n tokens: child.tokens,\n path: child.path.clone(),\n depth: node_priority.depth + 1,\n });\n }\n }\n }\n }\n }\n\n allowed_nodes\n}\n\n/// Find a node by its path\nfn find_node_by_path<'a>(root: &'a TreeNode, path: &str) -> Option<&'a TreeNode> {\n if path.is_empty() {\n return Some(root);\n }\n\n let components: Vec<&str> = path.split('/').collect();\n let mut current = root;\n\n for component in components {\n match current.children.get(component) {\n Some(child) => current = child,\n None => return None,\n }\n }\n\n Some(current)\n}\n\n/// Rebuild tree with only allowed nodes\nfn rebuild_filtered_tree(\n node: &TreeNode,\n path: String,\n allowed_nodes: &HashMap,\n entries: &mut Vec,\n depth: usize,\n total_tokens: usize,\n is_last: bool,\n) {\n // Check if this node should be included\n if !path.is_empty() && allowed_nodes.contains_key(&path) {\n let percentage = (node.tokens as f64 / total_tokens as f64) * 100.0;\n let name = path.split('/').next_back().unwrap_or(&path).to_string();\n\n let metadata = node.metadata.unwrap_or(EntryMetadata { is_dir: true });\n\n entries.push(TokenMapEntry {\n path: path.clone(),\n name,\n tokens: node.tokens,\n percentage,\n depth,\n is_last,\n metadata,\n });\n }\n\n // Process children that are in allowed_nodes\n let mut filtered_children: Vec<_> = node\n .children\n .iter()\n .filter(|(_, child)| allowed_nodes.contains_key(&child.path))\n .collect();\n\n // Sort by tokens descending\n filtered_children.sort_by(|a, b| b.1.tokens.cmp(&a.1.tokens));\n\n let child_count = filtered_children.len();\n for (i, (name, child)) in filtered_children.into_iter().enumerate() {\n let child_path = if path.is_empty() {\n name.clone()\n } else {\n format!(\"{}/{}\", path, name)\n };\n\n let is_last_child = i == child_count - 1;\n rebuild_filtered_tree(\n child,\n child_path,\n allowed_nodes,\n entries,\n depth + 1,\n total_tokens,\n is_last_child,\n );\n }\n}\n\nfn should_enable_colors() -> bool {\n // Check NO_COLOR environment variable (https://no-color.org/)\n if std::env::var_os(\"NO_COLOR\").is_some() {\n return false;\n }\n\n // Check if we're in a terminal\n if terminal_size::terminal_size().is_none() {\n return false;\n }\n\n // On Windows, enable ANSI support\n #[cfg(windows)]\n {\n use log::error;\n match ansi_term::enable_ansi_support() {\n Ok(_) => true,\n Err(_) => {\n error!(\"This version of Windows does not support ANSI colors\");\n false\n }\n }\n }\n\n #[cfg(not(windows))]\n {\n true\n }\n}\n\n/// Display a visual token map with colors and hierarchical tree structure.\n///\n/// Renders the token map entries as a formatted tree with visual progress bars,\n/// colors based on file types, and proper Unicode tree drawing characters.\n/// Automatically adapts to terminal width and applies appropriate colors.\n///\n/// # Arguments\n///\n/// * `entries` - The token map entries to display\n/// * `total_tokens` - Total token count for percentage calculations\npub fn display_token_map(entries: &[TokenMapEntry], total_tokens: usize) {\n if entries.is_empty() {\n return;\n }\n\n // Initialize LsColors from environment\n let ls_colors = LsColors::from_env().unwrap_or_default();\n let colors_enabled = should_enable_colors();\n\n // Terminal width detection\n let terminal_width = terminal_size::terminal_size()\n .map(|(terminal_size::Width(w), _)| w as usize)\n .unwrap_or(80);\n\n // Calculate max token width for alignment\n let max_token_width = entries\n .iter()\n .map(|e| format_tokens(e.tokens).len())\n .max()\n .unwrap_or(3)\n .max(format_tokens(total_tokens).len())\n .max(4);\n\n // Calculate max name length including tree prefix\n let max_name_length = entries\n .iter()\n .map(|e| {\n let prefix_width = if e.depth == 0 { 3 } else { (e.depth * 2) + 3 };\n prefix_width + UnicodeWidthStr::width(e.name.as_str())\n })\n .max()\n .unwrap_or(20)\n .min(terminal_width / 2);\n\n // Calculate bar width\n let bar_width = terminal_width\n .saturating_sub(max_token_width + 3 + max_name_length + 2 + 2 + 5)\n .max(20);\n\n // Initialize parent bars array\n let mut parent_bars: Vec = vec![String::new(); 10];\n parent_bars[0] = \"█\".repeat(bar_width);\n\n for (i, entry) in entries.iter().enumerate() {\n // Build tree prefix using shared logic\n let prefix = build_tree_prefix(entry, entries, i);\n\n // Format tokens\n let tokens_str = format_tokens(entry.tokens);\n\n // Generate hierarchical bar\n let parent_bar = if entry.depth > 0 {\n &parent_bars[entry.depth - 1]\n } else {\n &parent_bars[0]\n };\n\n let bar = generate_hierarchical_bar(bar_width, parent_bar, entry.percentage, entry.depth);\n\n // Update parent bars\n if entry.depth < parent_bars.len() {\n parent_bars[entry.depth] = bar.clone();\n }\n\n // Format percentage\n let percentage_str = format!(\"{:>4.0}%\", entry.percentage);\n\n // Calculate padding for name\n let prefix_display_width = prefix.chars().count();\n let name_padding = max_name_length\n .saturating_sub(prefix_display_width + UnicodeWidthStr::width(entry.name.as_str()));\n\n // Create name with padding FIRST\n let name_with_padding = format!(\"{}{}\", entry.name, \" \".repeat(name_padding));\n\n // THEN apply colors to the name+padding combination\n let colored_name_with_padding = if colors_enabled && entry.name != \"(other files)\" {\n // Use our cached metadata to choose the coloring strategy\n let ansi_style = if entry.metadata.is_dir {\n // For directories, we know the type. No need to hit the filesystem.\n ls_colors\n .style_for_indicator(Indicator::Directory)\n .map(|s| s.to_ansi_term_style())\n .unwrap_or_default()\n } else {\n // For files, rely on extension-based styling (no filesystem stat).\n ls_colors\n .style_for_path(std::path::Path::new(&entry.path))\n .map(lscolors::Style::to_ansi_term_style)\n .unwrap_or_default()\n };\n\n // Apply style to name WITH padding\n format!(\"{}\", ansi_style.paint(name_with_padding))\n } else {\n name_with_padding\n };\n\n eprintln!(\n \"{:>width$} {}{} │{}│ {}\",\n tokens_str,\n prefix,\n colored_name_with_padding,\n bar,\n percentage_str,\n width = max_token_width\n );\n }\n}\n\n/// Build tree prefix for an entry (shared logic for CLI and TUI)\nfn build_tree_prefix(entry: &TokenMapEntry, entries: &[TokenMapEntry], index: usize) -> String {\n let mut prefix = String::new();\n\n // Add vertical lines for parent levels\n for d in 0..entry.depth {\n if d < entry.depth - 1 {\n // Check if we need a vertical line at this depth\n let needs_line = entries\n .iter()\n .skip(index + 1)\n .take_while(|entry| entry.depth > d)\n .any(|entry| entry.depth == d + 1);\n if needs_line {\n prefix.push_str(\"│ \");\n } else {\n prefix.push_str(\" \");\n }\n } else if entry.is_last {\n prefix.push_str(\"└─\");\n } else {\n prefix.push_str(\"├─\");\n }\n }\n\n // Special handling for root\n if entry.depth == 0 && index == 0 && entry.name != \"(other files)\" {\n prefix = \"┌─\".to_string();\n }\n\n // Check if has children\n let has_children = entries\n .get(index + 1)\n .map(|next| next.depth > entry.depth)\n .unwrap_or(false);\n\n // Add the connecting character\n if entry.depth > 0 || entry.name == \"(other files)\" {\n if has_children {\n prefix.push('┬');\n } else {\n prefix.push('─');\n }\n } else if index == 0 {\n prefix.push('┴');\n }\n\n prefix.push(' ');\n prefix\n}\n\n/// Determine TUI color for an entry based on file type and extension\nfn determine_tui_color(entry: &TokenMapEntry) -> TuiColor {\n if entry.metadata.is_dir {\n TuiColor::Cyan\n } else {\n match entry.name.split('.').next_back().unwrap_or(\"\") {\n // Systems / compiled langs\n \"rs\" => TuiColor::Yellow,\n \"c\" | \"h\" | \"cpp\" | \"cxx\" | \"hpp\" => TuiColor::Blue,\n \"go\" => TuiColor::LightBlue,\n \"java\" | \"kt\" | \"kts\" => TuiColor::Red,\n \"swift\" => TuiColor::LightRed,\n \"zig\" => TuiColor::LightYellow,\n\n // Web\n \"js\" | \"mjs\" | \"cjs\" => TuiColor::LightGreen,\n \"ts\" | \"tsx\" | \"jsx\" => TuiColor::LightCyan,\n \"html\" | \"htm\" => TuiColor::Magenta,\n \"css\" | \"scss\" | \"less\" => TuiColor::LightMagenta,\n\n // Scripting / automation\n \"py\" => TuiColor::LightYellow,\n \"sh\" | \"bash\" | \"zsh\" => TuiColor::Gray,\n \"rb\" => TuiColor::LightRed,\n \"pl\" => TuiColor::LightCyan,\n \"php\" => TuiColor::LightMagenta,\n \"lua\" => TuiColor::LightBlue,\n\n // Data / config / markup\n \"json\" | \"toml\" | \"yaml\" | \"yml\" => TuiColor::Magenta,\n \"xml\" => TuiColor::LightGreen,\n \"csv\" => TuiColor::Green,\n \"ini\" => TuiColor::Gray,\n\n // Docs\n \"md\" | \"txt\" | \"rst\" | \"adoc\" => TuiColor::Green,\n \"pdf\" => TuiColor::Red,\n\n // Default\n _ => TuiColor::White,\n }\n }\n}\n\n/// Format token map entries for TUI display with adaptive layout.\n///\n/// Creates formatted lines with tree structure and color information suitable\n/// for rendering in a TUI interface using ratatui. This function uses the same\n/// adaptive layout logic as the CLI version but returns structured data components\n/// instead of printing directly.\n///\n/// # Arguments\n///\n/// * `entries` - The token map entries to format\n/// * `total_tokens` - Total token count for percentage calculations\n/// * `terminal_width` - Width of the terminal/TUI area for adaptive layout\n///\n/// # Returns\n///\n/// * `Vec` - Formatted lines ready for TUI rendering\npub fn format_token_map_for_tui(\n entries: &[TokenMapEntry],\n total_tokens: usize,\n terminal_width: usize,\n) -> Vec {\n if entries.is_empty() {\n return Vec::new();\n }\n\n // Use the same adaptive layout logic as CLI\n let terminal_width = terminal_width.max(80); // Minimum width\n\n // Calculate max token width for alignment (same as CLI)\n let max_token_width = entries\n .iter()\n .map(|e| format_tokens(e.tokens).len())\n .max()\n .unwrap_or(3)\n .max(format_tokens(total_tokens).len())\n .max(4);\n\n // Calculate max name length including tree prefix (same as CLI)\n let max_name_length = entries\n .iter()\n .map(|e| {\n let prefix_width = if e.depth == 0 { 3 } else { (e.depth * 2) + 3 };\n prefix_width + UnicodeWidthStr::width(e.name.as_str())\n })\n .max()\n .unwrap_or(20)\n .min(terminal_width / 2);\n\n // Calculate bar width (adjusted for TUI to prevent overflow)\n // TUI needs a bit more space than CLI to prevent the percentage column from overflowing\n let bar_width = terminal_width\n .saturating_sub(max_token_width + 3 + max_name_length + 2 + 2 + 7) // +2 more chars for TUI\n .max(15); // Minimum bar width reduced slightly for TUI\n\n // Initialize parent bars array (same as CLI)\n let mut parent_bars: Vec = vec![String::new(); 10];\n parent_bars[0] = \"█\".repeat(bar_width);\n\n let mut lines = Vec::new();\n\n for (i, entry) in entries.iter().enumerate() {\n // Build tree prefix using shared logic\n let prefix = build_tree_prefix(entry, entries, i);\n\n // Format tokens\n let tokens_str = format_tokens(entry.tokens);\n\n // Generate hierarchical bar (same as CLI)\n let parent_bar = if entry.depth > 0 {\n &parent_bars[entry.depth - 1]\n } else {\n &parent_bars[0]\n };\n\n let bar = generate_hierarchical_bar(bar_width, parent_bar, entry.percentage, entry.depth);\n\n // Update parent bars (same as CLI)\n if entry.depth < parent_bars.len() {\n parent_bars[entry.depth] = bar.clone();\n }\n\n // Format percentage\n let percentage_str = format!(\"{:>4.0}%\", entry.percentage);\n\n // Calculate padding for name (same as CLI)\n let prefix_display_width = prefix.chars().count();\n let name_padding = max_name_length\n .saturating_sub(prefix_display_width + UnicodeWidthStr::width(entry.name.as_str()));\n\n // Create name with padding\n let name_with_padding = format!(\"{}{}\", entry.name, \" \".repeat(name_padding));\n\n // Determine color based on entry type and extension\n let name_color = determine_tui_color(entry);\n\n // Create structured components for TUI rendering\n lines.push(TuiTokenMapLine {\n tokens_part: format!(\"{:>width$}\", tokens_str, width = max_token_width),\n prefix_part: prefix,\n name_part: name_with_padding,\n name_color,\n bar_part: format!(\"│{}│\", bar),\n percentage_part: percentage_str,\n });\n }\n\n lines\n}\n\n// Format token counts with K/M suffixes (dust-style)\nfn format_tokens(tokens: usize) -> String {\n if tokens >= 1_000_000 {\n let millions = (tokens + 500_000) / 1_000_000;\n format!(\"{}M\", millions)\n } else if tokens >= 1_000 {\n let thousands = (tokens + 500) / 1_000;\n format!(\"{}K\", thousands)\n } else {\n format!(\"{}\", tokens)\n }\n}\n\n// Generate bar with dust-style depth shading\nfn generate_hierarchical_bar(\n bar_width: usize,\n parent_bar: &str,\n percentage: f64,\n depth: usize,\n) -> String {\n // Calculate how many characters should be filled for this entry\n let filled_chars = ((percentage / 100.0) * bar_width as f64).round() as usize;\n let mut result = String::new();\n\n // Depth determines which shade to use for parent's solid blocks\n let shade_char = match depth.max(1) {\n 1 => ' ', // Level 1: parent blocks become spaces\n 2 => '░', // Level 2: light shade\n 3 => '▒', // Level 3: medium shade\n _ => '▓', // Level 4+: dark shade\n };\n\n // Process each character position\n let parent_chars: Vec = parent_bar.chars().collect();\n for i in 0..bar_width {\n if i < filled_chars {\n // This is our filled portion - always solid\n result.push('█');\n } else if i < parent_chars.len() {\n // This is parent's portion\n let parent_char = parent_chars[i];\n if parent_char == '█' {\n // Replace parent's solid blocks with our shade\n result.push(shade_char);\n } else {\n // Keep parent's existing shading\n result.push(parent_char);\n }\n } else {\n // Beyond parent's bar - empty\n result.push(' ');\n }\n }\n\n result\n}\n"
},
{
"path": "crates/code2prompt/src/tui.rs",
"content": "//! Terminal User Interface implementation.\n//!\n//! This module implements the complete TUI for code2prompt using ratatui and crossterm.\n//! It provides a tabbed interface with file selection, settings configuration,\n//! statistics viewing, and prompt output. The interface supports keyboard navigation,\n//! file tree browsing, real-time analysis, and clipboard integration.\n\nuse anyhow::Result;\nuse code2prompt_core::session::Code2PromptSession;\nuse crossterm::{\n execute,\n terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},\n};\nuse ratatui::{\n crossterm::event::{KeyCode, KeyEvent, KeyModifiers},\n prelude::*,\n widgets::*,\n};\nuse std::io::{Stdout, stdout};\nuse tokio::sync::mpsc;\n\nuse crate::clipboard::copy_to_clipboard;\nuse crate::model::{\n AnalysisResults, Cmd, FileTreeInputMode, Message, Model, StatisticsView, Tab, TemplateState,\n template::{FocusMode, TemplateFocus, VariableCategory},\n};\nuse crate::token_map::generate_token_map_with_limit;\nuse crate::utils::{save_template_to_custom_dir, save_to_file};\nuse crate::widgets::{\n FileSelectionWidget, OutputWidget, SettingsWidget, StatisticsByExtensionWidget,\n StatisticsOverviewWidget, StatisticsTokenMapWidget, TemplateWidget,\n};\n\nuse crate::utils::build_file_tree_from_session;\n\npub struct TuiApp {\n model: Model,\n terminal: Terminal>,\n message_tx: mpsc::UnboundedSender,\n message_rx: mpsc::UnboundedReceiver,\n}\n\nimpl TuiApp {\n /// Create a new TUI application.\n ///\n /// Initializes the terminal and sets up the application state from the provided session.\n /// The initial file tree is requested via a `RefreshFileTree` message in `run()`.\n ///\n /// Returns an error if the terminal cannot be initialized.\n pub fn new(session: Code2PromptSession) -> Result {\n let terminal = init_terminal()?;\n let (message_tx, message_rx) = mpsc::unbounded_channel();\n let model = Model::new(session);\n\n Ok(Self {\n model,\n terminal,\n message_tx,\n message_rx,\n })\n }\n\n // ~~~ Optimized Main Loop ~~~\n pub async fn run(&mut self) -> Result<()> {\n // Initialize file tree\n self.handle_message(Message::RefreshFileTree)?;\n\n loop {\n // Process all available events with coalescing\n let mut messages = Vec::new();\n\n // Drain all available keyboard events\n while crossterm::event::poll(std::time::Duration::from_millis(0))? {\n if let crossterm::event::Event::Key(key) = crossterm::event::read()?\n && key.kind == crossterm::event::KeyEventKind::Press\n {\n // Convert to ratatui KeyEvent\n let ratatui_key = self.convert_crossterm_key(key);\n\n // Handle the key event\n if let Some(message) = self.handle_key_event(ratatui_key) {\n if let Some(last_message) = messages.last_mut()\n && self.try_coalesce_messages(last_message, &message)\n {\n continue; // Message was coalesced\n }\n messages.push(message);\n }\n }\n }\n\n // Handle all messages\n for message in messages {\n self.handle_message(message)?;\n }\n\n // Handle internal messages (non-blocking)\n while let Ok(message) = self.message_rx.try_recv() {\n self.handle_message(message)?;\n }\n\n // Render the UI\n let model = self.model.clone();\n self.terminal.draw(|frame| {\n TuiApp::render_with_model(&model, frame);\n })?;\n\n if self.model.should_quit {\n break;\n }\n\n // Small sleep to prevent busy waiting\n tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;\n }\n\n Ok(())\n }\n\n /// Render the TUI using the provided model and frame.\n ///\n /// This function handles the layout and rendering of all components based on the current state.\n /// It divides the terminal into sections for the tab bar, content area, and status bar,\n /// and renders the appropriate widgets for the active tab.\n ///\n /// # Arguments\n ///\n /// * `model` - The current application state model\n /// * `frame` - The frame to render the UI components onto\n ///\n fn render_with_model(model: &Model, frame: &mut Frame) {\n let area = frame.area();\n\n // ~~~ Main layout ~~~\n let main_layout = Layout::default()\n .direction(Direction::Vertical)\n .constraints([\n Constraint::Length(3), // Tab bar\n Constraint::Min(0), // Content\n Constraint::Length(3), // Status bar\n ])\n .split(area);\n\n // Tab bar\n Self::render_tab_bar_static(model, frame, main_layout[0]);\n\n // Current tab content\n match model.current_tab {\n Tab::FileTree => {\n let widget = FileSelectionWidget::new(model);\n let mut state = ();\n frame.render_stateful_widget(widget, main_layout[1], &mut state);\n }\n Tab::Settings => {\n let widget = SettingsWidget::new(model);\n let mut state = ();\n frame.render_stateful_widget(widget, main_layout[1], &mut state);\n }\n Tab::Statistics => match model.statistics.view {\n StatisticsView::Overview => {\n let widget = StatisticsOverviewWidget::new(model);\n frame.render_widget(widget, main_layout[1]);\n }\n StatisticsView::TokenMap => {\n let widget = StatisticsTokenMapWidget::new(model);\n let mut state = ();\n frame.render_stateful_widget(widget, main_layout[1], &mut state);\n }\n StatisticsView::Extensions => {\n let widget = StatisticsByExtensionWidget::new(model);\n let mut state = ();\n frame.render_stateful_widget(widget, main_layout[1], &mut state);\n }\n },\n Tab::Template => {\n let widget = TemplateWidget::new(model);\n let mut state = TemplateState::from_model(model);\n frame.render_stateful_widget(widget, main_layout[1], &mut state);\n }\n Tab::PromptOutput => {\n let widget = OutputWidget::new(model);\n let mut state = ();\n frame.render_stateful_widget(widget, main_layout[1], &mut state);\n }\n }\n\n // Status bar\n Self::render_status_bar_static(model, frame, main_layout[2]);\n }\n\n /// Handle a key event and return an optional message.\n ///\n /// This function processes keyboard input, prioritizing search mode\n /// when active. It handles global shortcuts for tab switching and quitting,\n /// as well as delegating tab-specific key events to the appropriate handlers.\n /// # Arguments\n ///\n /// * `key` - The key event to handle.\n ///\n /// # Returns\n ///\n /// * `Option` - An optional message to be processed by the main loop.\n /// \n fn handle_key_event(&self, key: KeyEvent) -> Option {\n // Check if we're in search mode first - this takes priority over global shortcuts\n if self.model.file_tree_input_mode == FileTreeInputMode::Search\n && self.model.current_tab == Tab::FileTree\n {\n return self.handle_file_tree_keys(key);\n }\n\n // Check if we're in template editing mode - ESC should exit editing mode, not quit app\n if self.model.current_tab == Tab::Template && self.model.template.is_in_editing_mode() {\n if key.code == KeyCode::Esc {\n return Some(Message::SetTemplateFocusMode(FocusMode::Normal));\n }\n // In editing modes, delegate to template handler\n return self.handle_template_keys(key);\n }\n\n // Global shortcuts (only when not in search mode or template editing mode)\n match key.code {\n KeyCode::Char('q') if key.modifiers.contains(KeyModifiers::CONTROL) => {\n return Some(Message::Quit);\n }\n KeyCode::Esc => return Some(Message::Quit),\n KeyCode::Char('1') => return Some(Message::SwitchTab(Tab::FileTree)),\n KeyCode::Char('2') => return Some(Message::SwitchTab(Tab::Settings)),\n KeyCode::Char('3') => return Some(Message::SwitchTab(Tab::Statistics)),\n KeyCode::Char('4') => return Some(Message::SwitchTab(Tab::Template)),\n KeyCode::Char('5') => return Some(Message::SwitchTab(Tab::PromptOutput)),\n KeyCode::Tab if !key.modifiers.contains(KeyModifiers::SHIFT) => {\n // Cycle through tabs: Selection -> Settings -> Statistics -> Template -> Output -> Selection\n let next_tab = match self.model.current_tab {\n Tab::FileTree => Tab::Settings,\n Tab::Settings => Tab::Statistics,\n Tab::Statistics => Tab::Template,\n Tab::Template => Tab::PromptOutput,\n Tab::PromptOutput => Tab::FileTree,\n };\n return Some(Message::SwitchTab(next_tab));\n }\n KeyCode::BackTab | KeyCode::Tab if key.modifiers.contains(KeyModifiers::SHIFT) => {\n // Cycle through tabs in reverse: Selection <- Settings <- Statistics <- Template <- Output <- Selection\n let prev_tab = match self.model.current_tab {\n Tab::FileTree => Tab::PromptOutput,\n Tab::Settings => Tab::FileTree,\n Tab::Statistics => Tab::Settings,\n Tab::Template => Tab::Statistics,\n Tab::PromptOutput => Tab::Template,\n };\n return Some(Message::SwitchTab(prev_tab));\n }\n _ => {}\n }\n\n // Tab-specific shortcuts\n match self.model.current_tab {\n Tab::FileTree => self.handle_file_tree_keys(key),\n Tab::Settings => self.handle_settings_keys(key),\n Tab::Statistics => self.handle_statistics_keys(key),\n Tab::Template => self.handle_template_keys(key),\n Tab::PromptOutput => self.handle_prompt_output_keys(key),\n }\n }\n\n fn handle_file_tree_keys(&self, key: KeyEvent) -> Option {\n // Pure logic in TUI - no direct widget calls (Elm/Redux pattern)\n if self.model.file_tree_input_mode == FileTreeInputMode::Search {\n match key.code {\n KeyCode::Esc => Some(Message::ExitSearchMode),\n KeyCode::Enter => {\n // Apply search and exit search mode\n Some(Message::ExitSearchMode)\n }\n KeyCode::Backspace => {\n let mut query = self.model.search_query.clone();\n query.pop();\n Some(Message::UpdateSearchQuery(query))\n }\n KeyCode::Char(c) => {\n let mut query = self.model.search_query.clone();\n query.push(c);\n Some(Message::UpdateSearchQuery(query))\n }\n _ => None,\n }\n } else {\n // Normal navigation mode\n match key.code {\n KeyCode::Up => Some(Message::MoveTreeCursor(-1)),\n KeyCode::Down => Some(Message::MoveTreeCursor(1)),\n KeyCode::PageUp => Some(Message::MoveTreeCursor(-10)),\n KeyCode::PageDown => Some(Message::MoveTreeCursor(10)),\n KeyCode::Home => Some(Message::MoveTreeCursor(-9999)),\n KeyCode::End => Some(Message::MoveTreeCursor(9999)),\n KeyCode::Char(' ') => Some(Message::ToggleFileSelection(self.model.tree_cursor)),\n KeyCode::Enter => Some(Message::RunAnalysis),\n KeyCode::Right => Some(Message::ExpandDirectory(self.model.tree_cursor)),\n KeyCode::Left => Some(Message::CollapseDirectory(self.model.tree_cursor)),\n KeyCode::Char('/') => Some(Message::EnterSearchMode),\n KeyCode::Char('s') | KeyCode::Char('S') => Some(Message::EnterSearchMode),\n KeyCode::Char('r') | KeyCode::Char('R') => Some(Message::RefreshFileTree),\n _ => None,\n }\n }\n }\n\n fn handle_settings_keys(&self, key: KeyEvent) -> Option {\n match key.code {\n KeyCode::Up => Some(Message::MoveSettingsCursor(-1)),\n KeyCode::Down => Some(Message::MoveSettingsCursor(1)),\n KeyCode::Char(' ') => Some(Message::ToggleSetting(self.model.settings.settings_cursor)),\n KeyCode::Left | KeyCode::Right => {\n Some(Message::CycleSetting(self.model.settings.settings_cursor))\n }\n KeyCode::Enter => Some(Message::RunAnalysis),\n _ => None,\n }\n }\n\n fn handle_statistics_keys(&self, key: KeyEvent) -> Option {\n match key.code {\n KeyCode::Enter => Some(Message::RunAnalysis),\n KeyCode::Left => Some(Message::CycleStatisticsView(-1)), // Previous view\n KeyCode::Right => Some(Message::CycleStatisticsView(1)), // Next view\n KeyCode::Up => Some(Message::ScrollStatistics(-1)),\n KeyCode::Down => Some(Message::ScrollStatistics(1)),\n KeyCode::PageUp => Some(Message::ScrollStatistics(-5)),\n KeyCode::PageDown => Some(Message::ScrollStatistics(5)),\n KeyCode::Home => Some(Message::ScrollStatistics(-9999)),\n KeyCode::End => Some(Message::ScrollStatistics(9999)),\n _ => None,\n }\n }\n\n fn handle_template_keys(&self, key: KeyEvent) -> Option {\n let is_in_editing_mode = self.model.template.is_in_editing_mode();\n let current_focus = self.model.template.get_focus();\n\n // Handle ESC key to exit editing modes\n if key.code == KeyCode::Esc && is_in_editing_mode {\n return Some(Message::SetTemplateFocusMode(FocusMode::Normal));\n }\n\n if is_in_editing_mode {\n match current_focus {\n TemplateFocus::Editor => {\n return Some(Message::TemplateEditorInput(key));\n }\n TemplateFocus::Variables => {\n if self.model.template.variables.is_editing() {\n // Currently editing a variable value\n match key.code {\n KeyCode::Char(c) => return Some(Message::VariableInputChar(c)),\n KeyCode::Backspace => return Some(Message::VariableInputBackspace),\n KeyCode::Enter => return Some(Message::VariableInputEnter),\n KeyCode::Esc => return Some(Message::VariableInputCancel),\n _ => return None,\n }\n } else {\n // Navigating variables list\n match key.code {\n KeyCode::Up => return Some(Message::VariableNavigateUp),\n KeyCode::Down => return Some(Message::VariableNavigateDown),\n KeyCode::Enter | KeyCode::Char(' ') => {\n // Start editing the current variable\n let variables = self.model.template.get_organized_variables();\n if let Some(var) =\n variables.get(self.model.template.variables.cursor)\n && var.category == VariableCategory::Missing\n {\n return Some(Message::VariableStartEditing(var.name.clone()));\n }\n return None;\n }\n _ => return None,\n }\n }\n }\n _ => {}\n }\n }\n\n // Normal mode: Handle global shortcuts and focus switching\n match key.code {\n KeyCode::Char('e') | KeyCode::Char('E') => {\n return Some(Message::SetTemplateFocus(\n TemplateFocus::Editor,\n FocusMode::EditingTemplate,\n ));\n }\n KeyCode::Char('v') | KeyCode::Char('V') => {\n return Some(Message::SetTemplateFocus(\n TemplateFocus::Variables,\n FocusMode::EditingVariable,\n ));\n }\n KeyCode::Char('p') | KeyCode::Char('P') => {\n return Some(Message::SetTemplateFocus(\n TemplateFocus::Picker,\n FocusMode::Normal,\n ));\n }\n KeyCode::Char('s') | KeyCode::Char('S') => {\n // Save template with timestamp\n let timestamp = chrono::Utc::now().format(\"%Y%m%d_%H%M%S\");\n let filename = format!(\"custom_template_{}\", timestamp);\n return Some(Message::SaveTemplate(filename));\n }\n KeyCode::Char('r') | KeyCode::Char('R') => {\n // Reload default template\n return Some(Message::ReloadTemplate);\n }\n KeyCode::Enter => {\n // Run analysis\n return Some(Message::RunAnalysis);\n }\n _ => {}\n }\n\n // Handle input for focused component in normal mode\n if current_focus == TemplateFocus::Picker {\n match key.code {\n KeyCode::Up => return Some(Message::TemplatePickerMove(-1)),\n KeyCode::Down => return Some(Message::TemplatePickerMove(1)),\n KeyCode::Enter | KeyCode::Char('l') | KeyCode::Char('L') | KeyCode::Char(' ') => {\n return Some(Message::LoadTemplate);\n }\n KeyCode::Char('r') | KeyCode::Char('R') => {\n return Some(Message::RefreshTemplates);\n }\n _ => {}\n }\n }\n\n None\n }\n\n fn handle_prompt_output_keys(&self, key: KeyEvent) -> Option {\n match key.code {\n KeyCode::Up => Some(Message::ScrollOutput(-1)),\n KeyCode::Down => Some(Message::ScrollOutput(1)),\n KeyCode::PageUp => Some(Message::ScrollOutput(-10)),\n KeyCode::PageDown => Some(Message::ScrollOutput(10)),\n KeyCode::Home => Some(Message::ScrollOutput(-9999)),\n KeyCode::End => Some(Message::ScrollOutput(9999)),\n KeyCode::Char('c') | KeyCode::Char('C') => Some(Message::CopyToClipboard),\n KeyCode::Char('s') | KeyCode::Char('S') => {\n let timestamp = chrono::Utc::now().format(\"%Y%m%d_%H%M%S\");\n let filename = format!(\"prompt_{}.md\", timestamp);\n Some(Message::SaveToFile(filename))\n }\n KeyCode::Enter => Some(Message::RunAnalysis),\n _ => None,\n }\n }\n\n /// Handle a message using the Elm/Redux pattern.\n /// This uses the pure Model::update() function and executes any side effects.\n fn handle_message(&mut self, message: Message) -> Result<()> {\n let (new_model, cmd) = self.model.update(message);\n self.model = new_model;\n\n // Execute any side effects\n self.execute_cmd(cmd)?;\n\n Ok(())\n }\n\n /// Execute a command (side effect) from the Model::update() function.\n /// This is where all the impure operations happen.\n fn execute_cmd(&mut self, cmd: Cmd) -> Result<()> {\n match cmd {\n Cmd::None => {\n // No side effect\n }\n\n Cmd::RefreshFileTree => {\n // Always use session-based tree building for proper pattern initialization\n match build_file_tree_from_session(&mut self.model.session) {\n Ok(tree) => {\n self.model.file_tree_nodes = tree;\n self.model.status_message =\n \"File tree loaded with patterns applied and files auto-expanded\"\n .to_string();\n }\n Err(e) => {\n self.model.status_message = format!(\"Error loading files: {}\", e);\n }\n }\n }\n\n Cmd::RunAnalysis {\n template_content,\n user_variables,\n } => {\n // Use the current session state (with all user selections)\n let mut session = self.model.session.clone();\n let tx = self.message_tx.clone();\n\n tokio::spawn(async move {\n // Set custom template content\n session.config.template_str = template_content;\n session.config.template_name = \"Custom Template\".to_string();\n\n // Transfer user variables from TUI to session config\n session.config.user_variables = user_variables;\n\n match session.generate_prompt() {\n Ok(rendered) => {\n // Convert to AnalysisResults format expected by TUI\n let token_map_entries = if rendered.token_count > 0 {\n if let Some(files) = session.data.files.as_ref() {\n generate_token_map_with_limit(\n files,\n rendered.token_count,\n Some(50),\n Some(0.5),\n )\n } else {\n Vec::new()\n }\n } else {\n Vec::new()\n };\n\n let result = AnalysisResults {\n file_count: rendered.files.len(),\n token_count: Some(rendered.token_count),\n generated_prompt: rendered.prompt,\n token_map_entries,\n };\n let _ = tx.send(Message::AnalysisComplete(result));\n }\n Err(e) => {\n let _ = tx.send(Message::AnalysisError(e.to_string()));\n }\n }\n });\n }\n\n Cmd::CopyToClipboard(content) => match copy_to_clipboard(&content) {\n Ok(_) => {\n self.model.status_message = \"Copied to clipboard!\".to_string();\n }\n Err(e) => {\n self.model.status_message = format!(\"Copy failed: {}\", e);\n }\n },\n\n Cmd::SaveToFile { filename, content } => {\n match save_to_file(std::path::Path::new(&filename), &content) {\n Ok(_) => {\n self.model.status_message = format!(\"Saved to {}\", filename);\n }\n Err(e) => {\n self.model.status_message = format!(\"Save failed: {}\", e);\n }\n }\n }\n\n Cmd::SaveTemplate { filename, content } => {\n match save_template_to_custom_dir(std::path::Path::new(&filename), &content) {\n Ok(_) => {\n self.model.status_message = format!(\"Template saved as {}\", filename);\n // Refresh templates to show the new one\n self.model.template.picker.refresh();\n }\n Err(e) => {\n self.model.status_message = format!(\"Template save failed: {}\", e);\n }\n }\n }\n }\n\n Ok(())\n }\n\n fn render_tab_bar_static(model: &Model, frame: &mut Frame, area: Rect) {\n let tabs = vec![\n \"1. Selection\",\n \"2. Settings\",\n \"3. Statistics\",\n \"4. Template\",\n \"5. Output\",\n ];\n let selected = match model.current_tab {\n Tab::FileTree => 0,\n Tab::Settings => 1,\n Tab::Statistics => 2,\n Tab::Template => 3,\n Tab::PromptOutput => 4,\n };\n\n let tabs_widget = Tabs::new(tabs)\n .block(\n Block::default()\n .borders(Borders::ALL)\n .title(\"Code2Prompt TUI\"),\n )\n .select(selected)\n .style(Style::default().fg(Color::White))\n .highlight_style(\n Style::default()\n .fg(Color::Yellow)\n .add_modifier(Modifier::BOLD),\n );\n\n frame.render_widget(tabs_widget, area);\n }\n\n fn render_status_bar_static(model: &Model, frame: &mut Frame, area: Rect) {\n let status_text = if !model.status_message.is_empty() {\n model.status_message.clone()\n } else {\n \"Tab/Shift+Tab: Switch tabs | 1/2/3/4: Direct tab | Enter: Run Analysis | Esc/Ctrl+Q: Quit\".to_string()\n };\n\n let status_widget = Paragraph::new(status_text)\n .block(Block::default().borders(Borders::ALL))\n .style(Style::default().fg(Color::Cyan));\n frame.render_widget(status_widget, area);\n }\n\n /// Convert crossterm KeyEvent to ratatui KeyEvent\n fn convert_crossterm_key(&self, key: crossterm::event::KeyEvent) -> KeyEvent {\n use ratatui::crossterm::event::{KeyCode, KeyEventKind, KeyEventState, KeyModifiers};\n\n KeyEvent {\n code: match key.code {\n crossterm::event::KeyCode::Backspace => KeyCode::Backspace,\n crossterm::event::KeyCode::Enter => KeyCode::Enter,\n crossterm::event::KeyCode::Left => KeyCode::Left,\n crossterm::event::KeyCode::Right => KeyCode::Right,\n crossterm::event::KeyCode::Up => KeyCode::Up,\n crossterm::event::KeyCode::Down => KeyCode::Down,\n crossterm::event::KeyCode::Home => KeyCode::Home,\n crossterm::event::KeyCode::End => KeyCode::End,\n crossterm::event::KeyCode::PageUp => KeyCode::PageUp,\n crossterm::event::KeyCode::PageDown => KeyCode::PageDown,\n crossterm::event::KeyCode::Tab => KeyCode::Tab,\n crossterm::event::KeyCode::BackTab => KeyCode::BackTab,\n crossterm::event::KeyCode::Delete => KeyCode::Delete,\n crossterm::event::KeyCode::Insert => KeyCode::Insert,\n crossterm::event::KeyCode::F(n) => KeyCode::F(n),\n crossterm::event::KeyCode::Char(c) => KeyCode::Char(c),\n crossterm::event::KeyCode::Null => KeyCode::Null,\n crossterm::event::KeyCode::Esc => KeyCode::Esc,\n _ => KeyCode::Null, // Simplified for other key codes\n },\n modifiers: KeyModifiers::from_bits_truncate(key.modifiers.bits()),\n kind: match key.kind {\n crossterm::event::KeyEventKind::Press => KeyEventKind::Press,\n crossterm::event::KeyEventKind::Repeat => KeyEventKind::Repeat,\n crossterm::event::KeyEventKind::Release => KeyEventKind::Release,\n },\n state: KeyEventState::from_bits_truncate(key.state.bits()),\n }\n }\n\n /// Try to coalesce two messages if they are similar (e.g., scroll events)\n fn try_coalesce_messages(&self, last_message: &mut Message, new_message: &Message) -> bool {\n match (last_message, new_message) {\n (Message::MoveTreeCursor(delta1), Message::MoveTreeCursor(delta2)) => {\n *delta1 += delta2;\n true\n }\n (Message::MoveSettingsCursor(delta1), Message::MoveSettingsCursor(delta2)) => {\n *delta1 += delta2;\n true\n }\n (Message::ScrollStatistics(delta1), Message::ScrollStatistics(delta2)) => {\n *delta1 += delta2;\n true\n }\n (Message::ScrollOutput(delta1), Message::ScrollOutput(delta2)) => {\n *delta1 += delta2;\n true\n }\n (Message::TemplatePickerMove(delta1), Message::TemplatePickerMove(delta2)) => {\n *delta1 += delta2;\n true\n }\n _ => false, // Cannot coalesce these messages\n }\n }\n}\n\n/// Run the Terminal User Interface.\n///\n/// This is the main entry point for the TUI mode. It parses command-line arguments,\n/// initializes the TUI application, and runs the main event loop until the user exits.\n///\n/// # Returns\n///\n/// * `Result<()>` - Ok on successful exit, Err if initialization or runtime errors occur\n///\n/// # Errors\n///\n/// Returns an error if the TUI cannot be initialized or if runtime errors occur during execution.\npub async fn run_tui(session: Code2PromptSession) -> Result<()> {\n let mut app = TuiApp::new(session)?;\n\n let result = app.run().await;\n\n // Clean up terminal\n restore_terminal()?;\n\n result\n}\n\nfn init_terminal() -> Result>> {\n enable_raw_mode()?;\n let mut stdout = stdout();\n execute!(stdout, EnterAlternateScreen)?;\n let backend = CrosstermBackend::new(stdout);\n Terminal::new(backend).map_err(Into::into)\n}\n\nfn restore_terminal() -> Result<()> {\n disable_raw_mode()?;\n execute!(stdout(), LeaveAlternateScreen)?;\n Ok(())\n}\n"
},
{
"path": "crates/code2prompt/src/utils.rs",
"content": "//! Utility functions for the TUI application.\n//!\n//! This module contains helper functions for building file trees,\n//! managing file operations, and other utility functions used throughout the TUI.\n\nuse crate::model::DisplayFileNode;\nuse anyhow::Result;\nuse code2prompt_core::session::Code2PromptSession;\nuse regex::Regex;\nuse std::path::Path;\n\n/// Build hierarchical file tree from session using traverse_directory with SelectionEngine\npub fn build_file_tree_from_session(\n session: &mut Code2PromptSession,\n) -> Result> {\n let mut root_nodes = Vec::new();\n\n // Build root level nodes using ignore crate to respect gitignore\n use ignore::WalkBuilder;\n let walker = WalkBuilder::new(&session.config.path)\n .max_depth(Some(1))\n .git_ignore(!session.config.no_ignore) // Respect the no_ignore flag\n .hidden(!session.config.hidden) // Also respect the hidden flag for consistency\n .build();\n\n for entry in walker {\n let entry = entry?;\n let path = entry.path();\n\n if path == session.config.path {\n continue; // Skip root directory itself\n }\n\n let mut node = DisplayFileNode::new(path.to_path_buf(), 0);\n\n // Auto-expand recursively if directory contains selected files\n if node.is_directory {\n auto_expand_recursively(&mut node, session);\n }\n\n root_nodes.push(node);\n }\n\n // Sort root nodes: directories first, then alphabetically\n root_nodes.sort_by(|a, b| match (a.is_directory, b.is_directory) {\n (true, false) => std::cmp::Ordering::Less,\n (false, true) => std::cmp::Ordering::Greater,\n _ => a.name.cmp(&b.name),\n });\n\n Ok(root_nodes)\n}\n\n/// Recursively auto-expand directories that contain selected files\nfn auto_expand_recursively(node: &mut DisplayFileNode, session: &mut Code2PromptSession) {\n if !node.is_directory {\n return;\n }\n\n if directory_contains_selected_files(&node.path, session) {\n node.is_expanded = true;\n // Load children\n if let Err(e) = node.load_children(session) {\n eprintln!(\"Warning: Failed to load children for {}: {}\", node.name, e);\n return;\n }\n\n // Recursively auto-expand children\n for child in &mut node.children {\n if child.is_directory {\n auto_expand_recursively(child, session);\n }\n }\n }\n}\n\n/// Check if a directory contains any selected files (helper function)\npub(crate) fn directory_contains_selected_files(\n dir_path: &Path,\n session: &mut Code2PromptSession,\n) -> bool {\n if let Ok(entries) = std::fs::read_dir(dir_path) {\n for entry in entries.flatten() {\n let path = entry.path();\n let relative_path = if let Ok(rel) = path.strip_prefix(&session.config.path) {\n rel\n } else {\n continue;\n };\n\n if session.is_file_selected(relative_path) {\n return true;\n }\n\n // Recursively check subdirectories\n if path.is_dir() && directory_contains_selected_files(&path, session) {\n return true;\n }\n }\n }\n false\n}\n\n/// Get visible nodes for display (flattened tree with search filtering)\npub fn get_visible_nodes(\n nodes: &[DisplayFileNode],\n search_query: &str,\n session: &mut Code2PromptSession,\n) -> Vec {\n let mut visible = Vec::new();\n let search_active = !search_query.is_empty();\n let matcher = build_query_matcher(search_query);\n collect_visible_nodes_recursive(nodes, &matcher, session, &mut visible, search_active);\n visible\n}\n\n/// Simple matcher that supports case-insensitive substring and '*'/'?' wildcards.\nenum QueryMatcher {\n Substr(String),\n Regex(Regex),\n}\n\nfn build_query_matcher(raw: &str) -> QueryMatcher {\n // Trim incidental whitespace for more predictable matches.\n let raw = raw.trim();\n let has_wildcards = raw.contains('*') || raw.contains('?');\n if has_wildcards {\n // Escape regex meta, then re-introduce wildcards\n let mut pat = regex::escape(raw);\n pat = pat.replace(r\"\\*\", \".*\").replace(r\"\\?\", \".\");\n let anchored = format!(\"(?i)^{}$\", pat); // (?i) = case-insensitive\n QueryMatcher::Regex(Regex::new(&anchored).unwrap_or_else(|_| Regex::new(\".*\").unwrap()))\n } else {\n QueryMatcher::Substr(raw.to_lowercase())\n }\n}\n\nfn matches(m: &QueryMatcher, text: &str) -> bool {\n match m {\n QueryMatcher::Substr(needle) => text.to_lowercase().contains(needle),\n QueryMatcher::Regex(re) => re.is_match(text),\n }\n}\n\n/// Node with selection state for display\n#[derive(Debug, Clone)]\npub struct DisplayNodeWithSelection {\n pub node: DisplayFileNode,\n pub is_selected: bool,\n}\n\n/// Recursively collect visible nodes\nfn collect_visible_nodes_recursive(\n nodes: &[DisplayFileNode],\n matcher: &QueryMatcher,\n session: &mut Code2PromptSession,\n visible: &mut Vec,\n search_active: bool,\n) {\n for node in nodes {\n // Case-insensitive match on name or full path (with optional wildcards)\n let matches_current = if matches!(matcher, QueryMatcher::Substr(s) if s.is_empty()) {\n true\n } else {\n matches(matcher, &node.name) || matches(matcher, &node.path.to_string_lossy())\n };\n\n if search_active {\n // In search mode, traverse into directories regardless of expansion\n let mut child_results: Vec = Vec::new();\n if node.is_directory {\n let children = get_children_for_search(node, session);\n collect_visible_nodes_recursive(\n &children,\n matcher,\n session,\n &mut child_results,\n true,\n );\n }\n\n let include_self = matches_current || !child_results.is_empty();\n\n if include_self {\n let relative_path = if let Ok(rel) = node.path.strip_prefix(&session.config.path) {\n rel\n } else {\n &node.path\n };\n let is_selected = session.is_file_selected(relative_path);\n\n // Show directories as expanded in search results for better context\n let mut node_clone = node.clone();\n if node_clone.is_directory {\n node_clone.is_expanded = true;\n }\n\n visible.push(DisplayNodeWithSelection {\n node: node_clone,\n is_selected,\n });\n\n visible.extend(child_results);\n }\n } else {\n // Normal mode: only include node if it matches (empty query matches all)\n if matches_current {\n let relative_path = if let Ok(rel) = node.path.strip_prefix(&session.config.path) {\n rel\n } else {\n &node.path\n };\n let is_selected = session.is_file_selected(relative_path);\n\n visible.push(DisplayNodeWithSelection {\n node: node.clone(),\n is_selected,\n });\n\n // Only descend if the directory is expanded\n if node.is_directory && node.is_expanded {\n collect_visible_nodes_recursive(\n &node.children,\n matcher,\n session,\n visible,\n false,\n );\n }\n }\n }\n }\n}\n\n/// Save content to a file\npub fn save_to_file(path: &Path, content: &str) -> Result<()> {\n std::fs::write(path, content)?;\n Ok(())\n}\n\n/// Format a number with thousand separators according to TokenFormat\n///\n/// - TokenFormat::Raw: returns the number as-is (e.g., \"1234567\")\n/// - TokenFormat::Format: adds separators every 3 digits (e.g., \"1,234,567\")\n///\n/// # Arguments\n/// * `num` - The number to format\n/// * `format` - The token format setting\n///\n/// # Returns\n/// Formatted string representation of the number\npub fn format_number(num: usize, format: &code2prompt_core::tokenizer::TokenFormat) -> String {\n use code2prompt_core::tokenizer::TokenFormat;\n\n match format {\n TokenFormat::Raw => num.to_string(),\n TokenFormat::Format => {\n let s = num.to_string();\n let chars: Vec = s.chars().collect();\n let mut result = String::new();\n\n for (i, c) in chars.iter().enumerate() {\n if i > 0 && (chars.len() - i).is_multiple_of(3) {\n result.push(',');\n }\n result.push(*c);\n }\n result\n }\n }\n}\n\n/// Load children for search mode without mutating the original tree\nfn get_children_for_search(\n node: &DisplayFileNode,\n session: &mut Code2PromptSession,\n) -> Vec {\n if !node.is_directory {\n return Vec::new();\n }\n\n if node.children_loaded {\n return node.children.clone();\n }\n\n // Load children on the fly without mutating the original tree\n let mut children: Vec = Vec::new();\n\n // Use ignore crate to respect gitignore\n use ignore::WalkBuilder;\n let walker = WalkBuilder::new(&node.path)\n .max_depth(Some(1))\n .git_ignore(!session.config.no_ignore) // Respect the no_ignore flag\n .hidden(!session.config.hidden) // Also respect the hidden flag for consistency\n .build();\n\n for entry in walker.flatten() {\n let path = entry.path();\n if path == node.path {\n continue;\n }\n\n let mut child = DisplayFileNode::new(path.to_path_buf(), node.level + 1);\n\n // Auto-expand if contains selected files\n if child.is_directory && directory_contains_selected_files(&child.path, session) {\n child.is_expanded = true;\n }\n\n children.push(child);\n }\n\n // Sort children: directories first, then alphabetically\n children.sort_by(|a, b| match (a.is_directory, b.is_directory) {\n (true, false) => std::cmp::Ordering::Less,\n (false, true) => std::cmp::Ordering::Greater,\n _ => a.name.cmp(&b.name),\n });\n\n children\n}\n\n/// Save template to custom directory\npub fn save_template_to_custom_dir(filename: &Path, content: &str) -> Result<()> {\n let templates_dir = if let Some(cfg) = dirs::config_dir() {\n cfg.join(\"code2prompt\").join(\"templates\")\n } else {\n // Fallback to current directory if config_dir not available\n std::env::current_dir()?.join(\"templates\")\n };\n\n std::fs::create_dir_all(&templates_dir)?;\n let full_path = templates_dir.join(filename);\n std::fs::write(full_path, content)?;\n Ok(())\n}\n\n/// Find custom templates and return (display_name, absolute_path).\npub fn load_all_templates() -> Result> {\n let mut out = Vec::new();\n\n // Candidate roots\n let mut roots = Vec::new();\n roots.push(std::env::current_dir()?.join(\"templates\"));\n if let Some(cfg) = dirs::config_dir() {\n roots.push(cfg.join(\"code2prompt\").join(\"templates\"));\n }\n\n // Accept common template extensions\n let is_template = |p: &Path| {\n matches!(\n p.extension().and_then(|e| e.to_str()),\n Some(\"hbs\") | Some(\"handlebars\") | Some(\"md\") | Some(\"tmpl\")\n )\n };\n\n for root in roots {\n if !root.exists() {\n continue;\n }\n for entry in walkdir::WalkDir::new(&root).min_depth(1).max_depth(2) {\n let entry = entry?;\n let p = entry.path();\n if p.is_file() && is_template(p) {\n let name = p\n .file_stem()\n .and_then(|s| s.to_str())\n .unwrap_or(\"template\")\n .to_string();\n out.push((\n name,\n p.canonicalize()\n .unwrap_or_else(|_| p.to_path_buf())\n .to_string_lossy()\n .into(),\n ));\n }\n }\n }\n\n // De-duplicate (same path could appear twice)\n // Let the compiler infer tuple types for the sort closure.\n out.sort_by(|a: &(String, String), b: &(String, String)| a.0.cmp(&b.0).then(a.1.cmp(&b.1)));\n out.dedup_by(|a, b| a.1 == b.1);\n\n Ok(out)\n}\n\n/// Ensure a path exists in the file tree by creating missing intermediate nodes\npub fn ensure_path_exists_in_tree(\n root_nodes: &mut Vec,\n target_path: &Path,\n session: &mut Code2PromptSession,\n) -> Result<()> {\n let root_path = &session.config.path;\n\n // Get relative path components\n let relative_path = if let Ok(rel) = target_path.strip_prefix(root_path) {\n rel\n } else {\n return Ok(()); // Path is not under root, nothing to do\n };\n\n let components: Vec<_> = relative_path.components().collect();\n if components.is_empty() {\n return Ok(());\n }\n\n // Build path incrementally\n let mut current_path = root_path.to_path_buf();\n let mut current_nodes = root_nodes;\n\n for (level, component) in components.into_iter().enumerate() {\n current_path.push(component);\n\n // Find or create node at this level\n let node_name = component.as_os_str().to_string_lossy().to_string();\n\n // Look for existing node\n let existing_index = current_nodes.iter().position(|n| n.name == node_name);\n\n if let Some(index) = existing_index {\n // Node exists, ensure it's loaded if it's a directory\n let node = &mut current_nodes[index];\n if node.is_directory && !node.children_loaded {\n let _ = node.load_children(session);\n }\n current_nodes = &mut current_nodes[index].children;\n } else {\n // Node doesn't exist, create it\n let mut new_node = DisplayFileNode::new(current_path.clone(), level);\n\n if new_node.is_directory {\n let _ = new_node.load_children(session);\n }\n\n current_nodes.push(new_node);\n\n // Sort to maintain order\n current_nodes.sort_by(|a, b| match (a.is_directory, b.is_directory) {\n (true, false) => std::cmp::Ordering::Less,\n (false, true) => std::cmp::Ordering::Greater,\n _ => a.name.cmp(&b.name),\n });\n\n // Find the newly inserted node\n let new_index = current_nodes\n .iter()\n .position(|n| n.name == node_name)\n .unwrap();\n current_nodes = &mut current_nodes[new_index].children;\n }\n }\n\n Ok(())\n}\n"
},
{
"path": "crates/code2prompt/src/view/formatters.rs",
"content": "//! Formatting functions for display purposes.\n//!\n//! This module contains pure functions that format data for display in the TUI.\n//! These functions were previously scattered in Model and widgets.\n\nuse code2prompt_core::sort::FileSortMethod;\nuse code2prompt_core::template::OutputFormat;\nuse code2prompt_core::tokenizer::TokenFormat;\nuse code2prompt_core::{session::Code2PromptSession, tokenizer::TokenizerType};\n\nuse crate::model::{SettingKey, SettingType, SettingsGroup, SettingsItem};\n\n/// Format settings groups for display\npub fn format_settings_groups(session: &Code2PromptSession) -> Vec {\n vec![\n SettingsGroup {\n name: \"Output Format\".to_string(),\n items: vec![\n SettingsItem {\n key: SettingKey::LineNumbers,\n name: \"Line Numbers\".to_string(),\n description: \"Show line numbers in output\".to_string(),\n setting_type: SettingType::Boolean(session.config.line_numbers),\n },\n SettingsItem {\n key: SettingKey::AbsolutePaths,\n name: \"Absolute Paths\".to_string(),\n description: \"Use absolute instead of relative paths\".to_string(),\n setting_type: SettingType::Boolean(session.config.absolute_path),\n },\n SettingsItem {\n key: SettingKey::NoCodeblock,\n name: \"No Codeblock\".to_string(),\n description: \"Don't wrap code in markdown blocks\".to_string(),\n setting_type: SettingType::Boolean(session.config.no_codeblock),\n },\n SettingsItem {\n key: SettingKey::OutputFormat,\n name: \"Output Format\".to_string(),\n description: \"Format for generated output\".to_string(),\n setting_type: SettingType::Choice {\n options: vec![\n \"Markdown\".to_string(),\n \"JSON\".to_string(),\n \"XML\".to_string(),\n ],\n selected: match session.config.output_format {\n OutputFormat::Markdown => 0,\n OutputFormat::Json => 1,\n OutputFormat::Xml => 2,\n },\n },\n },\n SettingsItem {\n key: SettingKey::TokenFormat,\n name: \"Token Format\".to_string(),\n description: \"How to display token counts\".to_string(),\n setting_type: SettingType::Choice {\n options: vec![\n TokenFormat::Raw.to_string(),\n TokenFormat::Format.to_string(),\n ],\n selected: match session.config.token_format {\n TokenFormat::Raw => 0,\n TokenFormat::Format => 1,\n },\n },\n },\n SettingsItem {\n key: SettingKey::FullDirectoryTree,\n name: \"Full Directory Tree\".to_string(),\n description: \"Show complete directory structure\".to_string(),\n setting_type: SettingType::Boolean(session.config.full_directory_tree),\n },\n ],\n },\n SettingsGroup {\n name: \"Sorting & Organization\".to_string(),\n items: vec![SettingsItem {\n key: SettingKey::SortMethod,\n name: \"Sort Method\".to_string(),\n description: \"How to sort files in output\".to_string(),\n setting_type: SettingType::Choice {\n options: vec![\n FileSortMethod::NameAsc.to_string(),\n FileSortMethod::NameDesc.to_string(),\n FileSortMethod::DateAsc.to_string(),\n FileSortMethod::DateDesc.to_string(),\n ],\n selected: match session.config.sort_method {\n Some(FileSortMethod::NameAsc) => 0,\n Some(FileSortMethod::NameDesc) => 1,\n Some(FileSortMethod::DateAsc) => 2,\n Some(FileSortMethod::DateDesc) => 3,\n None => 0,\n },\n },\n }],\n },\n SettingsGroup {\n name: \"Tokenizer & Encoding\".to_string(),\n items: vec![SettingsItem {\n key: SettingKey::TokenizerType,\n name: \"Tokenizer Type\".to_string(),\n description: \"Encoding method for token counting\".to_string(),\n setting_type: SettingType::Choice {\n options: vec![\n TokenizerType::Cl100kBase.to_string(),\n TokenizerType::O200kBase.to_string(),\n TokenizerType::P50kBase.to_string(),\n TokenizerType::P50kEdit.to_string(),\n TokenizerType::R50kBase.to_string(),\n ],\n selected: match session.config.encoding {\n TokenizerType::Cl100kBase => 0,\n TokenizerType::O200kBase => 1,\n TokenizerType::P50kBase => 2,\n TokenizerType::P50kEdit => 3,\n TokenizerType::R50kBase => 4,\n },\n },\n }],\n },\n SettingsGroup {\n name: \"Git Integration\".to_string(),\n items: vec![SettingsItem {\n key: SettingKey::GitDiff,\n name: \"Git Diff\".to_string(),\n description: \"Include git diff in output\".to_string(),\n setting_type: SettingType::Boolean(session.config.diff_enabled),\n }],\n },\n SettingsGroup {\n name: \"File Selection\".to_string(),\n items: vec![\n SettingsItem {\n key: SettingKey::FollowSymlinks,\n name: \"Follow Symlinks\".to_string(),\n description: \"Follow symbolic links\".to_string(),\n setting_type: SettingType::Boolean(session.config.follow_symlinks),\n },\n SettingsItem {\n key: SettingKey::HiddenFiles,\n name: \"Hidden Files\".to_string(),\n description: \"Include hidden files and directories\".to_string(),\n setting_type: SettingType::Boolean(session.config.hidden),\n },\n SettingsItem {\n key: SettingKey::NoIgnore,\n name: \"No Ignore\".to_string(),\n description: \"Ignore .gitignore rules\".to_string(),\n setting_type: SettingType::Boolean(session.config.no_ignore),\n },\n SettingsItem {\n key: SettingKey::Deselected,\n name: \"Deselected by Default\".to_string(),\n description: \"Start with all files deselected\".to_string(),\n setting_type: SettingType::Boolean(session.config.deselected),\n },\n ],\n },\n ]\n}\n"
},
{
"path": "crates/code2prompt/src/view/mod.rs",
"content": "//! View layer for the TUI application.\n//!\n//! This module contains all the formatting and display logic that was previously\n//! mixed into the Model and widgets. It provides pure functions that take data\n//! and return formatted strings or display structures.\n\npub mod formatters;\n\npub use formatters::*;\n"
},
{
"path": "crates/code2prompt/src/widgets/file_selection.rs",
"content": "//! File selection widget for directory tree navigation and file selection.\n\nuse crate::model::Model;\nuse ratatui::{\n prelude::*,\n widgets::{Block, Borders, List, ListItem, Paragraph},\n};\n\n/// State for the file selection widget - no longer needed, read directly from Model\npub type FileSelectionState = ();\n\n/// Widget for file selection with directory tree, search, and filter patterns\npub struct FileSelectionWidget<'a> {\n pub model: &'a Model,\n}\n\nimpl<'a> FileSelectionWidget<'a> {\n pub fn new(model: &'a Model) -> Self {\n Self { model }\n }\n}\n\nimpl<'a> StatefulWidget for FileSelectionWidget<'a> {\n type State = FileSelectionState;\n\n fn render(self, area: Rect, buf: &mut Buffer, _state: &mut Self::State) {\n let layout = Layout::default()\n .direction(Direction::Vertical)\n .constraints([\n Constraint::Min(0), // File tree\n Constraint::Length(3), // Search bar\n Constraint::Length(3), // Pattern info\n Constraint::Length(3), // Instructions\n ])\n .split(area);\n\n // File tree with scroll support - use new session-based approach\n let mut session_clone = self.model.session.clone();\n let visible_nodes = crate::utils::get_visible_nodes(\n &self.model.file_tree_nodes,\n &self.model.search_query,\n &mut session_clone,\n );\n let total_nodes = visible_nodes.len();\n\n // Calculate viewport dimensions\n let tree_area = layout[0];\n let content_height = tree_area.height.saturating_sub(2).max(1) as usize; // Account for borders, keep >= 1\n\n // Derive a local, clamped scroll that keeps the cursor visible\n let cursor = self.model.tree_cursor.min(total_nodes.saturating_sub(1));\n let mut scroll_start = self.model.file_tree_scroll as usize;\n if cursor < scroll_start {\n scroll_start = cursor;\n } else if cursor >= scroll_start.saturating_add(content_height) {\n scroll_start = cursor.saturating_add(1).saturating_sub(content_height);\n }\n let max_scroll = total_nodes.saturating_sub(content_height);\n scroll_start = scroll_start.min(max_scroll);\n\n let scroll_end = (scroll_start + content_height).min(total_nodes);\n\n // Create items only for visible viewport\n let items: Vec = visible_nodes\n .iter()\n .enumerate()\n .skip(scroll_start)\n .take(content_height)\n .map(|(i, display_node)| {\n let node = &display_node.node;\n let is_selected = display_node.is_selected;\n\n let indent = \" \".repeat(node.level);\n let icon = if node.is_directory {\n if node.is_expanded { \"📂\" } else { \"📁\" }\n } else {\n \"📄\"\n };\n let checkbox = if is_selected { \"☑\" } else { \"☐\" };\n\n let content = format!(\"{}{} {} {}\", indent, icon, checkbox, node.name);\n let mut style = Style::default();\n\n // Adjust cursor position for viewport\n if i == cursor {\n style = style.bg(Color::Blue).fg(Color::White);\n }\n\n if is_selected {\n style = style.fg(Color::Green);\n }\n\n ListItem::new(content).style(style)\n })\n .collect();\n\n // Create title with scroll indicator\n let scroll_indicator = if total_nodes > content_height {\n let current_start = scroll_start + 1;\n let current_end = scroll_end;\n format!(\n \"Files ({}) | Showing {}-{} of {}\",\n total_nodes, current_start, current_end, total_nodes\n )\n } else {\n format!(\"Files ({})\", total_nodes)\n };\n\n let tree_widget = List::new(items)\n .block(\n Block::default()\n .borders(Borders::ALL)\n .title(scroll_indicator),\n )\n .highlight_style(Style::default().bg(Color::Blue).fg(Color::White));\n\n Widget::render(tree_widget, layout[0], buf);\n\n // Search bar - read directly from Model\n let title_spans = vec![\n Span::styled(\n \"s\",\n Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),\n ),\n Span::styled(\"earch\", Style::default().fg(Color::White)),\n Span::styled(\" (text or * ? wildcards)\", Style::default().fg(Color::Gray)),\n ];\n\n let search_widget = Paragraph::new(self.model.search_query.as_str())\n .block(\n Block::default()\n .borders(Borders::ALL)\n .title(Line::from(title_spans)),\n )\n .style(\n Style::default().fg(if self.model.search_query.contains('*') {\n Color::Yellow\n } else {\n Color::Green\n }),\n );\n Widget::render(search_widget, layout[1], buf);\n\n // Pattern info\n let include_text = if self.model.session.config.include_patterns.is_empty() {\n \"All files\".to_string()\n } else {\n format!(\n \"Include: {}\",\n self.model.session.config.include_patterns.join(\", \")\n )\n };\n let exclude_text = if self.model.session.config.exclude_patterns.is_empty() {\n \"\".to_string()\n } else {\n format!(\n \" | Exclude: {}\",\n self.model.session.config.exclude_patterns.join(\", \")\n )\n };\n let pattern_info = format!(\"{}{}\", include_text, exclude_text);\n\n let pattern_widget = Paragraph::new(pattern_info)\n .block(\n Block::default()\n .borders(Borders::ALL)\n .title(\"Filter Patterns\"),\n )\n .style(Style::default().fg(Color::Cyan));\n Widget::render(pattern_widget, layout[2], buf);\n\n // Instructions\n let instructions = Paragraph::new(\n \"Enter: Run Analysis | ↑↓: Navigate | Space: Select/Deselect | ←→: Expand/Collapse | PgUp/PgDn: Scroll | S: Search Mode | Esc: Exit\"\n )\n .block(Block::default().borders(Borders::ALL).title(\"Controls\"))\n .style(Style::default().fg(Color::Gray));\n Widget::render(instructions, layout[3], buf);\n }\n}\n"
},
{
"path": "crates/code2prompt/src/widgets/mod.rs",
"content": "//! Widget components for the TUI interface.\n//!\n//! This module contains all the widget implementations using Ratatui's native widget system.\n//! Each widget is responsible for rendering a specific part of the UI and managing its own state.\n\npub mod file_selection;\npub mod output;\npub mod settings;\npub mod statistics_by_extension;\npub mod statistics_overview;\npub mod statistics_token_map;\npub mod template;\n\npub use file_selection::FileSelectionWidget;\npub use output::OutputWidget;\npub use settings::SettingsWidget;\npub use statistics_by_extension::StatisticsByExtensionWidget;\npub use statistics_overview::StatisticsOverviewWidget;\npub use statistics_token_map::StatisticsTokenMapWidget;\npub use template::TemplateWidget;\n"
},
{
"path": "crates/code2prompt/src/widgets/output.rs",
"content": "//! Output widget for displaying generated prompt with scrolling capability.\n\nuse crate::model::Model;\nuse ratatui::{\n prelude::*,\n widgets::{Block, Borders, Paragraph, Wrap},\n};\n\n/// State for the output widget - no longer needed, read directly from Model\npub type OutputState = ();\n\n/// Widget for output display with scrolling\npub struct OutputWidget<'a> {\n pub model: &'a Model,\n}\n\nimpl<'a> OutputWidget<'a> {\n pub fn new(model: &'a Model) -> Self {\n Self { model }\n }\n}\n\nimpl<'a> StatefulWidget for OutputWidget<'a> {\n type State = OutputState;\n\n fn render(self, area: Rect, buf: &mut Buffer, _state: &mut Self::State) {\n let layout = Layout::default()\n .direction(Direction::Vertical)\n .constraints([\n Constraint::Length(3), // Info bar\n Constraint::Min(0), // Prompt content\n Constraint::Length(3), // Controls\n ])\n .split(area);\n\n // Simplified status bar - focus only on prompt availability\n let info_text = if self.model.prompt_output.analysis_in_progress {\n \"Generating prompt...\".to_string()\n } else if let Some(error) = &self.model.prompt_output.analysis_error {\n format!(\"Generation failed: {}\", error)\n } else if self.model.prompt_output.generated_prompt.is_some() {\n \"✓ Prompt ready! Copy (C) or Save (S)\".to_string()\n } else {\n \"Press Enter to generate prompt from selected files\".to_string()\n };\n\n let info_widget = Paragraph::new(info_text)\n .block(\n Block::default()\n .borders(Borders::ALL)\n .title(\"Generated Prompt\"),\n )\n .style(if self.model.prompt_output.analysis_error.is_some() {\n Style::default().fg(Color::Red)\n } else if self.model.prompt_output.analysis_in_progress {\n Style::default().fg(Color::Yellow)\n } else {\n Style::default().fg(Color::Green)\n });\n Widget::render(info_widget, layout[0], buf);\n\n // Prompt content\n let content = if self.model.prompt_output.analysis_in_progress {\n \"Generating prompt...\".to_string()\n } else if let Some(prompt) = &self.model.prompt_output.generated_prompt {\n prompt.clone()\n } else {\n \"Press to run analysis and generate prompt.\\n\\nSelected files will be processed according to your settings.\".to_string()\n };\n\n // Compute viewport-aware scroll\n let content_height = layout[1].height.saturating_sub(2).max(1) as usize; // borders\n let (display_scroll, scroll_info) =\n if let Some(prompt) = &self.model.prompt_output.generated_prompt {\n let total_lines = prompt.lines().count();\n let max_scroll = total_lines.saturating_sub(content_height);\n let ds = self\n .model\n .prompt_output\n .output_scroll\n .min(max_scroll as u16);\n let current_line = ds as usize + 1;\n (\n ds,\n format!(\"Generated Prompt (Line {}/{})\", current_line, total_lines),\n )\n } else {\n (\n self.model.prompt_output.output_scroll,\n \"Generated Prompt\".to_string(),\n )\n };\n\n let prompt_widget = Paragraph::new(content)\n .block(Block::default().borders(Borders::ALL).title(scroll_info))\n .wrap(Wrap { trim: false })\n .scroll((display_scroll, 0));\n Widget::render(prompt_widget, layout[1], buf);\n\n // Controls\n let controls_text = if self.model.prompt_output.generated_prompt.is_some() {\n \"↑↓/PgUp/PgDn: Scroll | C: Copy | S: Save | Enter: Re-run\"\n } else {\n \"Enter: Run Analysis\"\n };\n\n let controls_widget = Paragraph::new(controls_text)\n .block(Block::default().borders(Borders::ALL).title(\"Controls\"))\n .style(Style::default().fg(Color::Gray));\n Widget::render(controls_widget, layout[2], buf);\n }\n}\n"
},
{
"path": "crates/code2prompt/src/widgets/settings.rs",
"content": "//! Settings widget for configuration management.\n\nuse crate::model::Model;\nuse ratatui::{\n prelude::*,\n widgets::{Block, Borders, List, ListItem, Paragraph},\n};\n\n/// State for the settings widget - no longer needed, read directly from Model\npub type SettingsState = ();\n\n/// Widget for settings configuration\npub struct SettingsWidget<'a> {\n pub model: &'a Model,\n}\n\nimpl<'a> SettingsWidget<'a> {\n pub fn new(model: &'a Model) -> Self {\n Self { model }\n }\n}\n\nimpl<'a> StatefulWidget for SettingsWidget<'a> {\n type State = SettingsState;\n\n fn render(self, area: Rect, buf: &mut Buffer, _state: &mut Self::State) {\n let settings_groups = self.model.get_settings_groups();\n\n let layout = Layout::default()\n .direction(Direction::Vertical)\n .constraints([\n Constraint::Min(0), // Settings list\n Constraint::Length(3), // Instructions\n ])\n .split(area);\n\n // Build grouped settings display\n let mut items: Vec = Vec::new();\n let mut item_index = 0;\n\n for group in &settings_groups {\n // Group header\n items.push(\n ListItem::new(format!(\"── {} ──\", group.name)).style(\n Style::default()\n .fg(Color::Yellow)\n .add_modifier(Modifier::BOLD),\n ),\n );\n\n // Group items\n for item in &group.items {\n let value_display = match &item.setting_type {\n crate::model::SettingType::Boolean(val) => {\n if *val {\n \"[●] ON\".to_string()\n } else {\n \"[○] OFF\".to_string()\n }\n }\n crate::model::SettingType::Choice { options, selected } => {\n let current = options.get(*selected).cloned().unwrap_or_default();\n let total = options.len();\n format!(\"[▼ {} ({}/{})]\", current, selected + 1, total)\n }\n };\n\n // Better aligned layout: Name (20 chars) | Value (15 chars) | Description\n let content = format!(\n \" {:<20} {:<15} {}\",\n item.name, value_display, item.description\n );\n let mut style = Style::default();\n\n // Read cursor directly from Model\n if item_index == self.model.settings.settings_cursor {\n style = style\n .bg(Color::Blue)\n .fg(Color::White)\n .add_modifier(Modifier::BOLD);\n }\n\n // Color based on setting type\n match &item.setting_type {\n crate::model::SettingType::Boolean(true) => {\n style = style.fg(Color::Green);\n }\n crate::model::SettingType::Boolean(false) => {\n style = style.fg(Color::Red);\n }\n crate::model::SettingType::Choice { .. } => {\n style = style.fg(Color::Cyan);\n }\n }\n\n items.push(ListItem::new(content).style(style));\n item_index += 1;\n }\n\n // Add spacing between groups\n items.push(ListItem::new(\"\"));\n }\n\n let settings_widget = List::new(items)\n .block(Block::default().borders(Borders::ALL).title(\"Settings\"))\n .highlight_style(Style::default().bg(Color::Blue).fg(Color::White));\n\n Widget::render(settings_widget, layout[0], buf);\n\n // Instructions\n let instructions = Paragraph::new(\n \"Enter: Run Analysis | ↑↓: Navigate | Space: Toggle | ←→: Cycle Options\",\n )\n .block(Block::default().borders(Borders::ALL).title(\"Controls\"))\n .style(Style::default().fg(Color::Gray));\n Widget::render(instructions, layout[1], buf);\n }\n}\n"
},
{
"path": "crates/code2prompt/src/widgets/statistics_by_extension.rs",
"content": "//! Statistics by extension widget for displaying extension-based histogram.\n\nuse crate::model::{Model, StatisticsState};\nuse ratatui::{\n prelude::*,\n widgets::{Block, Borders, List, ListItem, Paragraph, Wrap},\n};\n\n/// State for the extension statistics widget - eliminated redundant state\npub type ExtensionState = ();\n\n/// Widget for extension-based statistics display\npub struct StatisticsByExtensionWidget<'a> {\n pub model: &'a Model,\n}\n\nimpl<'a> StatisticsByExtensionWidget<'a> {\n pub fn new(model: &'a Model) -> Self {\n Self { model }\n }\n}\n\nimpl<'a> StatefulWidget for StatisticsByExtensionWidget<'a> {\n type State = ExtensionState;\n\n fn render(self, area: Rect, buf: &mut Buffer, _state: &mut Self::State) {\n let layout = Layout::default()\n .direction(Direction::Vertical)\n .constraints([\n Constraint::Min(0), // Extension statistics content\n Constraint::Length(3), // Instructions\n ])\n .split(area);\n\n let title = \"📁 By Extension\";\n\n if self.model.statistics.token_map_entries.is_empty() {\n let placeholder_text = if self.model.prompt_output.generated_prompt.is_some() {\n \"\\nNo token map data available.\\n\\nPress Enter to re-run analysis.\"\n } else {\n \"\\nRun analysis first to see token breakdown by file extension.\\n\\nPress Enter to run analysis.\"\n };\n\n let placeholder_widget = Paragraph::new(placeholder_text)\n .block(Block::default().borders(Borders::ALL).title(title))\n .wrap(Wrap { trim: true })\n .style(Style::default().fg(Color::Gray))\n .alignment(Alignment::Center);\n\n Widget::render(placeholder_widget, layout[0], buf);\n\n // Instructions\n let instructions =\n Paragraph::new(\"Enter: Run Analysis | ←→: Switch View | Tab/Shift+Tab: Switch Tab\")\n .block(Block::default().borders(Borders::ALL).title(\"Controls\"))\n .style(Style::default().fg(Color::Gray));\n Widget::render(instructions, layout[1], buf);\n return;\n }\n\n // Use business logic from Model - pure Elm/Redux pattern\n let ext_vec = self.model.statistics.aggregate_by_extension();\n let total_tokens = self.model.prompt_output.token_count.unwrap_or(0);\n\n // Calculate viewport for scrolling - read directly from Model\n let content_height = layout[0].height.saturating_sub(2).max(1) as usize;\n let total = ext_vec.len();\n let max_scroll = total.saturating_sub(content_height);\n let scroll_start = (self.model.statistics.scroll as usize).min(max_scroll);\n let scroll_end = (scroll_start + content_height).min(total);\n\n // Calculate dynamic column widths based on available space and content\n let available_width = layout[0].width.saturating_sub(4) as usize; // Account for borders and padding\n\n // Calculate maximum widths needed for each column\n let max_ext_width = ext_vec\n .iter()\n .map(|(ext, _, _)| ext.len())\n .max()\n .unwrap_or(12)\n .max(12); // Minimum 12 chars for \"Extension\"\n\n let max_tokens_width = ext_vec\n .iter()\n .map(|(_, tokens, _)| {\n StatisticsState::format_number(*tokens, &self.model.session.config.token_format)\n .len()\n })\n .max()\n .unwrap_or(6)\n .max(6); // Minimum 6 chars for tokens\n\n let max_count_width = ext_vec\n .iter()\n .map(|(_, _, count)| count.to_string().len())\n .max()\n .unwrap_or(3)\n .max(3); // Minimum 3 chars for count\n\n // Fixed widths for percentage and separators\n let percentage_width = 7; // \"(100.0%)\"\n let separators_width = 8; // \" │ │ \" + \" | \" + \" files\"\n\n // Calculate remaining space for the progress bar\n let fixed_content_width = max_ext_width\n + max_tokens_width\n + percentage_width\n + max_count_width\n + separators_width\n + 5; // +5 for \"files\"\n let bar_width = if available_width > fixed_content_width {\n (available_width - fixed_content_width).clamp(10, 40) // Between 10 and 40 chars\n } else {\n 15 // Fallback minimum bar width\n };\n\n // Create list items with dynamic formatting\n let items: Vec = ext_vec\n .iter()\n .skip(scroll_start)\n .take(content_height)\n .map(|(extension, tokens, count)| {\n let percentage = if total_tokens > 0 {\n (*tokens as f64 / total_tokens as f64) * 100.0\n } else {\n 0.0\n };\n\n // Create visual bar with calculated width\n let filled_chars = ((percentage / 100.0) * bar_width as f64) as usize;\n let bar = format!(\n \"{}{}\",\n \"█\".repeat(filled_chars),\n \"░\".repeat(bar_width.saturating_sub(filled_chars))\n );\n\n // Choose color based on extension\n let color = match extension.as_str() {\n \".rs\" => Color::LightRed,\n \".md\" | \".txt\" | \".rst\" => Color::Green,\n \".toml\" | \".json\" | \".yaml\" | \".yml\" => Color::Magenta,\n \".js\" | \".ts\" | \".jsx\" | \".tsx\" => Color::Cyan,\n \".py\" => Color::LightYellow,\n \".go\" => Color::LightBlue,\n \".java\" | \".kt\" => Color::Red,\n \".cpp\" | \".c\" | \".h\" => Color::Blue,\n _ => Color::White,\n };\n\n // Format with dynamic column widths\n let formatted_tokens = StatisticsState::format_number(\n *tokens,\n &self.model.session.config.token_format,\n );\n let content = format!(\n \"{:width_tokens$} ({:>4.1}%) | {:>width_count$} files\",\n extension,\n bar,\n formatted_tokens,\n percentage,\n count,\n width_ext = max_ext_width,\n width_tokens = max_tokens_width,\n width_count = max_count_width\n );\n\n ListItem::new(content).style(Style::default().fg(color))\n })\n .collect();\n\n // Create title with scroll indicator\n let scroll_title = if ext_vec.len() > content_height {\n format!(\n \"{} | Showing {}-{} of {}\",\n title,\n scroll_start + 1,\n scroll_end,\n ext_vec.len()\n )\n } else {\n title.to_string()\n };\n\n // Add header row for better column alignment\n let header = format!(\n \"{:width_tokens$} {:>7} | {:>width_count$} Files\",\n \"Extension\",\n \"Usage\",\n \"Tokens\",\n \"Percent\",\n \"Count\",\n width_ext = max_ext_width,\n width_bar = bar_width,\n width_tokens = max_tokens_width,\n width_count = max_count_width\n );\n\n let mut all_items = vec![\n ListItem::new(header).style(\n Style::default()\n .fg(Color::Yellow)\n .add_modifier(Modifier::BOLD),\n ),\n ListItem::new(\"─\".repeat(available_width.min(120)))\n .style(Style::default().fg(Color::DarkGray)),\n ];\n all_items.extend(items);\n\n let extensions_widget = List::new(all_items)\n .block(Block::default().borders(Borders::ALL).title(scroll_title))\n .style(Style::default().fg(Color::White));\n\n Widget::render(extensions_widget, layout[0], buf);\n\n // Instructions\n let instructions = Paragraph::new(\"Enter: Run Analysis | ←→: Switch View | ↑↓/PgUp/PgDn: Scroll | Tab/Shift+Tab: Switch Tab\")\n .block(Block::default().borders(Borders::ALL).title(\"Controls\"))\n .style(Style::default().fg(Color::Gray));\n Widget::render(instructions, layout[1], buf);\n }\n}\n"
},
{
"path": "crates/code2prompt/src/widgets/statistics_overview.rs",
"content": "//! Statistics overview widget for displaying analysis summary.\nuse crate::model::{Model, StatisticsState};\nuse ratatui::{\n prelude::*,\n widgets::{Block, Borders, List, ListItem, Paragraph, Wrap},\n};\n\n/// Widget for statistics overview (stateless)\npub struct StatisticsOverviewWidget<'a> {\n pub model: &'a Model,\n}\n\nimpl<'a> StatisticsOverviewWidget<'a> {\n pub fn new(model: &'a Model) -> Self {\n Self { model }\n }\n}\n\nimpl<'a> Widget for StatisticsOverviewWidget<'a> {\n fn render(self, area: Rect, buf: &mut Buffer) {\n let layout = Layout::default()\n .direction(Direction::Vertical)\n .constraints([\n Constraint::Min(0), // Statistics content\n Constraint::Length(3), // Instructions\n ])\n .split(area);\n\n // Check if analysis has been run\n if self.model.prompt_output.generated_prompt.is_none()\n && !self.model.prompt_output.analysis_in_progress\n {\n // Show placeholder when no analysis has been run\n let placeholder_text =\n \"\\nNo analysis data available yet.\\n\\nPress Enter to run analysis.\";\n\n let placeholder_widget = Paragraph::new(placeholder_text)\n .block(Block::default().borders(Borders::ALL).title(\"📊 Overview\"))\n .wrap(Wrap { trim: true })\n .style(Style::default().fg(Color::Gray))\n .alignment(Alignment::Center);\n\n Widget::render(placeholder_widget, layout[0], buf);\n\n // Instructions for when no analysis is available\n let instructions = Paragraph::new(\"Enter: Go to Selection | Tab/Shift+Tab: Switch Tab\")\n .block(Block::default().borders(Borders::ALL).title(\"Controls\"))\n .style(Style::default().fg(Color::Gray));\n Widget::render(instructions, layout[1], buf);\n return;\n }\n\n let mut stats_items: Vec = Vec::new();\n\n // Analysis Status (most important first)\n let (status_text, status_color) = if self.model.prompt_output.analysis_in_progress {\n (\"Generating prompt...\".to_string(), Color::Yellow)\n } else if self.model.prompt_output.analysis_error.is_some() {\n (\"Analysis failed\".to_string(), Color::Red)\n } else if self.model.prompt_output.generated_prompt.is_some() {\n (\"Analysis complete\".to_string(), Color::Green)\n } else {\n (\"Ready to analyze\".to_string(), Color::Gray)\n };\n\n stats_items.push(\n ListItem::new(format!(\"Status: {}\", status_text)).style(\n Style::default()\n .fg(status_color)\n .add_modifier(Modifier::BOLD),\n ),\n );\n\n if let Some(error) = &self.model.prompt_output.analysis_error {\n stats_items.push(\n ListItem::new(format!(\" Error: {}\", error)).style(Style::default().fg(Color::Red)),\n );\n }\n stats_items.push(ListItem::new(\"\"));\n\n // File Summary\n stats_items.push(\n ListItem::new(\"📁 File Summary\").style(\n Style::default()\n .fg(Color::Cyan)\n .add_modifier(Modifier::BOLD),\n ),\n );\n\n let mut session_clone = self.model.session.clone();\n let selected_count = StatisticsState::count_selected_files(&mut session_clone);\n let eligible_count = StatisticsState::count_total_files(&self.model.file_tree_nodes);\n let total_files = self.model.prompt_output.file_count;\n stats_items.push(ListItem::new(format!(\n \" • Selected (current): {} files\",\n selected_count\n )));\n stats_items.push(ListItem::new(format!(\n \" • Eligible (current filters): {} files\",\n eligible_count\n )));\n stats_items.push(ListItem::new(format!(\n \" • Included (last run): {} files\",\n total_files\n )));\n\n if selected_count > 0 && eligible_count > 0 {\n let percentage = (selected_count as f64 / eligible_count as f64 * 100.0) as usize;\n stats_items.push(ListItem::new(format!(\n \" • Selection Rate (current): {}%\",\n percentage\n )));\n }\n stats_items.push(ListItem::new(\"\"));\n\n // Token Summary\n stats_items.push(\n ListItem::new(\"🎯 Token Summary\").style(\n Style::default()\n .fg(Color::Magenta)\n .add_modifier(Modifier::BOLD),\n ),\n );\n\n if let Some(token_count) = self.model.prompt_output.token_count {\n stats_items.push(ListItem::new(format!(\n \" • Total Tokens: {}\",\n StatisticsState::format_number(\n token_count,\n &self.model.session.config.token_format\n )\n )));\n if selected_count > 0 {\n let avg_tokens = token_count / selected_count;\n stats_items.push(ListItem::new(format!(\n \" • Avg per File: {}\",\n StatisticsState::format_number(\n avg_tokens,\n &self.model.session.config.token_format\n )\n )));\n }\n } else {\n stats_items.push(ListItem::new(\" • Total Tokens: Not calculated\"));\n }\n stats_items.push(ListItem::new(\"\"));\n\n // Configuration Summary\n stats_items.push(\n ListItem::new(\"⚙️ Configuration\").style(\n Style::default()\n .fg(Color::Yellow)\n .add_modifier(Modifier::BOLD),\n ),\n );\n\n let output_format = match self.model.session.config.output_format {\n code2prompt_core::template::OutputFormat::Markdown => \"Markdown\",\n code2prompt_core::template::OutputFormat::Json => \"JSON\",\n code2prompt_core::template::OutputFormat::Xml => \"XML\",\n };\n stats_items.push(ListItem::new(format!(\" • Output: {}\", output_format)));\n stats_items.push(ListItem::new(format!(\n \" • Line Numbers: {}\",\n if self.model.session.config.line_numbers {\n \"On\"\n } else {\n \"Off\"\n }\n )));\n stats_items.push(ListItem::new(format!(\n \" • Git Diff: {}\",\n if self.model.session.config.diff_enabled {\n \"On\"\n } else {\n \"Off\"\n }\n )));\n\n let pattern_summary = format!(\n \" • Patterns: {} include, {} exclude\",\n self.model.session.config.include_patterns.len(),\n self.model.session.config.exclude_patterns.len()\n );\n stats_items.push(ListItem::new(pattern_summary));\n\n let stats_widget = List::new(stats_items)\n .block(Block::default().borders(Borders::ALL).title(\"📊 Overview\"))\n .style(Style::default().fg(Color::White));\n\n Widget::render(stats_widget, layout[0], buf);\n\n // Instructions\n let instructions =\n Paragraph::new(\"Enter: Run Analysis | ←→: Switch View | Tab/Shift+Tab: Switch Tab\")\n .block(Block::default().borders(Borders::ALL).title(\"Controls\"))\n .style(Style::default().fg(Color::Gray));\n Widget::render(instructions, layout[1], buf);\n }\n}\n"
},
{
"path": "crates/code2prompt/src/widgets/statistics_token_map.rs",
"content": "//! Statistics token map widget for displaying token distribution.\n\nuse crate::model::Model;\nuse crate::token_map::{TuiColor, format_token_map_for_tui};\nuse ratatui::{\n prelude::*,\n widgets::{Block, Borders, List, ListItem, Paragraph, Wrap},\n};\n\n/// State for the token map widget - no longer needed, read directly from Model\npub type TokenMapState = ();\n\n/// Widget for token map display\npub struct StatisticsTokenMapWidget<'a> {\n pub model: &'a Model,\n}\n\nimpl<'a> StatisticsTokenMapWidget<'a> {\n pub fn new(model: &'a Model) -> Self {\n Self { model }\n }\n}\n\nimpl<'a> StatefulWidget for StatisticsTokenMapWidget<'a> {\n type State = TokenMapState;\n\n fn render(self, area: Rect, buf: &mut Buffer, _state: &mut Self::State) {\n let layout = Layout::default()\n .direction(Direction::Vertical)\n .constraints([\n Constraint::Min(0), // Token map content\n Constraint::Length(3), // Instructions\n ])\n .split(area);\n\n let title = \"🗂️ Token Map\";\n\n if self.model.statistics.token_map_entries.is_empty() {\n let placeholder_text = if self.model.prompt_output.generated_prompt.is_some() {\n \"\\nNo token map data available.\\n\\nPress Enter to re-run analysis.\"\n } else {\n \"\\nRun analysis first to see token distribution.\\n\\nPress Enter to run analysis.\"\n };\n\n let placeholder_widget = Paragraph::new(placeholder_text)\n .block(Block::default().borders(Borders::ALL).title(title))\n .wrap(Wrap { trim: true })\n .style(Style::default().fg(Color::Gray))\n .alignment(Alignment::Center);\n\n Widget::render(placeholder_widget, layout[0], buf);\n\n // Instructions\n let instructions =\n Paragraph::new(\"Enter: Run Analysis | ←→: Switch View | Tab/Shift+Tab: Switch Tab\")\n .block(Block::default().borders(Borders::ALL).title(\"Controls\"))\n .style(Style::default().fg(Color::Gray));\n Widget::render(instructions, layout[1], buf);\n return;\n }\n\n // Use the shared token map formatting logic from token_map.rs with adaptive layout\n let total_tokens = self.model.prompt_output.token_count.unwrap_or(0);\n let terminal_width = area.width as usize;\n let formatted_lines = format_token_map_for_tui(\n &self.model.statistics.token_map_entries,\n total_tokens,\n terminal_width,\n );\n\n // Calculate viewport for scrolling - read directly from Model\n let content_height = layout[0].height.saturating_sub(2).max(1) as usize; // Account for borders\n let total = formatted_lines.len();\n let max_scroll = total.saturating_sub(content_height);\n let scroll_start = (self.model.statistics.scroll as usize).min(max_scroll);\n let scroll_end = (scroll_start + content_height).min(formatted_lines.len());\n\n // Convert formatted lines to ListItems with proper column layout and filename coloring\n let items: Vec = formatted_lines\n .iter()\n .skip(scroll_start)\n .take(content_height)\n .map(|line| {\n // Convert TuiColor to ratatui Color for filename only\n let name_color = match line.name_color {\n TuiColor::White => Color::White,\n TuiColor::Gray => Color::Gray,\n TuiColor::Red => Color::Red,\n TuiColor::Green => Color::Green,\n TuiColor::Blue => Color::Blue,\n TuiColor::Yellow => Color::Yellow,\n TuiColor::Cyan => Color::Cyan,\n TuiColor::Magenta => Color::Magenta,\n TuiColor::LightRed => Color::LightRed,\n TuiColor::LightGreen => Color::LightGreen,\n TuiColor::LightBlue => Color::LightBlue,\n TuiColor::LightYellow => Color::LightYellow,\n TuiColor::LightCyan => Color::LightCyan,\n TuiColor::LightMagenta => Color::LightMagenta,\n };\n\n // Create spans with proper coloring - only filename gets color, rest is white\n let spans = vec![\n Span::styled(&line.tokens_part, Style::default().fg(Color::White)),\n Span::styled(\" \", Style::default().fg(Color::White)), // spacing\n Span::styled(&line.prefix_part, Style::default().fg(Color::White)),\n Span::styled(&line.name_part, Style::default().fg(name_color)), // Only filename colored\n Span::styled(\" \", Style::default().fg(Color::White)), // spacing\n Span::styled(&line.bar_part, Style::default().fg(Color::White)),\n Span::styled(\" \", Style::default().fg(Color::White)), // spacing\n Span::styled(&line.percentage_part, Style::default().fg(Color::White)),\n ];\n\n ListItem::new(Line::from(spans))\n })\n .collect();\n\n // Create title with scroll indicator\n let scroll_title = if formatted_lines.len() > content_height {\n format!(\n \"{} | Showing {}-{} of {}\",\n title,\n scroll_start + 1,\n scroll_end,\n formatted_lines.len()\n )\n } else {\n title.to_string()\n };\n\n let token_map_widget =\n List::new(items).block(Block::default().borders(Borders::ALL).title(scroll_title));\n\n Widget::render(token_map_widget, layout[0], buf);\n\n // Instructions\n let instructions = Paragraph::new(\"Enter: Run Analysis | ←→: Switch View | ↑↓/PgUp/PgDn: Scroll | Tab/Shift+Tab: Switch Tab\")\n .block(Block::default().borders(Borders::ALL).title(\"Controls\"))\n .style(Style::default().fg(Color::Gray));\n Widget::render(instructions, layout[1], buf);\n }\n}\n"
},
{
"path": "crates/code2prompt/src/widgets/template/editor.rs",
"content": "//! Template Editor sub-widget.\n//!\n//! This widget provides an editable text area for template content with validation.\n\nuse crate::model::template::EditorState;\nuse ratatui::{\n prelude::*,\n widgets::{Block, Borders},\n};\n\n/// Template Editor sub-widget\npub struct TemplateEditorWidget;\n\nimpl TemplateEditorWidget {\n pub fn new() -> Self {\n Self\n }\n\n /// Render the template editor\n pub fn render(\n &self,\n area: Rect,\n buf: &mut Buffer,\n state: &mut EditorState,\n is_focused: bool,\n has_missing_vars: bool,\n ) {\n // Determine border style based on validation and focus\n let border_style = if is_focused {\n Style::default().fg(Color::Yellow) // Focused\n } else {\n Style::default().fg(Color::Rgb(139, 69, 19)) // Brown for normal\n };\n\n // Create title with validation status\n let title_spans = if !state.is_valid {\n vec![\n Span::styled(\"Template \", Style::default().fg(Color::White)),\n Span::styled(\n \"e\",\n Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),\n ),\n Span::styled(\"ditor \", Style::default().fg(Color::White)),\n Span::styled(\n format!(\"(SYNTAX ERROR: {})\", state.validation_message),\n Style::default().fg(Color::Red),\n ),\n ]\n } else if has_missing_vars {\n vec![\n Span::styled(\"Template \", Style::default().fg(Color::White)),\n Span::styled(\n \"e\",\n Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),\n ),\n Span::styled(\"ditor \", Style::default().fg(Color::White)),\n Span::styled(\" (MISSING VARIABLES)\", Style::default().fg(Color::Red)),\n ]\n } else {\n vec![\n Span::styled(\"Template \", Style::default().fg(Color::White)),\n Span::styled(\n \"e\",\n Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),\n ),\n Span::styled(\"ditor \", Style::default().fg(Color::White)),\n Span::styled(\" (VALID)\", Style::default().fg(Color::Green)),\n ]\n };\n\n // Configure TextArea\n let mut textarea = state.editor.clone();\n textarea.set_block(\n Block::default()\n .borders(Borders::ALL)\n .title(Line::from(title_spans))\n .border_style(border_style),\n );\n\n // Set cursor and text styles based on focus and validation\n if is_focused {\n textarea.set_cursor_line_style(Style::default().add_modifier(Modifier::UNDERLINED));\n textarea.set_cursor_style(Style::default().fg(Color::Yellow));\n }\n\n // Set text color - always use brown highlight for invalid, white for valid\n if !state.is_valid || has_missing_vars {\n textarea.set_style(Style::default().fg(Color::Rgb(139, 69, 19))); // Brown highlight\n } else {\n textarea.set_style(Style::default().fg(Color::White));\n }\n\n // Render the TextArea\n Widget::render(&textarea, area, buf);\n }\n}\n\nimpl Default for TemplateEditorWidget {\n fn default() -> Self {\n Self::new()\n }\n}\n"
},
{
"path": "crates/code2prompt/src/widgets/template/mod.rs",
"content": "//! Template widget module.\n//!\n//! This module coordinates the three template sub-widgets:\n//! - Editor: Template content editing and validation\n//! - Variable: Variable management and validation \n//! - Picker: Template selection and loading\n\npub mod editor;\npub mod picker;\npub mod variable;\n\npub use editor::TemplateEditorWidget;\npub use picker::TemplatePickerWidget;\npub use variable::TemplateVariableWidget;\n\nuse crate::model::Model;\nuse crate::model::template::{TemplateFocus, TemplateState};\nuse ratatui::{\n prelude::*,\n widgets::{Block, Borders, Paragraph},\n};\n\n/// Main Template widget that coordinates the 3 sub-widgets\npub struct TemplateWidget {\n editor: TemplateEditorWidget,\n variables: TemplateVariableWidget,\n picker: TemplatePickerWidget,\n}\n\nimpl TemplateWidget {\n pub fn new(_model: &Model) -> Self {\n Self {\n editor: TemplateEditorWidget::new(),\n variables: TemplateVariableWidget::new(),\n picker: TemplatePickerWidget::new(),\n }\n }\n\n /// Render the template widget with 3 columns\n pub fn render(&self, area: Rect, buf: &mut Buffer, state: &mut TemplateState) {\n // Main layout - content and footer\n let chunks = Layout::default()\n .direction(Direction::Vertical)\n .constraints([\n Constraint::Min(0), // Content (3 columns)\n Constraint::Length(3), // Footer\n ])\n .split(area);\n\n // 3-column layout for content\n self.render_content(chunks[0], buf, state);\n\n // Footer\n self.render_footer(chunks[1], buf, state);\n }\n\n /// Render the 3-column content area\n fn render_content(&self, area: Rect, buf: &mut Buffer, state: &mut TemplateState) {\n // Flexible 3-column layout\n let min_width = 30;\n let available_width = area.width.saturating_sub(6); // Account for borders\n\n let constraints = if available_width >= min_width * 3 {\n // Full 3-column layout\n vec![\n Constraint::Percentage(40), // Editor\n Constraint::Percentage(35), // Variables\n Constraint::Percentage(25), // Picker\n ]\n } else if available_width >= min_width * 2 {\n // 2-column layout, hide picker or make it smaller\n vec![\n Constraint::Percentage(60), // Editor\n Constraint::Percentage(40), // Variables\n Constraint::Length(0), // Picker hidden\n ]\n } else {\n // Single column, show only focused column\n match state.get_focus() {\n TemplateFocus::Editor => vec![\n Constraint::Percentage(100),\n Constraint::Length(0),\n Constraint::Length(0),\n ],\n TemplateFocus::Variables => vec![\n Constraint::Length(0),\n Constraint::Percentage(100),\n Constraint::Length(0),\n ],\n TemplateFocus::Picker => vec![\n Constraint::Length(0),\n Constraint::Length(0),\n Constraint::Percentage(100),\n ],\n }\n };\n\n let columns = Layout::default()\n .direction(Direction::Horizontal)\n .constraints(constraints)\n .split(area);\n\n // Render each column if it has space\n if columns[0].width > 0 {\n let is_editor_focused = state.get_focus() == TemplateFocus::Editor;\n let is_editing_template =\n state.get_focus_mode() == crate::model::template::FocusMode::EditingTemplate;\n let has_missing_vars = state.variables.has_missing_variables();\n self.editor.render(\n columns[0],\n buf,\n &mut state.editor,\n is_editor_focused || is_editing_template,\n has_missing_vars,\n );\n }\n\n if columns[1].width > 0 {\n let variables = state.get_organized_variables();\n let is_variables_focused = state.get_focus() == TemplateFocus::Variables;\n let is_editing_variable =\n state.get_focus_mode() == crate::model::template::FocusMode::EditingVariable;\n self.variables.render(\n columns[1],\n buf,\n &state.variables,\n &variables,\n is_variables_focused || is_editing_variable,\n );\n }\n\n if columns[2].width > 0 {\n self.picker.render(\n columns[2],\n buf,\n &state.picker,\n state.get_focus() == TemplateFocus::Picker,\n );\n }\n }\n\n /// Render the footer with controls and status\n fn render_footer(&self, area: Rect, buf: &mut Buffer, state: &TemplateState) {\n let footer_content = if !state.get_status().is_empty() {\n // Simple text for status messages\n vec![Span::styled(\n state.get_status(),\n Style::default().fg(Color::Gray),\n )]\n } else {\n // Show different controls based on focus mode\n match state.get_focus_mode() {\n crate::model::template::FocusMode::Normal => {\n // Normal mode: can switch focus with colored letters\n let mut spans = vec![\n Span::styled(\n \"Enter: Run Analysis | Focus: \",\n Style::default().fg(Color::Gray),\n ),\n Span::styled(\n \"e\",\n Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),\n ),\n Span::styled(\"(dit) \", Style::default().fg(Color::Gray)),\n Span::styled(\n \"v\",\n Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),\n ),\n Span::styled(\"(ariables) \", Style::default().fg(Color::Gray)),\n Span::styled(\n \"p\",\n Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),\n ),\n Span::styled(\"(icker) | \", Style::default().fg(Color::Gray)),\n Span::styled(\n \"s\",\n Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),\n ),\n Span::styled(\"(ave Template) \", Style::default().fg(Color::Gray)),\n ];\n\n let specific_controls = match state.get_focus() {\n TemplateFocus::Editor => \"\",\n TemplateFocus::Variables => \"\",\n TemplateFocus::Picker => {\n TemplatePickerWidget::get_help_text(true, state.picker.active_list)\n }\n };\n\n spans.push(Span::styled(\n specific_controls,\n Style::default().fg(Color::Gray),\n ));\n spans\n }\n crate::model::template::FocusMode::EditingTemplate => {\n vec![Span::styled(\n \"EDIT MODE: Type to edit template | ESC: Exit edit mode\",\n Style::default().fg(Color::Gray),\n )]\n }\n crate::model::template::FocusMode::EditingVariable => {\n let text = if state.variables.is_editing() {\n \"VARIABLE INPUT: Type value | Enter: Save | ESC: Cancel\"\n } else {\n \"VARIABLE MODE: ↑↓: Navigate | Space: Edit variable | Tab: Next | ESC: Exit\"\n };\n vec![Span::styled(text, Style::default().fg(Color::Gray))]\n }\n }\n };\n\n let footer = Paragraph::new(Line::from(footer_content))\n .block(Block::default().borders(Borders::ALL).title(\"Controls\"));\n footer.render(area, buf);\n }\n}\n\nimpl StatefulWidget for TemplateWidget {\n type State = TemplateState;\n\n fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {\n TemplateWidget::render(&self, area, buf, state);\n }\n}\n"
},
{
"path": "crates/code2prompt/src/widgets/template/picker.rs",
"content": "//! Template Picker sub-widget.\n//!\n//! This widget provides template selection with separate default and custom lists.\n\nuse crate::model::template::{ActiveList, PickerState};\nuse ratatui::{\n prelude::*,\n widgets::{Block, Borders, List, ListItem},\n};\n\n/// Template Picker sub-widget\npub struct TemplatePickerWidget;\n\nimpl TemplatePickerWidget {\n pub fn new() -> Self {\n Self\n }\n\n /// Render the template picker as a single unified list with groups\n pub fn render(&self, area: Rect, buf: &mut Buffer, state: &PickerState, is_focused: bool) {\n let border_style = if is_focused {\n Style::default().fg(Color::Yellow)\n } else {\n Style::default().fg(Color::Gray)\n };\n\n // Create unified list with section headers\n let mut items = Vec::new();\n let mut item_index = 0;\n let global_cursor = state.get_global_cursor_position();\n\n // Default Templates Section\n if !state.default_templates.is_empty() {\n // Section header\n items.push(ListItem::new(Line::from(vec![\n Span::styled(\"📄 \", Style::default().fg(Color::White)),\n Span::styled(\n \"Default Templates\",\n Style::default()\n .fg(Color::Cyan)\n .add_modifier(Modifier::BOLD),\n ),\n ])));\n item_index += 1;\n\n // Default template items\n for template in state.default_templates.iter() {\n let is_selected = global_cursor == item_index;\n let style = if is_selected && is_focused {\n Style::default()\n .fg(Color::Yellow)\n .add_modifier(Modifier::BOLD)\n } else if is_selected {\n Style::default()\n .fg(Color::Cyan)\n .add_modifier(Modifier::BOLD)\n } else {\n Style::default().fg(Color::White)\n };\n\n let prefix = if is_selected { \"► \" } else { \" \" };\n items.push(ListItem::new(format!(\"{}📄 {}\", prefix, template.name)).style(style));\n item_index += 1;\n }\n }\n\n // Custom Templates Section\n if !state.custom_templates.is_empty() {\n // Add separator if we have default templates\n if !state.default_templates.is_empty() {\n items.push(ListItem::new(\"\"));\n item_index += 1;\n }\n\n // Section header\n items.push(ListItem::new(Line::from(vec![\n Span::styled(\"📝 \", Style::default().fg(Color::White)),\n Span::styled(\n \"Custom Templates\",\n Style::default()\n .fg(Color::Green)\n .add_modifier(Modifier::BOLD),\n ),\n ])));\n item_index += 1;\n\n // Custom template items\n for template in state.custom_templates.iter() {\n let is_selected = global_cursor == item_index;\n let style = if is_selected && is_focused {\n Style::default()\n .fg(Color::Yellow)\n .add_modifier(Modifier::BOLD)\n } else if is_selected {\n Style::default()\n .fg(Color::Green)\n .add_modifier(Modifier::BOLD)\n } else {\n Style::default().fg(Color::White)\n };\n\n let prefix = if is_selected { \"► \" } else { \" \" };\n items.push(ListItem::new(format!(\"{}📝 {}\", prefix, template.name)).style(style));\n item_index += 1;\n }\n }\n\n // Create title with focus indicators\n let title_spans = vec![\n Span::styled(\"Template \", Style::default().fg(Color::White)),\n Span::styled(\n \"p\",\n Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),\n ),\n Span::styled(\"icker\", Style::default().fg(Color::White)),\n ];\n\n let list = List::new(items).block(\n Block::default()\n .borders(Borders::ALL)\n .title(Line::from(title_spans))\n .border_style(border_style),\n );\n\n Widget::render(list, area, buf);\n }\n\n /// Get help text for the picker\n pub fn get_help_text(is_focused: bool, _active_list: ActiveList) -> &'static str {\n if is_focused {\n \"↑↓: Navigate | l/Space: Load | r: Refresh\"\n } else {\n \"Press 'p' to focus picker\"\n }\n }\n}\n\nimpl Default for TemplatePickerWidget {\n fn default() -> Self {\n Self::new()\n }\n}\n"
},
{
"path": "crates/code2prompt/src/widgets/template/variable.rs",
"content": "//! Template Variable sub-widget.\n//!\n//! This widget provides a 2-column display for template variables with direct editing.\n\nuse crate::model::template::{VariableCategory, VariableInfo, VariableState};\nuse ratatui::{\n prelude::*,\n widgets::{Block, Borders, Clear, Paragraph},\n};\n\n/// Template Variable sub-widget\npub struct TemplateVariableWidget;\n\nimpl TemplateVariableWidget {\n pub fn new() -> Self {\n Self\n }\n\n /// Render the variable widget\n pub fn render(\n &self,\n area: Rect,\n buf: &mut Buffer,\n state: &VariableState,\n variables: &[VariableInfo],\n is_focused: bool,\n ) {\n let border_style = if is_focused {\n Style::default().fg(Color::Yellow)\n } else {\n Style::default().fg(Color::Gray)\n };\n\n // Create table-like display with 2 columns\n let mut lines = Vec::new();\n\n // Header\n lines.push(Line::from(vec![\n Span::styled(\n \"Name\",\n Style::default()\n .fg(Color::White)\n .add_modifier(Modifier::BOLD),\n ),\n Span::raw(\" \"), // Spacing\n Span::styled(\n \"Description/Value\",\n Style::default()\n .fg(Color::White)\n .add_modifier(Modifier::BOLD),\n ),\n ]));\n\n lines.push(Line::from(vec![Span::raw(\n \"────────────────────────────────────────────────────────────────────────────────\",\n )]));\n\n // Variable rows\n for (i, var_info) in variables.iter().enumerate() {\n let is_selected = i == state.cursor && is_focused;\n\n let name_style = if is_selected {\n Style::default()\n .fg(Color::Yellow)\n .add_modifier(Modifier::BOLD)\n } else {\n match var_info.category {\n VariableCategory::System => Style::default().fg(Color::Green),\n VariableCategory::User => Style::default().fg(Color::Cyan),\n VariableCategory::Missing => Style::default().fg(Color::Red),\n }\n };\n\n let value_style = if is_selected {\n Style::default()\n .fg(Color::Yellow)\n .add_modifier(Modifier::BOLD)\n } else {\n Style::default().fg(Color::White)\n };\n\n let prefix = match var_info.category {\n VariableCategory::System => \"🔧 \",\n VariableCategory::User => \"👤 \",\n VariableCategory::Missing => \"❌ \",\n };\n\n let name_part = format!(\"{}{{{{{}}}}}\", prefix, var_info.name);\n let name_padded = format!(\"{:<24}\", name_part);\n\n let value_part = match var_info.category {\n VariableCategory::System => var_info\n .description\n .as_ref()\n .unwrap_or(&\"System variable\".to_string())\n .clone(),\n VariableCategory::User => var_info\n .value\n .as_ref()\n .unwrap_or(&\"(empty)\".to_string())\n .clone(),\n VariableCategory::Missing => \"⚠️ Not defined\".to_string(), // NO \"Press Enter to set\"\n };\n\n let line = if is_selected {\n // Highlight entire row for selected item\n Line::from(vec![Span::styled(\n format!(\"► {}{}\", name_padded, value_part),\n name_style,\n )])\n } else {\n Line::from(vec![\n Span::styled(format!(\" {}\", name_padded), name_style),\n Span::styled(value_part, value_style),\n ])\n };\n\n lines.push(line);\n }\n\n let title_spans = vec![\n Span::styled(\n \"v\",\n Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),\n ),\n Span::styled(\"ariables\", Style::default().fg(Color::White)),\n ];\n\n let paragraph = Paragraph::new(lines)\n .block(\n Block::default()\n .borders(Borders::ALL)\n .title(Line::from(title_spans))\n .border_style(border_style),\n )\n .wrap(ratatui::widgets::Wrap { trim: false });\n\n Widget::render(paragraph, area, buf);\n\n // Render variable input popup if active\n if state.is_editing() {\n self.render_variable_input(area, buf, state);\n }\n }\n\n /// Render variable input popup\n fn render_variable_input(&self, area: Rect, buf: &mut Buffer, state: &VariableState) {\n let popup_area = Self::centered_rect(60, 20, area);\n Clear.render(popup_area, buf);\n\n let var_name = state\n .get_editing_variable()\n .map(|s| s.as_str())\n .unwrap_or(\"Unknown\");\n let title = format!(\"Set Variable: {}\", var_name);\n\n let paragraph = Paragraph::new(state.get_input_content()).block(\n Block::default()\n .borders(Borders::ALL)\n .title(title)\n .border_style(Style::default().fg(Color::Yellow)),\n );\n\n Widget::render(paragraph, popup_area, buf);\n }\n\n /// Create centered rectangle for popup\n fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {\n let popup_layout = Layout::default()\n .direction(Direction::Vertical)\n .constraints([\n Constraint::Percentage((100 - percent_y) / 2),\n Constraint::Percentage(percent_y),\n Constraint::Percentage((100 - percent_y) / 2),\n ])\n .split(r);\n\n Layout::default()\n .direction(Direction::Horizontal)\n .constraints([\n Constraint::Percentage((100 - percent_x) / 2),\n Constraint::Percentage(percent_x),\n Constraint::Percentage((100 - percent_x) / 2),\n ])\n .split(popup_layout[1])[1]\n }\n}\n\nimpl Default for TemplateVariableWidget {\n fn default() -> Self {\n Self::new()\n }\n}\n"
},
{
"path": "crates/code2prompt/tests/common/fixtures.rs",
"content": "//! rstest fixtures for code2prompt integration tests\n\nuse super::test_env::*;\nuse colored::*;\nuse log::info;\nuse rstest::*;\nuse std::fs;\n\n/// Fixture for basic test environment with standard file hierarchy\n#[fixture]\npub fn basic_test_env() -> BasicTestEnv {\n let env = BasicTestEnv::new();\n create_standard_hierarchy(env.dir.path());\n env\n}\n\n/// Fixture for git test environment with gitignore setup\n#[fixture]\npub fn git_test_env() -> GitTestEnv {\n let env = GitTestEnv::new();\n create_git_hierarchy(env.dir.path());\n env\n}\n\n/// Fixture for stdout test environment with simple files\n#[fixture]\npub fn stdout_test_env() -> StdoutTestEnv {\n let env = StdoutTestEnv::new();\n create_simple_test_files(env.dir.path());\n env\n}\n\n/// Fixture for template test environment with code structure\n#[fixture]\npub fn template_test_env() -> TemplateTestEnv {\n let env = TemplateTestEnv::new();\n create_test_codebase(env.dir.path());\n env\n}\n\n/// Create standard test hierarchy (lowercase/uppercase directories with various files)\npub fn create_standard_hierarchy(base_path: &std::path::Path) {\n let lowercase_dir = base_path.join(\"lowercase\");\n let uppercase_dir = base_path.join(\"uppercase\");\n\n fs::create_dir_all(&lowercase_dir).unwrap();\n fs::create_dir_all(&uppercase_dir).unwrap();\n\n let files = vec![\n (\"lowercase/foo.py\", \"content foo.py\"),\n (\"lowercase/bar.py\", \"content bar.py\"),\n (\"lowercase/baz.py\", \"content baz.py\"),\n (\"lowercase/qux.txt\", \"content qux.txt\"),\n (\"lowercase/corge.txt\", \"content corge.txt\"),\n (\"lowercase/grault.txt\", \"content grault.txt\"),\n (\"uppercase/FOO.py\", \"CONTENT FOO.PY\"),\n (\"uppercase/BAR.py\", \"CONTENT BAR.PY\"),\n (\"uppercase/BAZ.py\", \"CONTENT BAZ.PY\"),\n (\"uppercase/QUX.txt\", \"CONTENT QUX.TXT\"),\n (\"uppercase/CORGE.txt\", \"CONTENT CORGE.TXT\"),\n (\"uppercase/GRAULT.txt\", \"CONTENT GRAULT.TXT\"),\n ];\n\n for (file_path, content) in files {\n create_temp_file(base_path, file_path, content);\n }\n\n info!(\n \"{}{}{} {}\",\n \"[\".bold().white(),\n \"✓\".bold().green(),\n \"]\".bold().white(),\n \"Standard test hierarchy created\".green()\n );\n}\n\n/// Create git test hierarchy with gitignore\npub fn create_git_hierarchy(base_path: &std::path::Path) {\n let test_dir = base_path.join(\"test_dir\");\n fs::create_dir_all(&test_dir).unwrap();\n\n let files = vec![\n (\"test_dir/included.txt\", \"Included file\"),\n (\"test_dir/ignored.txt\", \"Ignored file\"),\n ];\n\n for (file_path, content) in files {\n create_temp_file(base_path, file_path, content);\n }\n\n // Create a .gitignore file\n let gitignore_path = base_path.join(\".gitignore\");\n let mut gitignore_file =\n std::fs::File::create(&gitignore_path).expect(\"Failed to create .gitignore file\");\n use std::io::Write;\n writeln!(gitignore_file, \"test_dir/ignored.txt\").expect(\"Failed to write to .gitignore file\");\n\n info!(\n \"{}{}{} {}\",\n \"[\".bold().white(),\n \"✓\".bold().green(),\n \"]\".bold().white(),\n \"Git test hierarchy created\".green()\n );\n}\n\n/// Create simple test files for stdout tests\npub fn create_simple_test_files(base_path: &std::path::Path) {\n let files = vec![\n (\"test.py\", \"print('Hello, World!')\"),\n (\"README.md\", \"# Test Project\\nThis is a test.\"),\n (\"config.json\", r#\"{\"name\": \"test\", \"version\": \"1.0.0\"}\"#),\n ];\n\n for (file_path, content) in files {\n create_temp_file(base_path, file_path, content);\n }\n\n info!(\n \"{}{}{} {}\",\n \"[\".bold().white(),\n \"✓\".bold().green(),\n \"]\".bold().white(),\n \"Simple test files created\".green()\n );\n}\n\n/// Create test codebase for template tests\npub fn create_test_codebase(base_path: &std::path::Path) {\n let files = vec![\n (\n \"src/main.rs\",\n \"fn main() {\\n println!(\\\"Hello, world!\\\");\\n}\",\n ),\n (\n \"src/lib.rs\",\n \"pub fn add(a: i32, b: i32) -> i32 {\\n a + b\\n}\",\n ),\n (\n \"tests/test.rs\",\n \"#[test]\\nfn test_add() {\\n assert_eq!(3, add(1, 2));\\n}\",\n ),\n ];\n\n for (file_path, content) in files {\n create_temp_file(base_path, file_path, content);\n }\n\n info!(\n \"{}{}{} {}\",\n \"[\".bold().white(),\n \"✓\".bold().green(),\n \"]\".bold().white(),\n \"Test codebase created\".green()\n );\n}\n"
},
{
"path": "crates/code2prompt/tests/common/mod.rs",
"content": "//! Common test utilities and fixtures for code2prompt integration tests\n//!\n//! This module provides reusable fixtures and utilities to reduce code duplication\n//! across integration tests using rstest.\n\npub mod fixtures;\npub mod test_env;\n\npub use test_env::*;\n\nuse std::sync::Once;\n\nstatic INIT: Once = Once::new();\n\n/// Initialize logger for tests (called once)\npub fn init_logger() {\n INIT.call_once(|| {\n env_logger::builder()\n .is_test(true)\n .filter_level(log::LevelFilter::Debug)\n .try_init()\n .expect(\"Failed to initialize logger\");\n });\n}\n"
},
{
"path": "crates/code2prompt/tests/common/test_env.rs",
"content": "//! Test environment types and utilities\n\n#![allow(dead_code)]\n\nuse assert_cmd::Command;\nuse std::fs::{self, File};\nuse std::io::Write;\nuse std::path::Path;\nuse tempfile::TempDir;\n\n/// Basic test environment with temporary directory and output file\npub struct BasicTestEnv {\n pub dir: TempDir,\n output_file: String,\n}\n\nimpl BasicTestEnv {\n pub fn new() -> Self {\n super::init_logger();\n let dir = tempfile::tempdir().unwrap();\n let output_file = dir.path().join(\"output.txt\").to_str().unwrap().to_string();\n BasicTestEnv { dir, output_file }\n }\n\n pub fn command(&self) -> Command {\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(self.dir.path().to_str().unwrap())\n .arg(\"--output-file\")\n .arg(&self.output_file)\n .arg(\"--no-clipboard\");\n cmd\n }\n\n pub fn read_output(&self) -> String {\n let file_path = self.dir.path().join(\"output.txt\");\n std::fs::read_to_string(&file_path)\n .unwrap_or_else(|_| panic!(\"Failed to read output file: {:?}\", file_path))\n }\n}\n\n/// Git-enabled test environment\npub struct GitTestEnv {\n pub dir: TempDir,\n output_file: String,\n}\n\nimpl GitTestEnv {\n pub fn new() -> Self {\n super::init_logger();\n let dir = tempfile::tempdir().unwrap();\n let _repo = git2::Repository::init(dir.path()).expect(\"Failed to initialize repository\");\n let output_file = dir.path().join(\"output.txt\").to_str().unwrap().to_string();\n GitTestEnv { dir, output_file }\n }\n\n pub fn command(&self) -> Command {\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(self.dir.path().to_str().unwrap())\n .arg(\"--output-file\")\n .arg(&self.output_file)\n .arg(\"--no-clipboard\");\n cmd\n }\n\n pub fn read_output(&self) -> String {\n let file_path = self.dir.path().join(\"output.txt\");\n std::fs::read_to_string(&file_path)\n .unwrap_or_else(|_| panic!(\"Failed to read output file: {:?}\", file_path))\n }\n}\n\n/// Simple test environment for stdout tests\npub struct StdoutTestEnv {\n pub dir: TempDir,\n}\n\nimpl StdoutTestEnv {\n pub fn new() -> Self {\n super::init_logger();\n let dir = tempfile::tempdir().unwrap();\n StdoutTestEnv { dir }\n }\n\n pub fn path(&self) -> &str {\n self.dir.path().to_str().unwrap()\n }\n}\n\n/// Template test environment\npub struct TemplateTestEnv {\n pub dir: TempDir,\n output_file: std::path::PathBuf,\n}\n\nimpl TemplateTestEnv {\n pub fn new() -> Self {\n super::init_logger();\n let dir = tempfile::tempdir().unwrap();\n let output_file = dir.path().join(\"output.txt\");\n TemplateTestEnv { dir, output_file }\n }\n\n pub fn command(&self) -> Command {\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(self.dir.path().to_str().unwrap())\n .arg(\"--output-file\")\n .arg(self.output_file.to_str().unwrap())\n .arg(\"--no-clipboard\");\n cmd\n }\n\n pub fn read_output(&self) -> String {\n std::fs::read_to_string(&self.output_file)\n .unwrap_or_else(|_| panic!(\"Failed to read output file: {:?}\", self.output_file))\n }\n\n pub fn output_file_exists(&self) -> bool {\n self.output_file.exists()\n }\n}\n\n/// Utility functions\npub fn create_temp_file(dir: &Path, name: &str, content: &str) -> std::path::PathBuf {\n let file_path = dir.join(name);\n let parent_dir = file_path.parent().unwrap();\n fs::create_dir_all(parent_dir)\n .unwrap_or_else(|_| panic!(\"Failed to create directory: {:?}\", parent_dir));\n let mut file = File::create(&file_path)\n .unwrap_or_else(|_| panic!(\"Failed to create temp file: {:?}\", file_path));\n writeln!(file, \"{}\", content)\n .unwrap_or_else(|_| panic!(\"Failed to write to temp file: {:?}\", file_path));\n file_path\n}\n"
},
{
"path": "crates/code2prompt/tests/config_test.rs",
"content": "//! Tests for TOML configuration functionality\n//!\n//! This module tests the TOML configuration loading, parsing, and integration\n//! with the new Unix-style behavior.\n\nmod common;\n\nuse code2prompt_core::sort::FileSortMethod;\nuse code2prompt_core::template::OutputFormat;\nuse common::*;\nuse predicates::prelude::*;\nuse predicates::str::contains;\nuse std::fs;\nuse tempfile::TempDir;\n\n/// Test TOML configuration parsing\n#[test]\nfn test_toml_config_parsing() {\n let toml_content = r#\"\ndefault_output = \"clipboard\"\npath = \"./src\"\ninclude_patterns = [\"*.rs\", \"*.toml\"]\nexclude_patterns = [\"target\", \"node_modules\"]\nline_numbers = true\nabsolute_path = false\nfull_directory_tree = false\noutput_format = \"markdown\"\nsort_method = \"name_asc\"\nencoding = \"cl100k\"\ntoken_format = \"format\"\ndiff_enabled = true\ndiff_branches = [\"main\", \"feature-x\"]\nlog_branches = [\"v1.0.0\", \"v1.1.0\"]\ntemplate_name = \"default\"\ntemplate_str = \"\"\ntoken_map_enabled = true\n\n[user_variables]\nproject = \"code2prompt\"\nauthor = \"ODAncona\"\n\"#;\n\n use code2prompt_core::configuration::TomlConfig;\n let config = TomlConfig::from_toml_str(toml_content).expect(\"Should parse TOML config\");\n\n assert_eq!(\n config.default_output,\n code2prompt_core::configuration::OutputDestination::Clipboard\n );\n assert_eq!(config.path, Some(\"./src\".to_string()));\n assert_eq!(config.include_patterns, vec![\"*.rs\", \"*.toml\"]);\n assert_eq!(config.exclude_patterns, vec![\"target\", \"node_modules\"]);\n assert!(config.line_numbers);\n assert!(!config.absolute_path);\n assert!(!config.full_directory_tree);\n assert_eq!(config.output_format, Some(OutputFormat::Markdown));\n assert_eq!(config.sort_method, Some(FileSortMethod::NameAsc));\n assert_eq!(\n config.encoding,\n Some(code2prompt_core::tokenizer::TokenizerType::Cl100kBase)\n );\n assert_eq!(\n config.token_format,\n Some(code2prompt_core::tokenizer::TokenFormat::Format)\n );\n assert!(config.diff_enabled);\n assert_eq!(\n config.diff_branches,\n Some(vec![\"main\".to_string(), \"feature-x\".to_string()])\n );\n assert_eq!(\n config.log_branches,\n Some(vec![\"v1.0.0\".to_string(), \"v1.1.0\".to_string()])\n );\n assert_eq!(config.template_name, Some(\"default\".to_string()));\n assert!(config.token_map_enabled);\n assert_eq!(\n config.user_variables.get(\"project\"),\n Some(&\"code2prompt\".to_string())\n );\n assert_eq!(\n config.user_variables.get(\"author\"),\n Some(&\"ODAncona\".to_string())\n );\n}\n\n/// Test TOML config export functionality\n#[test]\nfn test_toml_config_export() {\n use code2prompt_core::configuration::{Code2PromptConfig, export_config_to_toml};\n\n let config = Code2PromptConfig::builder()\n .path(\"./test\")\n .include_patterns(vec![\"*.rs\".to_string()])\n .exclude_patterns(vec![\"target\".to_string()])\n .line_numbers(true)\n .build()\n .unwrap();\n\n let toml_str = export_config_to_toml(&config).expect(\"Should export to TOML\");\n\n // Verify the exported TOML contains expected values\n assert!(toml_str.contains(\"default_output = \\\"stdout\\\"\"));\n assert!(toml_str.contains(\"path = \\\"./test\\\"\"));\n assert!(toml_str.contains(\"include_patterns = [\\\"*.rs\\\"]\"));\n assert!(toml_str.contains(\"exclude_patterns = [\\\"target\\\"]\"));\n assert!(toml_str.contains(\"line_numbers = true\"));\n}\n\n/// Test local config file loading\n#[test]\nfn test_local_config_file_loading() {\n let temp_dir = TempDir::new().expect(\"Should create temp dir\");\n let config_path = temp_dir.path().join(\".c2pconfig\");\n\n let toml_content = r#\"\ndefault_output = \"stdout\"\ninclude_patterns = [\"*.rs\"]\nline_numbers = true\n\"#;\n\n fs::write(&config_path, toml_content).expect(\"Should write config file\");\n\n // Change to the temp directory\n let original_dir = std::env::current_dir().expect(\"Should get current dir\");\n std::env::set_current_dir(temp_dir.path()).expect(\"Should change dir\");\n\n // Test that the config is loaded (we can't easily test the actual loading here\n // without more complex setup, but we can test the file exists)\n assert!(config_path.exists());\n\n // Restore original directory\n std::env::set_current_dir(original_dir).expect(\"Should restore dir\");\n}\n\n/// Test new Unix-style default behavior (stdout)\n#[test]\nfn test_unix_style_default_stdout() {\n let temp_dir = TempDir::new().expect(\"Should create temp dir\");\n\n // Create a test.py file with expected content\n fs::write(temp_dir.path().join(\"test.py\"), \"print('Hello, World!')\")\n .expect(\"Should write test file\");\n\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n let temp_path = temp_dir.path().to_path_buf();\n cmd.arg(&temp_path)\n .assert()\n .success()\n .stdout(contains(\"test.py\"))\n .stdout(contains(\"print('Hello, World!')\"));\n\n // Keep temp_dir alive until the end\n drop(temp_dir);\n}\n\n/// Test new clipboard flag\n#[test]\nfn test_clipboard_flag() {\n let test_env = StdoutTestEnv::new();\n\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(test_env.path())\n .arg(\"-c\") // New clipboard flag\n .assert()\n .success()\n // Should not output to stdout when using clipboard\n .stdout(contains(\"test.py\").not());\n}\n\n/// Test that CLI args override config files\n#[test]\nfn test_cli_args_override_config() {\n let temp_dir = TempDir::new().expect(\"Should create temp dir\");\n let config_path = temp_dir.path().join(\".c2pconfig\");\n\n // Create a config that would normally exclude .py files\n let toml_content = r#\"\ndefault_output = \"clipboard\"\nexclude_patterns = [\"*.py\"]\n\"#;\n\n fs::write(&config_path, toml_content).expect(\"Should write config file\");\n fs::write(temp_dir.path().join(\"test.py\"), \"print('Hello')\").expect(\"Should write test file\");\n\n // CLI args should override config - include .py files despite config\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.current_dir(temp_dir.path())\n .arg(\".\")\n .arg(\"-i\")\n .arg(\"*.py\") // CLI override\n .arg(\"-O\")\n .arg(\"-\") // Force output to stdout to see the result\n .assert()\n .success()\n .stdout(contains(\"test.py\"))\n .stdout(contains(\"print('Hello')\"));\n}\n\n/// Test configuration info messages\n#[test]\nfn test_config_info_messages() {\n let temp_dir = TempDir::new().expect(\"Should create temp dir\");\n let config_path = temp_dir.path().join(\".c2pconfig\");\n\n let toml_content = r#\"\ndefault_output = \"stdout\"\n\"#;\n\n fs::write(&config_path, toml_content).expect(\"Should write config file\");\n fs::write(temp_dir.path().join(\"test.txt\"), \"content\").expect(\"Should write test file\");\n\n // Run with the temp directory as argument and set current directory for the command\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.current_dir(temp_dir.path())\n .arg(\".\")\n .assert()\n .success()\n .stderr(contains(\"[i] Using config from:\"));\n}\n\n/// Test default configuration message\n#[test]\nfn test_default_config_message() {\n let temp_dir = TempDir::new().expect(\"Should create temp dir\");\n fs::write(temp_dir.path().join(\"test.txt\"), \"content\").expect(\"Should write test file\");\n\n // Run with the temp directory as argument and set current directory for the command\n // No config file exists, so it should use default configuration\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.current_dir(temp_dir.path())\n .arg(\".\")\n .assert()\n .success()\n .stderr(contains(\"[i] Using default configuration\"));\n}\n\n/// Test CLI args message - now CLI args are applied on top of config\n#[test]\nfn test_cli_args_message() {\n let test_env = StdoutTestEnv::new();\n\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(test_env.path())\n .arg(\"-i\")\n .arg(\"*.py\")\n .assert()\n .success()\n .stderr(contains(\"[i] Using default configuration\")); // Now always loads config first\n}\n"
},
{
"path": "crates/code2prompt/tests/git_integration_test.rs",
"content": "//! Git integration tests for code2prompt\n//!\n//! This module tests git-related functionality including gitignore handling\n//! and git repository integration using rstest fixtures.\n\nmod common;\n\nuse common::fixtures::*;\nuse common::*;\nuse log::debug;\nuse predicates::prelude::*;\nuse predicates::str::contains;\nuse rstest::*;\n\n/// Test gitignore functionality - files should be ignored by default\n#[rstest]\nfn test_gitignore(git_test_env: GitTestEnv) {\n let mut cmd = git_test_env.command();\n cmd.assert().success();\n\n let output = git_test_env.read_output();\n debug!(\"Test gitignore output:\\n{}\", output);\n\n // Should include files not in gitignore\n assert!(contains(\"included.txt\").eval(&output));\n assert!(contains(\"Included file\").eval(&output));\n\n // Should exclude files in gitignore\n assert!(contains(\"ignored.txt\").not().eval(&output));\n assert!(contains(\"Ignored file\").not().eval(&output));\n}\n\n/// Test --no-ignore flag - should include gitignored files\n#[rstest]\nfn test_gitignore_no_ignore(git_test_env: GitTestEnv) {\n let mut cmd = git_test_env.command();\n cmd.arg(\"--no-ignore\").assert().success();\n\n let output = git_test_env.read_output();\n debug!(\"Test --no-ignore flag output:\\n{}\", output);\n\n // Should include all files when ignoring gitignore\n assert!(contains(\"included.txt\").eval(&output));\n assert!(contains(\"Included file\").eval(&output));\n assert!(contains(\"ignored.txt\").eval(&output));\n assert!(contains(\"Ignored file\").eval(&output));\n}\n\n/// Test that git repository is properly initialized in fixture\n#[rstest]\nfn test_git_repo_initialization(git_test_env: GitTestEnv) {\n // Verify that the git repository exists\n let git_dir = git_test_env.dir.path().join(\".git\");\n assert!(git_dir.exists(), \"Git repository should be initialized\");\n assert!(git_dir.is_dir(), \"Git directory should be a directory\");\n}\n\n/// Test gitignore with different patterns\n#[rstest]\n#[case(\"*.log\", \"test.log\", \"Log file content\")]\n#[case(\"build/\", \"build/output.txt\", \"Build output\")]\n#[case(\"*.tmp\", \"temp.tmp\", \"Temporary content\")]\nfn test_gitignore_patterns(\n #[case] pattern: &str,\n #[case] file_path: &str,\n #[case] file_content: &str,\n) {\n let env = GitTestEnv::new();\n\n // Create the test file\n create_temp_file(env.dir.path(), file_path, file_content);\n\n // Create gitignore with the pattern\n let gitignore_path = env.dir.path().join(\".gitignore\");\n std::fs::write(&gitignore_path, pattern).expect(\"Failed to write gitignore\");\n\n let mut cmd = env.command();\n cmd.assert().success();\n\n let output = env.read_output();\n debug!(\"Test gitignore pattern '{}' output:\\n{}\", pattern, output);\n\n // File should be ignored\n assert!(\n contains(file_content).not().eval(&output),\n \"File with pattern '{}' should be ignored\",\n pattern\n );\n\n // Test with --no-ignore\n let mut cmd_no_ignore = env.command();\n cmd_no_ignore.arg(\"--no-ignore\").assert().success();\n\n let output_no_ignore = env.read_output();\n assert!(\n contains(file_content).eval(&output_no_ignore),\n \"File with pattern '{}' should be included with --no-ignore\",\n pattern\n );\n}\n"
},
{
"path": "crates/code2prompt/tests/integration_test.rs",
"content": "//! Integration tests for code2prompt file filtering functionality\n//!\n//! This module tests the include/exclude patterns, file filtering,\n//! and directory tree generation features using rstest fixtures.\n\nmod common;\n\nuse common::fixtures::*;\nuse common::*;\nuse log::debug;\nuse predicates::prelude::*;\nuse predicates::str::contains;\nuse rstest::*;\n\n/// Test file filtering with various include/exclude patterns\n#[rstest]\nfn test_file_filtering(\n basic_test_env: BasicTestEnv,\n #[values(\n (\"include_extensions\", vec![\"--include=*.py\"], vec![\"foo.py\", \"content foo.py\", \"FOO.py\", \"CONTENT FOO.PY\"], vec![\"content qux.txt\"]),\n (\"exclude_extensions\", vec![\"--exclude=*.txt\"], vec![\"foo.py\", \"content foo.py\", \"FOO.py\", \"CONTENT FOO.PY\"], vec![\"lowercase/qux.txt\", \"content qux.txt\"]),\n (\"include_files\", vec![\"--include=**/foo.py,**/bar.py\"], vec![\"foo.py\", \"content foo.py\", \"bar.py\", \"content bar.py\"], vec![\"lowercase/baz.py\", \"content baz.py\"]),\n (\"include_folders\", vec![\"--include=**/lowercase/**\"], vec![\"foo.py\", \"content foo.py\", \"baz.py\", \"content baz.py\"], vec![\"uppercase/FOO\"]),\n (\"exclude_files\", vec![\"--exclude=**/foo.py,**/bar.py\"], vec![\"baz.py\", \"content baz.py\"], vec![\"lowercase/foo.py\", \"content foo.py\", \"lowercase/bar.py\", \"content bar.py\"]),\n (\"exclude_folders\", vec![\"--exclude=**/uppercase/**\"], vec![\"foo.py\", \"content foo.py\", \"baz.py\", \"content baz.py\"], vec![\"CONTENT FOO.py\"])\n )]\n test_case: (&str, Vec<&str>, Vec<&str>, Vec<&str>),\n) {\n let (name, args, should_include, should_exclude) = test_case;\n\n let mut cmd = basic_test_env.command();\n for arg in args {\n cmd.arg(arg);\n }\n cmd.assert().success();\n\n let output = basic_test_env.read_output();\n debug!(\"Test {} output:\\n{}\", name, output);\n\n // Check that expected content is included\n for expected in should_include {\n assert!(\n contains(expected).eval(&output),\n \"Test {}: Expected '{}' to be included in output\",\n name,\n expected\n );\n }\n\n // Check that expected content is excluded\n for expected in should_exclude {\n assert!(\n contains(expected).not().eval(&output),\n \"Test {}: Expected '{}' to be excluded from output\",\n name,\n expected\n );\n }\n}\n\n/// Test include/exclude combination with exclude priority\n#[rstest]\nfn test_include_exclude_with_exclude_priority(basic_test_env: BasicTestEnv) {\n let mut cmd = basic_test_env.command();\n cmd.arg(\"--include=*.py,**/lowercase/**\")\n .arg(\"--exclude=**/foo.py,**/uppercase/**\")\n .assert()\n .success();\n\n let output = basic_test_env.read_output();\n debug!(\"Test include and exclude combinations output:\\n{}\", output);\n\n // Should include\n assert!(contains(\"lowercase/baz.py\").eval(&output));\n assert!(contains(\"content baz.py\").eval(&output));\n\n // Should exclude (exclude takes priority)\n assert!(contains(\"lowercase/foo.py\").not().eval(&output));\n assert!(contains(\"content foo.py\").not().eval(&output));\n assert!(contains(\"uppercase/FOO.py\").not().eval(&output));\n assert!(contains(\"CONTENT FOO.PY\").not().eval(&output));\n}\n\n/// Test with no filters (should include everything)\n#[rstest]\nfn test_no_filters(basic_test_env: BasicTestEnv) {\n let mut cmd = basic_test_env.command();\n cmd.assert().success();\n\n let output = basic_test_env.read_output();\n debug!(\"Test no filters output:\\n{}\", output);\n\n // Should include all files\n let expected_files = vec![\n \"foo.py\",\n \"content foo.py\",\n \"baz.py\",\n \"content baz.py\",\n \"FOO.py\",\n \"CONTENT FOO.PY\",\n \"BAZ.py\",\n \"CONTENT BAZ.PY\",\n ];\n\n for expected in expected_files {\n assert!(\n contains(expected).eval(&output),\n \"Expected '{}' to be included when no filters are applied\",\n expected\n );\n }\n}\n\n/// Test full directory tree generation\n#[rstest]\nfn test_full_directory_tree(basic_test_env: BasicTestEnv) {\n let mut cmd = basic_test_env.command();\n cmd.arg(\"--full-directory-tree\")\n .arg(\"--exclude\")\n .arg(\"**/uppercase/**\")\n .assert()\n .success();\n\n let output = basic_test_env.read_output();\n debug!(\"Test full directory tree output:\\n{}\", output);\n\n // Should show directory structure\n assert!(contains(\"├── lowercase\").eval(&output));\n assert!(contains(\"└── uppercase\").eval(&output));\n\n // Should show files in tree format\n assert!(contains(\"├── foo.py\").eval(&output));\n assert!(contains(\"├── bar.py\").eval(&output));\n assert!(contains(\"├── baz.py\").eval(&output));\n\n // Should show excluded directory structure but not content\n assert!(contains(\"├── FOO.py\").eval(&output));\n assert!(contains(\"├── BAR.py\").eval(&output));\n assert!(contains(\"├── BAZ.py\").eval(&output));\n assert!(!contains(\"CONTENT BAR.PY\").eval(&output));\n}\n\n/// Test brace expansion patterns\n#[rstest]\nfn test_brace_expansion(basic_test_env: BasicTestEnv) {\n let mut cmd = basic_test_env.command();\n cmd.arg(\"--include\")\n .arg(\"lowercase/{foo.py,bar.py,baz.py}\")\n .arg(\"--exclude\")\n .arg(\"lowercase/{qux.txt,corge.txt,grault.txt}\")\n .assert()\n .success();\n\n let output = basic_test_env.read_output();\n debug!(\"Test brace expansion output:\\n{}\", output);\n\n // Should include specified Python files\n assert!(contains(\"foo.py\").eval(&output));\n assert!(contains(\"content foo.py\").eval(&output));\n assert!(contains(\"bar.py\").eval(&output));\n assert!(contains(\"content bar.py\").eval(&output));\n assert!(contains(\"baz.py\").eval(&output));\n assert!(contains(\"content baz.py\").eval(&output));\n\n // Should exclude specified text files\n assert!(contains(\"qux.txt\").not().eval(&output));\n assert!(contains(\"corge.txt\").not().eval(&output));\n assert!(contains(\"grault.txt\").not().eval(&output));\n}\n\n/// Test command creation helper\n#[rstest]\nfn test_command_helper(basic_test_env: BasicTestEnv) {\n // Test that our fixture creates working commands\n let mut cmd = basic_test_env.command();\n cmd.assert().success();\n\n // Verify output file was created and is readable\n let output = basic_test_env.read_output();\n assert!(!output.is_empty(), \"Output should not be empty\");\n}\n"
},
{
"path": "crates/code2prompt/tests/std_output_test.rs",
"content": "//! Standard output tests for code2prompt\n//!\n//! This module tests stdout functionality, output redirection,\n//! and various output modes using rstest fixtures.\n\nmod common;\n\nuse common::fixtures::*;\nuse common::*;\nuse log::debug;\nuse predicates::prelude::*;\nuse predicates::str::contains;\nuse rstest::*;\n\n/// ~~~ Default Output Behavior ~~~\n#[rstest]\nfn test_output_default(stdout_test_env: StdoutTestEnv) {\n // Default behavior: output to stdout with status messages in stderr\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(stdout_test_env.path())\n .assert()\n .success()\n // Content should be in stdout\n .stdout(contains(\"test.py\"))\n .stdout(contains(\"print('Hello, World!')\"))\n // Status messages should be in stderr\n .stderr(contains(\"Token count:\"))\n // Status messages should NOT be in stdout\n .stdout(contains(\"Token count:\").not());\n\n debug!(\"✓ Default stdout output test passed\");\n}\n\n/// ~~~ Stdout Configurations ~~~\n#[rstest]\n#[case(\"explicit_dash\", vec![\"-O\", \"-\", \"--no-clipboard\"], vec![\"test.py\", \"print('Hello, World!')\", \"README.md\", \"# Test Project\"], vec![\"✓\",\"▹▹▹▹▸ Done!\",\"Token count:\",\"Copied to clipboard successfully\"], true)]\n#[case(\"long_form\", vec![\"--output-file\", \"-\", \"--no-clipboard\"], vec![\"test.py\", \"print('Hello, World!')\", \"README.md\", \"# Test Project\"], vec![\"✓\",\"▹▹▹▹▸ Done!\",\"Token count:\",\"Copied to clipboard successfully\"], true)]\n#[case(\"quiet_mode\", vec![\"--quiet\", \"-O\", \"-\", \"--no-clipboard\"], vec![\"test.py\", \"print('Hello, World!')\"], vec![\"✓\",\"▹▹▹▹▸ Done!\",\"Token count:\",\"Copied to clipboard successfully\"], true)]\nfn test_stdout_configurations(\n stdout_test_env: StdoutTestEnv,\n #[case] test_name: &str,\n #[case] args: Vec<&str>,\n #[case] should_contain: Vec<&str>,\n #[case] should_not_contain: Vec<&str>,\n #[case] should_succeed: bool,\n) {\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(stdout_test_env.path());\n\n for arg in args {\n cmd.arg(arg);\n }\n\n let assertion = cmd.assert();\n\n if should_succeed {\n let assertion = assertion.success();\n\n // Check content that should be present\n let mut assertion = assertion;\n for content in should_contain {\n assertion = assertion.stdout(contains(content));\n }\n\n // Check content that should not be present\n for content in should_not_contain {\n assertion = assertion.stdout(contains(content).not());\n }\n\n debug!(\"✓ {} test passed\", test_name);\n } else {\n assertion.failure();\n debug!(\"✓ {} test passed (correctly failed)\", test_name);\n }\n}\n\n/// ~~~ File Output Configurations ~~~\n#[rstest]\n#[case(\"file_output\", vec![\"--output-file\", \"output.txt\", \"--no-clipboard\"], vec![\"test.py\", \"print('Hello, World!')\", \"README.md\"], vec![], true)]\n#[case(\"file_output_quiet\", vec![\"--output-file\", \"output.txt\", \"--quiet\", \"--no-clipboard\"], vec![\"test.py\", \"print('Hello, World!')\"], vec![\"✓\"], true)]\n#[case(\"file_output_json\", vec![\"--output-file\", \"output.txt\", \"--output-format\", \"json\", \"--no-clipboard\"], vec![\"{\", \"\\\"files\\\"\", \"test.py\"], vec![], true)]\n#[case(\"file_output_xml\", vec![\"--output-file\", \"output.txt\", \"--output-format\", \"xml\", \"--no-clipboard\"], vec![\"\", \"\", \"test.py\"], vec![], true)]\n#[case(\"file_output_markdown\", vec![\"--output-file\", \"output.txt\", \"--output-format\", \"markdown\", \"--no-clipboard\"], vec![\"Source Tree:\", \"```\", \"test.py\"], vec![], true)]\nfn test_file_output_configurations(\n stdout_test_env: StdoutTestEnv,\n #[case] test_name: &str,\n #[case] args: Vec<&str>,\n #[case] should_contain: Vec<&str>,\n #[case] should_not_contain: Vec<&str>,\n #[case] should_succeed: bool,\n) {\n let output_file = stdout_test_env.dir.path().join(\"output.txt\");\n\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(stdout_test_env.path());\n\n // Replace \"output.txt\" in args with the actual path\n for arg in args {\n if arg == \"output.txt\" {\n cmd.arg(output_file.to_str().unwrap());\n } else {\n cmd.arg(arg);\n }\n }\n\n let assertion = cmd.assert();\n\n if should_succeed {\n assertion.success();\n\n // Read the output file and check its contents\n let file_content =\n std::fs::read_to_string(&output_file).expect(\"Should be able to read output file\");\n\n // Check content that should be present\n for content in should_contain {\n assert!(\n file_content.contains(content),\n \"Test {}: Expected '{}' in file output\",\n test_name,\n content\n );\n }\n\n // Check content that should not be present\n for content in should_not_contain {\n assert!(\n !file_content.contains(content),\n \"Test {}: Expected '{}' NOT to be in file output\",\n test_name,\n content\n );\n }\n\n debug!(\"✓ {} test passed\", test_name);\n } else {\n assertion.failure();\n debug!(\"✓ {} test passed (correctly failed)\", test_name);\n }\n}\n\n/// Test conflicting output options (should fail)\n#[rstest]\nfn test_conflicting_output_options_should_fail(stdout_test_env: StdoutTestEnv) {\n // Test: Using both default stdout and explicit -O - should fail\n // This is a logical conflict - you can't output to stdout in two different ways\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(stdout_test_env.path())\n .arg(\"-\")\n .arg(\"-O\")\n .arg(\"-\")\n .arg(\"--no-clipboard\")\n .assert()\n .failure();\n\n debug!(\"✓ Conflicting output options test passed (correctly failed)\");\n}\n\n// Using both output file and stdout should fail\n#[rstest]\nfn test_output_file_vs_stdout_conflict(stdout_test_env: StdoutTestEnv) {\n let output_file = stdout_test_env.dir.path().join(\"output.txt\");\n\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(stdout_test_env.path())\n .arg(\"--output-file\")\n .arg(output_file.to_str().unwrap())\n .arg(\"-O\")\n .arg(\"-\")\n .arg(\"--no-clipboard\")\n .assert()\n .failure()\n .stderr(\n contains(\"cannot be used multiple times\")\n .or(contains(\"conflict\"))\n .or(contains(\"mutually exclusive\")),\n );\n\n debug!(\"✓ Output file vs stdout conflict test passed (correctly failed)\");\n}\n\n/// Test stdout with different output formats\n#[rstest]\n#[case(\"json\", \"{\", \"\\\"files\\\"\")]\n#[case(\"xml\", \"<\", \">\")]\n#[case(\"markdown\", \"Source Tree:\", \"```\")]\nfn test_stdout_with_different_formats(\n stdout_test_env: StdoutTestEnv,\n #[case] format: &str,\n #[case] expected_start: &str,\n #[case] expected_content: &str,\n) {\n // Test: Stdout should work with different output formats\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(stdout_test_env.path())\n .arg(\"--output-format\")\n .arg(format)\n .arg(\"-O\")\n .arg(\"-\")\n .arg(\"--no-clipboard\")\n .assert()\n .success()\n .stdout(contains(expected_start))\n .stdout(contains(expected_content))\n .stdout(contains(\"test.py\"));\n\n debug!(\"✓ Stdout with {} format test passed\", format);\n}\n\n/// Test stderr messages in normal mode (should show status messages)\n#[rstest]\nfn test_stderr_messages_normal_mode(stdout_test_env: StdoutTestEnv) {\n let output_file = stdout_test_env.dir.path().join(\"output.txt\");\n\n // Test with file output in normal mode - should show success message in stderr\n // Note: In test environment, auto-quiet is enabled, so Token count might not appear\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(stdout_test_env.path())\n .arg(\"--output-file\")\n .arg(output_file.to_str().unwrap())\n .arg(\"--no-clipboard\")\n .assert()\n .success()\n .stderr(contains(\"Prompt written to file:\"));\n\n debug!(\"✓ Normal mode stderr messages test passed\");\n}\n\n/// Test stderr messages in quiet mode\n#[rstest]\nfn test_stderr_messages_quiet_mode(stdout_test_env: StdoutTestEnv) {\n let output_file = stdout_test_env.dir.path().join(\"output.txt\");\n\n // Test with file output in quiet mode - should still show file write confirmation\n // but suppress other messages\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(stdout_test_env.path())\n .arg(\"--output-file\")\n .arg(output_file.to_str().unwrap())\n .arg(\"--quiet\")\n .arg(\"--no-clipboard\")\n .assert()\n .success()\n .stderr(contains(\"Done!\").not());\n // Note: Even in quiet mode, file write confirmation might still appear\n // This is expected behavior for important operations\n\n debug!(\"✓ Quiet mode stderr messages test passed\");\n}\n\n/// Test stderr messages with clipboard operations\n#[rstest]\nfn test_stderr_messages_with_clipboard(stdout_test_env: StdoutTestEnv) {\n // Test without --no-clipboard flag - should attempt clipboard operation\n // Note: In test environment (non-terminal), auto-quiet is enabled\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(stdout_test_env.path()).assert().success();\n // In test environment, clipboard operations might be silent due to auto-quiet\n // This is expected behavior\n\n debug!(\"✓ Clipboard stderr messages test passed\");\n}\n\n/// Test stderr behavior with different output formats\n#[rstest]\n#[case(\"json\")]\n#[case(\"xml\")]\n#[case(\"markdown\")]\nfn test_stderr_with_output_formats(stdout_test_env: StdoutTestEnv, #[case] format: &str) {\n let output_file = stdout_test_env.dir.path().join(\"output.txt\");\n\n // Test that stderr messages appear regardless of output format\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(stdout_test_env.path())\n .arg(\"--output-file\")\n .arg(output_file.to_str().unwrap())\n .arg(\"--output-format\")\n .arg(format)\n .arg(\"--no-clipboard\")\n .assert()\n .success()\n .stderr(contains(\"Prompt written to file:\"));\n\n debug!(\"✓ Stderr with {} format test passed\", format);\n}\n\n/// Test that stdout and stderr are properly separated\n#[rstest]\nfn test_stdout_stderr_separation(stdout_test_env: StdoutTestEnv) {\n // Test that when outputting to stdout, status messages go to stderr, not stdout\n let mut cmd = assert_cmd::cargo::cargo_bin_cmd!(\"code2prompt\");\n cmd.arg(stdout_test_env.path())\n .arg(\"-O\")\n .arg(\"-\")\n .arg(\"--no-clipboard\")\n .assert()\n .success()\n // Content should be in stdout\n .stdout(contains(\"test.py\"))\n .stdout(contains(\"print('Hello, World!')\"))\n // Status messages should NOT be in stdout (they go to stderr in non-quiet mode)\n .stdout(contains(\"Token count:\").not())\n .stdout(contains(\"✓\").not());\n\n debug!(\"✓ Stdout/stderr separation test passed\");\n}\n\n/// Test that fixture creates proper test environment\n#[rstest]\nfn test_stdout_fixture_setup(stdout_test_env: StdoutTestEnv) {\n // Verify that the fixture created the expected files\n let test_files = vec![\"test.py\", \"README.md\", \"config.json\"];\n\n for file in test_files {\n let file_path = stdout_test_env.dir.path().join(file);\n assert!(file_path.exists(), \"Test file {} should exist\", file);\n }\n\n debug!(\"✓ Stdout fixture setup test passed\");\n}\n"
},
{
"path": "crates/code2prompt/tests/template_integration_test.rs",
"content": "//! Template integration tests for code2prompt\n//!\n//! This module tests template functionality, output formats,\n//! and template rendering using rstest fixtures.\n\nmod common;\n\nuse common::fixtures::*;\nuse common::*;\nuse log::debug;\nuse predicates::prelude::*;\nuse predicates::str::{contains, ends_with, starts_with};\nuse rstest::*;\n\n/// Test different output format templates\n#[rstest]\n#[case(\"markdown\", vec![\"Source Tree:\", \"```rs\", \"fn main()\", \"Hello, world!\"])]\n#[case(\"xml\", vec![\"\", \"\", \".rs\\\"\", \"fn main()\", \"Hello, world!\"])]\nfn test_output_format_templates(\n template_test_env: TemplateTestEnv,\n #[case] format: &str,\n #[case] expected_content: Vec<&str>,\n) {\n let mut cmd = template_test_env.command();\n cmd.arg(format!(\"--output-format={}\", format))\n .assert()\n .success();\n\n let output = template_test_env.read_output();\n debug!(\"{} template output:\\n{}\", format, output);\n\n // Check format-specific content\n for expected in expected_content {\n assert!(\n contains(expected).eval(&output),\n \"Expected '{}' in {} format output\",\n expected,\n format\n );\n }\n}\n\n/// Test JSON output format (special case with structured output)\n#[rstest]\nfn test_json_output_format(template_test_env: TemplateTestEnv) {\n let mut cmd = template_test_env.command();\n cmd.arg(\"--output-format=json\").assert().success();\n\n let output = template_test_env.read_output();\n debug!(\"JSON output format:\\n{}\", output);\n\n // JSON output should be structured\n assert!(starts_with(\"{\").eval(&output));\n assert!(contains(\"\\\"directory_name\\\":\").eval(&output));\n assert!(contains(\"\\\"prompt\\\": \\\"\").eval(&output));\n assert!(ends_with(\"}\").eval(&output));\n}\n\n/// Test that template fixture creates proper codebase structure\n#[rstest]\nfn test_template_fixture_setup(template_test_env: TemplateTestEnv) {\n // Verify that the fixture created the expected code structure\n let expected_files = vec![\n (\"src/main.rs\", \"fn main()\"),\n (\"src/lib.rs\", \"pub fn add\"),\n (\"tests/test.rs\", \"#[test]\"),\n ];\n\n for (file_path, expected_content) in expected_files {\n let file_path = template_test_env.dir.path().join(file_path);\n assert!(\n file_path.exists(),\n \"Test file {} should exist\",\n file_path.display()\n );\n\n let content =\n std::fs::read_to_string(&file_path).expect(\"Should be able to read test file\");\n assert!(\n content.contains(expected_content),\n \"File {} should contain '{}'\",\n file_path.display(),\n expected_content\n );\n }\n\n debug!(\"✓ Template fixture setup test passed\");\n}\n\n/// Test basic template rendering with default format\n#[rstest]\nfn test_basic_template_rendering(template_test_env: TemplateTestEnv) {\n let mut cmd = template_test_env.command();\n cmd.assert().success();\n\n let output = template_test_env.read_output();\n debug!(\"Basic template rendering output:\\n{}\", output);\n\n // Should contain code from all test files\n assert!(contains(\"fn main()\").eval(&output));\n assert!(contains(\"Hello, world!\").eval(&output));\n assert!(contains(\"pub fn add\").eval(&output));\n assert!(contains(\"#[test]\").eval(&output));\n assert!(contains(\"assert_eq!\").eval(&output));\n}\n\n/// Test template with different file extensions\n#[rstest]\nfn test_template_with_file_extensions(template_test_env: TemplateTestEnv) {\n let mut cmd = template_test_env.command();\n cmd.assert().success();\n\n let output = template_test_env.read_output();\n debug!(\"Template with file extensions output:\\n{}\", output);\n\n // Should properly identify and format Rust files\n assert!(contains(\"src/main.rs\").eval(&output));\n assert!(contains(\"src/lib.rs\").eval(&output));\n assert!(contains(\"tests/test.rs\").eval(&output));\n}\n\n/// Test template output contains proper structure\n#[rstest]\nfn test_template_output_structure(template_test_env: TemplateTestEnv) {\n let mut cmd = template_test_env.command();\n cmd.assert().success();\n\n let output = template_test_env.read_output();\n debug!(\"Template output structure:\\n{}\", output);\n\n // Should contain directory structure information\n assert!(contains(\"src\").eval(&output));\n assert!(contains(\"tests\").eval(&output));\n\n // Should contain file content\n assert!(!output.trim().is_empty(), \"Output should not be empty\");\n\n // Should be properly formatted (not just raw concatenation)\n let line_count = output.lines().count();\n assert!(\n line_count > 10,\n \"Output should have substantial content with multiple lines\"\n );\n}\n\n/// Test template with include/exclude filters\n#[rstest]\n#[case(\"--include=*.rs\", vec![\"src/main.rs\", \"src/lib.rs\", \"tests/test.rs\"])]\n#[case(\"--exclude=**/test.rs\", vec![\"src/main.rs\", \"src/lib.rs\"])]\n#[case(\"--include=src/**\", vec![\"src/main.rs\", \"src/lib.rs\"])]\nfn test_template_with_filters(\n template_test_env: TemplateTestEnv,\n #[case] filter_arg: &str,\n #[case] expected_files: Vec<&str>,\n) {\n let mut cmd = template_test_env.command();\n cmd.arg(filter_arg).assert().success();\n\n let output = template_test_env.read_output();\n debug!(\"Template with filter '{}' output:\\n{}\", filter_arg, output);\n\n // Should contain expected files\n for expected_file in expected_files {\n assert!(\n contains(expected_file).eval(&output),\n \"Expected file '{}' with filter '{}'\",\n expected_file,\n filter_arg\n );\n }\n}\n\n/// Test template command creation\n#[rstest]\nfn test_template_command_creation(template_test_env: TemplateTestEnv) {\n // Test that our fixture creates working commands\n let mut cmd = template_test_env.command();\n cmd.assert().success();\n\n // Verify output file was created and is readable\n let output = template_test_env.read_output();\n assert!(!output.is_empty(), \"Template output should not be empty\");\n\n // Verify the output file exists\n assert!(\n template_test_env.output_file_exists(),\n \"Output file should exist after command execution\"\n );\n}\n"
},
{
"path": "crates/code2prompt-core/Cargo.toml",
"content": "[package]\nname = \"code2prompt_core\"\nversion = \"4.2.0\"\nauthors = [\n \"Mufeed VH \",\n \"Olivier D'Ancona \",\n]\ndescription = \"A command-line (CLI) tool to generate an LLM prompt from codebases of any size, fast.\"\nkeywords = [\"code\", \"ingestion\", \"prompt\", \"llm\", \"agent\"]\ncategories = [\"command-line-utilities\", \"development-tools\"]\nhomepage = \"https://code2prompt.dev\"\ndocumentation = \"https://code2prompt.dev/docs/welcome\"\nrepository = \"https://github.com/mufeedvh/code2prompt\"\nlicense = \"MIT\"\nexclude = [\".github/*\", \".assets/*\"]\nedition = \"2024\"\nreadme = \"../../README.md\"\n\n\n[features]\ndefault = []\n\n[dependencies]\nanyhow = { workspace = true }\nbracoxide = { workspace = true }\ncolored = { workspace = true }\ncontent_inspector = { workspace = true }\ncsv = { workspace = true }\nderive_builder = { workspace = true }\nencoding_rs = { workspace = true }\nignore = { workspace = true }\nindicatif = { workspace = true }\ngit2 = { workspace = true }\nglobset = { workspace = true }\nhandlebars = { workspace = true }\nlog = { workspace = true }\nonce_cell = { workspace = true }\nregex = { workspace = true }\nserde = { workspace = true }\nserde_json = { workspace = true }\ntermtree = { workspace = true }\ntiktoken-rs = { workspace = true }\ntoml = { workspace = true }\nrayon = { workspace = true }\nchardetng = { workspace = true }\n\n[lib]\nname = \"code2prompt_core\"\npath = \"src/lib.rs\"\ncrate-type = [\"rlib\"]\n\n[package.metadata.deb]\nsection = \"utility\"\nassets = [[\"target/release/code2prompt_core\", \"/usr/bin/\", \"755\"]]\n\n[dev-dependencies]\ntempfile = \"3.24\"\nassert_cmd = \"2.1.1\"\npredicates = \"3.1\"\nenv_logger = \"0.11.3\"\nrstest = \"0.26.1\"\n"
},
{
"path": "crates/code2prompt-core/src/builtin_templates.rs",
"content": "//! Built-in templates embedded as static resources.\n//!\n//! This module provides access to all built-in templates that are embedded\n//! directly into the binary, making them available even when the crate is\n//! installed from crates.io without access to the source file structure.\n\nuse std::{collections::HashMap, sync::OnceLock};\n\n/// Information about a built-in template\n#[derive(Debug, Clone, Copy)]\npub struct BuiltinTemplate {\n pub name: &'static str,\n pub content: &'static str,\n pub description: &'static str,\n}\n\n/// All built-in templates embedded as static strings\npub struct BuiltinTemplates;\n\nstatic TEMPLATES: OnceLock> = OnceLock::new();\n\nimpl BuiltinTemplates {\n /// Get all available built-in templates\n pub fn get_all() -> &'static HashMap<&'static str, BuiltinTemplate> {\n TEMPLATES.get_or_init(|| {\n HashMap::from([\n (\n \"default-markdown\",\n BuiltinTemplate {\n name: \"Default (Markdown)\",\n content: include_str!(\"default_template_md.hbs\"),\n description: \"Default markdown template for code analysis\",\n },\n ),\n (\n \"default-xml\",\n BuiltinTemplate {\n name: \"Default (XML)\",\n content: include_str!(\"default_template_xml.hbs\"),\n description: \"Default XML template for code analysis\",\n },\n ),\n (\n \"binary-exploitation-ctf-solver\",\n BuiltinTemplate {\n name: \"Binary Exploitation CTF Solver\",\n content: include_str!(\"../templates/binary-exploitation-ctf-solver.hbs\"),\n description: \"Template for solving binary exploitation CTF challenges\",\n },\n ),\n (\n \"clean-up-code\",\n BuiltinTemplate {\n name: \"Clean Up Code\",\n content: include_str!(\"../templates/clean-up-code.hbs\"),\n description: \"Template for code cleanup and refactoring\",\n },\n ),\n (\n \"cryptography-ctf-solver\",\n BuiltinTemplate {\n name: \"Cryptography CTF Solver\",\n content: include_str!(\"../templates/cryptography-ctf-solver.hbs\"),\n description: \"Template for solving cryptography CTF challenges\",\n },\n ),\n (\n \"document-the-code\",\n BuiltinTemplate {\n name: \"Document the Code\",\n content: include_str!(\"../templates/document-the-code.hbs\"),\n description: \"Template for generating code documentation\",\n },\n ),\n (\n \"find-security-vulnerabilities\",\n BuiltinTemplate {\n name: \"Find Security Vulnerabilities\",\n content: include_str!(\"../templates/find-security-vulnerabilities.hbs\"),\n description: \"Template for security vulnerability analysis\",\n },\n ),\n (\n \"fix-bugs\",\n BuiltinTemplate {\n name: \"Fix Bugs\",\n content: include_str!(\"../templates/fix-bugs.hbs\"),\n description: \"Template for bug fixing and debugging\",\n },\n ),\n (\n \"improve-performance\",\n BuiltinTemplate {\n name: \"Improve Performance\",\n content: include_str!(\"../templates/improve-performance.hbs\"),\n description: \"Template for performance optimization\",\n },\n ),\n (\n \"refactor\",\n BuiltinTemplate {\n name: \"Refactor\",\n content: include_str!(\"../templates/refactor.hbs\"),\n description: \"Template for code refactoring\",\n },\n ),\n (\n \"reverse-engineering-ctf-solver\",\n BuiltinTemplate {\n name: \"Reverse Engineering CTF Solver\",\n content: include_str!(\"../templates/reverse-engineering-ctf-solver.hbs\"),\n description: \"Template for solving reverse engineering CTF challenges\",\n },\n ),\n (\n \"web-ctf-solver\",\n BuiltinTemplate {\n name: \"Web CTF Solver\",\n content: include_str!(\"../templates/web-ctf-solver.hbs\"),\n description: \"Template for solving web CTF challenges\",\n },\n ),\n (\n \"write-git-commit\",\n BuiltinTemplate {\n name: \"Write Git Commit\",\n content: include_str!(\"../templates/write-git-commit.hbs\"),\n description: \"Template for generating git commit messages\",\n },\n ),\n (\n \"write-github-pull-request\",\n BuiltinTemplate {\n name: \"Write GitHub Pull Request\",\n content: include_str!(\"../templates/write-github-pull-request.hbs\"),\n description: \"Template for generating GitHub pull request descriptions\",\n },\n ),\n (\n \"write-github-readme\",\n BuiltinTemplate {\n name: \"Write GitHub README\",\n content: include_str!(\"../templates/write-github-readme.hbs\"),\n description: \"Template for generating GitHub README files\",\n },\n ),\n ])\n })\n }\n\n /// Get a specific template by its key\n pub fn get_template(key: &str) -> Option {\n Self::get_all().get(key).cloned()\n }\n\n /// Get all template keys\n pub fn get_template_keys() -> Vec<&'static str> {\n Self::get_all().keys().copied().collect()\n }\n\n /// Check if a template exists\n pub fn has_template(key: &str) -> bool {\n Self::get_all().contains_key(key)\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/configuration.rs",
"content": "//! This module defines the `Code2PromptConfig` struct and its Builder for configuring the behavior\n//! of code2prompt in a stateless manner. It includes all parameters needed for file traversal,\n//! code filtering, token counting, and more.\n\nuse crate::template::OutputFormat;\nuse crate::tokenizer::TokenizerType;\nuse crate::{sort::FileSortMethod, tokenizer::TokenFormat};\nuse derive_builder::Builder;\nuse serde::{Deserialize, Serialize};\nuse std::collections::HashMap;\nuse std::path::PathBuf;\n\n/// A stateless configuration object describing all the preferences and filters\n/// applied when generating a code prompt. It does not store any mutable data,\n/// so it can be cloned freely or shared across multiple sessions.\n#[derive(Debug, Clone, Default, Builder)]\n#[builder(setter(into), default)]\npub struct Code2PromptConfig {\n /// Path to the root directory of the codebase.\n pub path: PathBuf,\n\n /// List of glob-like patterns to include.\n pub include_patterns: Vec,\n\n /// List of glob-like patterns to exclude.\n pub exclude_patterns: Vec,\n\n /// If true, code lines will be numbered in the output.\n pub line_numbers: bool,\n\n /// If true, paths in the output will be absolute instead of relative.\n pub absolute_path: bool,\n\n /// If true, code2prompt will generate a full directory tree, ignoring include/exclude rules.\n pub full_directory_tree: bool,\n\n /// If true, code blocks will not be wrapped in Markdown fences (```).\n pub no_codeblock: bool,\n\n /// If true, symbolic links will be followed during traversal.\n pub follow_symlinks: bool,\n\n /// If true, hidden files and directories will be included.\n pub hidden: bool,\n\n /// If true, .gitignore rules will be ignored.\n pub no_ignore: bool,\n\n /// Defines the sorting method for files.\n pub sort_method: Option,\n\n /// Determines the output format of the final prompt.\n pub output_format: OutputFormat,\n\n /// An optional custom Handlebars template string.\n pub custom_template: Option,\n\n /// The tokenizer encoding to use for counting tokens.\n pub encoding: TokenizerType,\n\n /// The counting format to use for token counting.\n pub token_format: TokenFormat,\n\n /// If true, the git diff between HEAD and index will be included.\n pub diff_enabled: bool,\n\n /// If set, contains two branch names for which code2prompt will generate a git diff.\n pub diff_branches: Option<(String, String)>,\n\n /// If set, contains two branch names for which code2prompt will retrieve the git log.\n pub log_branches: Option<(String, String)>,\n\n /// The name of the template used.\n pub template_name: String,\n\n /// The template string itself.\n pub template_str: String,\n\n /// Extra template data\n pub user_variables: HashMap,\n\n /// If true, detailed token map breakdown will be displayed in output.\n ///\n /// Note: Token counting always happens internally for performance optimization\n /// (parallelized during file I/O). This flag only controls whether the breakdown\n /// is shown to users in the final output.\n pub token_map_enabled: bool,\n\n /// If true, starts with all files deselected.\n pub deselected: bool,\n}\n\nimpl Code2PromptConfig {\n pub fn builder() -> Code2PromptConfigBuilder {\n Code2PromptConfigBuilder::default()\n }\n}\n\n/// Output destination for code2prompt\n#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]\n#[serde(rename_all = \"lowercase\")]\npub enum OutputDestination {\n #[default]\n Stdout,\n Clipboard,\n File,\n}\n\n/// TOML configuration structure that can be serialized/deserialized\n#[derive(Debug, Clone, Serialize, Deserialize, Default)]\n#[serde(default)]\npub struct TomlConfig {\n /// Default output behavior: \"stdout\", \"clipboard\", or \"file\"\n pub default_output: OutputDestination,\n\n /// Path to the codebase directory\n pub path: Option,\n\n /// Patterns to include\n pub include_patterns: Vec,\n\n /// Patterns to exclude\n pub exclude_patterns: Vec,\n\n /// Display options\n pub line_numbers: bool,\n pub absolute_path: bool,\n pub full_directory_tree: bool,\n\n /// Output format\n pub output_format: Option,\n\n /// Sort method\n pub sort_method: Option,\n\n /// Tokenizer settings\n pub encoding: Option,\n pub token_format: Option,\n\n /// Git settings\n pub diff_enabled: bool,\n pub diff_branches: Option>,\n pub log_branches: Option>,\n\n /// Template settings\n pub template_name: Option,\n pub template_str: Option,\n\n /// User variables\n pub user_variables: HashMap,\n\n /// Token map\n pub token_map_enabled: bool,\n\n /// Initial selection state\n pub deselected: bool,\n}\n\nimpl TomlConfig {\n /// Load TOML configuration from a string\n pub fn from_toml_str(content: &str) -> Result {\n toml::from_str(content)\n }\n\n /// Convert TOML configuration to string\n pub fn to_string(&self) -> Result {\n toml::to_string_pretty(self)\n }\n\n /// Convert TomlConfig to Code2PromptConfig\n pub fn to_code2prompt_config(&self) -> Code2PromptConfig {\n let mut builder = Code2PromptConfig::builder();\n\n if let Some(path) = &self.path {\n builder.path(PathBuf::from(path));\n }\n\n builder\n .include_patterns(self.include_patterns.clone())\n .exclude_patterns(self.exclude_patterns.clone())\n .line_numbers(self.line_numbers)\n .absolute_path(self.absolute_path)\n .full_directory_tree(self.full_directory_tree);\n\n builder.output_format(self.output_format.unwrap_or_default());\n\n builder.sort_method(self.sort_method);\n\n builder.encoding(self.encoding.unwrap_or_default());\n\n builder.token_format(self.token_format.unwrap_or_default());\n\n builder.diff_enabled(self.diff_enabled);\n\n if let Some(diff_branches) = &self.diff_branches\n && diff_branches.len() == 2\n {\n builder.diff_branches(Some((diff_branches[0].clone(), diff_branches[1].clone())));\n }\n\n if let Some(log_branches) = &self.log_branches\n && log_branches.len() == 2\n {\n builder.log_branches(Some((log_branches[0].clone(), log_branches[1].clone())));\n }\n\n if let Some(template_name) = &self.template_name {\n builder.template_name(template_name.clone());\n }\n\n if let Some(template_str) = &self.template_str {\n builder.template_str(template_str.clone());\n }\n\n builder\n .user_variables(self.user_variables.clone())\n .token_map_enabled(self.token_map_enabled)\n .deselected(self.deselected);\n\n builder.build().unwrap_or_default()\n }\n}\n\n/// Export a Code2PromptConfig to TOML format\npub fn export_config_to_toml(config: &Code2PromptConfig) -> Result {\n let toml_config = TomlConfig {\n default_output: OutputDestination::Stdout, // Default for new behavior\n path: Some(config.path.to_string_lossy().to_string()),\n include_patterns: config.include_patterns.clone(),\n exclude_patterns: config.exclude_patterns.clone(),\n line_numbers: config.line_numbers,\n absolute_path: config.absolute_path,\n full_directory_tree: config.full_directory_tree,\n output_format: Some(config.output_format),\n sort_method: config.sort_method,\n encoding: Some(config.encoding),\n token_format: Some(config.token_format),\n diff_enabled: config.diff_enabled,\n diff_branches: config\n .diff_branches\n .as_ref()\n .map(|(a, b)| vec![a.clone(), b.clone()]),\n log_branches: config\n .log_branches\n .as_ref()\n .map(|(a, b)| vec![a.clone(), b.clone()]),\n template_name: if config.template_name.is_empty() {\n None\n } else {\n Some(config.template_name.clone())\n },\n template_str: if config.template_str.is_empty() {\n None\n } else {\n Some(config.template_str.clone())\n },\n user_variables: config.user_variables.clone(),\n token_map_enabled: config.token_map_enabled,\n deselected: config.deselected,\n };\n\n toml_config.to_string()\n}\n"
},
{
"path": "crates/code2prompt-core/src/default_template_md.hbs",
"content": "Project Path: {{ absolute_code_path }}\n\nSource Tree:\n\n```txt\n{{ source_tree }}\n```\n\n{{#each files}}\n{{#if code}}\n`{{path}}`:\n\n{{code}}\n\n{{/if}}\n{{/each}}\n\n{{#if git_diff}}\nGit Diff:\n{{ git_diff }}\n{{/if}}"
},
{
"path": "crates/code2prompt-core/src/default_template_xml.hbs",
"content": "{{absolute_code_path}}\n\n\n {{source_tree}}\n\n\n\n {{#each files}}\n {{#if code}}\n \n {{code}}\n \n {{/if}}\n {{/each}}\n\n\n{{#if git_diff}}\n \n {{git_diff}}\n \n{{/if}}"
},
{
"path": "crates/code2prompt-core/src/file_processor/csv.rs",
"content": "//! CSV file processor with schema extraction.\n//!\n//! This processor uses the `csv` crate to robustly parse CSV files and extract:\n//! - Column headers\n//! - One sample data row\n//!\n//! This provides sufficient context for LLMs to understand the data structure\n//! without wasting tokens on thousands of rows.\n\nuse super::{DefaultTextProcessor, FileProcessor};\nuse anyhow::{Context, Result};\nuse std::path::Path;\n\n/// CSV processor that extracts headers and one sample row.\n///\n/// Uses streaming to avoid loading large files into memory.\n/// Falls back to raw text if parsing fails.\npub struct CsvProcessor;\n\nimpl CsvProcessor {\n /// Internal processing with specific delimiter.\n ///\n /// # Arguments\n ///\n /// * `content` - Raw CSV bytes\n /// * `delimiter` - Field delimiter (b',' for CSV, b'\\t' for TSV)\n /// * `path` - File path for error messages\n pub(crate) fn process_with_delimiter(\n &self,\n content: &[u8],\n delimiter: u8,\n _path: &Path,\n ) -> Result {\n let mut reader = csv::ReaderBuilder::new()\n .delimiter(delimiter)\n .flexible(true) // Allow variable number of fields\n .from_reader(content);\n\n // Extract headers\n let headers = reader\n .headers()\n .context(\"Failed to read CSV headers\")?\n .iter()\n .map(|s| s.to_string())\n .collect::>();\n\n if headers.is_empty() {\n anyhow::bail!(\"CSV file has no headers\");\n }\n\n // Read first data row\n let mut records = reader.records();\n let first_row = records\n .next()\n .transpose()\n .context(\"Failed to read first data row\")?;\n\n let mut output = String::new();\n output.push_str(\"CSV Schema (1 sample row):\\n\");\n output.push_str(&format!(\"Headers: {}\\n\", headers.join(\", \")));\n\n if let Some(row) = first_row {\n let values: Vec = row.iter().map(|field| format!(\"\\\"{}\\\"\", field)).collect();\n output.push_str(&format!(\"Sample: {}\\n\", values.join(\", \")));\n\n // Count remaining rows for truncation message\n let remaining_rows = records.count();\n if remaining_rows > 0 {\n output.push_str(&format!(\"... [{} more rows omitted]\\n\", remaining_rows));\n }\n } else {\n output.push_str(\"(No data rows found)\\n\");\n }\n\n Ok(output)\n }\n}\n\nimpl FileProcessor for CsvProcessor {\n fn process(&self, content: &[u8], path: &Path) -> Result {\n match self.process_with_delimiter(content, b',', path) {\n Ok(result) => Ok(result),\n Err(e) => {\n log::warn!(\n \"CSV parsing failed for {:?}: {}. Using raw text fallback.\",\n path,\n e\n );\n // Fallback to raw text\n let fallback = DefaultTextProcessor;\n fallback.process(content, path)\n }\n }\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/file_processor/default.rs",
"content": "//! Default text processor for standard file types.\n//!\n//! This processor handles all file types that don't require special processing.\n//! It converts raw bytes to UTF-8 strings using lossy conversion to handle\n//! invalid UTF-8 sequences gracefully.\n\nuse super::FileProcessor;\nuse anyhow::Result;\nuse chardetng::EncodingDetector;\nuse std::path::Path;\n\n/// Default processor that converts bytes to UTF-8 string.\n///\n/// This processor uses the `chardetng` crate to detect the encoding of the input bytes\n/// and converts them to a UTF-8 string. If the encoding cannot be determined, it\n/// defaults to UTF-8. Invalid sequences are replaced with the Unicode replacement character.\npub struct DefaultTextProcessor;\n\nimpl FileProcessor for DefaultTextProcessor {\n fn process(&self, content: &[u8], _path: &Path) -> Result {\n let mut detector = EncodingDetector::new();\n detector.feed(content, true);\n\n // Guess the encoding; if none is found, default to UTF-8\n let encoding = detector.guess(None, true);\n\n let (cow, _encoding_used, _had_errors) = encoding.decode(content);\n\n match cow {\n std::borrow::Cow::Owned(s) => Ok(s),\n std::borrow::Cow::Borrowed(s) => Ok(s.to_string()),\n }\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/file_processor/ipynb.rs",
"content": "//! Jupyter Notebook (.ipynb) file processor.\n//!\n//! This processor parses Jupyter notebook JSON and extracts:\n//! - Total number of cells and their types\n//! - Code cells only (ignoring markdown and raw cells)\n//! - First 2-3 code cells as samples\n//!\n//! This provides LLMs with notebook structure context without overwhelming them with all cells.\n\nuse super::{DefaultTextProcessor, FileProcessor};\nuse anyhow::{Context, Result};\nuse serde_json::Value;\nuse std::path::Path;\n\n/// Jupyter Notebook processor that extracts code cells and metadata.\npub struct JupyterNotebookProcessor;\n\nimpl FileProcessor for JupyterNotebookProcessor {\n fn process(&self, content: &[u8], _path: &Path) -> Result {\n // Parse notebook JSON\n let notebook: Value =\n serde_json::from_slice(content).context(\"Failed to parse .ipynb file as JSON\")?;\n\n // Extract cells array\n let cells = notebook\n .get(\"cells\")\n .and_then(|v| v.as_array())\n .context(\"Notebook has no 'cells' array\")?;\n\n // Count cell types\n let mut code_cells = Vec::new();\n let mut markdown_count = 0;\n let mut raw_count = 0;\n\n for cell in cells {\n let cell_type = cell\n .get(\"cell_type\")\n .and_then(|v| v.as_str())\n .unwrap_or(\"unknown\");\n\n match cell_type {\n \"code\" => code_cells.push(cell),\n \"markdown\" => markdown_count += 1,\n \"raw\" => raw_count += 1,\n _ => {}\n }\n }\n\n let total_cells = cells.len();\n\n // Format output\n let mut output = String::new();\n output.push_str(\"Jupyter Notebook Summary:\\n\");\n output.push_str(&format!(\n \"Total cells: {} ({} code, {} markdown, {} raw)\\n\\n\",\n total_cells,\n code_cells.len(),\n markdown_count,\n raw_count\n ));\n\n if code_cells.is_empty() {\n output.push_str(\"(No code cells found)\\n\");\n return Ok(output);\n }\n\n // Show first 2-3 code cells\n let max_cells_to_show = 3.min(code_cells.len());\n\n for (idx, cell) in code_cells.iter().take(max_cells_to_show).enumerate() {\n output.push_str(&format!(\"Code Cell #{}:\\n\", idx + 1));\n\n // Extract source code\n if let Some(source) = cell.get(\"source\") {\n let code = match source {\n Value::String(s) => s.clone(),\n Value::Array(arr) => {\n // Join array of strings\n arr.iter()\n .filter_map(|v| v.as_str())\n .collect::>()\n .join(\"\")\n }\n _ => String::from(\"(Unable to extract source)\"),\n };\n\n output.push_str(\"```python\\n\");\n output.push_str(&code);\n if !code.ends_with('\\n') {\n output.push('\\n');\n }\n output.push_str(\"```\\n\\n\");\n }\n }\n\n if code_cells.len() > max_cells_to_show {\n output.push_str(&format!(\n \"... [{} more code cells omitted]\\n\",\n code_cells.len() - max_cells_to_show\n ));\n }\n\n Ok(output)\n }\n}\n\nimpl JupyterNotebookProcessor {\n /// Process with fallback to raw text on error.\n pub fn process_with_fallback(&self, content: &[u8], path: &Path) -> Result {\n match self.process(content, path) {\n Ok(result) => Ok(result),\n Err(e) => {\n log::warn!(\n \"Jupyter notebook parsing failed for {:?}: {}. Using raw text fallback.\",\n path,\n e\n );\n let fallback = DefaultTextProcessor;\n fallback.process(content, path)\n }\n }\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/file_processor/jsonl.rs",
"content": "//! JSON Lines (JSONL) file processor with schema extraction.\n//!\n//! This processor parses JSONL/NDJSON files and extracts:\n//! - Field names from the first JSON object\n//! - One sample JSON object\n//!\n//! This provides sufficient context for LLMs without including thousands of lines.\n\nuse super::{DefaultTextProcessor, FileProcessor};\nuse anyhow::{Context, Result};\nuse serde_json::Value;\nuse std::path::Path;\n\n/// JSONL processor that extracts schema and one sample line.\npub struct JsonLinesProcessor;\n\nimpl FileProcessor for JsonLinesProcessor {\n fn process(&self, content: &[u8], _path: &Path) -> Result {\n let text = String::from_utf8_lossy(content);\n let mut lines = text.lines();\n\n // Get first line\n let first_line = match lines.next() {\n Some(line) if !line.trim().is_empty() => line,\n _ => {\n anyhow::bail!(\"JSONL file is empty or has no valid lines\");\n }\n };\n\n // Parse first line as JSON\n let json_obj: Value = serde_json::from_str(first_line)\n .with_context(|| format!(\"Failed to parse first line as JSON: {}\", first_line))?;\n\n // Extract field names\n let fields = if let Value::Object(map) = &json_obj {\n map.keys().cloned().collect::>()\n } else {\n anyhow::bail!(\"First line is not a JSON object\");\n };\n\n if fields.is_empty() {\n anyhow::bail!(\"JSON object has no fields\");\n }\n\n // Count remaining lines\n let remaining_lines = lines.filter(|line| !line.trim().is_empty()).count();\n\n // Format output\n let mut output = String::new();\n output.push_str(\"JSONL Schema (1 sample line):\\n\");\n output.push_str(&format!(\"Fields: {}\\n\", fields.join(\", \")));\n output.push_str(&format!(\"Sample: {}\\n\", first_line));\n\n if remaining_lines > 0 {\n output.push_str(&format!(\"... [{} more lines omitted]\\n\", remaining_lines));\n }\n\n Ok(output)\n }\n}\n\nimpl JsonLinesProcessor {\n /// Process with fallback to raw text on error.\n pub fn process_with_fallback(&self, content: &[u8], path: &Path) -> Result {\n match self.process(content, path) {\n Ok(result) => Ok(result),\n Err(e) => {\n log::warn!(\n \"JSONL parsing failed for {:?}: {}. Using raw text fallback.\",\n path,\n e\n );\n let fallback = DefaultTextProcessor;\n fallback.process(content, path)\n }\n }\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/file_processor/mod.rs",
"content": "//! File processor module for handling different file types intelligently.\n//!\n//! This module provides a strategy pattern for processing file contents based on their extension\n//! in order to optimize for LLM token usage. The main idea is to extract the schema rather than\n//! raw data where applicable. (e.g., schema + sample for CSV, code cells for Jupyter notebooks).\n\nuse anyhow::Result;\nuse std::path::Path;\n\nmod csv;\nmod default;\nmod ipynb;\nmod jsonl;\nmod tsv;\n\npub use csv::CsvProcessor;\npub use default::DefaultTextProcessor;\npub use ipynb::JupyterNotebookProcessor;\npub use jsonl::JsonLinesProcessor;\npub use tsv::TsvProcessor;\n\n/// Trait for processing file contents into LLM-optimized string representations.\n///\n/// Each processor takes raw bytes and produces a formatted string suitable for\n/// inclusion in an LLM prompt. Processors may extract schemas, truncate content,\n/// or apply other transformations to reduce token usage while preserving semantic value.\npub trait FileProcessor: Send + Sync {\n /// Process file content and return a formatted string.\n ///\n /// # Arguments\n ///\n /// * `content` - Raw file bytes\n /// * `path` - File path for context and error messages\n ///\n /// # Returns\n ///\n /// * `Result` - Processed content or error\n fn process(&self, content: &[u8], path: &Path) -> Result;\n}\n\n/// Factory function to get the appropriate processor for a file extension.\n///\n/// # Arguments\n///\n/// * `extension` - File extension (without dot)\n///\n/// # Returns\n///\n/// * `Box` - Processor instance for the given extension\n///\n/// # Examples\n///\n/// ```ignore\n/// let processor = get_processor_for_extension(\"csv\");\n/// let result = processor.process(&bytes, path)?;\n/// ```\npub fn get_processor_for_extension(extension: &str) -> Box {\n match extension.to_lowercase().as_str() {\n \"csv\" => Box::new(CsvProcessor),\n \"tsv\" => Box::new(TsvProcessor),\n \"jsonl\" | \"ndjson\" => Box::new(JsonLinesProcessor),\n \"ipynb\" => Box::new(JupyterNotebookProcessor),\n // Future processors can be added here:\n // \"parquet\" => Box::new(ParquetProcessor),\n // \"xml\" => Box::new(XmlProcessor),\n _ => Box::new(DefaultTextProcessor),\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/file_processor/tsv.rs",
"content": "//! TSV (Tab-Separated Values) file processor.\n//!\n//! This processor is a thin wrapper around the CSV processor with tab delimiter.\n//! It extracts headers and one sample row from TSV files.\n\nuse super::{CsvProcessor, FileProcessor};\nuse anyhow::Result;\nuse std::path::Path;\n\n/// TSV processor that reuses CSV logic with tab delimiter.\npub struct TsvProcessor;\n\nimpl FileProcessor for TsvProcessor {\n fn process(&self, content: &[u8], path: &Path) -> Result {\n let csv_processor = CsvProcessor;\n match csv_processor.process_with_delimiter(content, b'\\t', path) {\n Ok(mut result) => {\n // Replace \"CSV\" with \"TSV\" in the output\n result = result.replace(\"CSV Schema\", \"TSV Schema\");\n Ok(result)\n }\n Err(e) => {\n log::warn!(\n \"TSV parsing failed for {:?}: {}. Using raw text fallback.\",\n path,\n e\n );\n // Fallback to raw text\n let fallback = super::DefaultTextProcessor;\n fallback.process(content, path)\n }\n }\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/filter.rs",
"content": "//! This module contains pure filtering logic for files based on glob patterns.\n//!\n//! This module provides reusable, stateless functions for pattern matching and file filtering.\n\nuse bracoxide::explode;\nuse colored::*;\nuse globset::{Glob, GlobSet, GlobSetBuilder};\nuse log::{debug, warn};\nuse std::path::Path;\n\n/// FilterEngine encapsulates pattern-based file filtering logic.\n/// This handles the base patterns (A, B in the A,A',B,B' system).\n#[derive(Debug, Clone)]\npub struct FilterEngine {\n include_globset: GlobSet,\n exclude_globset: GlobSet,\n}\n\nimpl FilterEngine {\n /// Create a new FilterEngine with the given patterns\n pub fn new(include_patterns: &[String], exclude_patterns: &[String]) -> Self {\n Self {\n include_globset: build_globset(include_patterns),\n exclude_globset: build_globset(exclude_patterns),\n }\n }\n\n /// Check if a file matches the base patterns (A, B logic)\n pub fn matches_patterns(&self, path: &Path) -> bool {\n should_include_file(path, &self.include_globset, &self.exclude_globset)\n }\n\n /// Get access to the include globset (for advanced usage)\n pub fn include_globset(&self) -> &GlobSet {\n &self.include_globset\n }\n\n /// Get access to the exclude globset (for advanced usage)\n pub fn exclude_globset(&self) -> &GlobSet {\n &self.exclude_globset\n }\n\n /// Check if there are any include patterns\n pub fn has_include_patterns(&self) -> bool {\n !self.include_globset.is_empty()\n }\n\n /// Check if a file is excluded by exclude patterns\n pub fn is_excluded(&self, path: &Path) -> bool {\n self.exclude_globset.is_match(path)\n }\n}\n\n/// Constructs a `GlobSet` from a list of glob patterns.\n///\n/// This function takes a slice of `String` patterns, attempts to convert each\n/// pattern into a `Glob`, and adds it to a `GlobSetBuilder`. If any pattern is\n/// invalid, it is ignored. The function then builds and returns a `GlobSet`.\n///\n/// # Arguments\n///\n/// * `patterns` - A slice of `String` containing glob patterns.\n///\n/// # Returns\n///\n/// * A `globset::GlobSet` containing all valid glob patterns from the input.\npub fn build_globset(patterns: &[String]) -> GlobSet {\n let mut builder = GlobSetBuilder::new();\n\n let mut expanded_patterns = Vec::new();\n for pattern in patterns {\n if pattern.contains('{') {\n match explode(pattern) {\n Ok(exp) => expanded_patterns.extend(exp),\n Err(e) => warn!(\"⚠️ Invalid brace pattern '{}': {:?}\", pattern, e),\n }\n } else {\n expanded_patterns.push(pattern.clone());\n }\n }\n\n for pattern in expanded_patterns {\n // If the pattern does not contain a '/' or the platform's separator, prepend \"**/\"\n let normalized_pattern = if pattern.contains('/') {\n pattern.trim_start_matches(\"./\").to_string()\n } else {\n format!(\"**/{}\", pattern.trim_start_matches(\"./\"))\n };\n\n match Glob::new(&normalized_pattern) {\n Ok(glob) => {\n builder.add(glob);\n debug!(\"✅ Glob pattern added: '{}'\", normalized_pattern);\n }\n Err(_) => {\n warn!(\"⚠️ Invalid pattern: '{}'\", normalized_pattern);\n }\n }\n }\n\n match builder.build() {\n Ok(set) => set,\n Err(e) => {\n warn!(\"❌ Failed to build GlobSet: {e}\");\n GlobSetBuilder::new()\n .build()\n .expect(\"empty GlobSet never fails\")\n }\n }\n}\n\n/// Determines whether a file should be included based on the provided glob patterns.\n///\n/// Note: The `path` argument must be a relative path (i.e. relative to the base directory)\n/// for the patterns to match as expected. Absolute paths will not yield correct matching.\n///\n/// # Arguments\n///\n/// * `path` - A relative path to the file that will be checked against the patterns.\n/// * `include_globset` - A GlobSet specifying which files to include.\n/// If empty, all files are considered included unless excluded.\n/// * `exclude_globset` - A GlobSet specifying which files to exclude.\n///\n/// # Returns\n///\n/// * `bool` - Returns `true` if the file should be included; otherwise, returns `false`.\n///\n/// # Behavior\n///\n/// When both include and exclude patterns match, exclude patterns take precedence.\npub fn should_include_file(\n path: &Path,\n include_globset: &GlobSet,\n exclude_globset: &GlobSet,\n) -> bool {\n // ~~~ Matching ~~~\n let included = include_globset.is_match(path);\n let excluded = exclude_globset.is_match(path);\n\n // ~~~ Decision ~~~\n let result = match (included, excluded) {\n (true, true) => false, // If both match, exclude takes precedence\n (true, false) => true, // If only included, include it\n (false, true) => false, // If only excluded, exclude it\n (false, false) => include_globset.is_empty(), // If no include patterns, include everything\n };\n\n debug!(\n \"Result: {}, {}: {}, {}: {}, Path: {:?}\",\n result,\n \"included\".bold().green(),\n included,\n \"excluded\".bold().red(),\n excluded,\n path.display()\n );\n result\n}\n"
},
{
"path": "crates/code2prompt-core/src/git.rs",
"content": "//! This module handles git operations.\n\nuse anyhow::{Context, Result};\nuse git2::{DiffOptions, Repository};\nuse log::info;\nuse std::path::Path;\n\n/// Generates a git diff for the repository at the provided path.\n///\n/// This function compares the repository's HEAD tree with the index to produce a diff of staged changes.\n/// It also checks for unstaged changes (differences between the index and the working directory) and,\n/// if found, appends a notification to the output.\n///\n/// If there are no staged changes, the function returns a message in the format:\n/// `\"no diff between HEAD and index\"`.\n///\n/// # Arguments\n///\n/// * `repo_path` - A reference to the path of the git repository.\n///\n/// # Returns\n///\n/// * `Result` - On success, returns either the diff (with an appended note if unstaged changes exist)\n/// or a message indicating that there is no diff between the compared git objects.\n/// In case of error, returns an appropriate error.\npub fn get_git_diff(repo_path: &Path) -> Result {\n info!(\"Opening repository at path: {:?}\", repo_path);\n let repo = Repository::open(repo_path).context(\"Failed to open repository\")?;\n\n let head = repo.head().context(\"Failed to get repository head\")?;\n let head_tree = head.peel_to_tree().context(\"Failed to peel to tree\")?;\n\n // Generate diff for staged changes (HEAD vs. index)\n let staged_diff = repo\n .diff_tree_to_index(\n Some(&head_tree),\n None,\n Some(DiffOptions::new().ignore_whitespace(true)),\n )\n .context(\"Failed to generate diff for staged changes\")?;\n\n let mut staged_diff_text = Vec::new();\n staged_diff\n .print(git2::DiffFormat::Patch, |_delta, _hunk, line| {\n staged_diff_text.extend_from_slice(line.content());\n true\n })\n .context(\"Failed to print staged diff\")?;\n\n let staged_diff_output = String::from_utf8_lossy(&staged_diff_text).into_owned();\n\n // If there is no staged diff, return a message indicating so.\n if staged_diff_output.trim().is_empty() {\n return Ok(\"no diff between HEAD and index\".to_string());\n }\n\n // Generate diff for unstaged changes (index vs. working directory)\n let unstaged_diff = repo\n .diff_index_to_workdir(None, Some(DiffOptions::new().ignore_whitespace(true)))\n .context(\"Failed to generate diff for unstaged changes\")?;\n\n let mut unstaged_diff_text = Vec::new();\n unstaged_diff\n .print(git2::DiffFormat::Patch, |_delta, _hunk, line| {\n unstaged_diff_text.extend_from_slice(line.content());\n true\n })\n .context(\"Failed to print unstaged diff\")?;\n\n let unstaged_diff_output = String::from_utf8_lossy(&unstaged_diff_text).into_owned();\n\n let mut output = staged_diff_output;\n if !unstaged_diff_output.trim().is_empty() {\n output.push_str(\"\\nNote: Some changes are not staged.\");\n }\n\n info!(\"Generated git diff successfully\");\n Ok(output)\n}\n\n/// Generates a git diff between two branches for the repository at the provided path\n///\n/// # Arguments\n///\n/// * `repo_path` - A reference to the path of the git repository\n/// * `branch1` - The name of the first branch\n/// * `branch2` - The name of the second branch\n///\n/// # Returns\n///\n/// * `Result` - The generated git diff as a string or an error\npub fn get_git_diff_between_branches(\n repo_path: &Path,\n branch1: &str,\n branch2: &str,\n) -> Result {\n info!(\"Opening repository at path: {:?}\", repo_path);\n let repo = Repository::open(repo_path).context(\"Failed to open repository\")?;\n\n for branch in [branch1, branch2].iter() {\n if !branch_exists(&repo, branch) {\n return Err(anyhow::anyhow!(\"Branch {} doesn't exist!\", branch));\n }\n }\n\n let branch1_commit = repo.revparse_single(branch1)?.peel_to_commit()?;\n let branch2_commit = repo.revparse_single(branch2)?.peel_to_commit()?;\n\n let branch1_tree = branch1_commit.tree()?;\n let branch2_tree = branch2_commit.tree()?;\n\n let diff = repo\n .diff_tree_to_tree(\n Some(&branch1_tree),\n Some(&branch2_tree),\n Some(DiffOptions::new().ignore_whitespace(true)),\n )\n .context(\"Failed to generate diff between branches\")?;\n\n let mut diff_text = Vec::new();\n diff.print(git2::DiffFormat::Patch, |_delta, _hunk, line| {\n diff_text.extend_from_slice(line.content());\n true\n })\n .context(\"Failed to print diff\")?;\n\n info!(\"Generated git diff between branches successfully\");\n Ok(String::from_utf8_lossy(&diff_text).into_owned())\n}\n\n/// Retrieves the git log between two branches for the repository at the provided path\n///\n/// # Arguments\n///\n/// * `repo_path` - A reference to the path of the git repository\n/// * `branch1` - The name of the first branch (e.g., \"master\")\n/// * `branch2` - The name of the second branch (e.g., \"migrate-manifest-v3\")\n///\n/// # Returns\n///\n/// * `Result` - The git log as a string or an error\npub fn get_git_log(repo_path: &Path, branch1: &str, branch2: &str) -> Result {\n info!(\"Opening repository at path: {:?}\", repo_path);\n let repo = Repository::open(repo_path).context(\"Failed to open repository\")?;\n\n for branch in [branch1, branch2].iter() {\n if !branch_exists(&repo, branch) {\n return Err(anyhow::anyhow!(\"Branch {} doesn't exist!\", branch));\n }\n }\n\n let branch1_commit = repo.revparse_single(branch1)?.peel_to_commit()?;\n let branch2_commit = repo.revparse_single(branch2)?.peel_to_commit()?;\n\n let mut revwalk = repo.revwalk().context(\"Failed to create revwalk\")?;\n revwalk\n .push(branch2_commit.id())\n .context(\"Failed to push branch2 commit to revwalk\")?;\n revwalk\n .hide(branch1_commit.id())\n .context(\"Failed to hide branch1 commit from revwalk\")?;\n revwalk.set_sorting(git2::Sort::REVERSE)?;\n\n let mut log_text = String::new();\n for oid in revwalk {\n let oid = oid.context(\"Failed to get OID from revwalk\")?;\n let commit = repo.find_commit(oid).context(\"Failed to find commit\")?;\n log_text.push_str(&format!(\n \"{} - {}\\n\",\n &commit.id().to_string()[..7],\n commit.summary().unwrap_or(\"No commit message\")\n ));\n }\n\n info!(\"Retrieved git log successfully\");\n Ok(log_text)\n}\n\n/// Checks if a git reference exists in the given repository\n///\n/// This function can validate any git reference including:\n/// - Local and remote branch names\n/// - Commit hashes (full or abbreviated)\n/// - Tags\n/// - Any reference that git rev-parse can resolve\n///\n/// # Arguments\n///\n/// * `repo` - A reference to the `Repository` where the reference should be checked\n/// * `branch_name` - A string slice that holds the name of the reference to check\n///\n/// # Returns\n///\n/// * `bool` - `true` if the reference exists, `false` otherwise\nfn branch_exists(repo: &Repository, branch_name: &str) -> bool {\n repo.revparse_single(branch_name).is_ok()\n}\n"
},
{
"path": "crates/code2prompt-core/src/lib.rs",
"content": "//! Core library for code2prompt.\npub mod builtin_templates;\npub mod configuration;\npub mod file_processor;\npub mod filter;\npub mod git;\npub mod path;\npub mod selection;\npub mod session;\npub mod sort;\npub mod template;\npub mod tokenizer;\npub mod util;\n"
},
{
"path": "crates/code2prompt-core/src/path.rs",
"content": "//! This module contains the functions for traversing the directory and processing the files.\nuse crate::configuration::Code2PromptConfig;\nuse crate::file_processor;\nuse crate::filter::{build_globset, should_include_file};\nuse crate::sort::{FileSortMethod, sort_files, sort_tree};\nuse crate::tokenizer::count_tokens;\nuse crate::util::strip_utf8_bom;\nuse anyhow::Result;\nuse content_inspector::{ContentType, inspect};\nuse ignore::WalkBuilder;\nuse log::debug;\nuse rayon::prelude::*;\nuse serde::{Deserialize, Serialize};\nuse std::fs;\nuse std::io::Read;\nuse std::path::{Path, PathBuf};\nuse termtree::Tree;\n\n#[derive(Debug, Clone, Copy, Serialize, Deserialize)]\npub struct EntryMetadata {\n pub is_dir: bool,\n pub is_symlink: bool,\n}\n\nimpl From<&std::fs::Metadata> for EntryMetadata {\n fn from(meta: &std::fs::Metadata) -> Self {\n Self {\n is_dir: meta.is_dir(),\n is_symlink: meta.is_symlink(),\n }\n }\n}\n\n/// Represents a file entry with all its metadata and content\n#[derive(Debug, Clone, Serialize, Deserialize)]\npub struct FileEntry {\n pub path: String,\n pub extension: String,\n pub code: String,\n pub token_count: usize,\n pub metadata: EntryMetadata,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub mod_time: Option,\n}\n\n/// Represents a file that needs to be processed\n#[derive(Debug, Clone)]\nstruct FileToProcess {\n /// Absolute path to the file\n absolute_path: PathBuf,\n /// Relative path from the root\n relative_path: PathBuf,\n /// File metadata\n metadata: std::fs::Metadata,\n}\n\n/// Traverses the directory and returns the string representation of the tree and the vector of file entries.\n///\n/// This function uses the provided configuration to determine which files to include, how to format them,\n/// and how to structure the directory tree.\n///\n/// # Arguments\n///\n/// * `config` - Configuration object containing path, include/exclude patterns, and other settings\n/// * `selection_engine` - Optional SelectionEngine for advanced file selection with user actions\n///\n/// # Returns\n///\n/// * `Result<(String, Vec)>` - A tuple containing the string representation of the directory\n/// tree and a vector of file entries\npub fn traverse_directory(\n config: &Code2PromptConfig,\n selection_engine: Option<&mut crate::selection::SelectionEngine>,\n) -> Result<(String, Vec)> {\n // Phase 1: Discovery - Build tree and collect files to process\n let (tree, files_to_process) = discover_files(config, selection_engine)?;\n\n // Phase 2: Processing - Process files in parallel\n let mut files = process_files_parallel(files_to_process, config)?;\n\n // Phase 3: Assembly - Sort and return results\n assemble_results(tree, &mut files, config)\n}\n\n/// Phase 1: Discovery - Walk directories, build tree, and collect files that need processing\n///\n/// This phase is sequential because:\n/// - Directory walking is already optimized\n/// - Tree building needs sequential structure\n/// - Selection engine has caching that would need synchronization\nfn discover_files(\n config: &Code2PromptConfig,\n mut selection_engine: Option<&mut crate::selection::SelectionEngine>,\n) -> Result<(Tree, Vec)> {\n let canonical_root_path = config.path.canonicalize()?;\n let parent_directory = display_name(&canonical_root_path);\n\n let include_globset = build_globset(&config.include_patterns);\n let exclude_globset = build_globset(&config.exclude_patterns);\n\n // Build the Walker\n let walker = WalkBuilder::new(&canonical_root_path)\n .hidden(!config.hidden)\n .git_ignore(!config.no_ignore)\n .follow_links(config.follow_symlinks)\n .build()\n .filter_map(|entry| entry.ok());\n\n // Build the Tree\n let mut tree = Tree::new(parent_directory.to_owned());\n let mut files_to_process = Vec::new();\n\n for entry in walker {\n let path = entry.path();\n if let Ok(relative_path) = path.strip_prefix(&canonical_root_path) {\n // Use SelectionEngine if available, otherwise fall back to pattern matching\n let entry_match = if let Some(engine) = selection_engine.as_mut() {\n engine.is_selected(relative_path)\n } else {\n should_include_file(relative_path, &include_globset, &exclude_globset)\n };\n\n // Directory Tree\n let include_in_tree = config.full_directory_tree || entry_match;\n\n if include_in_tree {\n let mut current_tree = &mut tree;\n for component in relative_path.components() {\n let component_str = component.as_os_str().to_string_lossy().to_string();\n current_tree = if let Some(pos) = current_tree\n .leaves\n .iter_mut()\n .position(|child| child.root == component_str)\n {\n &mut current_tree.leaves[pos]\n } else {\n let new_tree = Tree::new(component_str.clone());\n current_tree.leaves.push(new_tree);\n current_tree.leaves.last_mut().unwrap()\n };\n }\n }\n\n // Collect files for processing\n if path.is_file()\n && entry_match\n && let Ok(metadata) = entry.metadata()\n {\n files_to_process.push(FileToProcess {\n absolute_path: path.to_path_buf(),\n relative_path: relative_path.to_path_buf(),\n metadata,\n });\n }\n }\n }\n\n Ok((tree, files_to_process))\n}\n\n/// Phase 2: Processing - Process files in parallel using rayon\n///\n/// This phase processes files in parallel:\n/// - Read file contents (I/O bound)\n/// - Process file content (CPU/I/O bound)\n/// - Tokenize if enabled (CPU bound)\n/// - Build FileEntry structures\nfn process_files_parallel(\n files_to_process: Vec,\n config: &Code2PromptConfig,\n) -> Result> {\n // Process files in parallel with rayon\n let files: Vec> = files_to_process\n .par_iter()\n .map(|file_info| process_single_file(file_info, config))\n .collect();\n\n // Filter out None values (files that failed to process or were empty)\n Ok(files.into_iter().flatten().collect())\n}\n\n/// Read file with single-pass binary detection\n///\n/// Reads file incrementally: first 8KB for binary detection, then remainder if text.\nfn read_file_with_binary_check(path: &Path, file_size: u64) -> std::io::Result>> {\n const SAMPLE_SIZE: usize = 8192;\n\n let mut file = fs::File::open(path)?;\n let mut buffer = Vec::with_capacity(file_size.min(1024 * 1024 * 10) as usize); // Cap at 10MB initial allocation\n\n // Read first chunk for binary detection\n let bytes_to_read = SAMPLE_SIZE.min(file_size as usize);\n let mut sample_buffer = vec![0u8; bytes_to_read];\n file.read_exact(&mut sample_buffer)?;\n\n // Check if binary\n if inspect(&sample_buffer) == ContentType::BINARY {\n return Ok(None); // Return None for binary files\n }\n\n // It's text! Add sample to buffer and read the rest\n buffer.extend_from_slice(&sample_buffer);\n\n // Read remaining bytes if file is larger than sample\n if file_size > SAMPLE_SIZE as u64 {\n file.read_to_end(&mut buffer)?;\n }\n\n Ok(Some(buffer))\n}\n\n/// Process a single file and return its FileEntry representation\nfn process_single_file(file_info: &FileToProcess, config: &Code2PromptConfig) -> Option {\n let path = &file_info.absolute_path;\n let relative_path = &file_info.relative_path;\n let metadata = &file_info.metadata;\n\n let code_bytes = match read_file_with_binary_check(path, metadata.len()) {\n Ok(Some(bytes)) => bytes,\n Ok(None) => {\n debug!(\"Skipped binary file: {}\", path.display());\n return None;\n }\n Err(e) => {\n debug!(\"Failed to read file {}: {}\", path.display(), e);\n return None;\n }\n };\n\n let clean_bytes = strip_utf8_bom(&code_bytes);\n\n // Get appropriate processor for file extension\n let extension = path.extension().and_then(|ext| ext.to_str()).unwrap_or(\"\");\n let processor = file_processor::get_processor_for_extension(extension);\n\n // Process file content\n let code = match processor.process(clean_bytes, path) {\n Ok(processed) => processed,\n Err(e) => {\n log::warn!(\n \"File processing failed for {}: {}. Using raw text fallback.\",\n path.display(),\n e\n );\n String::from_utf8_lossy(clean_bytes).into_owned()\n }\n };\n\n // Wrap code block\n let code_block = wrap_code_block(&code, extension, config.line_numbers, config.no_codeblock);\n\n // Filter empty or invalid files\n if code.trim().is_empty() || code.contains(char::REPLACEMENT_CHARACTER) {\n debug!(\"Excluded file (empty or invalid UTF-8): {}\", path.display());\n return None;\n }\n\n // Build filepath\n let file_path = if config.absolute_path {\n path.to_string_lossy().to_string()\n } else {\n relative_path.to_string_lossy().to_string()\n };\n\n // Always calculate token count in parallel (amortized by I/O wait time)\n // This enables zero-overhead token counting regardless of display preferences\n let token_count = count_tokens(&code, &config.encoding);\n\n // Get modification time if date sorting is requested\n let mod_time = if let Some(method) = config.sort_method {\n if method == FileSortMethod::DateAsc || method == FileSortMethod::DateDesc {\n metadata\n .modified()\n .ok()\n .and_then(|mtime| mtime.duration_since(std::time::SystemTime::UNIX_EPOCH).ok())\n .map(|d| d.as_secs())\n } else {\n None\n }\n } else {\n None\n };\n\n debug!(target: \"included_files\", \"Included file: {}\", file_path);\n\n Some(FileEntry {\n path: file_path,\n extension: extension.to_string(),\n code: code_block,\n token_count,\n metadata: EntryMetadata::from(metadata),\n mod_time,\n })\n}\n\n/// Phase 3: Assembly - Sort results and return\nfn assemble_results(\n mut tree: Tree,\n files: &mut [FileEntry],\n config: &Code2PromptConfig,\n) -> Result<(String, Vec)> {\n // Sort tree and files\n sort_tree(&mut tree, config.sort_method);\n sort_files(files, config.sort_method);\n\n Ok((tree.to_string(), files.to_owned()))\n}\n\n/// Returns the file name or the string representation of the path.\n///\n/// # Arguments\n///\n/// * `p` - The path to label.\n///\n/// # Returns\n///\n/// * `String` - The file name or string representation of the path.\npub fn display_name>(p: P) -> String {\n let path = p.as_ref();\n // File name if available\n if let Some(name) = path.file_name() {\n return name.to_string_lossy().into_owned();\n }\n // Current directory name\n if let Ok(cwd) = std::env::current_dir()\n && let Some(name) = cwd.file_name()\n {\n return name.to_string_lossy().into_owned();\n }\n // Fallback\n \".\".to_string()\n}\n\n/// Wraps the code block with a delimiter and adds line numbers if required.\n///\n/// # Arguments\n///\n/// * `code` - The code block to wrap.\n/// * `extension` - The file extension of the code block.\n/// * `line_numbers` - Whether to add line numbers to the code.\n/// * `no_codeblock` - Whether to not wrap the code block with a delimiter.\n///\n/// # Returns\n///\n/// * `String` - The wrapped code block.\npub fn wrap_code_block(\n code: &str,\n extension: &str,\n line_numbers: bool,\n no_codeblock: bool,\n) -> String {\n let delimiter = \"`\".repeat(3);\n let mut code_with_line_numbers = String::new();\n\n if line_numbers {\n for (line_number, line) in code.lines().enumerate() {\n code_with_line_numbers.push_str(&format!(\"{:4} | {}\\n\", line_number + 1, line));\n }\n } else {\n code_with_line_numbers = code.to_string();\n }\n\n if no_codeblock {\n code_with_line_numbers\n } else {\n format!(\n \"{}{}\\n{}\\n{}\",\n delimiter, extension, code_with_line_numbers, delimiter\n )\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/selection.rs",
"content": "//! This module contains the SelectionEngine that handles user file selection with precedence rules.\n//!\n//! The SelectionEngine implements the A,A',B,B' system where:\n//! - A, B: Base patterns (handled by FilterEngine)\n//! - A', B': User actions with precedence rules (specific > generic, recent > old)\n\nuse crate::filter::FilterEngine;\nuse std::collections::HashMap;\nuse std::path::{Path, PathBuf};\nuse std::time::SystemTime;\n\n/// Represents a user action on a file or directory\n#[derive(Debug, Clone)]\npub struct SelectionAction {\n pub path: PathBuf,\n pub action: ActionType,\n pub timestamp: SystemTime,\n pub specificity: u32, // Higher = more specific (more path components)\n}\n\n/// Type of selection action\n#[derive(Debug, Clone, PartialEq)]\npub enum ActionType {\n Include,\n Exclude,\n}\n\n/// SelectionEngine handles both pattern-based filtering and user actions\n/// with clear precedence rules: specific > generic, recent > old\n#[derive(Clone)]\npub struct SelectionEngine {\n /// Base pattern filtering (A, B in A,A',B,B' system)\n filter_engine: FilterEngine,\n\n /// User actions (A', B' in A,A',B,B' system)\n user_actions: Vec,\n\n /// Cache for performance\n cache: HashMap,\n\n /// Default behavior when no patterns or user actions match\n deselected_by_default: bool,\n}\n\nimpl SelectionEngine {\n /// Create a new SelectionEngine with base patterns\n pub fn new(\n include_patterns: Vec,\n exclude_patterns: Vec,\n deselected_by_default: bool,\n ) -> Self {\n Self {\n filter_engine: FilterEngine::new(&include_patterns, &exclude_patterns),\n user_actions: Vec::new(),\n cache: HashMap::new(),\n deselected_by_default,\n }\n }\n\n /// The core decision method: determines if a file should be selected\n /// Uses precedence rules: specific > generic, recent > old\n pub fn is_selected(&mut self, path: &Path) -> bool {\n // Check cache first for performance\n if let Some(&cached) = self.cache.get(path) {\n return cached;\n }\n\n let result = self.compute_selection(path);\n self.cache.insert(path.to_path_buf(), result);\n result\n }\n\n /// Compute selection without caching\n fn compute_selection(&self, path: &Path) -> bool {\n // Rule 1: Find the most specific and recent user action\n if let Some(action) = self.find_applicable_user_action(path) {\n return action.action == ActionType::Include;\n }\n\n // Rule 2: Fall back to existing FilterEngine logic (A, B)\n if self.filter_engine.has_include_patterns() {\n // If there are include patterns, use them\n self.filter_engine.matches_patterns(path)\n } else {\n // No include patterns: default behavior depends on deselected_by_default\n if self.deselected_by_default {\n false\n } else {\n !self.filter_engine.is_excluded(path)\n }\n }\n }\n\n /// Find the most applicable user action using precedence rules\n fn find_applicable_user_action(&self, path: &Path) -> Option<&SelectionAction> {\n let applicable_actions: Vec<&SelectionAction> = self\n .user_actions\n .iter()\n .filter(|action| self.action_applies_to_path(action, path))\n .collect();\n\n if applicable_actions.is_empty() {\n return None;\n }\n\n // Apply precedence rules: specific > generic, recent > old\n applicable_actions.into_iter().max_by(|a, b| {\n // First compare specificity (higher is better)\n match a.specificity.cmp(&b.specificity) {\n std::cmp::Ordering::Equal => {\n // If same specificity, compare timestamp (more recent is better)\n a.timestamp.cmp(&b.timestamp)\n }\n other => other,\n }\n })\n }\n\n /// Check if a user action applies to a given path\n fn action_applies_to_path(&self, action: &SelectionAction, path: &Path) -> bool {\n // Exact match\n if action.path == path {\n return true;\n }\n\n // Directory action applies to all children\n if path.starts_with(&action.path) {\n return true;\n }\n\n false\n }\n\n /// Calculate specificity score for a path (more components = more specific)\n fn calculate_specificity(&self, path: &Path) -> u32 {\n path.components().count() as u32\n }\n\n /// User interaction: include a file or directory\n pub fn include_file(&mut self, path: PathBuf) {\n self.add_user_action(path, ActionType::Include);\n }\n\n /// User interaction: exclude a file or directory\n pub fn exclude_file(&mut self, path: PathBuf) {\n self.add_user_action(path, ActionType::Exclude);\n }\n\n /// User interaction: toggle selection state\n pub fn toggle_file(&mut self, path: PathBuf) {\n let current_state = self.is_selected(&path);\n let new_action = if current_state {\n ActionType::Exclude\n } else {\n ActionType::Include\n };\n self.add_user_action(path, new_action);\n }\n\n /// Add a user action with timestamp and specificity\n fn add_user_action(&mut self, path: PathBuf, action: ActionType) {\n let specificity = self.calculate_specificity(&path);\n let user_action = SelectionAction {\n path,\n action,\n timestamp: SystemTime::now(),\n specificity,\n };\n\n self.user_actions.push(user_action);\n self.cache.clear(); // Invalidate cache when actions change\n }\n\n /// Get all currently selected files by scanning the filesystem\n pub fn get_selected_files(&mut self, root_path: &Path) -> Result, std::io::Error> {\n // If we have user actions, return files based on those actions\n if !self.user_actions.is_empty() {\n let mut selected = Vec::new();\n\n // Clone the actions to avoid borrow checker issues\n let actions = self.user_actions.clone();\n\n // Collect files from user actions that are includes\n for action in &actions {\n if action.action == ActionType::Include {\n // Check if this action is still the winning action for this path\n if self.is_selected(&action.path) {\n selected.push(action.path.clone());\n }\n }\n }\n\n // Remove duplicates and sort\n selected.sort();\n selected.dedup();\n return Ok(selected);\n }\n\n // Otherwise, scan filesystem for pattern matches\n let mut selected = Vec::new();\n self.collect_selected_files_recursive(root_path, root_path, &mut selected)?;\n Ok(selected)\n }\n\n /// Recursively collect selected files\n fn collect_selected_files_recursive(\n &mut self,\n root_path: &Path,\n current_dir: &Path,\n selected: &mut Vec,\n ) -> Result<(), std::io::Error> {\n for entry in std::fs::read_dir(current_dir)? {\n let entry = entry?;\n let path = entry.path();\n\n // Convert to relative path for selection checking\n let relative_path = if let Ok(rel) = path.strip_prefix(root_path) {\n rel\n } else {\n continue;\n };\n\n if self.is_selected(relative_path) {\n if path.is_file() {\n selected.push(relative_path.to_path_buf());\n } else if path.is_dir() {\n // Recursively check subdirectories\n self.collect_selected_files_recursive(root_path, &path, selected)?;\n }\n }\n }\n Ok(())\n }\n\n /// Clear all user actions (reset to pattern-only behavior)\n pub fn clear_user_actions(&mut self) {\n self.user_actions.clear();\n self.cache.clear();\n }\n\n /// Get the number of user actions\n pub fn user_action_count(&self) -> usize {\n self.user_actions.len()\n }\n\n /// Check if there are any user actions\n pub fn has_user_actions(&self) -> bool {\n !self.user_actions.is_empty()\n }\n\n /// Get access to the underlying filter engine\n pub fn filter_engine(&self) -> &FilterEngine {\n &self.filter_engine\n }\n\n /// Set whether the engine should default to deselected\n pub fn set_deselected_by_default(&mut self, value: bool) {\n self.deselected_by_default = value;\n self.cache.clear();\n }\n}\n\nimpl std::fmt::Debug for SelectionEngine {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n f.debug_struct(\"SelectionEngine\")\n .field(\"filter_engine\", &self.filter_engine)\n .field(\"user_actions\", &self.user_actions)\n .field(\"cache_size\", &self.cache.len())\n .field(\"deselected_by_default\", &self.deselected_by_default)\n .finish()\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn test_specificity_calculation() {\n let engine = SelectionEngine::new(vec![], vec![], false);\n\n assert_eq!(engine.calculate_specificity(Path::new(\"file.rs\")), 1);\n assert_eq!(engine.calculate_specificity(Path::new(\"src/main.rs\")), 2);\n assert_eq!(\n engine.calculate_specificity(Path::new(\"src/utils/helper.rs\")),\n 3\n );\n }\n\n #[test]\n fn test_precedence_rules() {\n let mut engine = SelectionEngine::new(vec![], vec![], false);\n\n // Add less specific action first\n engine.exclude_file(PathBuf::from(\"src\"));\n\n // Add more specific action later\n engine.include_file(PathBuf::from(\"src/main.rs\"));\n\n // More specific should win\n assert!(!engine.is_selected(Path::new(\"src/lib.rs\"))); // Excluded by src/\n assert!(engine.is_selected(Path::new(\"src/main.rs\"))); // Included specifically\n }\n\n #[test]\n fn test_recent_wins_over_old() {\n let mut engine = SelectionEngine::new(vec![], vec![], false);\n\n // First action\n engine.exclude_file(PathBuf::from(\"main.rs\"));\n assert!(!engine.is_selected(Path::new(\"main.rs\")));\n\n // More recent action with same specificity\n engine.include_file(PathBuf::from(\"main.rs\"));\n assert!(engine.is_selected(Path::new(\"main.rs\")));\n }\n\n #[test]\n fn test_deselected_by_default() {\n let mut engine = SelectionEngine::new(vec![], vec![], true);\n\n // By default everything is deselected\n assert!(!engine.is_selected(Path::new(\"main.rs\")));\n assert!(!engine.is_selected(Path::new(\"src/lib.rs\")));\n\n // User action should still work\n engine.include_file(PathBuf::from(\"main.rs\"));\n assert!(engine.is_selected(Path::new(\"main.rs\")));\n assert!(!engine.is_selected(Path::new(\"src/lib.rs\")));\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/session.rs",
"content": "//! This module defines a Code2promptSession struct that provide a stateful interface to code2prompt-core.\n//! It allows you to load codebase data, Git info, and render prompts using a template.\n\nuse anyhow::{Context, Result};\nuse serde::Serialize;\nuse std::collections::HashMap;\nuse std::path::PathBuf;\n\nuse crate::configuration::Code2PromptConfig;\nuse crate::git::{get_git_diff, get_git_diff_between_branches, get_git_log};\nuse crate::path::{FileEntry, display_name, traverse_directory, wrap_code_block};\nuse crate::selection::SelectionEngine;\nuse crate::template::{OutputFormat, handlebars_setup, render_template};\nuse crate::tokenizer::{TokenizerType, count_tokens};\n\n/// Represents a live session that holds stateful data about the user's codebase,\n/// including which files have been added or removed, or other data that evolves over time.\n#[derive(Debug, Clone)]\npub struct Code2PromptSession {\n pub config: Code2PromptConfig,\n pub selection_engine: SelectionEngine,\n pub data: SessionData,\n}\n\n/// Represents the collected data about the code (tree + files) and optional Git info.\n/// The session loads these pieces separately, so you can manage them step by step.\n#[derive(Debug, Default, Clone)]\npub struct SessionData {\n pub absolute_code_path: Option,\n pub source_tree: Option,\n pub files: Option>,\n pub stats: Option,\n pub git_diff: Option,\n pub git_diff_branch: Option,\n pub git_log_branch: Option,\n}\n\n/// Zero-copy template context for rendering\n/// Uses references to avoid deep copying of heavy data\n#[derive(Serialize)]\npub struct TemplateContext<'a> {\n pub absolute_code_path: &'a str,\n\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub source_tree: &'a Option,\n\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub files: Option<&'a [FileEntry]>,\n\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub git_diff: &'a Option,\n\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub git_diff_branch: &'a Option,\n\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub git_log_branch: &'a Option,\n\n #[serde(flatten)]\n pub user_variables: &'a HashMap,\n}\n\n/// Encapsulates the final rendered prompt and some metadata\n#[derive(Debug)]\npub struct RenderedPrompt {\n pub prompt: String,\n pub directory_name: String,\n pub token_count: usize,\n pub model_info: &'static str,\n pub files: Vec,\n}\n\nimpl Code2PromptSession {\n /// Creates a new session with SelectionEngine for pattern-based and user-driven file selection\n pub fn new(config: Code2PromptConfig) -> Self {\n let selection_engine = SelectionEngine::new(\n config.include_patterns.clone(),\n config.exclude_patterns.clone(),\n config.deselected,\n );\n\n Self {\n selection_engine,\n config,\n data: SessionData::default(),\n }\n }\n\n /// Add pattern and recreate SelectionEngine\n pub fn add_include_pattern(&mut self, pattern: String) -> &mut Self {\n self.config.include_patterns.push(pattern);\n // Recreate SelectionEngine with new patterns\n self.selection_engine = SelectionEngine::new(\n self.config.include_patterns.clone(),\n self.config.exclude_patterns.clone(),\n self.config.deselected,\n );\n self\n }\n\n pub fn add_exclude_pattern(&mut self, pattern: String) -> &mut Self {\n self.config.exclude_patterns.push(pattern);\n // Recreate SelectionEngine with new patterns\n self.selection_engine = SelectionEngine::new(\n self.config.include_patterns.clone(),\n self.config.exclude_patterns.clone(),\n self.config.deselected,\n );\n self\n }\n\n /// User interaction: include a file (delegates to SelectionEngine)\n pub fn select_file(&mut self, path: PathBuf) -> &mut Self {\n let relative_path = if path.is_absolute() {\n path.strip_prefix(&self.config.path)\n .unwrap_or(&path)\n .to_path_buf()\n } else {\n path\n };\n\n self.selection_engine.include_file(relative_path);\n self\n }\n\n /// User interaction: exclude a file (delegates to SelectionEngine)\n pub fn deselect_file(&mut self, path: PathBuf) -> &mut Self {\n let relative_path = if path.is_absolute() {\n path.strip_prefix(&self.config.path)\n .unwrap_or(&path)\n .to_path_buf()\n } else {\n path\n };\n\n self.selection_engine.exclude_file(relative_path);\n self\n }\n\n /// User interaction: toggle file selection (delegates to SelectionEngine)\n pub fn toggle_file_selection(&mut self, path: PathBuf) -> &mut Self {\n let relative_path = if path.is_absolute() {\n path.strip_prefix(&self.config.path)\n .unwrap_or(&path)\n .to_path_buf()\n } else {\n path\n };\n\n self.selection_engine.toggle_file(relative_path);\n self\n }\n\n /// Check if a file is selected (delegates to SelectionEngine)\n pub fn is_file_selected(&mut self, path: &std::path::Path) -> bool {\n let relative_path = if path.is_absolute() {\n path.strip_prefix(&self.config.path).unwrap_or(path)\n } else {\n path\n };\n\n self.selection_engine.is_selected(relative_path)\n }\n\n /// Get all currently selected files (delegates to SelectionEngine)\n pub fn get_selected_files(&mut self) -> Result> {\n Ok(self\n .selection_engine\n .get_selected_files(&self.config.path)?)\n }\n\n /// Clear all user actions (reset to pattern-only behavior)\n pub fn clear_user_actions(&mut self) -> &mut Self {\n self.selection_engine.clear_user_actions();\n self\n }\n\n /// Check if there are any user actions beyond base patterns\n pub fn has_user_actions(&self) -> bool {\n self.selection_engine.has_user_actions()\n }\n\n /// Set deselected by default and update selection engine\n pub fn set_deselected(&mut self, value: bool) -> &mut Self {\n self.config.deselected = value;\n self.selection_engine.set_deselected_by_default(value);\n self\n }\n\n /// Loads the codebase data (source tree and file list) into the session.\n pub fn load_codebase(&mut self) -> Result<()> {\n let (tree, files) = traverse_directory(&self.config, Some(&mut self.selection_engine))\n .with_context(|| \"Failed to traverse directory\")?;\n\n // Store absolute_code_path as Single Source of Truth\n self.data.absolute_code_path = Some(display_name(&self.config.path));\n self.data.source_tree = Some(tree);\n self.data.files = Some(files);\n\n Ok(())\n }\n\n /// Loads the Git diff into the session data.\n pub fn load_git_diff(&mut self) -> Result<()> {\n let diff = get_git_diff(&self.config.path)?;\n self.data.git_diff = Some(diff);\n Ok(())\n }\n\n /// Loads the Git diff between two branches into the session data.\n pub fn load_git_diff_between_branches(&mut self) -> Result<()> {\n if let Some((b1, b2)) = &self.config.diff_branches {\n let diff = get_git_diff_between_branches(&self.config.path, b1, b2)?;\n self.data.git_diff_branch = Some(diff);\n }\n Ok(())\n }\n\n /// Loads the Git log between two branches into the session data.\n pub fn load_git_log_between_branches(&mut self) -> Result<()> {\n if let Some((b1, b2)) = &self.config.log_branches {\n let log_output = get_git_log(&self.config.path, b1, b2)?;\n self.data.git_log_branch = Some(log_output);\n }\n Ok(())\n }\n\n /// Constructs a zero-copy template context for rendering.\n pub fn build_template_data(&self) -> TemplateContext<'_> {\n TemplateContext {\n absolute_code_path: self.data.absolute_code_path.as_deref().unwrap_or(\"unknown\"),\n source_tree: &self.data.source_tree,\n files: self.data.files.as_deref(),\n git_diff: &self.data.git_diff,\n git_diff_branch: &self.data.git_diff_branch,\n git_log_branch: &self.data.git_log_branch,\n user_variables: &self.config.user_variables,\n }\n }\n\n /// Renders the final prompt given a template context. Returns both\n /// the rendered prompt and the token count information.\n pub fn render_prompt(&self, template_context: &TemplateContext) -> Result {\n // ~~~ Template selection ~~~\n let mut template_str = self.config.template_str.clone();\n let mut template_name = self.config.template_name.clone();\n if self.config.template_str.is_empty() {\n template_str = match self.config.output_format {\n OutputFormat::Markdown => include_str!(\"./default_template_md.hbs\").to_string(),\n OutputFormat::Xml | OutputFormat::Json => {\n include_str!(\"./default_template_xml.hbs\").to_string()\n }\n };\n template_name = match self.config.output_format {\n OutputFormat::Markdown => \"markdown\".to_string(),\n OutputFormat::Xml | OutputFormat::Json => \"xml\".to_string(),\n };\n }\n\n // ~~~ Rendering ~~~\n let handlebars = handlebars_setup(&template_str, &template_name)?;\n let template_content = render_template(&handlebars, &template_name, template_context)?;\n\n // ~~~ Informations ~~~\n let tokenizer_type: TokenizerType = self.config.encoding;\n // Always use the cached calculation: Σ(FileTokens) + TemplateOverhead\n // This avoids re-tokenizing the entire rendered output (sequential bottleneck)\n let token_count = self.calculate_token_count_from_cache(&tokenizer_type);\n\n let model_info = tokenizer_type.description();\n let directory_name = template_context.absolute_code_path.to_string();\n let files: Vec = self\n .data\n .files\n .as_ref()\n .map(|files| files.iter().map(|file| file.path.clone()).collect())\n .unwrap_or_default();\n\n // ~~~ Final output format ~~~\n let final_output = match self.config.output_format {\n OutputFormat::Json => {\n let json_data = serde_json::json!({\n \"prompt\": template_content,\n \"directory_name\": directory_name.clone(),\n \"token_count\": token_count,\n \"model_info\": model_info,\n \"files\": files.clone(),\n });\n serde_json::to_string_pretty(&json_data)?\n }\n _ => template_content,\n };\n\n Ok(RenderedPrompt {\n prompt: final_output,\n directory_name,\n token_count,\n model_info,\n files,\n })\n }\n\n /// Calculate exact token count using cached per-file token counts + skeleton rendering\n ///\n /// This method provides precise token counting by:\n /// 1. Summing the cached per-file token counts (from actual content tokenized in parallel)\n /// 2. Rendering a \"skeleton\" template with empty file contents to get structural tokens\n /// 3. Adding them together for an exact count\n ///\n /// This approach avoids re-tokenizing the entire rendered output (sequential bottleneck).\n ///\n /// # Arguments\n ///\n /// * `tokenizer_type` - The tokenizer to use for tokenization\n ///\n /// # Returns\n ///\n /// * `usize` - The exact total token count\n fn calculate_token_count_from_cache(&self, tokenizer_type: &TokenizerType) -> usize {\n // Sum up cached per-file token counts (tokens from actual file content)\n let files_token_count: usize = self\n .data\n .files\n .as_ref()\n .map(|files| files.iter().map(|file| file.token_count).sum())\n .unwrap_or(0);\n\n // Calculate exact structural/template overhead using skeleton rendering\n let structural_tokens = self.calculate_structural_tokens(tokenizer_type);\n\n files_token_count + structural_tokens\n }\n\n /// Calculate structural tokens by rendering a skeleton template\n ///\n /// Creates FileEntry \"skeletons\" with empty code blocks but same structure,\n /// renders the template, and counts tokens. This gives us the exact token count\n /// for everything except the actual file content (tree, headers, wrappers, git info).\n ///\n /// # Arguments\n ///\n /// * `tokenizer_type` - The tokenizer to use for counting\n ///\n /// # Returns\n ///\n /// * `usize` - The number of structural tokens\n fn calculate_structural_tokens(&self, tokenizer_type: &TokenizerType) -> usize {\n // Create skeleton file entries (empty code, but same structure/metadata)\n let skeleton_files: Option> = self.data.files.as_ref().map(|files| {\n files\n .iter()\n .map(|file| {\n // Create empty code block with same wrapping structure\n let empty_code_block = wrap_code_block(\n \"\",\n &file.extension,\n self.config.line_numbers,\n self.config.no_codeblock,\n );\n\n FileEntry {\n path: file.path.clone(),\n extension: file.extension.clone(),\n code: empty_code_block,\n token_count: 0, // Not used in skeleton\n metadata: file.metadata,\n mod_time: file.mod_time,\n }\n })\n .collect()\n });\n\n // Build skeleton template context (same structure, but with empty file contents)\n let skeleton_context = TemplateContext {\n absolute_code_path: self.data.absolute_code_path.as_deref().unwrap_or(\"unknown\"),\n source_tree: &self.data.source_tree,\n files: skeleton_files.as_deref(),\n git_diff: &self.data.git_diff,\n git_diff_branch: &self.data.git_diff_branch,\n git_log_branch: &self.data.git_log_branch,\n user_variables: &self.config.user_variables,\n };\n\n // Render skeleton template\n let template_str = if self.config.template_str.is_empty() {\n match self.config.output_format {\n OutputFormat::Markdown => include_str!(\"./default_template_md.hbs\").to_string(),\n OutputFormat::Xml | OutputFormat::Json => {\n include_str!(\"./default_template_xml.hbs\").to_string()\n }\n }\n } else {\n self.config.template_str.clone()\n };\n\n let template_name = if self.config.template_name.is_empty() {\n match self.config.output_format {\n OutputFormat::Markdown => \"markdown\".to_string(),\n OutputFormat::Xml | OutputFormat::Json => \"xml\".to_string(),\n }\n } else {\n self.config.template_name.clone()\n };\n\n // Render and count tokens\n match handlebars_setup(&template_str, &template_name) {\n Ok(handlebars) => {\n match render_template(&handlebars, &template_name, &skeleton_context) {\n Ok(skeleton_rendered) => count_tokens(&skeleton_rendered, tokenizer_type),\n Err(_) => {\n // Fallback to simple estimation if rendering fails\n self.fallback_structural_estimate(tokenizer_type)\n }\n }\n }\n Err(_) => {\n // Fallback to simple estimation if handlebars setup fails\n self.fallback_structural_estimate(tokenizer_type)\n }\n }\n }\n\n /// Fallback estimation when skeleton rendering fails\n ///\n /// Uses a simple heuristic based on tree/git sizes as a safety net.\n ///\n /// # Arguments\n ///\n /// * `tokenizer_type` - The tokenizer to use\n ///\n /// # Returns\n ///\n /// * `usize` - Estimated structural tokens\n fn fallback_structural_estimate(&self, tokenizer_type: &TokenizerType) -> usize {\n let mut total_chars = 0;\n\n if let Some(tree) = &self.data.source_tree {\n total_chars += tree.len();\n }\n if let Some(diff) = &self.data.git_diff {\n total_chars += diff.len();\n }\n if let Some(diff_branch) = &self.data.git_diff_branch {\n total_chars += diff_branch.len();\n }\n if let Some(log_branch) = &self.data.git_log_branch {\n total_chars += log_branch.len();\n }\n\n // Simple approximation: ~4 chars per token + buffer for headers\n let estimated = (total_chars / 4) + 100;\n\n // For better accuracy on smaller sizes, actually tokenize\n if total_chars < 10000 {\n let combined = format!(\n \"{}{}{}{}\",\n self.data.source_tree.as_deref().unwrap_or(\"\"),\n self.data.git_diff.as_deref().unwrap_or(\"\"),\n self.data.git_diff_branch.as_deref().unwrap_or(\"\"),\n self.data.git_log_branch.as_deref().unwrap_or(\"\")\n );\n count_tokens(&combined, tokenizer_type)\n } else {\n estimated\n }\n }\n\n pub fn generate_prompt(&mut self) -> Result {\n self.load_codebase()?;\n\n // ~~~~ Load Git info ~~~\n if self.config.diff_enabled {\n match self.load_git_diff() {\n Ok(_) => {}\n Err(e) => log::warn!(\"Git diff could not be loaded: {}\", e),\n }\n }\n\n // ~~~ Load Git info between branches ~~~\n if self.config.diff_branches.is_some() {\n match self.load_git_diff_between_branches() {\n Ok(_) => {}\n Err(e) => log::warn!(\"Git branch diff could not be loaded: {}\", e),\n }\n }\n\n // ~~~ Load Git log between branches ~~~\n if self.config.log_branches.is_some() {\n match self.load_git_log_between_branches() {\n Ok(_) => {}\n Err(e) => log::warn!(\"Git branch log could not be loaded: {}\", e),\n }\n }\n let template_data = self.build_template_data();\n let rendered = self.render_prompt(&template_data)?;\n Ok(rendered)\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/sort.rs",
"content": "//! This module provides sorting methods for files and directory trees.\n\nuse crate::path::FileEntry;\nuse serde::{self, Deserialize, Serialize};\nuse std::fmt;\nuse termtree::Tree;\n\n// Define the available sort methods.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]\n#[serde(rename_all = \"snake_case\")]\npub enum FileSortMethod {\n /// Sort files by name (A → Z)\n NameAsc,\n /// Sort files by name (Z → A)\n NameDesc,\n /// Sort files by modification date (oldest first)\n DateAsc,\n /// Sort files by modification date (newest first)\n DateDesc,\n}\n\nimpl fmt::Display for FileSortMethod {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match self {\n FileSortMethod::NameAsc => write!(f, \"Name (A → Z)\"),\n FileSortMethod::NameDesc => write!(f, \"Name (Z → A)\"),\n FileSortMethod::DateAsc => write!(f, \"Date (Old → New)\"),\n FileSortMethod::DateDesc => write!(f, \"Date (New → Old)\"),\n }\n }\n}\n\n/// Sorts the provided `files` in place using the specified `sort_method`.\n///\n/// If `sort_method` is `None`, no sorting will be performed.\n///\n/// # Arguments\n///\n/// * `files` - A mutable slice of FileEntry representing files.\n/// * `sort_method` - An optional `FileSortMethod` indicating how to sort the files.\npub fn sort_files(files: &mut [FileEntry], sort_method: Option) {\n if let Some(method) = sort_method {\n match method {\n FileSortMethod::NameAsc => {\n files.sort_by(|a, b| a.path.cmp(&b.path));\n }\n FileSortMethod::NameDesc => {\n files.sort_by(|a, b| b.path.cmp(&a.path));\n }\n FileSortMethod::DateAsc => {\n files.sort_by_key(|f| f.mod_time.unwrap_or(0));\n }\n FileSortMethod::DateDesc => {\n files.sort_by_key(|f| std::cmp::Reverse(f.mod_time.unwrap_or(0)));\n }\n }\n }\n}\n\n/// Recursively sorts a directory tree (represented by `termtree::Tree`) in place using the specified\n/// `FileSortMethod`. For directory nodes, since modification time is typically unavailable, this function\n/// falls back to sorting by name. In effect, DateAsc is treated as NameAsc and DateDesc as NameDesc for directories.\n///\n/// If `sort_method` is `None`, no sorting is performed.\n///\n/// # Arguments\n///\n/// * `tree` - A mutable reference to the directory tree.\n/// * `sort_method` - An optional `FileSortMethod` that determines the sorting order.\npub fn sort_tree(\n tree: &mut Tree,\n sort_method: Option,\n) {\n if let Some(method) = sort_method {\n // For directories we only have the name (the root), so date-based sorts fall back to name sorting.\n let ascending = match method {\n FileSortMethod::NameAsc | FileSortMethod::DateAsc => true,\n FileSortMethod::NameDesc | FileSortMethod::DateDesc => false,\n };\n sort_tree_impl(tree, ascending);\n }\n}\n\n/// Internal helper: recursively sorts the leaves of a directory tree in the specified order.\nfn sort_tree_impl(tree: &mut Tree, ascending: bool) {\n tree.leaves.sort_by(|a, b| {\n if ascending {\n a.root.cmp(&b.root)\n } else {\n b.root.cmp(&a.root)\n }\n });\n for leaf in &mut tree.leaves {\n sort_tree_impl(leaf, ascending);\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/template.rs",
"content": "//! This module contains the functions to set up the Handlebars template engine and render the template with the provided data.\n//! It also includes functions for handling user-defined variables, copying the rendered output to the clipboard, and writing it to a file.\nuse anyhow::{Result, anyhow};\nuse handlebars::{Handlebars, no_escape};\nuse regex::Regex;\nuse serde::{Deserialize, Serialize};\nuse std::io::Write;\n\n/// Set up the Handlebars template engine with a template string and a template name.\n///\n/// # Arguments\n///\n/// * `template_str` - The Handlebars template string.\n/// * `template_name` - The name of the template.\n///\n/// # Returns\n///\n/// * `Result>` - The configured Handlebars instance.\npub fn handlebars_setup(template_str: &str, template_name: &str) -> Result> {\n let mut handlebars = Handlebars::new();\n handlebars.register_escape_fn(no_escape);\n\n handlebars\n .register_template_string(template_name, template_str)\n .map_err(|e| anyhow!(\"Failed to register template: {}\", e))?;\n\n Ok(handlebars)\n}\n\n/// Extracts the undefined variables from the template string.\n///\n/// # Arguments\n///\n/// * `template` - The Handlebars template string.\n///\n/// # Returns\n///\n/// * `Vec` - A vector of undefined variable names.\npub fn extract_undefined_variables(template: &str) -> Vec {\n let registered_identifiers = [\n \"absolute_code_path\",\n \"source_tree\",\n \"files\",\n \"path\",\n \"code\",\n \"git_diff\",\n \"git_diff_branch\",\n \"git_log_branch\"\n ];\n let re = Regex::new(r\"\\{\\{\\s*(?P[a-zA-Z_][a-zA-Z_0-9]*)\\s*\\}\\}\").unwrap();\n re.captures_iter(template)\n .map(|cap| cap[\"var\"].to_string())\n .filter(|var| !registered_identifiers.contains(&var.as_str()))\n .collect()\n}\n\n/// Renders the template with the provided data.\n///\n/// # Arguments\n///\n/// * `handlebars` - The configured Handlebars instance.\n/// * `template_name` - The name of the template.\n/// * `data` - Any serializable data object.\n///\n/// # Returns\n///\n/// * `Result` - The rendered template as a string.\npub fn render_template(\n handlebars: &Handlebars,\n template_name: &str,\n data: &T,\n) -> Result {\n let rendered = handlebars\n .render(template_name, data)\n .map_err(|e| anyhow!(\"Failed to render template: {}\", e))?;\n Ok(rendered.trim().to_string())\n}\n\n/// Writes the rendered template to a specified output file\n///\n/// # Arguments\n///\n/// * `output_path` - The path to the output file.\n/// * `rendered` - The rendered template string.\n///\n/// # Returns\n///\n/// * `Result<()>` - An empty result indicating success or an error.\npub fn write_to_file(output_path: &str, rendered: &str) -> Result<()> {\n let file = std::fs::File::create(output_path)?;\n let mut writer = std::io::BufWriter::new(file);\n write!(writer, \"{}\", rendered)?;\n Ok(())\n}\n\n/// Enum to represent the output format.\n#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]\n#[serde(rename_all = \"lowercase\")]\npub enum OutputFormat {\n #[default]\n Markdown,\n Json,\n Xml,\n}\n\nimpl std::fmt::Display for OutputFormat {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n match self {\n OutputFormat::Markdown => write!(f, \"markdown\"),\n OutputFormat::Json => write!(f, \"json\"),\n OutputFormat::Xml => write!(f, \"xml\"),\n }\n }\n}\n"
},
{
"path": "crates/code2prompt-core/src/tokenizer.rs",
"content": "//! This module encapsulates the logic for counting the tokens in the rendered text.\nuse log::debug;\nuse serde::{Deserialize, Serialize};\nuse std::fmt;\nuse std::sync::OnceLock;\nuse tiktoken_rs::{CoreBPE, cl100k_base, o200k_base, p50k_base, p50k_edit, r50k_base};\n\n#[derive(Default, Debug, Clone, Copy, PartialEq, Deserialize, Serialize)]\n#[serde(rename_all = \"lowercase\")]\npub enum TokenFormat {\n #[default]\n Raw,\n Format,\n}\n\nimpl fmt::Display for TokenFormat {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match self {\n TokenFormat::Raw => write!(f, \"Raw\"),\n TokenFormat::Format => write!(f, \"Formatted\"),\n }\n }\n}\n\n/// Tokenizer types supported by tiktoken.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]\npub enum TokenizerType {\n #[serde(alias = \"o200k\")]\n O200kBase,\n #[default]\n #[serde(alias = \"cl100k\")]\n Cl100kBase,\n #[serde(alias = \"p50k\")]\n P50kBase,\n #[serde(alias = \"p50k_edit\")]\n P50kEdit,\n #[serde(alias = \"r50k\")]\n R50kBase,\n}\n\nimpl fmt::Display for TokenizerType {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match self {\n TokenizerType::O200kBase => write!(f, \"o200k (GPT-4o)\"),\n TokenizerType::Cl100kBase => write!(f, \"cl100k (ChatGPT)\"),\n TokenizerType::P50kBase => write!(f, \"p50k (Code models)\"),\n TokenizerType::P50kEdit => write!(f, \"p50k_edit (Edit models)\"),\n TokenizerType::R50kBase => write!(f, \"r50k (GPT-3)\"),\n }\n }\n}\n\n/// Returns a description of the tokenizer type.\nimpl TokenizerType {\n pub fn description(&self) -> &'static str {\n match self {\n TokenizerType::O200kBase => \"OpenAI models, ChatGPT-4o\",\n TokenizerType::Cl100kBase => \"ChatGPT models, text-embedding-ada-002\",\n TokenizerType::P50kBase => \"Code models, text-davinci-002, text-davinci-003\",\n TokenizerType::P50kEdit => {\n \"Edit models like text-davinci-edit-001, code-davinci-edit-001\"\n }\n TokenizerType::R50kBase => \"GPT-3 models like davinci\",\n }\n }\n}\n\n// Cache tokenizers to avoid expensive re-initialization\nstatic O200K_BASE: OnceLock = OnceLock::new();\nstatic CL100K_BASE: OnceLock = OnceLock::new();\nstatic P50K_BASE: OnceLock = OnceLock::new();\nstatic P50K_EDIT: OnceLock = OnceLock::new();\nstatic R50K_BASE: OnceLock = OnceLock::new();\n\n/// Counts the tokens in the provided text using the specified tokenizer type.\n///\n/// # Arguments\n///\n/// * `rendered` - The text to count tokens in\n/// * `tokenizer_type` - The tokenizer encoding to use\n///\n/// # Returns\n///\n/// * `usize` - The number of tokens in the text\npub fn count_tokens(rendered: &str, tokenizer_type: &TokenizerType) -> usize {\n use std::time::Instant;\n let start = Instant::now();\n\n let bpe = match tokenizer_type {\n TokenizerType::O200kBase => O200K_BASE.get_or_init(|| o200k_base().unwrap()),\n TokenizerType::Cl100kBase => CL100K_BASE.get_or_init(|| cl100k_base().unwrap()),\n TokenizerType::P50kBase => P50K_BASE.get_or_init(|| p50k_base().unwrap()),\n TokenizerType::P50kEdit => P50K_EDIT.get_or_init(|| p50k_edit().unwrap()),\n TokenizerType::R50kBase => R50K_BASE.get_or_init(|| r50k_base().unwrap()),\n };\n\n let token_count = bpe.encode_with_special_tokens(rendered).len();\n\n if std::env::var(\"DEBUG_TOKENIZER\").is_ok() {\n debug!(\n \"Tokenized {} chars in {:?}\",\n rendered.len(),\n start.elapsed()\n );\n }\n\n token_count\n}\n"
},
{
"path": "crates/code2prompt-core/src/util.rs",
"content": "//! This module contains util functions\n\n/// Removes a UTF‑8 Byte Order Mark (BOM) from the beginning of a byte slice if present.\n///\n/// The UTF‑8 BOM is the byte sequence `[0xEF, 0xBB, 0xBF]`. This function checks whether\n/// the provided slice starts with these bytes and, if so, returns a subslice without them.\n/// Otherwise, it returns the original slice.\npub fn strip_utf8_bom(data: &[u8]) -> &[u8] {\n const BOM: &[u8] = &[0xEF, 0xBB, 0xBF];\n if data.starts_with(BOM) {\n &data[BOM.len()..]\n } else {\n data\n }\n}\n"
},
{
"path": "crates/code2prompt-core/templates/binary-exploitation-ctf-solver.hbs",
"content": "Challenge Name: {{challenge_name}}\nCategory: Binary Exploitation\n\nDescription: {{challenge_description}}\n\nProvided Files:\n{{#each files}}\n{{#if code}} \n`{{path}}`:\n{{code}}\n\n{{/if}}\n{{/each}}\n\nTo solve this binary exploitation challenge:\n\n1. Examine the provided source code (if any):\n- Identify vulnerabilities (buffer overflow, use-after-free, integer issues, etc.)\n- Understand intended behavior and user input \n- Note compiled binary type (ELF 32/64-bit, Windows PE, etc.)\n\n2. Perform static analysis on the binary:\n- Enumerate input vectors (local files, network port, stdin, etc.) \n- Reverse engineer relevant code paths\n- Locate vulnerable functions (unsafe C functions, syscalls, etc.)\n- Check for stack canaries, NX, PIE, ASLR, RELRO \n\n3. Proceed to dynamic analysis:\n- Attach debugger and send input\n- Determine segfault type (IP overwrite, invalid read/write, etc.)\n- Inspect registers, stack, heap contents\n- Dump process memory \n- Set breakpoints and watchpoints as needed\n\n4. Develop your exploit strategy:\n- Goal (EIP control, arbitrary read/write, information leak, etc.) \n- Payload (spawning a shell, leaking a flag, ret2libc, ROP, etc.)\n- Method to reach vulnerable code\n- Bypassing any exploit mitigations\n\n5. Construct your exploit payload:\n- Determine bad characters and encoding \n- Find ROP gadgets, function addresses, etc. as needed\n- Use pwntools, Ropper, one_gadget, etc. \n- Build payload in debugger, then script it\n\n6. If remote, ensure your exploit is stable and reliable:\n- Adapt to remote environment \n- Handle network quirks, latency\n- Encode payload for transmission\n\n7. Launch the exploit, catch the shell or leaked flag.\n\nInclude your process, not just the final payload. Stay within scope (no attacking unintended targets)."
},
{
"path": "crates/code2prompt-core/templates/clean-up-code.hbs",
"content": "Project Path: {{ absolute_code_path }}\n\nI'd like your help cleaning up and improving the code quality in this project. Please review all the code files carefully:\n\nSource Tree:\n```\n{{ source_tree }} \n```\n\n{{#each files}}\n{{#if code}}\n`{{path}}`:\n\n{{code}}\n\n{{/if}} \n{{/each}}\n\nWhen reviewing the code, look for opportunities to improve:\n- Readability and clarity \n- Adherence to language idioms and best practices\n- Modularity and code organization \n- Efficiency and performance (within reason)\n- Consistency in style and conventions\n- Error handling and reliability\n- Simplicity (remove unused code, simplify complex logic)\n- Naming of variables, functions, classes, etc.\n- Formatting and whitespace\n- Comments and documentation \n\nMake sure your changes don't alter existing behavior (except perhaps for improved error handling). Try to infer the original intent as much as possible, and refactor towards that intent.\n\nFor each change you make, include a brief code comment explaining your rationale, something like:\n\n// Refactored to improve readability and efficiency. \n// Combined error handling logic into a reusable function.\n\nBe thoughtful and judicious with your changes. I trust your programming expertise! Let me know if any part of the original code is unclear."
},
{
"path": "crates/code2prompt-core/templates/cryptography-ctf-solver.hbs",
"content": "Challenge Name: {{challenge_name}}\nCategory: Cryptography\n\nDescription: {{challenge_description}}\n\nProvided Files:\n{{#each files}}\n{{#if code}}\n`{{path}}`:\n{{code}}\n\n{{/if}}\n{{/each}}\n\nI need your help to solve this cryptography challenge. Here are some steps to follow:\n\n1. Identify the type of encryption or encoding used based on the challenge description and any provided files. Common types include:\n- Classical ciphers (Caesar, Vigenère, substitution, etc.) \n- Modern symmetric ciphers (AES, DES, etc.)\n- Asymmetric cryptography (RSA, ECC, etc.)\n- Hashes and password cracking\n- Encoding schemes (Base64, hex, etc.)\n\n2. If there are any encrypted messages or ciphertexts, paste them here. Also include any keys, IVs, or other relevant parameters.\n\n3. Analyze the encryption for weaknesses. Look for:\n- Weak keys or poor randomness\n- Use of insecure modes like ECB\n- Oracles that leak information \n- Flaws in custom encryption schemes\n- Reused one-time pads or nonces\n- Hash length extension attacks\n\n4. Attempt to decrypt the message:\n- Brute-force attack if key space is small\n- Frequency analysis and cribs for classical ciphers\n- Exploit mathematical weaknesses of RSA\n- Crack hashes with wordlists/rules/masks\n- Abuse padding oracle vulnerabilities\n\n5. If you successfully decrypt, the flag format is usually `flag{...}`. Submit that to the scoring system.\n\nLet me know if you need any other information to solve the challenge! Cryptography can be tricky."
},
{
"path": "crates/code2prompt-core/templates/document-the-code.hbs",
"content": "Project Path: {{ absolute_code_path }}\n\nSource Tree: \n```\n{{ source_tree }}\n```\n\n{{#each files}}\n{{#if code}}\n`{{path}}`:\n\n{{code}} \n\n{{/if}}\n{{/each}}\n\nI'd like you to add documentation comments to all public functions, methods, classes and modules in this codebase.\n\nFor each one, the comment should include:\n1. A brief description of what it does\n2. Explanations of all parameters including types/constraints \n3. Description of the return value (if applicable)\n4. Any notable error or edge cases handled\n5. Links to any related code entities\n\nTry to keep comments concise but informative. Use the function/parameter names as clues to infer their purpose. Analyze the implementation carefully to determine behavior.\n\nComments should use the idiomatic style for the language, e.g. /// for Rust, \"\"\" for Python, /** */ for TypeScript, etc. Place them directly above the function/class/module definition.\n\nLet me know if you have any questions! And be sure to review your work for accuracy before submitting."
},
{
"path": "crates/code2prompt-core/templates/find-security-vulnerabilities.hbs",
"content": "Project Path: {{ absolute_code_path }}\n\nI want you to carefully review the code in this project and identify any potential security vulnerabilities or weaknesses. Take your time, think step-by-step, and consider all the code paths and interactions between different parts of the codebase.\n\nSource Tree:\n```\n{{ source_tree }}\n```\n\n{{#each files}}\n{{#if code}} \n`{{path}}`:\n\n{{code}}\n\n{{/if}}\n{{/each}}\n\nWhen analyzing the code, look for common security issues like:\n- Input validation vulnerabilities \n- Weak authentication or authorization\n- Insecure handling of sensitive data\n- Injection flaws (SQL injection, XXE, command injection, etc)\n- Cross-site scripting (XSS)\n- Insecure configuration settings\n- Outdated or vulnerable dependencies\n- Privilege escalation\n- Unrestricted resource consumption (via DoS, etc)\n- Insecure cryptography (like weak keys, etc)\n- Unrestricted file uploads\n- Insecure deserialization\n- Insecure randomness\n- Insecure logging and monitoring\n- Deserialization attacks (like Pickle, etc)\n- Business logic vulnerabilities (example scenario: user can withdraw 3 times in a row but the code allows for 4)\n\nFor each vulnerability you find, provide:\n1. The file path and line number(s)\n2. A description of the issue and why it's a vulnerability\n3. The potential impact if the vulnerability was exploited\n4. The code snippets responsible for the vulnerability, from source to sink and which user input or value is passed\n5. Exploit PoC (Proof of Concept)\n6. Recommendations on how to fix or mitigate the vulnerability\n\nAfter you have finished analyzing the codebase, provide a Markdown table with the following headers: Vulnerability Name, Vulnerability Description, File Path, CVSS Vector, Confidence Score, Exploitation Steps.\n\nBe as thorough and detailed as possible in your analysis. The security of this codebase is critical.\n"
},
{
"path": "crates/code2prompt-core/templates/fix-bugs.hbs",
"content": "Project Path: {{ absolute_code_path }}\n\nI need your help tracking down and fixing some bugs that have been reported in this codebase. Here are the files involved:\n\nSource Tree:\n```\n{{ source_tree }}\n```\n\n{{#each files}} \n{{#if code}}\n`{{path}}`: \n\n{{code}}\n\n{{/if}}\n{{/each}}\n\nI suspect the bugs are related to:\n- Incorrect handling of edge cases \n- Off-by-one errors in loops or array indexing\n- Unexpected data types\n- Uncaught exceptions\n- Concurrency issues\n- Improper configuration settings\n\nTo diagnose:\n1. Review the code carefully and systematically \n2. Trace the relevant code paths \n3. Consider boundary conditions and potential error states\n4. Look for antipatterns that tend to cause bugs\n5. Run the code mentally with example inputs \n6. Think about interactions between components\n\nWhen you find potential bugs, for each one provide:\n1. File path and line number(s)\n2. Description of the issue and why it's a bug\n3. Example input that would trigger the bug \n4. Suggestions for how to fix it\n\nAfter analysis, please update the code with your proposed fixes. Try to match the existing code style. Add regression tests if possible to prevent the bugs from recurring.\n\nI appreciate your diligence and attention to detail! Let me know if you need any clarification on the intended behavior of the code."
},
{
"path": "crates/code2prompt-core/templates/improve-performance.hbs",
"content": "Project Path: {{ absolute_code_path }}\n\nI'd like your help improving the performance of this codebase. It works correctly, but we need it to be faster and more efficient. Analyze the code thoroughly with this goal in mind:\n\nSource Tree:\n```\n{{ source_tree }}\n``` \n\n{{#each files}}\n{{#if code}}\n`{{path}}`:\n\n{{code}}\n\n{{/if}}\n{{/each}}\n\nWhen looking for optimization opportunities, consider:\n- Algorithm complexity and big O analysis \n- Expensive operations like disk/network I/O\n- Unnecessary iterations or computations\n- Repeated calculations of the same value \n- Inefficient data structures or data types\n- Opportunities to cache or memoize results\n- Parallelization with threads/async \n- More efficient built-in functions or libraries\n- Query or code paths that can be short-circuited\n- Reducing memory allocations and copying\n- Compiler or interpreter optimizations to leverage\n\nFor each potential improvement, provide:\n1. File path and line number(s) \n2. Description of the issue/inefficiency\n3. Estimated impact on performance \n4. Specific suggestions for optimization\n\nThen update the code with your changes. Be sure to maintain readability and organization. Minor optimizations that significantly reduce clarity are not worth it.\n\nAdd benchmarks if possible to quantify the performance improvements. Document any new usage constraints (e.g. increased memory requirements).\n\nTry to prioritize the changes that will have the largest impact on typical usage scenarios based on your understanding of the codebase. Let me know if you have any questions!"
},
{
"path": "crates/code2prompt-core/templates/refactor.hbs",
"content": "Project Path: {{ absolute_code_path }}\n\nI need your help refactoring this codebase to improve its design, maintainability, and performance. Here are the files involved:\n\nSource Tree:\n```\n{{ source_tree }}\n```\n\n{{#each files}} \n{{#if code}}\n`{{path}}`: \n\n{{code}}\n\n{{/if}}\n{{/each}}\n\nSome areas to focus on during the refactoring:\n\n- Adherence to SOLID principles (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion)\n- Separation of concerns\n- Reducing duplication (DRY - Don't Repeat Yourself)\n- Improving naming and code readability\n- Enhancing modularity and reusability\n- Optimizing performance\n- Removing dead or redundant code\n- Updating to modern language features or idioms where appropriate\n- Ensuring consistent code style and formatting\n\nTo refactor effectively:\n\n- Understand the current design and architecture\n- Identify pain points, code smells, and areas for improvement\n- Break down the refactoring into manageable steps\n- Ensure the existing tests pass after each refactoring step\n- Look for opportunities to extract reusable functions, classes or modules\n- Consider performance implications of design changes\n- Keep the code readable and maintainable\n- Preserve the original functionality and API contracts\n\nFor each major refactoring you propose, please provide:\n\n- File path(s) and line number(s)\n- Description of the current code and why it needs refactoring\n- Explanation of your proposed changes and their benefits\n- Updated code snippets with your refactoring applied\n\nAfter refactoring, please share the updated codebase. Update any relevant documentation to reflect the changes. Add new unit tests for the refactored code if applicable.\n"
},
{
"path": "crates/code2prompt-core/templates/reverse-engineering-ctf-solver.hbs",
"content": "Challenge Name: {{challenge_name}}\nCategory: Reverse Engineering \n\nDescription: {{challenge_description}}\n\nProvided Files:\n{{#each files}} \n{{#if code}}\n`{{path}}`:\n{{code}}\n\n{{/if}}\n{{/each}}\n\nHere's a plan to tackle this reverse engineering challenge:\n\n1. Identify the target file type(s):\n- Compiled binary (ELF, PE, Mach-O) \n- Bytecode (Java, .NET, Python, etc.)\n- Obfuscated script (JavaScript, Lua, etc.)\n- Document (maldoc, PDF) with macros \n\n2. Set up your analysis environment:\n- Disassembler/decompiler (Ghidra, IDA Pro, radare2)\n- Debugger (gdb, x64dbg, WinDbg)\n- VM or container to isolate malware\n- Automated unpacking/deobfuscation tools\n\n3. Perform static analysis:\n- Scan strings for clues, crypto/encoding, flag format\n- Examine imported functions for interesting behavior\n- Decompile and review logic, control flow \n- Locate comparison with user input or flag\n\n4. Proceed to dynamic analysis if needed:\n- Run binary in debugger \n- Set breakpoints on key functions\n- Inspect variables, memory, and registers\n- Modify execution flow or patch binary\n\n5. Identify and bypass anti-reversing:\n- Packed or obfuscated code\n- Anti-debug checks (IsDebuggerPresent, timing, etc.) \n- Junk code, opaque predicates\n- Virtualization/emulation\n\n6. Solve any necessary steps:\n- Satisfy input checks (password, serial, etc.)\n- Defuse anti-tampering protections\n- Decrypt embedded resources\n- Forge crypto/hash to match expected value\n\n7. Locate the flag in memory, output, or decrypted resource.\n\nProvide the key reversing insights you discover. Focus on reaching the minimum goal, not full understanding."
},
{
"path": "crates/code2prompt-core/templates/web-ctf-solver.hbs",
"content": "Challenge Name: {{challenge_name}} \nCategory: Web Exploitation\n\nDescription: {{challenge_description}}\n\nTarget URL: {{target_url}}\n\nProvided Files:\n{{#each files}}\n{{#if code}}\n`{{path}}`:\n{{code}}\n\n{{/if}} \n{{/each}}\n\nTo solve this web exploitation challenge, follow these steps:\n\n1. Explore the target web app in a browser. Note down:\n- Visible URLs and endpoints \n- Login/auth mechanisms\n- Key functionality and pages\n- User-supplied input fields \n- Technologies used (framework, frontend, backend, DB)\n\n2. View page source and inspect HTTP traffic. Look for:\n- HTML comments with clues/TODOs\n- JavaScript source code \n- API endpoints and request/response formats\n- Cookies, auth tokens, headers\n\n3. Test for common web vulns:\n- SQL injection in search/login/URLs \n- Cross-site scripting (XSS) in input fields\n- Server-side template injection \n- Command injection \n- Directory traversal\n- Insecure file uploads\n- Broken access control for admin/hidden pages\n\n4. If you find an exploitable vuln, craft a malicious payload:\n- SQL injection to bypass login, dump DB, UNION query\n- XSS to steal admin cookies/creds or call APIs \n- Template injection to leak source or run OS commands\n- Directory traversal to view sensitive files\n\n5. The flag is often in an admin page, DBdump, or source code file. Access it via the vulnerability.\n\nProvide the vulnerable URL and your exploit payload. Stay within scope and rules - no scanning/attacking other targets."
},
{
"path": "crates/code2prompt-core/templates/write-git-commit.hbs",
"content": "Project Path: {{ absolute_code_path }}\n\nI'd like you to generate a high-quality git commit message for the provided `git diff`. Analyze the diff to understand the purpose and functionality.\n\nSource Tree:\n```\n{{ source_tree }}\n```\n\n{{#if git_diff}}\nDiff:\n```\n{{git_diff}}\n```\n{{/if}}\n\nThe git commit should adhere to these points:\n\n1. Concise Subject: Short and informative subject line, less than 50 characters.\n2. Descriptive Body: Optional summary of 1 to 2 sentences, wrapping at 72 characters.\n3. Use Imperative Mood: For example, \"Fix bug\" instead of \"Fixed bug\" or \"Fixes bug.\"\n4. Capitalize the Subject: First letter of the subject should be capitalized.\n5. No Period at the End: Subject line does not end with a period.\n7. Separate Subject From Body With a Blank Line: If using a body, leave one blank line after the subject.\n\nWrite the content in Markdown format. Use your analysis of the diff to generate a short, naccurate and helpful commit message.\n\nFeel free to infer reasonable details if needed, but try to stick to what can be determined from the diff itself. Let me know if you have any other questions as you're writing!\n"
},
{
"path": "crates/code2prompt-core/templates/write-github-pull-request.hbs",
"content": "Project Path: {{ absolute_code_path }}\n\nI want you to generate a high-quality well-crafted Github pull request description for this project.\nI will provide you with the source tree, git diff, git log, and pull request template.\n\nSource Tree:\n```\n{{ source_tree }}\n```\n\n{{#if git_diff_branch}}\nGit diff:\n```\n{{git_diff_branch}}\n```\n{{/if}}\n\n\n{{#if git_log_branch}}\nGit log:\n```\n{{git_log_branch}}\n```\n{{/if}}\n\n\nThe Pull Request description should include the following template and adhere best practice:\n```\nTitle: provide with concise and informative title.\n\n# What is this?\n- Explain the motivation why this is needed and the expected outcome of implementing this.\n- Write it in a humanized manner.\n\n# Changes\n- Provide list of key changes with good structure.\n- Mention the class name, function name, and file name.\n- Explain the code changes.\nFor example:\n# Changes\n## Added Features:\n 1. **New Functions in `file_name.`**:\n - `function_name.`: code description.\n## Code Changes:\n 1. **In `file_name.`**:\n## Documentation Updates:\n 1. **In `file_name.`**:\n\n# Demo\n- N/A\n\n# Context\n- N/A\n```\n\nPlease, analyze the git diff and git log to understand the changes. Do not output git log and git diff to the content.\nUse your analysis of the code to generate accurate and helpful content, but also explain things clearly for users who may not be familiar with the implementation details.\nWrite the content in Markdown format and follow the provided pull request template.\n"
},
{
"path": "crates/code2prompt-core/templates/write-github-readme.hbs",
"content": "Project Path: {{ absolute_code_path }}\n\nI'd like you to generate a high-quality README file for this project, suitable for hosting on GitHub. Analyze the codebase to understand the purpose, functionality, and structure of the project. \n\nSource Tree:\n```\n{{ source_tree }}\n```\n\n{{#each files}}\n{{#if code}}\n`{{path}}`:\n\n{{code}}\n\n{{/if}}\n{{/each}}\n\nThe README should include the following sections:\n\n1. Project Title\n2. Brief description (1-2 sentences)\n3. Features\n4. Installation instructions\n5. Usage examples\n6. Configuration options (if applicable) \n7. Contribution guidelines\n8. Testing instructions\n9. License\n10. Acknowledgements/Credits\n\nWrite the content in Markdown format. Use your analysis of the code to generate accurate and helpful content, but also explain things clearly for users who may not be familiar with the implementation details.\n\nFeel free to infer reasonable details if needed, but try to stick to what can be determined from the codebase itself. Let me know if you have any other questions as you're writing!"
},
{
"path": "crates/code2prompt-core/tests/binary_detection_test.rs",
"content": "//! Tests for binary file detection using content_inspector\n\nuse code2prompt_core::configuration::Code2PromptConfig;\nuse code2prompt_core::path::traverse_directory;\nuse std::fs;\nuse tempfile::TempDir;\n\n/// Helper to create a test directory with mixed binary and text files\nfn create_test_directory_with_binary() -> TempDir {\n let temp_dir = TempDir::new().unwrap();\n let base_path = temp_dir.path();\n\n // Create text files\n fs::write(base_path.join(\"text.txt\"), \"This is a text file\").unwrap();\n fs::write(\n base_path.join(\"code.rs\"),\n \"fn main() { println!(\\\"Hello\\\"); }\",\n )\n .unwrap();\n fs::write(base_path.join(\"data.json\"), r#\"{\"key\": \"value\"}\"#).unwrap();\n\n // Create text file with non-UTF8 encoding (GB2312)\n let mut gb2312_data = b\"GB2312 test: \".to_vec();\n // Append \"你好\" encoded in GB2312\n // '你' is 0xC4 0xE3\n // '好' is 0xBA 0xC3\n gb2312_data.extend_from_slice(&[0xC4, 0xE3, 0xBA, 0xC3]);\n fs::write(base_path.join(\"chinese_gb2312.txt\"), gb2312_data).unwrap();\n\n // Create binary files (simulated)\n // PNG header signature\n let mut png_data = vec![0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];\n // Append some zeros and random high bytes to ensure it hits the binary heuristic\n png_data.extend_from_slice(&[0x00, 0x00, 0x00, 0xFF, 0xFE]);\n fs::write(base_path.join(\"image.png\"), png_data).unwrap();\n\n // Random binary data\n let binary_data: Vec = (0..100).map(|i| (i * 7) as u8).collect();\n fs::write(base_path.join(\"binary.bin\"), binary_data).unwrap();\n\n // JPEG header\n let mut jpeg_data = vec![0xFF, 0xD8, 0xFF, 0xE0];\n jpeg_data.extend_from_slice(&[0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00]);\n fs::write(base_path.join(\"photo.jpg\"), jpeg_data).unwrap();\n\n // Compiled object file simulation (ELF header with more data)\n let mut elf_data = vec![0x7F, b'E', b'L', b'F']; // ELF magic\n // Add more binary data to make it clearly binary\n elf_data.extend_from_slice(&[0x02, 0x01, 0x01, 0x00]); // 64-bit, little endian, etc\n elf_data.extend((0..50).map(|i| (i * 13) as u8)); // More binary content\n fs::write(base_path.join(\"compiled.o\"), elf_data).unwrap();\n\n temp_dir\n}\n\n#[test]\nfn test_binary_files_are_skipped() {\n let temp_dir = create_test_directory_with_binary();\n let config = Code2PromptConfig::builder()\n .path(temp_dir.path().to_path_buf())\n .build()\n .unwrap();\n\n let (_, files) = traverse_directory(&config, None).unwrap();\n\n // Should only include text files, not binary files\n let file_paths: Vec = files.iter().map(|f| f.path.clone()).collect();\n\n // Text files should be included\n assert!(file_paths.iter().any(|p| p.contains(\"text.txt\")));\n assert!(file_paths.iter().any(|p| p.contains(\"code.rs\")));\n assert!(file_paths.iter().any(|p| p.contains(\"data.json\")));\n assert!(file_paths.iter().any(|p| p.contains(\"chinese_gb2312.txt\")));\n\n // Binary files should be excluded\n assert!(!file_paths.iter().any(|p| p.contains(\"image.png\")));\n assert!(!file_paths.iter().any(|p| p.contains(\"binary.bin\")));\n assert!(!file_paths.iter().any(|p| p.contains(\"photo.jpg\")));\n assert!(!file_paths.iter().any(|p| p.contains(\"compiled.o\")));\n\n // Should have exactly 3 text files\n assert_eq!(files.len(), 4);\n}\n\n#[test]\nfn test_empty_file_handling() {\n let temp_dir = TempDir::new().unwrap();\n let base_path = temp_dir.path();\n\n // Create an empty file\n fs::write(base_path.join(\"empty.txt\"), \"\").unwrap();\n\n let config = Code2PromptConfig::builder()\n .path(base_path.to_path_buf())\n .build()\n .unwrap();\n\n let (_, files) = traverse_directory(&config, None).unwrap();\n\n // Empty files should be excluded (existing behavior)\n assert_eq!(files.len(), 0);\n}\n\n#[test]\nfn test_small_binary_file() {\n let temp_dir = TempDir::new().unwrap();\n let base_path = temp_dir.path();\n\n // Create a very small binary file (less than 8KB)\n let small_binary: Vec = vec![0x00, 0xFF, 0x00, 0xFF, 0xFE, 0xED];\n fs::write(base_path.join(\"small.bin\"), small_binary).unwrap();\n\n let config = Code2PromptConfig::builder()\n .path(base_path.to_path_buf())\n .build()\n .unwrap();\n\n let (_, files) = traverse_directory(&config, None).unwrap();\n\n // Small binary file should still be detected and excluded\n assert_eq!(files.len(), 0);\n}\n\n#[test]\nfn test_text_file_with_unicode() {\n let temp_dir = TempDir::new().unwrap();\n let base_path = temp_dir.path();\n\n // Create text file with Unicode characters\n fs::write(\n base_path.join(\"unicode.txt\"),\n \"Hello 世界 🌍 Здравствуй мир\",\n )\n .unwrap();\n\n let config = Code2PromptConfig::builder()\n .path(base_path.to_path_buf())\n .build()\n .unwrap();\n\n let (_, files) = traverse_directory(&config, None).unwrap();\n\n // Unicode text should be detected as text and included\n assert_eq!(files.len(), 1);\n let file_path = &files[0].path;\n assert!(file_path.contains(\"unicode.txt\"));\n}\n\n#[test]\nfn test_mixed_directory_structure() {\n let temp_dir = TempDir::new().unwrap();\n let base_path = temp_dir.path();\n\n // Create nested structure with mixed files\n fs::create_dir(base_path.join(\"src\")).unwrap();\n fs::create_dir(base_path.join(\"assets\")).unwrap();\n\n // Text files in src/\n fs::write(base_path.join(\"src/main.rs\"), \"fn main() {}\").unwrap();\n fs::write(base_path.join(\"src/lib.rs\"), \"pub mod test {}\").unwrap();\n\n // Binary files in assets/\n let png_data = vec![0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];\n fs::write(base_path.join(\"assets/logo.png\"), png_data).unwrap();\n\n let config = Code2PromptConfig::builder()\n .path(base_path.to_path_buf())\n .build()\n .unwrap();\n\n let (_, files) = traverse_directory(&config, None).unwrap();\n\n // Should only have 2 text files from src/\n assert_eq!(files.len(), 2);\n\n let file_paths: Vec = files.iter().map(|f| f.path.clone()).collect();\n\n assert!(file_paths.iter().any(|p| p.contains(\"main.rs\")));\n assert!(file_paths.iter().any(|p| p.contains(\"lib.rs\")));\n assert!(!file_paths.iter().any(|p| p.contains(\"logo.png\")));\n}\n\n#[test]\nfn test_large_text_file() {\n let temp_dir = TempDir::new().unwrap();\n let base_path = temp_dir.path();\n\n // Create a large text file (> 8KB) to test that full file is read after sample\n let large_text = \"Lorem ipsum dolor sit amet. \".repeat(1000); // ~28KB\n fs::write(base_path.join(\"large.txt\"), &large_text).unwrap();\n\n let config = Code2PromptConfig::builder()\n .path(base_path.to_path_buf())\n .build()\n .unwrap();\n\n let (_, files) = traverse_directory(&config, None).unwrap();\n\n // Large text file should be detected and included\n assert_eq!(files.len(), 1);\n\n // Verify the entire content was read (not just the sample)\n let code = &files[0].code;\n assert!(code.contains(&large_text));\n}\n\n#[test]\nfn test_pdf_detection() {\n let temp_dir = TempDir::new().unwrap();\n let base_path = temp_dir.path();\n\n // PDF file header\n let pdf_header = b\"%PDF-1.4\\n\";\n fs::write(base_path.join(\"document.pdf\"), pdf_header).unwrap();\n\n let config = Code2PromptConfig::builder()\n .path(base_path.to_path_buf())\n .build()\n .unwrap();\n\n let (_, files) = traverse_directory(&config, None).unwrap();\n\n // PDF should be detected as binary and excluded\n assert_eq!(files.len(), 0);\n}\n\n#[test]\nfn test_various_text_formats() {\n let temp_dir = TempDir::new().unwrap();\n let base_path = temp_dir.path();\n\n // Various text file formats\n fs::write(base_path.join(\"config.yaml\"), \"key: value\\n\").unwrap();\n fs::write(base_path.join(\"data.xml\"), \"