Added new set of changes

README.md

@@ -1,22 +1,264 @@
----
-title: Git Branch Visualizer
-emoji: 🌿
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 6.17.3
-python_version: '3.11'
-app_file: app.py
-pinned: false
-license: mit
-short_description: Git branch DAG with next-commit preview
----
+# git-commit-app 🎯
+
+**A suite of AI-powered git commit tools** for effortless, consistent commit messages.
+
+This monorepo contains multiple projects for generating and managing git commits:
+
+## Community
+
+- [Reddit: I made a CLI that generates conventional commit messages locally using AI](https://www.reddit.com/user/bhargavi_r/comments/1u6v9uc/i_made_a_cli_that_generates_conventional_commit/)
+
+## Projects
+
+### 🚀 [git-commit-at](./git-commit-at)
+
+**AI-powered commit message generator with interactive CLI and web UI**
+
+- Generate conventional commit messages using AI (Ollama)
+- Interactive selection from 3 AI-suggested options
+- Web UI for login, commit history, and branch visualization
+- Session persistence and Redis caching
+- Docker Compose setup with Ollama, Redis, and Gradio
+
+**Quick start:**
+```bash
+cd git-commit-at
+npm install
+npm start
+git-commit-at
+```
+
+**Features:**
+- ✅ Conventional commit format (`feat:`, `fix:`, `refactor:`, etc.)
+- ✅ Custom commit format templates
+- ✅ Ticket number integration
+- ✅ Live branch graph visualization
+- ✅ Commit history tracking
+
+## Directory Structure
+
+```
+git-commit-app/
+├── git-commit-at/          # npm package — CLI + bundled web UI
+│   ├── index.js            # Core commit logic (Ollama AI)
+│   ├── wrapper.js          # CLI orchestrator
+│   ├── docker-compose.yml  # All services (Ollama, Redis, Gradio)
+│   ├── Dockerfile          # Node app container
+│   ├── entrypoint.sh       # Docker setup script
+│   ├── gradio/             # Bundled web UI (Python/Gradio)
+│   │   ├── app.py          # Login + history + branch visualizer
+│   │   ├── auth_service.py # Redis-based user auth
+│   │   ├── generate_graph.py
+│   │   ├── git_graph.py
+│   │   └── Dockerfile
+│   └── package.json
+│
+└── README.md               # This file
+```
+
+## Getting Started
+
+### Prerequisites
+
+- Docker & Docker Compose
+- Node.js 18+ (for development)
+- Git
+
+### Installation
+
+```bash
+# Clone the repo
+git clone https://huggingface.co/spaces/build-small-hackathon/git-commit-app
+cd git-commit-app
+
+# Navigate to the project you want to use
+cd git-commit-at
+
+# Install and run
+npm install
+npm start
+```
+
+### First Use
+
+```bash
+# Stage your changes
+git add .
+
+# Generate commit message
+git-commit-at
+
+# Follow the interactive prompts
+# - Log in or register
+# - Select a suggested message
+# - Confirm and commit
+```
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────┐
+│          git-commit-at (npm package)         │
+├──────────────────────────────────────────────┤
+│                                              │
+│  CLI (Node.js)  ←→  Docker Compose          │
+│                      ├── Ollama (AI)         │
+│                      ├── Redis (cache)       │
+│                      ├── Gradio (web UI)     │
+│                      └── commit-at (Node)    │
+│                                              │
+└──────────────────────────────────────────────┘
+```
+
+## Features Overview
+
+### git-commit-at
+
+- 🤖 **AI Suggestions** — 3 smart commit message options
+- 🎯 **Conventional Format** — Follows commit standards
+- 🌐 **Web UI** — Login, history, branch visualization
+- 📝 **Custom Formats** — Define your own commit template
+- 🔐 **Session Persistence** — Stay logged in
+- 🐳 **Docker Ready** — One-click setup
+- 📊 **Branch Visualizer** — See your git graph live
+
+## Development
+
+### Project Docs
+
+- **git-commit-at**: [README](./git-commit-at/README.md) — Full setup, troubleshooting, contributing
+
+### Development Workflow
+
+```bash
+# Install all dependencies
+npm install
+
+# Run services
+docker compose up -d
+
+# Access web UI
+# http://localhost:7860
 
-# Git Branch Graph Visualizer
+# Run CLI
+node wrapper.js
+```
+
+### File Structure (git-commit-at)
+
+| File | Purpose |
+|------|---------|
+| `wrapper.js` | CLI entry; manages Docker services |
+| `index.js` | Main commit logic |
+| `diff-parser.js` | Parses git diffs |
+| `entrypoint.sh` | Docker setup |
+| `gradio/app.py` | Web UI |
+| `gradio/git_graph.py` | Branch visualization |
+
+## Contributing
+
+We welcome contributions! Here's how:
+
+1. **Fork** the repo
+2. **Create a branch** for your feature: `git checkout -b feature/my-feature`
+3. **Make changes** and test locally
+4. **Use git-commit-at** for your commits 😉
+5. **Push** and open a PR
+
+### Commit Guidelines
+
+Use [Conventional Commits](https://www.conventionalcommits.org/):
+- `feat:` — New feature
+- `fix:` — Bug fix
+- `docs:` — Documentation
+- `refactor:` — Code refactor
+- `test:` — Tests
+- `chore:` — Build, dependencies, etc.
+
+## Troubleshooting
+
+### General Issues
+
+| Problem | Solution |
+|---------|----------|
+| Docker won't start | Check if Docker daemon is running |
+| Port already in use | Change port in `docker-compose.yml` |
+| "Not a git repo" | Run from inside a git repository |
+
+### git-commit-at Issues
+
+See [git-commit-at Troubleshooting](./git-commit-at/README.md#troubleshooting)
+
+## Performance
+
+| Operation | Time |
+|-----------|------|
+| First run (download models) | ~30s |
+| Generate suggestions | ~5-10s |
+| Web UI load | <1s |
+
+## Environment Setup
+
+### Using Docker (Recommended)
+
+Everything runs in containers—no local setup needed!
+
+```bash
+docker compose up -d
+npm start
+```
+
+### Local Development
+
+```bash
+# Set up Node environment
+node --version  # Should be 18+
+
+# Install deps
+npm install
+
+# Start Docker services only
+docker compose up -d ollama redis gradio
+
+# Run app
+node wrapper.js
+```
+
+## FAQ
+
+**Q: Do I need Ollama installed locally?**
+A: No! Ollama runs in a Docker container. Just ensure Docker is running.
+
+**Q: Can I use a different AI model?**
+A: Yes! Edit the `MODEL` variable in `git-commit-at/index.js`.
+
+**Q: Does this work offline?**
+A: After the first run (which downloads the AI model), yes!
+
+**Q: Can I use this without the web UI?**
+A: Yes! Just run `git-commit-at` from the CLI.
+
+**Q: How do I customize the commit format?**
+A: You'll be prompted each time. Or edit the format in the Gradio UI after logging in.
+
+## License
+
+MIT — See [LICENSE](LICENSE) for details
+
+## Links
+
+- 🐳 Docker Hub: [git-commit-at](https://hub.docker.com)
+- 🤗 Hugging Face: [Spaces](https://huggingface.co/spaces/build-small-hackathon/git-commit-a)
+- 📦 NPM: [git-commit-at](https://npmjs.com/package/git-commit-at)
+
+## Support
+
+- 📖 **Docs**: Check individual project READMEs
+- 🐛 **Issues**: Report on GitHub
+- 💬 **Discussions**: Ask questions in GitHub Discussions
+
+---
 
-Visualize your git repository's branch history as an interactive DAG.
+**Made with ❤️ for developers who want better commits, faster.**
 
-- Local branches shown with **green** badges
-- Remote tracking branches shown with **blue** badges
-- **HEAD** commit highlighted with a white ring
-- Type a commit message to preview the **gold ghost node** — shows exactly where the next commit will land
+🚀 Start generating smarter commits today!

app.py

@@ -1,54 +1,148 @@
-import os
 import gradio as gr
-from git import InvalidGitRepositoryError
-from git_graph import render_branch_graph
 
-DEFAULT_REPO_PATH = os.environ.get("REPO_PATH", os.getcwd())
+INSTALL_CMD = "npm install -g git-commit-at"
+NPM_URL = "https://www.npmjs.com/package/git-commit-at"
+GITHUB_URL = "https://github.com/bhargavirengarajan21/git-commit-at"
+DEMO_URL = "#"  # TBH
 
+ABOUT_MD = """
+# git-commit-at
 
-def draw_graph(repo_path: str, next_commit_message: str):
-    repo_path = repo_path.strip() or DEFAULT_REPO_PATH
-    try:
-        return render_branch_graph(repo_path, next_commit_message)
-    except InvalidGitRepositoryError:
-        raise gr.Error(f"'{repo_path}' is not a git repository.")
+**AI-powered git commit message generator** — local, private, no API key needed.
 
+`git-commit-at` analyzes your staged changes and suggests 3 conventional commit messages
+using a locally-running AI model (Ollama). Pick one, customize it, and commit — all from
+the terminal.
 
-with gr.Blocks(title="Git Branch Visualizer", theme=gr.themes.Base()) as demo:
-    gr.Markdown("## Git Branch Graph Visualizer")
-    gr.Markdown(
-        "Shows all local **and remote** branches as a commit DAG. "
-        "Type a commit message to preview **where the next commit lands** (gold ghost node)."
-    )
+---
+
+## Why git-commit-at?
+
+| | git-commit-at | Manual commits | Cloud AI tools |
+|---|---|---|---|
+| **Private** | ✅ 100% local | ✅ | ❌ sends code to cloud |
+| **No API key** | ✅ | ✅ | ❌ requires subscription |
+| **Conventional commits** | ✅ auto | ❌ manual discipline | ⚠️ sometimes |
+| **Branch visualizer** | ✅ built-in | ❌ | ❌ |
+| **Commit history** | ✅ tracked | ❌ | ❌ |
+
+---
+
+## Install
+
+```bash
+npm install -g git-commit-at
+```
+
+Requires: **Docker** (all AI/backend services run in containers — no extra setup).
+
+---
+
+## How to use
+
+```bash
+# 1. Stage your changes
+git add .
+
+# 2. Run the tool
+git-commit-at
+
+# 3. First time: register/login at http://localhost:7860
+# 4. Pick a suggested commit message
+# 5. Confirm — done!
+```
+
+On first run, Docker starts Ollama, Redis, and the Gradio UI automatically.
+
+---
+
+## Features
+
+- 🤖 **3 AI suggestions** per run, tailored to your actual diff
+- 📋 **Conventional commits** — `feat:`, `fix:`, `refactor:`, `chore:`, etc.
+- 🎫 **Ticket integration** — prefix messages with JIRA/Linear ticket numbers
+- 🌿 **Branch visualizer** — live git branch DAG in the web UI
+- 📊 **Commit history** — track everything you've committed across repos
+- 🔐 **Session persistence** — stay logged in between runs
+- 🐳 **Zero local dependencies** — everything runs in Docker
+
+---
+
+## Numbers
+
+*(TBH — to be updated with real metrics)*
+
+| Metric | Value |
+|--------|-------|
+| Average suggestion time | ~5–10 s |
+| First-run setup time | ~30 s |
+| AI model size | ~1 GB (qwen2.5-coder:1.5b) |
+| Runs entirely offline after setup | ✅ |
+
+---
+
+## Links
+
+- 📦 **npm**: [{npm}]({npm})
+- 💻 **GitHub**: [{gh}]({gh})
+- 🎬 **Demo**: [Coming soon]({demo})
+""".format(npm=NPM_URL, gh=GITHUB_URL, demo=DEMO_URL)
+
+QUICKSTART_MD = """
+## Quick Start
+
+```bash
+# Install
+npm install -g git-commit-at
+
+# Go to any git repo
+cd your-project
+git add .
+
+# Generate commit message
+git-commit-at
+```
+
+The first run starts all Docker services and opens the login UI at `http://localhost:7860`.
+After login, you'll see 3 commit message suggestions based on your staged diff.
+"""
+
+HOW_IT_WORKS_MD = """
+## How it works
+
+```
+git-commit-at (CLI)
+      │
+      ├── Checks Docker services
+      │     ├── Ollama  (AI model, port 11434)
+      │     ├── Redis   (session + cache, port 6379)
+      │     └── Gradio  (web UI, port 7860)
+      │
+      ├── Waits for login at http://localhost:7860
+      │
+      └── Runs commit flow
+            ├── Reads git diff of staged files
+            ├── Sends diff to Ollama (qwen2.5-coder:1.5b)
+            ├── Streams 3 commit suggestions
+            ├── Prompts: ticket number? format?
+            ├── You pick a message
+            └── git commit -m "..."
+```
+"""
+
+with gr.Blocks(title="git-commit-at", theme=gr.themes.Monochrome()) as demo:
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown(ABOUT_MD)
+        with gr.Column(scale=1):
+            gr.Markdown("## Install now")
+            gr.Code(value=INSTALL_CMD, language="bash", label="npm")
+            gr.Markdown(f"[View on npm]({NPM_URL})  ·  [GitHub]({GITHUB_URL})")
+            gr.Markdown("---")
+            gr.Markdown(QUICKSTART_MD)
 
     with gr.Row():
-        repo_path_input = gr.Textbox(
-            label="Repository path",
-            value=DEFAULT_REPO_PATH,
-            placeholder="/path/to/your/repo",
-            scale=3,
-        )
-        next_commit_input = gr.Textbox(
-            label="Next commit message (preview)",
-            placeholder="feat: add new feature",
-            scale=2,
-        )
-
-    render_button = gr.Button("Render Graph", variant="primary")
-
-    graph_output = gr.Plot(label="Branch Graph")
-    info_output = gr.Markdown()
-
-    render_button.click(
-        fn=draw_graph,
-        inputs=[repo_path_input, next_commit_input],
-        outputs=[graph_output, info_output],
-    )
-    demo.load(
-        fn=draw_graph,
-        inputs=[repo_path_input, next_commit_input],
-        outputs=[graph_output, info_output],
-    )
+        gr.Markdown(HOW_IT_WORKS_MD)
 
 if __name__ == "__main__":
     demo.launch()

git-commit-at

@@ -0,0 +1 @@
+Subproject commit fb7169fbc27f0b23149ad3818b290e698dfa9203

git_graph.py

@@ -1,244 +0,0 @@
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-from git import Repo, InvalidGitRepositoryError
-
-BRANCH_COLORS = {
-    "main": "#4C8BF5",
-    "master": "#4C8BF5",
-}
-FALLBACK_COLORS = ["#2ECC71", "#E84B3A", "#F39C12", "#9B59B6", "#1ABC9C", "#E67E22"]
-GHOST_COLOR = "#FFD700"
-HEAD_RING_COLOR = "#FFFFFF"
-BG_COLOR = "#0D1117"
-TEXT_COLOR = "#C9D1D9"
-X_SPACING = 1.5
-Y_SPACING = -0.7
-
-
-def get_branch_color(branch_name: str, index: int) -> str:
-    return BRANCH_COLORS.get(branch_name, FALLBACK_COLORS[index % len(FALLBACK_COLORS)])
-
-
-def load_repo(repo_path: str) -> Repo:
-    return Repo(repo_path)
-
-
-def get_commit_graph(repo: Repo) -> list[dict]:
-    seen = set()
-    commits = []
-    for commit in repo.iter_commits("--all"):
-        if commit.hexsha in seen:
-            continue
-        seen.add(commit.hexsha)
-        commits.append({
-            "sha": commit.hexsha,
-            "short_sha": commit.hexsha[:7],
-            "message": commit.message.strip().splitlines()[0],
-            "parents": [p.hexsha for p in commit.parents],
-        })
-    return commits
-
-
-def tag_commits_with_branches(repo: Repo, commits: list[dict]) -> list[dict]:
-    sha_to_local: dict[str, list[str]] = {}
-    for branch in repo.branches:
-        tip = branch.commit.hexsha
-        sha_to_local.setdefault(tip, []).append(branch.name)
-
-    sha_to_remote: dict[str, list[str]] = {}
-    for remote in repo.remotes:
-        for ref in remote.refs:
-            if ref.name.endswith("/HEAD"):
-                continue
-            tip = ref.commit.hexsha
-            sha_to_remote.setdefault(tip, []).append(ref.name)
-
-    head_sha = repo.head.commit.hexsha
-    for commit in commits:
-        commit["local_labels"] = sha_to_local.get(commit["sha"], [])
-        commit["remote_labels"] = sha_to_remote.get(commit["sha"], [])
-        commit["is_head"] = commit["sha"] == head_sha
-    return commits
-
-
-def assign_lanes(commits: list[dict]) -> dict[str, int]:
-    lane_by_sha: dict[str, int] = {}
-    active_lanes: list[str | None] = []
-
-    for commit in commits:
-        sha = commit["sha"]
-        parents = commit["parents"]
-
-        inherited_lane = None
-        for parent_sha in parents:
-            if parent_sha in lane_by_sha:
-                candidate = lane_by_sha[parent_sha]
-                if active_lanes[candidate] == parent_sha:
-                    inherited_lane = candidate
-                    break
-
-        if inherited_lane is not None:
-            lane = inherited_lane
-        else:
-            try:
-                lane = active_lanes.index(None)
-            except ValueError:
-                lane = len(active_lanes)
-                active_lanes.append(None)
-
-        lane_by_sha[sha] = lane
-        if lane < len(active_lanes):
-            active_lanes[lane] = sha
-        else:
-            active_lanes.append(sha)
-
-    return lane_by_sha
-
-
-def inject_ghost_node(commits: list[dict], head_sha: str, current_branch: str, message: str) -> list[dict]:
-    ghost = {
-        "sha": "GHOST_NEXT",
-        "short_sha": "next",
-        "message": message.strip(),
-        "parents": [head_sha],
-        "local_labels": [f"← {current_branch} (next)"],
-        "remote_labels": [],
-        "is_head": False,
-    }
-    return [ghost] + commits
-
-
-def build_figure(repo: Repo, commits: list[dict], current_branch: str, next_commit_message: str) -> plt.Figure:
-    head_sha = repo.head.commit.hexsha
-    ghost_sha = "GHOST_NEXT"
-
-    if next_commit_message.strip():
-        commits = inject_ghost_node(commits, head_sha, current_branch, next_commit_message)
-
-    lane_by_sha = assign_lanes(commits)
-    sha_to_index = {c["sha"]: i for i, c in enumerate(commits)}
-
-    num_lanes = max(lane_by_sha.values(), default=0) + 1
-    fig_width = max(12, 4 + num_lanes * 2)
-    fig_height = max(6, len(commits) * 0.6 + 2)
-
-    fig, ax = plt.subplots(figsize=(fig_width, fig_height))
-    fig.patch.set_facecolor(BG_COLOR)
-    ax.set_facecolor(BG_COLOR)
-
-    def node_position(sha: str) -> tuple[float, float]:
-        idx = sha_to_index[sha]
-        lane = lane_by_sha[sha]
-        return lane * X_SPACING, idx * Y_SPACING
-
-    for commit in commits:
-        x_child, y_child = node_position(commit["sha"])
-        lane = lane_by_sha[commit["sha"]]
-        edge_color = get_branch_color("", lane)
-
-        for parent_sha in commit["parents"]:
-            if parent_sha not in sha_to_index:
-                continue
-            x_parent, y_parent = node_position(parent_sha)
-            is_merge = x_child != x_parent
-            ax.annotate(
-                "",
-                xy=(x_parent, y_parent),
-                xytext=(x_child, y_child),
-                arrowprops=dict(
-                    arrowstyle="-|>",
-                    color=edge_color,
-                    lw=1.8,
-                    connectionstyle=f"arc3,rad={'0.3' if is_merge else '0.0'}",
-                ),
-                zorder=2,
-            )
-
-    for commit in commits:
-        x, y = node_position(commit["sha"])
-        lane = lane_by_sha[commit["sha"]]
-        node_color = get_branch_color("", lane)
-        is_ghost = commit["sha"] == ghost_sha
-
-        if is_ghost:
-            ax.plot(x, y, "o", markersize=13, color=GHOST_COLOR, alpha=0.35, zorder=4)
-            ax.plot(x, y, "o", markersize=13, color=GHOST_COLOR, fillstyle="none",
-                    markeredgewidth=2, linestyle="--", zorder=5)
-        elif commit["is_head"]:
-            ax.plot(x, y, "o", markersize=15, color=node_color, zorder=4)
-            ax.plot(x, y, "o", markersize=8, color=HEAD_RING_COLOR, zorder=5)
-        else:
-            ax.plot(x, y, "o", markersize=10, color=node_color, zorder=4)
-
-        label_text = f"{commit['short_sha']}  {commit['message'][:50]}"
-        ax.text(x + 0.35, y, label_text, va="center", ha="left",
-                fontsize=8, color=TEXT_COLOR, fontfamily="monospace", zorder=6)
-
-        badge_offset_x = x + 0.35
-        badge_offset_y = y + 0.22
-        for label in commit["local_labels"]:
-            badge_bg = "#9E6A03" if label == current_branch else "#238636"
-            ax.text(
-                badge_offset_x, badge_offset_y,
-                f"  {label}  ",
-                va="center", ha="left",
-                fontsize=7, color="white", fontfamily="monospace",
-                bbox=dict(boxstyle="round,pad=0.25", facecolor=badge_bg, edgecolor="none"),
-                zorder=7,
-            )
-            badge_offset_x += len(label) * 0.075 + 0.6
-        for label in commit["remote_labels"]:
-            ax.text(
-                badge_offset_x, badge_offset_y,
-                f"  {label}  ",
-                va="center", ha="left",
-                fontsize=7, color="white", fontfamily="monospace",
-                bbox=dict(boxstyle="round,pad=0.25", facecolor="#1F6FEB", edgecolor="none"),
-                zorder=7,
-            )
-            badge_offset_x += len(label) * 0.075 + 0.6
-
-    ax.set_xlim(-0.8, num_lanes * X_SPACING + 6)
-    ax.set_ylim(len(commits) * Y_SPACING - 0.8, 0.8)
-    ax.set_title("Git Branch Graph", color=TEXT_COLOR, fontsize=12, pad=12)
-    ax.axis("off")
-    plt.tight_layout()
-
-    return fig
-
-
-def build_info(repo: Repo, current_branch: str, next_commit_message: str) -> str:
-    head_sha = repo.head.commit.hexsha
-    staged_files = [item.a_path for item in repo.index.diff("HEAD")]
-    untracked = repo.untracked_files
-    remote_branches = [
-        ref.name for remote in repo.remotes for ref in remote.refs if not ref.name.endswith("/HEAD")
-    ]
-
-    info_lines = [
-        f"**Current branch:** `{current_branch}`",
-        f"**HEAD:** `{head_sha[:7]}`",
-    ]
-    if remote_branches:
-        info_lines.append("**Remote branches:** " + ", ".join(f"`{r}`" for r in remote_branches))
-    if staged_files:
-        info_lines.append("**Staged (ready to commit):** " + ", ".join(f"`{f}`" for f in staged_files))
-    if untracked:
-        info_lines.append("**Untracked:** " + ", ".join(f"`{f}`" for f in untracked[:5]))
-    if next_commit_message.strip():
-        info_lines.append(
-            f"**Next commit preview:** `{next_commit_message.strip()}`  ← will land on `{current_branch}`"
-        )
-
-    return "\n\n".join(info_lines)
-
-
-def render_branch_graph(repo_path: str, next_commit_message: str) -> tuple[plt.Figure, str]:
-    repo = load_repo(repo_path)
-    commits = get_commit_graph(repo)
-    commits = tag_commits_with_branches(repo, commits)
-    current_branch = repo.active_branch.name if not repo.head.is_detached else "HEAD (detached)"
-    fig = build_figure(repo, commits, current_branch, next_commit_message)
-    info = build_info(repo, current_branch, next_commit_message)
-    return fig, info