gitterApp 0.1.10__tar.gz

gitterapp-0.1.10/BusinessLogic/GitManager.py

@@ -0,0 +1,263 @@
+
+import subprocess
+
+from model.GitLog import GitLog
+from model.GitStatus import GitStatus
+
+
+class GitManager:
+    """Runs git CLI commands via subprocess for a given repository path."""
+
+    def __init__(self, repo_path: str):
+        """
+        :param repo_path: Absolute path to the git repository.
+        """
+        self.repo = repo_path
+
+    def get_status(self):
+        """
+        Returns the current working tree status as a GitStatus object.
+
+        :returns: GitStatus with staged, unstaged, and untracked file lists,
+                  or a string error message if no repository is set.
+        """
+        if self.repo is None:
+            return "No repository initialized"
+
+        theStatus = subprocess.run(["git", "-C", self.repo, "status"], capture_output=True, text=True)
+
+        result = GitStatus()
+        result.process_status_response(theStatus.stdout)
+
+        return result
+
+    def commit(self, message: str, add_unstaged: bool = False) -> tuple:
+        """
+        Creates a commit with the given message.
+
+        :param message: The commit message.
+        :param add_unstaged: If True, passes -a to also stage tracked modified files.
+        :returns: (success, output) tuple where success is True if returncode == 0.
+        """
+        args = ["git", "-C", self.repo, "commit"]
+        if add_unstaged:
+            args.append("-a")
+        args += ["-m", message]
+        result = subprocess.run(args, capture_output=True, text=True)
+        success = result.returncode == 0
+        output = result.stdout.strip() or result.stderr.strip()
+        return success, output
+
+    def stage(self, filename: str) -> tuple:
+        """
+        Stages a single file.
+
+        :param filename: Path to the file to stage, relative to the repository root.
+        :returns: (success, output) tuple.
+        """
+        result = subprocess.run(
+            ["git", "-C", self.repo, "add", filename],
+            capture_output=True, text=True,
+        )
+        return result.returncode == 0, result.stdout.strip() or result.stderr.strip()
+
+    def stage_all(self) -> tuple:
+        """
+        Stages all changes in the repository (git add -A).
+
+        :returns: (success, output) tuple.
+        """
+        result = subprocess.run(
+            ["git", "-C", self.repo, "add", "-A"],
+            capture_output=True, text=True,
+        )
+        return result.returncode == 0, result.stdout.strip() or result.stderr.strip()
+
+    def unstage(self, filename: str) -> tuple:
+        """
+        Unstages a single file, keeping working tree changes intact.
+
+        :param filename: Path to the file to unstage, relative to the repository root.
+        :returns: (success, output) tuple.
+        """
+        result = subprocess.run(
+            ["git", "-C", self.repo, "restore", "--staged", filename],
+            capture_output=True, text=True,
+        )
+        return result.returncode == 0, result.stdout.strip() or result.stderr.strip()
+
+    def unstage_all(self) -> tuple:
+        """
+        Unstages all staged changes, keeping working tree changes intact.
+
+        :returns: (success, output) tuple.
+        """
+        result = subprocess.run(
+            ["git", "-C", self.repo, "restore", "--staged", "."],
+            capture_output=True, text=True,
+        )
+        return result.returncode == 0, result.stdout.strip() or result.stderr.strip()
+
+    def push(self, remote: str = "origin", branch: str = "") -> tuple:
+        """
+        Pushes commits to a remote repository.
+
+        :param remote: The remote name to push to (default: "origin").
+        :param branch: The branch to push. If empty, uses the current tracking branch.
+        :returns: (success, output) tuple.
+        """
+        args = ["git", "-C", self.repo, "push", remote]
+        if branch:
+            args.append(branch)
+        result = subprocess.run(args, capture_output=True, text=True)
+        return result.returncode == 0, result.stdout.strip() or result.stderr.strip()
+
+    def push_main_and_develop(self, remote: str = "origin") -> tuple:
+        """
+        Pushes both the main/master branch and develop to the remote.
+
+        :param remote: The remote name to push to (default: "origin").
+        :returns: (success, output) tuple.
+        """
+        main_branch = self._detect_main_branch()
+        return self._run_sequence(
+            ["push", remote, main_branch],
+            ["push", remote, "develop"],
+        )
+
+    def pull(self, remote: str = "origin", branch: str = "") -> tuple:
+        """
+        Pulls and merges changes from a remote repository.
+
+        :param remote: The remote name to pull from (default: "origin").
+        :param branch: The branch to pull. If empty, uses the current tracking branch.
+        :returns: (success, output) tuple.
+        """
+        args = ["git", "-C", self.repo, "pull", remote]
+        if branch:
+            args.append(branch)
+        result = subprocess.run(args, capture_output=True, text=True)
+        return result.returncode == 0, result.stdout.strip() or result.stderr.strip()
+
+    def fetch(self, remote: str = "origin", prune: bool = False) -> tuple:
+        """
+        Fetches changes from a remote without merging.
+
+        :param remote: The remote name to fetch from (default: "origin").
+        :param prune: If True, removes remote-tracking branches that no longer exist on the remote.
+        :returns: (success, output) tuple.
+        """
+        args = ["git", "-C", self.repo, "fetch", remote]
+        if prune:
+            args.append("--prune")
+        result = subprocess.run(args, capture_output=True, text=True)
+        return result.returncode == 0, result.stdout.strip() or result.stderr.strip()
+
+    def _run(self, *args) -> tuple:
+        """Run a single git command, returning (success, output)."""
+        result = subprocess.run(
+            ["git", "-C", self.repo] + list(args),
+            capture_output=True, text=True,
+        )
+        return result.returncode == 0, result.stdout.strip() or result.stderr.strip()
+
+    def _run_sequence(self, *commands) -> tuple:
+        """Run a sequence of git command arg-lists, stopping on first failure."""
+        output_lines = []
+        for args in commands:
+            success, output = self._run(*args)
+            if output:
+                output_lines.append(output)
+            if not success:
+                return False, "\n".join(output_lines)
+        return True, "\n".join(output_lines)
+
+    def flow_feature_start(self, name: str) -> tuple:
+        """
+        Starts a feature branch from develop: checkout develop, create feature/<name>.
+
+        :param name: Feature branch name (without the feature/ prefix).
+        :returns: (success, output) tuple.
+        """
+        safe_name = name.replace(" ", "_")
+        return self._run_sequence(
+            ["checkout", "develop"],
+            ["checkout", "-b", f"feature/{safe_name}"],
+        )
+
+    def flow_feature_finish(self, name: str) -> tuple:
+        """
+        Finishes a feature branch: merge --no-ff into develop, delete the branch.
+
+        :param name: Feature branch name (without the feature/ prefix).
+        :returns: (success, output) tuple.
+        """
+        branch = f"feature/{name}"
+        return self._run_sequence(
+            ["checkout", "develop"],
+            ["merge", "--no-ff", branch, "-m", f"Merge feature '{name}' into develop"],
+            ["branch", "-d", branch],
+        )
+
+    def flow_release_start(self, version: str) -> tuple:
+        """
+        Starts a release branch from develop: checkout develop, create release/<version>.
+
+        :param version: Release version string (e.g. "1.2.0").
+        :returns: (success, output) tuple.
+        """
+        return self._run_sequence(
+            ["checkout", "develop"],
+            ["checkout", "-b", f"release/{version}"],
+        )
+
+    def _detect_main_branch(self) -> str:
+        """Returns 'main' if it exists as a local branch, otherwise 'master'."""
+        result = subprocess.run(
+            ["git", "-C", self.repo, "show-ref", "--verify", "--quiet", "refs/heads/main"],
+            capture_output=True, text=True,
+        )
+        return "main" if result.returncode == 0 else "master"
+
+    def flow_release_finish(self, version: str) -> tuple:
+        """
+        Finishes a release branch: merge into main/master, tag, merge into develop, delete branch, merge main/master back into develop.
+
+        :param version: Release version string (e.g. "1.2.0").
+        :returns: (success, output) tuple.
+        """
+        main_branch = self._detect_main_branch()
+        branch = f"release/{version}"
+        return self._run_sequence(
+            ["checkout", main_branch],
+            ["merge", "--no-ff", branch, "-m", f"Release {version}"],
+            ["tag", "-a", version, "-m", f"Release {version}"],
+            ["checkout", "develop"],
+            ["merge", "--no-ff", branch, "-m", f"Merge release '{version}' into develop"],
+            ["branch", "-d", branch],
+            ["merge", "--no-ff", main_branch, "-m", f"Merge {main_branch} into develop after release {version}"],
+        )
+
+    def get_logs(self, limit: int = 1000, branch: str = ""):
+        """
+        Returns parsed git log entries for the repository.
+
+        :param limit: Maximum number of commits to retrieve (default: 1000).
+        :param branch: Branch to retrieve logs for. If empty, uses the current branch.
+        :returns: List of parsed GitLog entries.
+        """
+        # GitterLogger.log( f"**********************************\nGetting logs for branch {branch} at {self.repo}\n**********************************" )
+
+        if self.repo is None:
+            return "No repository initialized"
+
+        args = ["git", "-C", self.repo, "log", "--decorate", "-n", f"{limit}"]
+        if (branch != ""):
+            args.append( branch)
+
+        theLogs = subprocess.run( args, capture_output=True, text=True)
+
+        # GitterLogger.log( f"Git logs: {theLogs.stdout}" )
+        # GitterLogger.log( f"Git error: {theLogs.stderr}" )
+
+        return GitLog.parse_logstring( theLogs.stdout )

