@ishaan812/devlog 0.0.1 → 0.0.2

package/README.md

@@ -13,6 +13,8 @@
 
 Open-source, local-first AI work logging for developers who juggle<br>too many repos, too many branches, and too many standups.
 
+**[devlog.ishaan812.com](https://devlog.ishaan812.com)**
+
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Go Version](https://img.shields.io/badge/go-%3E%3D1.21-blue.svg)](https://go.dev)
 [![Open Source](https://img.shields.io/badge/open%20source-%E2%9C%93-brightgreen.svg)](https://github.com/ishaan812/devlog)
@@ -22,7 +24,7 @@ Open-source, local-first AI work logging for developers who juggle<br>too many r
 
 You ship code across 5 repos, 12 branches, and 3 teams. Monday morning standup hits and you're scrolling through `git log` trying to remember what you did last Thursday.
 
-**DevLog fixes that.** It ingests your git history across every repo and branch you work on, and turns it into smart, structured work logs — automatically. No more "I think I worked on the auth thing?" Ask DevLog and get an answer in seconds.
+**DevLog fixes that.** It ingests your git history across every repo and branch you work on, and turns it into smart, structured work logs — automatically. No more "I think I worked on the auth thing?" Get your work summary in seconds.
 
 ---
 
@@ -33,6 +35,7 @@ npm install -g @ishaan812/devlog  # Install
 devlog onboard              # Set up (works with free local Ollama)
 devlog ingest               # Point it at your repos
 devlog worklog --days 7     # Get your week's work, organized by branch
+devlog console              # Browse worklogs in an interactive TUI
 ```
 
 That's it. Professional markdown work logs, generated from your actual commits. Multi-repo, multi-branch, zero effort.
@@ -60,24 +63,22 @@ DevLog is **local-first**. Run it with [Ollama](https://ollama.ai) and your data
 | Feature | Description |
 |---------|-------------|
 | **Smart Work Logs** | Auto-generated markdown summaries organized by branch, date, and repo — ready for standups, PRs, or performance reviews |
+| **Interactive Console** | Full-screen terminal UI to browse repos and navigate through your cached worklogs day-by-day |
 | **Multi-Repo Ingestion** | Ingest as many repos as you want into a single profile. See your full picture. |
 | **Multi-Branch Tracking** | Branch-aware ingestion remembers your selections per repo. Track `main`, `develop`, and every feature branch. |
 | **Local-First AI** | Works completely offline with Ollama. Your code and history stay on your machine. |
-| **Cheap Cloud Fallback** | Optionally use Anthropic, OpenAI, OpenRouter, or AWS Bedrock — most queries cost fractions of a cent |
-| **Natural Language Queries** | Ask questions about your git history in plain English |
-| **Semantic Code Search** | Find code by describing what it does, not just grepping keywords |
+| **Cheap Cloud Fallback** | Optionally use Anthropic, OpenAI, OpenRouter, or AWS Bedrock — most queries are very lightweight and would cost fractions of a cent |
 | **Profile System** | Isolated databases for work vs. personal, or per-client contexts |
 | **Incremental Updates** | Re-runs only process new commits. Fast even on large repos. |
-| **Codebase Visualization** | Generate structure diagrams and collaboration graphs |
 
 ## Quick Start
 
 ```bash
 # 1. Install DevLog
-npm install -g devlog
+npm install -g @ishaan812/devlog
 # or: go install github.com/ishaan812/devlog/cmd/devlog@latest
 
-# 2. Run the setup wizard (picks up Ollama automatically)
+# 2. Run the setup wizard
 devlog onboard
 
 # 3. Ingest your repositories
@@ -87,8 +88,6 @@ devlog ingest ~/projects/shared-lib
 
 # 4. See what you actually shipped
 devlog worklog --days 7
-devlog ask "What did I work on this week?"
-devlog search "error handling"
 ```
 
 ## Installation
@@ -105,6 +104,16 @@ npm install -g @ishaan812/devlog
 go install github.com/ishaan812/devlog/cmd/devlog@latest
 ```
 
+**Note:** Make sure `$HOME/go/bin` (or `$GOPATH/bin`) is in your PATH. Add this to your shell config if needed:
+
+```bash
+# For bash (~/.bashrc) or zsh (~/.zshrc)
+export PATH="$HOME/go/bin:$PATH"
+
+# For fish (~/.config/fish/config.fish)
+set -gx PATH $HOME/go/bin $PATH
+```
+
 ### From Source
 
 ```bash
@@ -190,58 +199,22 @@ One command. Every repo. Every branch. Organized and summarized:
 
 That's your standup, done. Copy-paste it, email it, or drop it in Slack.
 
-### 4. Query Your Activity
-
-```bash
-# Ask natural language questions
-devlog ask "What features did I add this month?"
-devlog ask "Show me commits related to the payment system"
-devlog ask "Which files have I changed the most?"
-
-# Semantic code search
-devlog search "database connection pooling"
-devlog search "user authentication flow"
-```
-
 ## Commands Reference
 
 ### `devlog ingest`
 
-Ingest git history and index your codebase for search.
+Ingest git history from your repositories.
 
 ```bash
 devlog ingest                      # Current directory
 devlog ingest ~/projects/myapp     # Specific path
 devlog ingest --days 90            # Last 90 days (default: 30)
 devlog ingest --all                # Full git history
-devlog ingest --git-only           # Skip codebase indexing
-devlog ingest --index-only         # Skip git history
 devlog ingest --reselect-branches  # Re-select branches
 devlog ingest --all-branches       # Ingest all branches
 devlog ingest --fill-summaries     # Generate missing commit summaries
 ```
 
-### `devlog ask`
-
-Query your development activity using natural language.
-
-```bash
-devlog ask "What did I work on this week?"
-devlog ask "Show commits about authentication"
-devlog ask "Which files changed the most in January?"
-devlog ask --provider anthropic "Summarize my recent work"
-```
-
-### `devlog search`
-
-Semantic search across your indexed codebase.
-
-```bash
-devlog search "authentication logic"
-devlog search "database queries"
-devlog search -n 20 "error handling"    # More results
-```
-
 ### `devlog worklog`
 
 Generate formatted work logs from your commit history.
@@ -254,6 +227,22 @@ devlog worklog --no-llm            # Skip AI summaries
 devlog worklog --group-by date     # Group by date instead of branch
 ```
 
+### `devlog console`
+
+Interactive terminal UI to browse repositories and worklogs.
+
+```bash
+devlog console                     # Launch full-screen TUI
+```
+
+Features:
+- Browse through all your ingested repositories
+- Navigate day-by-day worklogs
+- View formatted markdown content in the terminal
+- Keyboard shortcuts for quick navigation (arrow keys, j/k, tab)
+
+Requires at least one prior `devlog worklog` run to populate the cache.
+
 ### `devlog profile`
 
 Manage isolated profiles for different work contexts.
@@ -270,19 +259,9 @@ devlog profile delete old          # Delete a profile
 Use a profile temporarily:
 ```bash
 devlog --profile work ingest ~/work/project
-devlog --profile personal ask "What did I do this weekend?"
+devlog --profile personal worklog --days 7
 ```
 
-### `devlog graph`
-
-Visualize your codebase structure.
-
-```bash
-devlog graph                       # Folder structure
-devlog graph --type commits        # Commit activity
-devlog graph --type files          # File change heatmap
-devlog graph --type collab         # Developer collaboration
-devlog graph -o diagram.md         # Export as Mermaid markdown
 ```
 
 ### `devlog list`
@@ -442,7 +421,6 @@ make install
 
 # Run development commands
 make run-ingest
-make run-ask
 make run-worklog
 ```
 
@@ -484,9 +462,92 @@ devlog ingest --skip-summaries
 - **Open source maintainers** who want to generate changelogs and activity summaries
 - **Anyone tired of `git log --oneline | head -50`** as a standup prep strategy
 
+## About the Project
+
+### The Problem That Started It All
+
+Every Monday morning, the same ritual: staring at four terminal windows, trying to piece together what I shipped last week. Between juggling multiple feature branches, emergency hotfixes, and code reviews across frontend, backend, and infrastructure repos, I'd lose track of my own work.
+
+Standup meetings became archaeology sessions. Performance reviews meant hours of manual git history diving and piecing together scraps I had left to remember what I worked on. I'd spend an awful amount of time *remembering* what I built.
+
+The final straw? Missing a critical bug fix in a standup because it happened in a repo I forgot I'd touched. I realized: **git is the perfect source of truth, but humans are terrible at reading raw git logs across dozens of branches.**
+
+What if your git history could just... explain itself?
+
+### What I Learned
+
+Building DevLog taught me that **context is expensive, but structured data is cheap**:
+
+1. **LLM Integration Patterns**: Initially, I hardcoded Gemini. Bad idea. Abstracting provider interfaces taught me the value of flexibility—users shouldn't be forced into expensive APIs when Ollama runs free on their laptop. The `llm.Client` interface now supports 5+ providers with zero code changes to the core logic.
+
+2. **Git Isn't Just Text**: Walking a git repository efficiently is *hard*. I learned about git object databases, tree traversal algorithms, and how to use `git2go` (libgit2 bindings) to avoid shelling out to git commands thousands of times. The performance difference was \( O(n \log n) \to O(n) \) for large repos.
+
+3. **Terminal UIs That Don't Suck**: Building the interactive console with [Bubble Tea](https://github.com/charmbracelet/bubbletea) taught me functional reactive patterns in Go. State management in a TUI is surprisingly similar to React—every keypress is an event, every render is a pure function of state.
+
+4. **Distribution Complexity**: Shipping a Go binary via npm was trickier than expected. I learned about platform detection, cross-compilation, release automation with GitHub Actions, and why `install.js` scripts need extensive error handling. Supporting `npm install -g`, `go install`, and `brew` simultaneously meant tripling my packaging logic.
+
+5. **Privacy-First Design**: Making Ollama the default provider wasn't just philosophical—it forced architectural decisions that made the tool better. Every API call had to be justified. Every piece of data sent to an LLM had to be minimal. The result: most queries are < 2KB, even for large repos.
+
+### Challenges I Faced
+
+1. **Multi-Repo Timeline Merging**  
+   **Problem**: Users work on 5+ repos simultaneously. How do you merge timelines across repos while keeping branch context clear?  
+   **Solution**: Unified timestamp sorting with branch metadata preserved. WorkLogs group by `(date, repo, branch)` tuples, then sort commits within each group. The data model stores absolute timestamps, avoiding timezone hell.
+
+2. **LLM Prompt Engineering for Code**  
+   **Problem**: Early summaries were terrible—either too verbose ("added semicolon to line 47") or too vague ("updated files").  
+   **Solution**: Iterative prompt design with few-shot examples. I learned that LLMs need *explicit structure*:
+   ```
+   Given these commits, extract:
+   - High-level changes (what feature/fix)
+   - Technical approach (how it works)
+   - Files affected (why it matters)
+   ```
+   This increased summary quality by ~60% based on user feedback.
+
+3. **Performance on Large Repos**  
+   **Problem**: A repo with 50,000 commits would take 2+ minutes to ingest. Unacceptable.  
+   **Solution**: Incremental ingestion. DevLog tracks the last processed commit SHA per branch. Re-runs only walk new commits:
+   \[
+   T_{\text{ingest}} = O(k) \text{ where } k = \text{new commits}, \text{ not } O(n)
+   \]
+   Average re-ingest time dropped from 120s to 3s on active repos.
+
+4. **Cross-Platform Binary Distribution**  
+   **Problem**: Go users want `go install`. JS developers want `npm install -g`. Both should work.  
+   **Solution**: `package.json` includes a post-install script (`install.js`) that detects the platform, downloads the correct pre-built binary from GitHub releases, and symlinks it. Go users bypass npm entirely. One codebase, two package managers.
+
+5. **Making TUIs Feel Native**  
+   **Problem**: Terminal UIs often feel sluggish or unresponsive. Arrow key lag, janky scrolling, unclear state changes.  
+   **Solution**: Embraced Bubble Tea's Elm architecture. Every component is a pure state machine. Render logic never blocks. The result: 60 FPS terminal UIs with smooth vim-style navigation (`j`/`k` keys, `Ctrl+D`/`Ctrl+U` scrolling).
+
+### What's Next
+
+- **Linear/Slack/Jira integrations**: To be able to gather informations from all work surfaces
+- **Team mode**: Aggregate worklogs across teams for engineering manager reports
+- **Git hooks**: Auto-commit worklogs to a markdown file in your repo on each commit
+
+DevLog started as a personal itch—I was tired of forgetting my own work. It turned into a lesson in building tools that respect user privacy, embrace local-first principles, and make boring tasks (standup prep) disappear. If you've ever fumbled through your slack messages at 8:59am before a standup, this tool is for you.
+
 ## Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+Contributions are welcome! DevLog is open source and we'd love your help making it better.
+
+**Ways to contribute:**
+- 🐛 Report bugs or issues
+- 💡 Suggest new features or improvements
+- 📝 Improve documentation
+- 🔧 Submit pull requests for bug fixes or features
+- ⭐ Star the repo if you find it useful
+
+**Getting started:**
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes and commit (`git commit -m 'feat: add amazing feature'`)
+4. Push to your branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+See the [Development](#development) section for build instructions.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ishaan812/devlog",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "AI-powered development activity tracker and code intelligence tool. Local-first work logging for developers who juggle too many repos.",
   "bin": {
     "devlog": "./bin/devlog-wrapper.js"