No cloud, no accounts, just a binary and a local database.

Quick workflow:

    tmpo milestone start "Sprint 5"
    tmpo start "fixing auth bug"
    # ... work happens ...
    tmpo pause  # lunch break
    tmpo resume
    tmpo stop
    tmpo stats --week

If you think it is cool or you want to add a feature, feel free to star the repo and open an issue! I would love to have some help from other developers!

You can find the MIT-licensed GitHub repository here: <https://github.com/DylanDevelops/tmpo>

Comments URL: https://news.ycombinator.com/item?id=47427461

Points: 2

# Comments: 2

Quick workflow:

  cd my-project/
  tmpo start "Implementing auth"
  # ... work happens ...
  tmpo pause              # take a break
  tmpo resume             # back to work
  tmpo stop
  tmpo stats --week       # see your hours
  tmpo export --week      # CSV for invoicing

- Automatically detects projects via git repos or .tmporc files

- Pure-Go SQLite storage (modernc.org/sqlite) - no CGO, easy cross-compilation

- Milestone tracking to organize work into sprints/phases

- Pause/resume for break tracking with full audit trail

- Local-first - all data stays on your machine

- Configurable date/time formats and timezone display

- CSV/JSON export for invoicing

Technical highlights:

- UTC timestamps in database with timezone conversion for display

- Migration system for schema evolution

- Currency handling for 30+ currency codes

- GoReleaser for automated cross-platform builds (macOS, Linux, Windows)

- Built with Cobra CLI framework

Started this because I needed something that worked with my git workflow and didn't require cloud accounts or subscriptions. Happy to answer questions about the architecture or design decisions.

MIT licensed: <https://github.com/DylanDevelops/tmpo>

Comments URL: https://news.ycombinator.com/item?id=46888908

Points: 2

# Comments: 0

Key technical decisions:

- Pure Go implementation with modernc.org/sqlite (no CGO, easier cross-compilation)

- Auto-detection via git rev-parse for project names

- Local SQLite database in ~/.tmpo/ (nothing leaves your machine)

- Single binary, zero dependencies

New features since I started:

- Milestone tracking - organize entries into sprints/releases with auto-tagging

- Pause/resume workflow for context switching

- Manual entry creation for forgotten time

- Configurable date/time formats and currency (stored in global config)

- Edit/delete entries

Example workflow:

```bash cd ~/projects/client-website

tmpo milestone start "Sprint 5"

tmpo start "Fix auth bug"

# ... work ...

tmpo pause # lunch break

tmpo resume

tmpo stop

tmpo stats --week

tmpo export --milestone "Sprint 5" --format csv ```

It detects "client-website" from git and tags everything with the active milestone automatically.

The codebase is ~6k LOC. Working on the Homebrew formula, but pre-built binaries are now available.

GitHub: <https://github.com/DylanDevelops/tmpo>

Questions for you all:

1. Are there any features that you want to see in tmpo?

2. Currently using a 3-tier config priority (.tmporc > git > directory). Better approaches?

3. Any concerns with the milestone auto-tagging approach?

Comments URL: https://news.ycombinator.com/item?id=46438040

Points: 2

# Comments: 0

I'm thrilled that the Unix-y approach resonates with you, as that is exactly what I am aiming for!

And yes, you have hit the main tradeoff that I have and am currently struggling with. The auto-detection works great for "I'm in X project, working on X," but it doesn't work well for the exact cases you mentioned.

Right now, this is how I handle these types of scenarios:

1. Context switches in the same repo: I use the description field to differentiate: `tmpo start "Refactoring auth module"` `tmpo start "Fixing CSS bugs"`

    This has the same project name but with different descriptions. When you export for invoicing or just personal statistics, you can see this breakdown.

    Or I just run `tmpo start "Team standup"` from wherever I am and let it tag to whatever directory I'm in. This is obviously a bit janky.

A feature I am also working on currently is a category/phase system that can significantly improve tagging time entries.

What is your current workflow? Do you switch contexts within the same repo often, or is the non-directory work the bigger pain point?

I was tracking billable hours using Google Forms (yes, really). Every time I switched tasks, I had to manually fill out the project name, start time, end time, and description. After forgetting to log hours several times and losing money, I decided there had to be a better way.

tmpo is a CLI time tracker that gets out of your way:

- Automatically detects project names from git repos or .tmporc config files - All data stored locally in SQLite (no cloud, no login) - Simple commands: tmpo start, tmpo stop, tmpo stats - Export to CSV/JSON for invoicing - Cross-platform (macOS, Linux, Windows)

Built with Go for speed and easy cross-compilation. The entire project consists of ~5k lines of code.

Example workflow: cd ~/projects/client-website tmpo start "Fixing authentication bug" # ... work happens ... tmpo stop tmpo stats --today

It detects "client-website" from the git repo and logs everything locally.

The thing I'm most proud of: zero configuration required. It just works. But if you need per-project hourly rates for billing, you can add a .tmporc file.

GitHub: <https://github.com/DylanDevelops/tmpo>

I'm working on getting it on Homebrew, but you can also install it via pre-built binaries or build it from source.

Would love feedback on: 1. What features would make this actually useful for you? 2. Is the auto-detection too "magical" or is it helpful? 3. Any concerns about the approach?

Thanks for reading!

Comments URL: https://news.ycombinator.com/item?id=46346549

Points: 1

# Comments: 2