gitterapp-0.1.10/BusinessLogic/toml_helper.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+
+from pathlib import Path
+
+class TomlHelper:
+    def __init__(self):
+        self.filename = Path(__file__).parent.parent / "pyproject.toml"
+
+    """Helper class for working with TOML files."""
+    def get_version(self) -> str:
+        with open(self.filename, "r") as file:
+            for line in file:
+                strip_line = line.strip()
+                if strip_line.startswith("version"):
+                    return strip_line.split("=")[1].strip()
+
+        return "ERROR: Version not found in pyproject.toml"
+
+
+if __name__ == "__main__":
+    helper = TomlHelper()
+    version = helper.get_version()
+    print(f"Project version: {version}")

gitterapp-0.1.10/LICENSE.md

@@ -0,0 +1,23 @@
+
+
+# MIT License
+
+Copyright 2026 Bobby Skinner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy 
+of this software and associated documentation files (the “Software”), to deal 
+in the Software without restriction, including without limitation the rights 
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+**THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.**

gitterapp-0.1.10/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: gitterApp
+Version: 0.1.10
+Summary: Git repo manager get status of multiple git repos in one place
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: gitstatus>=1.2
+Requires-Dist: textual>=8.1.1
+Requires-Dist: textual-dev>=1.8.0
+Dynamic: license-file
+
+# Gitter
+
+A terminal dashboard for monitoring multiple Git repositories. Built with Python and [Textual](https://github.com/Textualize/textual).
+
+Gitter shows the status, current release, and upcoming issues for all your configured repos at a glance — and lets you stage files and write commits without leaving the terminal.
+
+---
+
+## Features
+
+- **Multi-repo dashboard** — see branch status, release version, and next-release issues for all projects in one view
+- **Release notes** — commits are parsed into tagged releases and issues, displayed as a Markdown panel
+- **Git commit modal** — type/issue/summary fields auto-filled from the branch name, with a staging view for reviewing changes before committing
+- **Stage/unstage files** — double-click files to stage or unstage; one-click stage all / unstage all
+- **CLI interface** — `status` and `issues` commands with Rich-formatted tables for use in scripts or pipelines
+- **Auto-refresh** — repos are polled every 90 seconds in the background
+
+## Requirements
+
+- Python 3.9+
+- Git installed and available on `PATH`
+
+## Installation
+
+```bash
+git clone https://github.com/bobbyskinnerart/Gitter.git
+cd Gitter
+python -m venv .venv
+source .venv/bin/activate       # Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+```
+
+## Usage
+
+### TUI (interactive dashboard)
+
+```bash
+python main.py tui
+```
+
+### CLI commands
+
+```bash
+python main.py status                   # Table of all projects with status and release info
+python main.py issues                   # All issues grouped by project and release
+python main.py issues -p <project>      # Filter by project name
+python main.py issues -r <release>      # Filter by release tag
+python main.py version                  # Print version
+```
+
+### Key bindings (TUI)
+
+| Key | Action |
+|-----|--------|
+| `Ctrl+K` | Commit selected project |
+| `Ctrl+A` | Add project |
+| `Ctrl+E` | Edit selected project |
+| `Ctrl+D` | Delete selected project |
+| `Ctrl+R` | Toggle release notes panel |
+| `Ctrl+L` | Toggle log panel |
+| `Ctrl+Q` | Quit |
+
+Double-click a project row to edit it.
+
+## Configuration
+
+Projects are stored in `~/.gitter` as JSON. Add a repo via `Ctrl+A` in the TUI or by editing the file directly.
+
+Each project entry supports:
+
+| Field | Description |
+|-------|-------------|
+| `name` | Display name |
+| `directory` | Absolute path to the git repo |
+| `tagBranch` | Branch where release tags live (e.g. `main`) |
+| `issuePrefixes` | Issue prefixes to detect in commit messages (e.g. `GIT`, `PROJ`) |
+| `prPatterns` | PR number patterns (regex) |
+| `groups` | Optional grouping labels |
+| `favorite` | Mark as favorite |
+
+## License
+
+MIT — see [LICENSE.md](LICENSE.md) for details.

gitterapp-0.1.10/README.md

@@ -0,0 +1,83 @@
+# Gitter
+
+A terminal dashboard for monitoring multiple Git repositories. Built with Python and [Textual](https://github.com/Textualize/textual).
+
+Gitter shows the status, current release, and upcoming issues for all your configured repos at a glance — and lets you stage files and write commits without leaving the terminal.
+
+---
+
+## Features
+
+- **Multi-repo dashboard** — see branch status, release version, and next-release issues for all projects in one view
+- **Release notes** — commits are parsed into tagged releases and issues, displayed as a Markdown panel
+- **Git commit modal** — type/issue/summary fields auto-filled from the branch name, with a staging view for reviewing changes before committing
+- **Stage/unstage files** — double-click files to stage or unstage; one-click stage all / unstage all
+- **CLI interface** — `status` and `issues` commands with Rich-formatted tables for use in scripts or pipelines
+- **Auto-refresh** — repos are polled every 90 seconds in the background
+
+## Requirements
+
+- Python 3.9+
+- Git installed and available on `PATH`
+
+## Installation
+
+```bash
+git clone https://github.com/bobbyskinnerart/Gitter.git
+cd Gitter
+python -m venv .venv
+source .venv/bin/activate       # Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+```
+
+## Usage
+
+### TUI (interactive dashboard)
+
+```bash
+python main.py tui
+```
+
+### CLI commands
+
+```bash
+python main.py status                   # Table of all projects with status and release info
+python main.py issues                   # All issues grouped by project and release
+python main.py issues -p <project>      # Filter by project name
+python main.py issues -r <release>      # Filter by release tag
+python main.py version                  # Print version
+```
+
+### Key bindings (TUI)
+
+| Key | Action |
+|-----|--------|
+| `Ctrl+K` | Commit selected project |
+| `Ctrl+A` | Add project |
+| `Ctrl+E` | Edit selected project |
+| `Ctrl+D` | Delete selected project |
+| `Ctrl+R` | Toggle release notes panel |
+| `Ctrl+L` | Toggle log panel |
+| `Ctrl+Q` | Quit |
+
+Double-click a project row to edit it.
+
+## Configuration
+
+Projects are stored in `~/.gitter` as JSON. Add a repo via `Ctrl+A` in the TUI or by editing the file directly.
+
+Each project entry supports:
+
+| Field | Description |
+|-------|-------------|
+| `name` | Display name |
+| `directory` | Absolute path to the git repo |
+| `tagBranch` | Branch where release tags live (e.g. `main`) |
+| `issuePrefixes` | Issue prefixes to detect in commit messages (e.g. `GIT`, `PROJ`) |
+| `prPatterns` | PR number patterns (regex) |
+| `groups` | Optional grouping labels |
+| `favorite` | Mark as favorite |
+
+## License
+
+MIT — see [LICENSE.md](LICENSE.md) for details.

gitterapp-0.1.10/TUI/GitFlow/finish_feature.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from textual import on
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label
+from textual.containers import Horizontal, Vertical
+
+from model.Project import Project
+
+
+class FinishFeatureModal(ModalScreen[bool]):
+    """Modal confirming finish of the current git-flow feature branch.
+
+    Dismisses with True on Finish, or False on Cancel.
+    """
+
+    def __init__(self, project: Project):
+        super().__init__()
+        self._project = project
+        branch = project.status.branch if project.status else ""
+        self._feature_name = branch.split("/", 1)[1] if "/" in branch else branch
+
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Label("Finish Feature", id="finish_feature_title"),
+            Label(
+                f"Do you want to finish the feature: [bold cyan]{self._feature_name}[/bold cyan]?",
+                id="finish_feature_message",
+            ),
+            Horizontal(
+                Button("Cancel", variant="default", id="btn_cancel"),
+                Button("Finish", variant="primary", id="btn_finish"),
+                id="finish_feature_buttons",
+            ),
+            id="finish_feature_container",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one("#btn_finish", Button).focus()
+
+    @on(Button.Pressed, "#btn_cancel")
+    def handle_cancel(self) -> None:
+        self.dismiss(False)
+
+    @on(Button.Pressed, "#btn_finish")
+    def handle_finish(self) -> None:
+        self.dismiss(True)
+
+    @property
+    def feature_name(self) -> str:
+        return self._feature_name

gitterapp-0.1.10/TUI/GitFlow/finish_release.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from textual import on
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label
+from textual.containers import Horizontal, Vertical
+
+from model.Project import Project
+
+
+class FinishReleaseModal(ModalScreen[bool]):
+    """Modal confirming finish of the current git-flow release branch.
+
+    Dismisses with True on Finish, or False on Cancel.
+    """
+
+    def __init__(self, project: Project):
+        super().__init__()
+        self._project = project
+        branch = project.status.branch if project.status else ""
+        self._version = branch.split("/", 1)[1] if "/" in branch else branch
+
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Label("Finish Release", id="finish_release_title"),
+            Label(
+                f"Do you want to finish release: [bold cyan]{self._version}[/bold cyan]?",
+                id="finish_release_message",
+            ),
+            Horizontal(
+                Button("Cancel", variant="default", id="btn_cancel"),
+                Button("Finish", variant="primary", id="btn_finish"),
+                id="finish_release_buttons",
+            ),
+            id="finish_release_container",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one("#btn_finish", Button).focus()
+
+    @on(Button.Pressed, "#btn_cancel")
+    def handle_cancel(self) -> None:
+        self.dismiss(False)
+
+    @on(Button.Pressed, "#btn_finish")
+    def handle_finish(self) -> None:
+        self.dismiss(True)
+
+    @property
+    def version(self) -> str:
+        return self._version

gitterapp-0.1.10/TUI/GitFlow/start_feature.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from textual import on
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label
+from textual.containers import Horizontal, Vertical
+
+from model.Project import Project
+
+
+class StartFeatureModal(ModalScreen[Optional[str]]):
+    """Modal for starting a new git-flow feature branch.
+
+    Dismisses with the feature name string on Start, or None on Cancel.
+    """
+
+    def __init__(self, project: Project):
+        super().__init__()
+        self._project = project
+
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Label(f"Start Feature — {self._project.name}", id="start_feature_title"),
+            Label("Feature name", classes="start_feature_label"),
+            Input(placeholder="my-feature", id="feature_name"),
+            Horizontal(
+                Button("Cancel", variant="default", id="btn_cancel"),
+                Button("Start", variant="primary", id="btn_start"),
+                id="start_feature_buttons",
+            ),
+            id="start_feature_container",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one("#feature_name", Input).focus()
+
+    @on(Button.Pressed, "#btn_cancel")
+    def handle_cancel(self) -> None:
+        self.dismiss(None)
+
+    @on(Button.Pressed, "#btn_start")
+    def handle_start(self) -> None:
+        name = self.query_one("#feature_name", Input).value.strip()
+        if name:
+            self.dismiss(name)