# Code2Prompt: Turn a Repository into an LLM Prompt from the Command Line

> Code2Prompt is a Python CLI that renders a codebase into a Markdown prompt using Jinja2 templates, with token counting and gitignore awareness. It is convenient for one-shot context building and awkward when you need incremental or auditable context.

**raphaelmansuy/code2prompt** — Code2Prompt is a powerful command-line tool that simplifies the process of providing context to Large Language Models (LLMs) by generating a comprehensive Markdown file containing the content of your codebase. ⭐ If you find Code2Prompt useful, consider giving us a star on GitHub! It helps us reach more developers and improve the tool. ⭐ 

- Repository: https://github.com/raphaelmansuy/code2prompt
- Stars: 884 · Forks: 57
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/raphaelmansuy-code2prompt

## What Code2Prompt is for, and who actually needs it

Pasting files into a chat window works until a project has more than a handful of them. Code2Prompt exists for the point where you want the model to see structure as well as content: it walks a path, produces a source tree, and concatenates file contents into one Markdown document. The README frames the goal as giving an LLM "a comprehensive view of your project for more accurate suggestions and analysis."

The audience is narrow but real. Someone asking a model to review a module they have never seen benefits from the tree plus the files. Someone generating documentation from a small library benefits from a stable, repeatable output file they can diff. Someone who only needs to ask about a single function does not need this tool at all, and the README's own first example, a single Python file passed with --path, is barely more than cat.

The project is a Python package published as version 0.9.0 under the MIT licence, with pyproject.toml declaring Development Status 4 - Beta. The last push to the repository was on 2026-07-07, so treat it as a maintained but small tool rather than a platform.

## How the pipeline works: paths in, templated Markdown out

The mechanism is a straight line. You pass one or more --path values. The tool enumerates the files under them, applies .gitignore rules plus any --exclude globs, and hands the surviving set to a Jinja2 template. The template renders the source tree and the file contents into Markdown, and the result goes to stdout, to a file via --output, or to the clipboard.

Two details matter more than the feature list suggests. First, token counting uses tiktoken, and the README describes counting and optimizing tokens "to ensure compatibility with various LLM token limits." That is a measurement, not a guarantee: the count reflects one tokenizer, and a different model will tokenize the same text differently. Second, the templating layer is genuinely open. The package ships templates under code2prompt/templates, and pyproject.toml includes that directory in the distribution, so you can read and replace what the tool renders rather than accepting a fixed format.

File selection is the part people underestimate. There is no semantic filter and no ranking. If your .gitignore is sloppy, generated files, lockfiles and vendored dependencies go straight into the prompt and eat the budget.

## Installing Code2Prompt with pip or pipx

The README gives two installation routes. The plain pip install puts the package in the current environment; the pipx route installs it as an isolated command, which the README marks as recommended.

```bash
pip install code2prompt
```

```bash
pipx install code2prompt
```

Either way you get a code2prompt command, wired through the [tool.poetry.scripts] entry that points at code2prompt.main:cli. The package requires Python 3.8 or newer and pulls in click, jinja2, tiktoken, rich, pyperclip and pydantic, so the install is not trivial in size. After installing, confirm the command resolves before pointing it at anything large.

```bash
code2prompt --path /path/to/your/script.py
```

The README's getting-started example runs the tool against a single file, which is the smallest useful check that the command is on your PATH and the template renders.

## A first real run: one directory, one output file

Start with a project small enough to read the whole output. The README's second quick-start example processes a directory and writes the result to a file.

```bash
code2prompt --path /path/to/your/project --output project_summary.md
```

Open project_summary.md and check three things before sending it anywhere: that the source tree matches what you expect, that no build artefacts or secrets are inlined, and roughly how long the document is. If it is far longer than your model's context window, narrow the input rather than truncating the file by hand.

Excluding directories is done with glob patterns. The README's third example passes two source paths and drops tests.

```bash
code2prompt --path /path/to/src --path /path/to/lib --exclude "*/tests/*" --output codebase_summary.md
```

For extensions the tool does not recognise, --syntax-map pairs an extension with a syntax name, given as extension:syntax and comma-separated.

```bash
code2prompt --path /path/to/your/code --syntax-map "inc:bash,customext:python,ext2:javascript"
```

