Hey r/CLI ,

As developers, we spend way too much time staring at raw log streams and debugging server crashes. I built SmartLog TUI to turn log inspection into a fast, interactive terminal dashboard.

It streams your logs in real-time, calculates anomaly rates, and lets you hit 'a' on any error to get an AI-powered root-cause summary and fix commands.

It's built with Python/Textual, features an open-core model with lifetime Pro licensing via Lemon Squeezy, and supports local Ollama models for privacy.

Check out the GitHub repo: GitHub Link

Would love your feedback on the UX and feature set!

Meet HelixBox, your full development environment in your pocket.

Pair your laptop CLI with a QR code, open the workspace on your phone, inspect files, logs and Git, and run AI-assisted agent sessions from anywhere. Workspace controls are free. Agent access uses Algorand x402: $0.25 for 1 hour or $2 for 7 days via Pera Wallet. Build, run, and ship from anywhere.

[https://helix-box.vercel.app/\](https://helix-box.vercel.app/)

Open source https://github.com/dele-to/cli to share secrets securely (via https://dele.to/ API)

Everything is encrypted locally, only encrypted payload is sent via API.

Can be also used to pipe content from other process / envs like

echo $API_KEY | deleto

to get started

curl -fsSL https://dele.to/install.sh | sh

https://reddit.com/link/1w4obdy/video/0jgfqy9exymh1/player

Text utilities for the terminal. Everything the online text tool sites do, done locally: your text never leaves the machine, there is no network call, and there is nothing to paste into a web form.

143 operations across 10 categories, each usable as an argument, over a pipe, or from an interactive interface.

Repo: https://github.com/kannamma-labs/cie
Install: `pip install "cie-mcp[mcp]"`, then `cie index .` from inside
any project. That's the whole setup.

One maintainer, weeks-old alpha, generation-scale problem. If that
combination excites you rather than scares you off then lets build

(This post was first shared in [r/commandline](r/commandline).)

I built this because I kept rebuilding my setup from scratch and got tired of manually reinstalling packages and hunting down files every time. It started as a small script and grew into something I figured it was worth of sharing to everyone.

What it does:

Backs up the user´s installed packages, AUR packages, and Flatpak apps, in the right format for whichever package manager the user is using. It lets the user interactively pick which config files/folders to include (via a gum powered TUI) and restores everything in the same place on a fresh install even on a different distro.

Supports Arch, Debian/Ubuntu, Fedora, and openSUSE, with best-effort package name translation between them.

The user´s backup data lives in their own private repository, completely separate from the tool's one, so the tool itself stays fully public/shareable without exposing anything personal.

Some things I cared about while building it:

If you select `~/.ssh` or `~/.gnupg`, it warns you and lets you review exactly which files go in, rather than blindly sweeping the whole directory . Git only tracks the executable permission bit, not full file modes so it explicitly resets SSH/GPG key permissions back to their correct values on restore, and shows you the exact commands before running them. And so on.

Honest caveats:

It's a young project, I'm the only person who's stress-tested it so far (including on some fresh VM installs), and cross-distro package name translation is inherently best-effort. Distros don't agree on package names, so some things need manual installing after a cross-distro restore. I've documented that limitation rather than pretend it's solved.

Anyway here´s the tool link:
https://github.com/lumertya/Nomad

Would genuinely appreciate feedback, bug reports, or just someone else trying it on a distro I haven't tested yet. Thank you.

I recently added a lightweight terminal client for my communicator.

It is written in pure Python and uses only the standard library. It connects to the same websocket backend as the web client.

Features include:
- Direct messages
- Friends and friend requests
- Groups and group management
- Profiles
- Message history
- Persistent sessions
- Secret phrase login
- ANSI terminal UI

The goal was to have a simpel way to use the communicator directly from a terminal without needing a browser.

Compared with Discord, this project is much smaller and focused on self-hosting and simplicity. IRC and Matrix are also alternatives, but ChatSec uses its own account, friend and group system.

I'd be interested in feedback on the CLI and terminal UX.

https://chatsec.pl

https://imgur.com/a/TpSZua7

Hey everybody! It's been a time I posted here: eilmeldung is an RSS reader based on news-flash and it supports many RSS backends. If you have been using eilmeldung before, here are some new features:

• pipe articles through external commands (for saving articles as markdown, sending via mail or piping through an LLM if this is your thing)
• better display of articles with direct opening of links and images
• support of base16 themes, with many already included (supports direct preview from within eilmeldung; see animated gif)
• support for Linux (NixOS/homemanager, Arch AUR), Windows (scoop), macOS (homebrew) and NetBSD

If you encounter any issues or have suggestions for improvements, please feel free to comment or raise an issue.

https://github.com/christo-auer/eilmeldung

I think, in terms of UI, CLI is layers and layers of legacy slop stacked on top of each other, meanwhile vim philosophy is modern and more efficient way for a user to interact with a computer. But if you want to control your PC with your keyboard, the best I could do in terms of efficiency and usefulness usefulness is keyboard shortcuts. Is there a better alternative, maybe a better shell, with a file manager and a good completion engine, with auto-sudo and stuff like that, ot even a way to autobind used commands to shortcuts and vim-like commands? That would be awesome.

Hello!

I’ve been working on this project for a little while and wanted to share it here once again. I think I did several months ago.

This side-project started as a way for me to catch up on several football leagues after work or if I missed games. However, it has grown a lot since its inception and specially after the World Cup with some new feature added for that. Lots of people have liked it and actively use it, which is why I thought to share it once again in this sub.

If you haven’t seen it, let me introduce you to https://github.com/0xjuanma/golazo

My favourite minimal way of catching up on football matches with just the data that I care about. No ads, browser tabs, pop-ups, and completely free, right from your terminal.

Features:

• Live Match Tracking: Timeline & Real-time updates for goals, cards, and substitutions with automatic polling
• Finished Matches: View results from today, last 3 days, or last 5 days
• Match Statistics & Details: Possession, shots, passes, standings, formations with player ratings, and more in focused dialogs
• Official Highlights & Replay Links: Clickable links for official highlights and instant goal replays
• Goal Notifications: Desktop notifications for goals as they happen
• 65+ Leagues: Organized by region (Europe, Americas, Global) with tab navigation in Settings

Check it out, star it and share it with anyone you know that might enjoy it.

Cheers!

I've always found one part of learning a new technology annoying.

You find a roadmap, tutorial, or course, but then the actual learning environment is usually up to you.

You create folders manually, decide what topics to separate, create files, write notes, and eventually the structure becomes inconsistent or gets abandoned.

So I built TRAK to solve that specific problem.

The idea is simple:

trak list

Pick something you want to learn:

trak init lang/go

TRAK fetches a learning blueprint and creates the corresponding workspace locally.

For example, instead of starting with an empty directory, you get a structured workspace organized around the concepts you're trying to learn.

The part I'm more interested in is making this community-driven.

The learning blueprints live in a remote registry, and developers can contribute their own tracks for languages, tools, databases, operating systems, etc.

There's also a web interface for browsing the available tracks and working with blueprints.

Current version: v1.1.0

Some things currently included:

- Local-first CLI

- Remote registry

- Community-contributed blueprints

- 19+ official tracks / 350+ modules

- Cross-platform binaries

- Blueprint validation

- Filesystem safety checks

- Blueprint Studio

- Windows / Linux / macOS support

I'm mainly posting this because I want honest feedback.

Would you actually use something like this when learning a new language or tool?

And if not, what would make this workflow useful to you?

lazyftp is a terminal FTP/FTPS/SFTP client built in the same spirit as lazygit, but for moving files: one view, everything on the keyboard, nothing to configure before you can actually use it.

Local and remote sit side by side. Enter opens a directory, - goes up, and both panes work exactly the same whether you're looking at your own filesystem or a server on the other side of the world. Mark a handful of files with space, hit t (or u/D from either panel), and they transfer in the background with a live progress bar, while a log panel keeps the whole connection history around in case something goes wrong.

It has fuzzy filtering with /, sort by name/size/date, jump straight to a path by typing it, and a --highlight-diff flag that flags files that only exist on one side. None of it needs a mouse, and the full key reference is one keystroke away (?), so nothing has to be memorized up front.

It speaks FTP, FTPS and SFTP through the same interface — connecting is just picking a protocol and typing host/user/pass, nothing protocol-specific to remember. And since it's Go + Bubble Tea compiled into one static binary, it runs anywhere you can open a terminal: over SSH, on a headless box, wherever — no display server, no runtime, no config file.

It just went through a full interface overhaul.

Repo: https://github.com/MawCeron/lazyftp

What do you think?
Check: https://chatsec.pl

I've been working on Varn, a command-line tool for creating checkpoints of local filesystem state and safely restoring them later.

The basic workflow is:

varn init

varn checkpoint "before changes"

# make changes...

varn diff <checkpoint>

varn restore <checkpoint>

A checkpoint records the filesystem state at that point, including file contents, paths, metadata, symlinks, and hard links on Unix.

Varn uses content-addressed storage with SHA-256 hashing and deduplication, so identical file contents are only stored once across checkpoints.

Some other features:

• Incremental scanning using a persistent mtime/size cache
• Symlink scanning and restoration
• Hard link detection and restoration on Unix
• Permission, mtime, and uid/gid restoration on Unix
• Conflict detection before restoring
• Automatic safety checkpoint before a restore
• .varnignore with gitignore-style patterns
• Garbage collection for unreferenced objects
• Storage format migrations
• Machine-readable --json output
• Linux, macOS, and Windows support

The idea isn't to replace Git. Git is great for tracking project history; Varn is focused on local filesystem state and being able to return a directory to a known previous state.

For example:

checkpoint
    ↓
make changes
    ↓
inspect diff
    ↓
restore if needed

It's open source, and I'm currently looking for feedback on the design.

GitHub: varn

Any advice or opinion on dashvoard TUI

Y'all I'm wondering and looking for advice/feedback if building a simple TUI or having some custom tmux config for a dashboard that will open default tools in panes or some type of widget could be helpful. Wanted to get feedback or just chat about whether its worth building since I'm pretty busy with things.

Ive seen in the past when I briefly attempted to use Obsidian (which reminds me, I need to cancel that $4 subscription at some point) that other redditors set up visually appealing dashboards that seem to have info/links, though I can't name one.

Obviously I can't know if it would be useful in getting me into a workflow more quickly where I'm productive rather than scatterbrained or clueless like I am much of the time. Important to include in my question as well as to speak to the clueless aspect of me: does this exist? This is really my only motivation for potentially making one, but I don't feel like wasting time doing work making tools in order to do actual work more than I already do, and I'm able to decently maintain my tmux sessions, panes and windows in an organized chaos.

Would be cool to shoot the shit about this or collaborate in a public repo. I'm just gonna have Claude do the coding but I would like to take care with planning and iteration.

Source

https://gist.github.com/itzender5820/58f5bc228918abe5fc50504a82f7a169

the gif says most of it: claude code works in one pane, i play snake in the other.

terminalika tails the agent's own session files locally and freezes the game with a clean one-line notice the moment the agent finishes or asks a question. switch panes, answer, head back.

your game and score are right where you left them. desktop notifications and a background listener cover you when you're away from the terminal.

works natively with claude code, pi agent, and aider, plus cursor cli (or anything with a hook) via terminalika notify. tmux, zellij, and windows all work out of the box. mit licensed, single static binary, built with go.

site: https://terminalika.dev · source: https://github.com/terminalika/terminalika

I got tired of copying terminal error logs back and forth to browser chats just to get a fix command.

I wrote a shell setup called AFE CLI (Ask, Fix, Explain) that plugs directly into Zsh/Bash:

- a <query>: Generates an executable shell command from plain text.

- f: Reads recent terminal output from your screen buffer and outputs the fix command.

- fe: Explains the root cause in 2 lines without conversational filler.

- e: Explains manual/flags for any command (or the last suggested command).

- Ctrl + G: Pastes the generated command at your current cursor position so you can review and hit enter.

It supports both local models via Ollama and Gemini API. It is written in pure shell functions (no background daemons or extra app windows) and includes automatic name collision checks.

GitHub: https://github.com/vuhaipro2707/afe-cli

Feedback and suggestions are welcome.

I built a small Go CLI called portctl to make working with local network ports and processes easier.

Current commands:

portctl ls
portctl info 3000
portctl why 3000
portctl kill 3000
portctl watch
portctl clean
portctl tree
portctl services

A few examples:

portctl why 3000

Explains why a port is unavailable or in a particular socket state.

portctl tree 3000

Shows the process and its parent process chain.

portctl services

Shows the services currently running locally and the ports they're using.

portctl clean

Finds potentially stale/orphaned development processes and lets you clean them up safely.

It's written in Go and currently supports macOS and Linux.

I'm looking for feedback from other developers: what would you want a tool like this to do next?

GitHub: https://github.com/vikas0686/portctl

tmr-cli: a timer and stopwatch for your terminal.

It handles the basics like countdowns and stopwatches, but also lets you wait until a specific time, sends desktop notifications, and saves your progress so you can resume timers even after closing the terminal.

Install it with: cargo install tmr-cli Repo: https://github.com/honerop/tmr-cli

I made yanklog because I wanted clipboard history that just stays on my machine — searchable, encrypted, and never uploaded anywhere. It's open source (MIT), Rust core, and built to be quick to open and stay out of the way.

What it does:

\- Search your full history fast, all from the keyboard (Quick Pick lets you copy/pin/delete with arrow keys + number shortcuts)

\- Encrypted at rest with SQLCipher

\- Filters out secrets, OTPs, and custom patterns — or pause capture whenever

\- Encrypted backups you can move between machines

\- Undo deletions, keep pinned clips

Install on Linux via AppImage (x86_64/aarch64) or Flatpak:

\`flatpak remote-add --user --if-not-exists yanklog [https://downloads.yanklog.com/linux/flatpak/yanklog.flatpakrepo\](https://downloads.yanklog.com/linux/flatpak/yanklog.flatpakrepo) \--no-gpg-verify\`

\`flatpak install --user yanklog com.yanklog.YankLog\`

Site: [https://yanklog.com\](https://yanklog.com)

Source: [https://github.com/thisiseesmaeel/yanklog-linux\](https://github.com/thisiseesmaeel/yanklog-linux)

Would love any feedback — happy to answer questions!

I’ve built this copy tool for espacially native windows users because I couldn’t exclude some files / folders with copy-item, but I think people didn’t find it usefull. Anyways, I am still trying to improve it maybe someone can find a use for it.

Skip-Existing and Update Flags

-s skips files already at the destination by name + size (resume an interrupted copy), and -u copies only files that are newer than the destination (re-run the same command, only changed files copy). Both work with -n dry-run.

Any feature requests are welcome.

https://github.com/CanManalp/cpr