Toolipie: Turning Scattered Scripts into a Swiss-army Knife
The problem was not that I lacked tools. It was that every useful script disappeared after solving one problem.
Toolipie is my local-first toolbox for turning one-off snippets into reusable, private, and consistent utilities.
TL;DR
Toolipie is where my throwaway scripts stop being throwaway.
For a long time, my coding life was full of small scripts: scrapers, file renamers, PDF converters, CSV cleaners, OCR helpers, and research utilities. Each one solved a real problem, but most of them vanished into a project folder after one use.
Toolipie is my answer to that chaos. It is a local-first toolbox with a consistent CLI, a small TUI, and a plugin structure that turns useful snippets into tools I can find, trust, reuse, and keep improving.
The open-source CLI/TUI is already usable. The longer-term direction is a small ecosystem of local tools: optional AI-generated plugins, MCP integration, and a registry where useful tiny tools can be shared without giving up privacy or control.
Script Sprawl
The mess was not a lack of tools. It was too many tools without a system.
The more I built, the more one-off scripts accumulated across projects, devices, downloads, and forgotten folders.
Some scripts were scrapers I wrote in five minutes to extract information for a dataset. Some were renamers to fix messy file structures. Others converted PDFs, cleaned CSVs, summarized research material, or processed OCR output.
They all did their job once, and then disappeared. Months later, I would remember writing something similar, fail to find it, and rewrite it from scratch. That was not just inefficient. It was chaotic.
Script chaos
- Tools lived in random project folders, Downloads, and half-forgotten directories.
- Every script had its own argument style, logging pattern, and assumptions.
- AI made the problem bigger by making new utilities easier to generate than organize.
Online tool friction
- Many free converters and OCR tools are wrappers around libraries I could run locally.
- They often come with ads, upload delays, resolution limits, or batch restrictions.
- They require sending potentially sensitive files to random servers, which never felt right.
The Toolipie Bet
If a small script is useful once, it is probably useful ten more times.
The core idea is simple: give every useful snippet a permanent, reusable place instead of letting it disappear after one task.
I wanted something that felt like a Swiss-army knife for code snippets. Not an IDE, not a framework, not a large application. Just a structured toolbox that made small tools easy to keep and easy to run.
That meant a consistent CLI, a small TUI, predictable input/output patterns, logs, metadata, and a way to drop in a script and immediately turn it into a reusable plugin.
Toolipie grew around five principles: clean structure, extensibility, reusability, consistency, and local control. Every tool gets a defined home, every plugin has a manifest, and everything follows the same basic format.
How It Works
Toolipie is small on purpose: one core, many focused plugins.
The point is not to make every tool complex. The point is to make every small tool easier to find, run, and maintain.
- Core
-
Shared base
The core includes the CLI, the TUI, the plugin loader, and shared utilities for file paths, logging, and consistent execution.
- Plugins
-
Reusable units
Each plugin lives in its own folder with a manifest describing commands, parameters, expected inputs, and outputs.
- Tools
-
Consistent behavior
Some tools convert files, some run OCR, some enrich contact lists, and some clean data columns. The important part is that they feel like one ecosystem.
Why Local Matters
The real value is not just convenience. It is workflow control.
Toolipie matters to me because it replaces scattered scripts and unreliable online utilities with a local system I can adapt to my own work.
My needs are specific: enriching large contact lists, summarizing datasets for WED, bulk-processing OCR outputs, cleaning scraped data, and converting files in batches. These are not generic tasks, and no random online tool can truly solve them.
Toolipie makes those small tasks permanent. It saves time across projects, reduces the friction of creating new tools, and turns code chaos into order.
-
01
Find or add a plugin
The tool has a stable place instead of living inside a random project folder.
-
02
Run it locally
Files stay on my machine, and the command follows the same conventions as the rest of the toolbox.
-
03
Improve it once
The next time I need it, the improvement is already part of the system.
AI's Real Role
AI belongs around Toolipie, not at the center of it.
Toolipie is not an AI product. AI helped build it and may help generate tools later, but the toolbox remains local-first and usable without AI.
AI-assisted coding helped me build the early scaffolding: the CLI, the TUI, the plugin loader, and the first structure. That accelerated development, but it did not change the nature of the product.
The more interesting long-term idea is that users might eventually describe a task in plain language, let AI generate a minimal snippet, and have Toolipie register it as a plugin. The tool would then become permanent instead of remaining a one-off chat result.
- Scaffolding
-
Build acceleration
AI helped create the early project structure and speed up implementation, especially where the requirements were clear.
- Generated tools
-
Optional future
A user could describe a file-renaming, extraction, cleaning, or conversion task, then turn the generated snippet into a reusable plugin.
- MCP
-
Local automation
MCP would let AI call Toolipie tools like local utilities, with permission, without sending private files anywhere.
What Comes Next
Toolipie should grow one small tool at a time.
The roadmap is not about becoming a giant platform overnight. It is about making the toolbox easier to extend, share, and use.
-
01
Smoother creation
More plugin scaffolds, better defaults, and a smoother TUI so adding a new tool feels natural.
-
02
A tiny-tool registry
A small marketplace or registry where people can share reusable local tools without forcing cloud accounts or storage.
-
03
More real workflows
OCR, web scraping, PDF extraction, text processing, data cleanup, and the other repetitive tasks that show up in actual work.
Final thought
Toolipie started as cleanup. It became a way to make small work compound.
I am turning years of scattered scripts into a reliable, local-first Swiss-army knife. The value is not only that I can run tools faster. It is that every small utility now has somewhere to live and improve.
If you have your own pile of half-forgotten scripts, the question is not whether you need Toolipie specifically. The question is what form those useful little tools should have one year from now.