That last flag is the one worth testing early, because a mis-mapped extension changes how the fenced block is labelled in the output, and the model reads those labels.

## Where Code2Prompt gets in your way

The output is a snapshot. Every run regenerates the whole document, so a repository that changes often means regenerating and re-sending everything, and there is no documented incremental mode, no caching layer, and no change detection in the README. For a monorepo that is a real cost, not a rounding error.

Selection is also entirely your responsibility. There is no relevance ranking, no symbol extraction, and no way to ask for "the files that touch this function." The tool respects .gitignore and your globs, and that is the whole filter. A repository with a weak .gitignore produces a weak prompt.

Finally, the README is silent on several things a production user would ask about: there is no documented rollback or version pinning guidance for template changes, no discussion of how secrets should be scrubbed before generation, and no statement about what happens on very large trees beyond token counting. The README does describe a Troubleshooting section, but the documentation does not detail its contents. Treat those as gaps to close yourself, not as features.

## Code2Prompt compared with repomix

The obvious comparison is repomix, which people search for alongside this tool. Both take a repository and emit a single document intended for an LLM, and both are command-line tools that pack file contents together. The difference is in the packaging and the extension points.

Code2Prompt is a Python package with a Jinja2 templating layer you can replace, plus a token count via tiktoken. If your workflow already lives in Python and you want to control the exact prompt shape, including input variables and template imports, that layer is the reason to pick it. Repomix is a Node.js tool, so adopting it means a second runtime in an otherwise Python environment, and its output format is the one it ships rather than one you author.

Neither tool decides what is relevant. If what you actually want is retrieval over a large codebase rather than a full dump, this is the wrong category of tool, and the right answer is an indexing or search layer in front of the model.

## Licence, maintenance and the cost of upgrading

The project is MIT licensed, declared in pyproject.toml and repeated in the README badge. MIT is permissive: you can use it commercially, modify it and redistribute it, provided the copyright notice and licence text travel with it. That is a description of the licence terms, not legal advice, and if you are embedding the tool in a product you should read LICENCE.md in the repository yourself.

The dependency set is the real upgrade surface. click, jinja2, tiktoken, pydantic, rich, pyperclip, colorama, tqdm, tabulate, prompt-toolkit and colorlog are all pinned with caret ranges, which means a fresh install can resolve to newer minor versions than the ones the author tested. tiktoken in particular ships tokenizer data that changes over time, so a token count you recorded months ago may not reproduce exactly today.

Upgrade cost is mostly template compatibility. If you have customised a template and the bundled templates change shape, your output changes silently. The version is 0.9.0 and the classifier says Beta, so pin the version in your environment and diff the generated Markdown after any bump rather than assuming the output is stable.

## Conclusion

Adopt Code2Prompt if you want a single Markdown file that describes a repository and you are comfortable editing Jinja2 templates to shape it. Do not adopt it if you need incremental context updates, a server, or a tool that decides which files matter; it renders what your globs and .gitignore allow, nothing more. Before relying on it, verify the token count against your model's real limit, check that your .gitignore excludes build output and vendored code, and read the bundled templates under code2prompt/templates to confirm the placeholders match what you intend to send.

## FAQ

### How do I use Code2Prompt on a project directory?

Pass the directory with --path and, if you want a file rather than console output, add --output with a filename. The README's quick-start example is code2prompt --path /path/to/your/project --output project_summary.md, which produces a Markdown document containing the source tree and file contents.

### Does Code2Prompt have a VS Code extension?

The README describes Code2Prompt as a command-line tool installed through pip or pipx, and the repository layout shows no VS Code extension package. There is a .vscode/ directory in the repository, but that is editor configuration for the project itself, not a published extension.

### What is an example of a prompt Code2Prompt generates?

The README's quick-start examples show the shape: a single file with code2prompt --path /path/to/your/script.py, or a whole directory written to project_summary.md. The output is a Markdown document containing a source tree and the file contents, rendered through a Jinja2 template.

## Sources

- [Issues](https://github.com/raphaelmansuy/code2prompt/issues)
- [License: MIT](https://github.com/raphaelmansuy/code2prompt/blob/master/LICENSE)
- [raphaelmansuy/code2prompt on GitHub](https://github.com/raphaelmansuy/code2prompt)
- [README](https://github.com/raphaelmansuy/code2prompt/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/raphaelmansuy-code2prompt