# Flattenify: The Ultimate CLI Tool to Flatten Your Codebase for Reviews, AI Analysis, and Documentation

You’re knee-deep in a project, and someone asks for a quick code review. Or maybe you need to share a snippet with an AI model like Grok or ChatGPT for some quick analysis. Sounds simple, right? But then you realize: your code is scattered across dozens of files, buried in directories, and tangled with imports. Manually copying and pasting each piece while keeping the context intact? That’s a nightmare. And don’t even get me started on the time wasted reformatting it all into something readable.

If you’ve ever faced this, you’re not alone. Developers waste hours every week just trying to consolidate code for sharing, documentation, or debugging. It’s tedious, error-prone, and—let’s be honest—mind-numbingly boring. But what if there was a better way? A way to flatten your entire codebase (or just the parts you need) into a single, organized file with descriptive paths, all with a few simple commands?

That’s where `flattenify` comes in. It’s a CLI tool designed to save you from this chaos, and it’s built specifically for Python and JavaScript projects on Unix/Linux. Whether you’re prepping code for a review, generating documentation, or feeding it to an AI for insights, `flattenify` automates the heavy lifting so you can focus on what matters.

---

## Why This Tool Matters *Now*

In 2025, development workflows are more distributed and collaborative than ever. Teams are spread across time zones, AI-assisted coding is the norm, and documentation needs to be machine-readable as much as human-readable. Yet, most tools still assume you’re working in isolation, manually managing your codebase.

`flattenify` flips that script. It’s not just about consolidating files—it’s about making your code *portable* and *shareable* in seconds. Need to send a colleague a quick overview of your project? Done. Want to feed your codebase to an AI model for optimization suggestions? Easy. Trying to generate a single markdown file for project documentation? You’ll have it in a snap.

And here’s the kicker: it’s not a one-trick pony. With support for auto-detection of files and directories, wildcard patterns, and even one-depth import inclusion, `flattenify` adapts to *your* workflow, not the other way around.

---

## Interactive Demo: See It in Action

Let’s cut to the chase. You’re a developer—you want to see it work. Here are three quick commands to get you started. Copy, paste, and watch the magic happen.

### 1\. Flatten a Single File

```bash
flatten ./src/components/Button.tsx
```

**Output:**  
A neatly formatted file in `.flatten/output/` with the content of `Button.tsx`, prefixed by its path for context.

### 2\. Flatten a Directory Recursively

```bash
flatten ./src/ --recursive -o project.md
```

**Output:**  
A single markdown file (`project.md`) containing all supported files from `./src/` and its subdirectories, each sectioned by file path.

### 3\. Flatten with Imports

```bash
flatten ./src/index.js --with-imports
```

**Output:**  
The content of `index.js` plus any directly imported files, all in one place.

### Try This: Trim a 5-Step Workflow to 2 Commands

Here’s a challenge: Normally, to share a file and its dependencies, you’d have to manually track down each import, copy the files, and paste them together. With `flattenify`, it’s two steps:

1. Run `flatten ./src/index.js --with-imports -o shared_code.txt`
    
2. Share `shared_code.txt`
    

That’s it. No more hunting through directories or worrying about missing dependencies.

---

## Under the Hood: Clever Tech for Real Speed

You might be wondering, “How does it handle large codebases without choking?” Great question. `flattenify` uses Python’s `multiprocessing` to process files in parallel, making it blazing fast even for big projects. Plus, it’s built with a plugin system, so if you need custom import parsing (say, for a niche language or framework), you can extend it without touching the core code.

Here’s a peek at the code that makes this possible:

```python
pool = mp.Pool(mp.cpu_count())
results = []
with tqdm.tqdm(total=len(valid_files), desc="Flattening files", unit="file") as pbar:
    for result in pool.imap_unordered(process_file, args):
        results.extend(result)
        pbar.update(1)
```

It’s efficient, it’s scalable, and it’s designed to handle the messiest of codebases.

