# eureka: capture an idea from the terminal and push it to a private git repo

> eureka is a small Rust command line tool that opens your editor, appends an idea to a markdown file in a git repository you own, and commits and pushes it, so that a thought can be captured in seconds from wherever you are working. It is deliberately thin, it depends on git2 and clap, and its newest tagged release is from 2021.

**simeg/eureka** — 💡 CLI tool to input and store your ideas without leaving the terminal

- Repository: https://github.com/simeg/eureka
- Stars: 886 · Forks: 43
- Language: Rust
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/simeg-eureka

## The problem: an idea that arrives while you are doing something else

The gap this tool fills is small and specific. You are working on something, an idea arrives, and if capturing it takes more than a few seconds it will not happen. A notes application is too much ceremony for that moment, and a text file in a directory is not somewhere you will look again.

eureka is a CLI tool that allows you to quickly write down an idea using your preferred editor, and then have the idea committed and pushed to your idea git repository. The description in the project is a CLI tool to input and store your ideas without leaving the terminal, and the scenario is stated plainly: imagine working on something important and then having an idea, and instead of letting your idea slip by you you can just type eureka and you are able to quickly store the idea and then continue working.

That last phrase is the design constraint that shapes everything else. The tool does not have a rich interface, it does not tag, search or organise, and it does not have a database. It has one job and it does it in the way a terminal user expects: it opens the editor you already use, it appends to a file, and it does the git work for you.

The audience is a developer with a personal notes habit and a git workflow, who wants their ideas to be under version control and, if they want them private, in a private repository. The licence is MIT, the language is Rust, the default branch is master, and the last push was on 2026-08-28.

## The mechanism: an editor, a markdown file and a git push

The implementation is short enough to describe in three steps, and that is the appeal.

First, the tool opens your editor with the ideas file. Which editor is decided by looking at your environment variables: $EDITOR for what to edit your ideas with, falling back to vi, and $PAGER for what to view your ideas with, falling back to less. So the tool inherits your existing muscle memory rather than asking you to configure anything.

Second, the idea is written into a markdown file at the root of your ideas repository. The requirement is specific: eureka requires a git repository with a markdown file in the root folder, and the default is README.md. By default this is the README.md file, which is the default structure when you create an empty repository with a readme on GitHub, and you can customise the filename during setup. The documentation also points out the obvious consequence: since it is your own repository you can make it private to keep your ideas secret.

Third, the file is committed and pushed. After the setup, simply run eureka to capture an idea, and it will then be committed and pushed to the origin remote and the main branch.

The git work is done through the git2 crate rather than by shelling out to a git binary, which is why the dependency list is short and self-contained. The manifest shows clap with the cargo feature for the command line, dirs for locating the configuration directory, git2, termcolor for the output colouring, which for finding the editor binary, log and pretty_env_logger for logging, and serde with serde_json for the configuration file.

The consequence of the design is that your ideas are a text file in a git history, which means you get diffs, branches and backups for free, and you get no structure, no search and no linking beyond what markdown gives you.

## Setup: the repository, the filename, and where the configuration lands

The first run is a conversation, and it asks for exactly two things: the path to your ideas repository and the filename to use, defaulting to README.md if left blank.

That configuration is then stored in your XDG Base Directory if found, otherwise in $HOME/.config/eureka. The dirs crate in the dependency list is what implements that lookup, and the fallback is what makes the tool work on a machine without an XDG configuration.

The setup is worth doing properly the first time, because the tool needs the repository to exist already. The documentation describes the shape it expects: a git repository with a markdown file in the root folder. The natural way to get that is to create an empty repository with a readme on GitHub, which gives both the repository and the README.md, and then to mark it private if the ideas are to stay private.

The one behaviour here that deserves a note is the push target. After setup, a capture is committed and pushed to the origin remote and the main branch. That is not configurable in the flags, so if your workflow expects a different branch, or expects ideas to stay uncommitted until you have reviewed them, the tool does not fit that workflow as written.

The other edge is that the first run and every later run share the same configuration file, which is why there is a flag to clear it.

## Two flags, and the alias everybody ends up using

The whole command line surface is two flags:

```sh
    --clear-config    Clear your stored configuration
-v, --view            View ideas with your $PAGER env variable. If unset use less
```

The view flag is the read side of the tool, and it reuses the $PAGER convention so that paging, searching and quitting work the way they do everywhere else in a terminal.

The second half of the documentation is a recommendation that is really a usability decision. An easy to remember alias for eureka is the word idea, which makes it easy to remember to use eureka to store your ideas, and the recommended aliases are the same line in three shells:

```sh
echo 'alias idea="eureka"' >> ~/.zshrc
```

```sh
echo 'alias idea="eureka"' >> ~/.bashrc
```

```sh
echo 'alias idea="eureka"' >> ~/.config/fish/config.fish
```

