A terminal writing environment with Git, E2EE sync and temporal search

I am a 40 years old jobless sys-admin with no cs degree and no development experience and 25 yeras of system knowledge. I built a fully encrypted writing environment where I can write with focus forgetting about the application. Here ai was my code translator while I strictly was the architect and instructor. It all started when i asked myself that "why and how i remember any past memory instantly without searching inside my head". This became the design principle of my app. Thus I solved a fundamental git problem of tracking a single note throughout the history by embedding uuid in every commit.

Its responsive data-as-UI based interface keeps the app (nearly) learning curve free. Navigating deep hierarchies is easy using numbered fisheye jump system without forward button. Every operation is in one or two keystroke like v(view), c(create), d(delete), r(rename), (j)ump s(sync), (s)earch, b(back) or v1, d1, j1, jb etc. It is built using python standard library (no other dependency), Git, cryptography standard primitive (embedded). I used git-filter-repo programaically for permanent item erasure using uuid from inside the application. It has full timeline for each item (note, file, subnotebook) to see the entire life cycle from create to erase with tombstone. Its subnotebook hierarchy can be upto any depth. It supports 80 file types with syntax highlighted editing with export feature for files. It has activity viewer inside every notebook or subnotebook. It shows your last 50 activities in the notebook. Searching is easy like "s files* file.md date* 02-04-2026 in* notebook/subnotebook_name", "s note_name date* 01-04-2026 05-04-2026", "s edited* any_text thisweek" "s in notebook/subnotebook_name" or just "s anytext".

Notebook can be encrypted using 8-24 words BIP-39 phrases and use password for regular lock/unlock. It is encrypted using standard AES-GCM and also portable. It can show password change log in each notebook management screen. Key vaults are hardware bound yet portable and a usb drive can act as TPM like security. It means when the keys are not reachable, notebooks can't be accessed. The application architecture and data structure is decoupled. Where app architecture allows the app, notebook and key vault can be in three different locations or even in different systems and data architecture allows metadata and content remain separated in different files inside each notebook folder linked via UUID. Git is implemented for doing item level (not file level) versioning and temporal search with uuid based commit metadata. Here commit metadata is not encrypted, though doable modifying the existing code if required. Every notebook is self contained in just a movable single folder. The architectur also enables optional e2ee conflict free sync using github and other platforms. It does not need someone to be a git expert to use the application and cloud vendor cannot see the data even with public visibility.

I will request respected HN people to go through the documents and the story_n_constraint.md file, that will explain the what, how, why in details. I also put a couple of abstract ideas inside the repo (what_can_be_done files). I want to thank the creators of Python, Git, cryptography, nvim, micro and git-filter-repo. Their tools came together and turned a concept into a working application.

The post, the GitHub repository, and all source code and documentation are part of the prior art with appropriete license (Public + timestamped + enabling)

repo: * https://github.com/sys-ronin/terminal-notes *

requirement: linux/mac/win/docker, python 3.13, git, nvim/micro or any terminal based editor (can be configured from config.json inside root folder),internet for using github sync example - python3 terminal_notes_ui.py (from linux) * tested on debian 13 only

git clone https://github.com/sys-ronin/terminal-notes.git && cd terminal-notes && python3 terminal_notes_ui.py

sys-ronin