---

## Future-Proof: Ready for 2025 and Beyond

As we move deeper into 2025, trends like AIOps and edge development are reshaping how we build and deploy software. `flattenify` is ready for that future. Its modular design and plugin architecture mean it can evolve with new languages, frameworks, and workflows. Plus, with output formats like JSON, it’s already primed for integration with AI-driven tools and automated documentation pipelines.

Imagine a world where your codebase is always ready for AI analysis, or where documentation updates itself with a single command. That’s the direction we’re heading, and `flattenify` is a step toward that reality.

---

## The Tradeoff: What It Doesn’t Do (Yet)

No tool is perfect, and `flattenify` is no exception. Right now, it’s focused on Unix/Linux environments, so Windows support isn’t there yet. But don’t worry—the roadmap includes cross-platform compatibility, and we’re actively working on it. In the meantime, if you’re on Windows, you can use WSL (Windows Subsystem for Linux) as a workaround.

Another thing to note: while it handles one-depth imports beautifully, multi-depth dependency inclusion is still in the works. For most use cases, one-depth is plenty, but if you need more, stay tuned for future releases.

---

## The Story Behind the Tool

I’ll be honest: `flattenify` was born out of frustration. One night, after a 3 AM outage caused by a typo in a bash script (we’ve all been there), I realized I needed a better way to share and review code. Manually consolidating files was eating up too much time, and the existing tools just didn’t cut it. So, I built `flattenify` to solve that problem—not just for me, but for every developer who’s ever felt that pain.

It’s not just a tool; it’s a time-saver, a sanity-preserver, and—dare I say—a bit of a lifesaver when the clock is ticking.

---

## Your Call to Action

You’ve seen the demo, peeked under the hood, and know why *flattenify* matters. Now it’s time to join the journey and make it even better. Here’s how you can dive in:

- **Try It Out**: Install *flattenify* and take it for a spin! It’s as easy as:
  ```bash
  pip install flattenify
  flattenify examples
  ```
  Check out our [Cheat Sheet](#) (link coming soon) for a quick reference to all commands and options.

- **Contribute to the Project**: *flattenify* is open-source, and we’re excited to welcome contributions! Whether it’s fixing a bug, adding a feature, or improving docs, your input is invaluable. Here’s how to get started:
  - Fork the repo on [GitHub](https://github.com/devshittu/flattenify).
  - Make your changes, create a pull request (PR), and we’ll review and merge.
  - Not sure where to begin? Check our [Contributing Guide](https://github.com/devshittu/flattenify/CONTRIBUTING.md) (link coming soon) or browse open issues for inspiration.

- **Extend with Custom Parsers**: Right now, *flattenify* supports Python, JavaScript, and TypeScript, with some limitations for TypeScript and Python parsing. Want to add support for Java, Rust, Go, or another language? Write a custom parser and contribute it! 

- **Platform Note**: *flattenify* currently runs on Linux and macOS. Windows support is on the roadmap, but we need your help to make it happen. If you’re a Windows expert, jump in and contribute!

- **Share Feedback**: Love *flattenify*? Run into a bug? Have a feature idea? Let us know:
  - **Open a GitHub Issue**: Report bugs or suggest features at [GitHub Issues](https://github.com/devshittu/flattenify/issues).
  - **Start a Discussion**: Share ideas or ask questions in [GitHub Discussions](https://github.com/devshittu/flattenify/discussions).
  - **Post on Stack Overflow**: Tag your question with `flattenify` for community help.
  - Your feedback shapes *flattenify*’s future, so don’t hold back!

- **Star the Repo**: If *flattenify* saves you time or sparks joy, give us a star on [GitHub](https://github.com/devshittu/flattenify) to show your support.

The next time you’re drowning in codebase chaos, *flattenify* has your back. Join our community, try it today, and help us build a tool that makes every developer’s life easier. Let’s flatten the chaos together!