That choice of word is the point of the whole tool. The name of a command that you type under pressure has to be one you can reach for, and a two-syllable word that means the thing you are trying to do beats a product name. It is also why the tool is called eureka at all.

The improvements section points at the issue tracker, which is the honest way for a project of this size to handle the request for more features, and the repository has a CHANGELOG.md, a Makefile and a codecov configuration alongside the src/ and tests/ directories.

## The build: cargo, clippy, and tests that run one at a time

The Makefile is a good description of the project's engineering habits, and it is a conventional Rust one.

The targets are check, ci, clippy, fmt, install, lint, publish, release and test. The ci target is lint, clippy, check and test in that order, so a single make invocation runs the whole thing. The release target builds with cargo build --release, and the install target copies the built binary into /usr/local/bin under the name eureka:

```bash
	@cp ./target/release/$(BIN_NAME) /usr/local/bin/$(BIN_NAME)
```

The test target is the one with a detail worth noting:

```bash
	@$(CARGO) test -- --nocapture --test-threads=1
```

The test threads are pinned to one and the output is not captured. Both choices point at the same thing: the tests touch a real git repository and a real configuration file, so running them in parallel would have them fighting over the same working tree, and the nocapture flag is there so that a failure prints the state of the repository it was operating on. The dev dependencies support that reading, with serial_test and tempfile.

The clippy target is run with --fix, and the lint target runs cargo fmt in check mode, so the formatting gate is the same command as the formatter, just without the write. The package itself is edition 2021, and the manifest excludes assets, tests and scripts from the published crate.

## Maintenance, the version gap, and where eureka is the wrong tool

The licence is MIT, stated in the package metadata and carried by the LICENSE file at the root, and for a tool whose whole function is to write into your own repository the licensing is a non-issue.

The maintenance picture is the interesting part. The published releases are v2.0.0 from 2022-04-10, v1.8.1 from 2020-11-07 and v1.7.0 from 2020-06-09, while the package metadata in the tree says version 2.1.0. The last push was on 2026-08-28, so work has happened since the last tag, but the newest artefact you can install from crates.io is more than four years old, and the manifest version is not a release.

That does not make the tool unusable. It is a small program with a small dependency set, the behaviour is fully described in the documentation, and the code is easy to read. But a reader should know that they are installing something whose released behaviour has been frozen since 2021, and that the fixes in the tree since then are not necessarily packaged.

Where eureka is the wrong tool is about the data model rather than the code. If you want to search your ideas, link them, tag them, sort them, or have more than one person add to them, a markdown file in a git repository is the wrong structure and this tool will not grow into something else. If you need the ideas to leave your machine, a private git repository that only you can push to is the wrong target. And if your editor is a terminal multiplexer or a GUI editor that needs a running server, the $EDITOR convention is the one place the tool assumes a fairly simple setup.

Within that envelope it does one thing, and the documentation, the alias recommendation and the dependency list are all evidence that the author intended it to stay that way.

## Conclusion

Adopt eureka if you want an idea capture that takes two seconds, keeps the ideas in a git repository you control, and never asks you to leave the terminal, and if you are happy to live with a tool whose last tagged release is from April 2021. Do not adopt it if you need search, tagging, structure or any kind of query over your notes, because a markdown file in a git repository is the entire data model. Before you install, create the repository and the readme first, since the setup asks for both, and check that the tool's push to the main branch fits your workflow, because that is hard coded rather than configurable.

## FAQ

### What does eureka do with my ideas?

It opens your editor with the ideas file, appends what you write, then commits and pushes the change to the origin remote and the main branch of your ideas repository. The file is a markdown file in the root of that repository, README.md by default.

### What setup does eureka need?

A git repository with a markdown file in the root folder, README.md by default, with the filename customisable during setup. The configuration, the repository path and the filename, is stored in your XDG Base Directory if there is one and otherwise in $HOME/.config/eureka.

### How do I install eureka?

With Homebrew, brew install eureka, or with cargo, cargo install eureka. The project states that the Rust stable version will always be supported, and the Makefile also has an install target that copies the built release binary into /usr/local/bin.

### Which environment variables does eureka use?

It looks at your environment variables to decide what program to use: $EDITOR for editing ideas, falling back to vi, and $PAGER for viewing them, falling back to less. The --view flag uses the pager, and --clear-config clears the stored configuration.

### Is eureka still maintained?

The repository is not archived and the last push was on 2026-08-28, but the published releases stop at v2.0.0 from 2022-04-10, while the package metadata in the tree says version 2.1.0. So the released artefact is several years old even though work continues in the tree.

## Sources

- [Issues](https://github.com/simeg/eureka/issues)
- [License: MIT](https://github.com/simeg/eureka/blob/master/LICENSE)
- [README](https://github.com/simeg/eureka/blob/master/README.md)
- [Releases](https://github.com/simeg/eureka/releases)
- [simeg/eureka on GitHub](https://github.com/simeg/eureka)

---

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