cli-comet 1.2.0__tar.gz → 1.2.2__tar.gz

cli_comet-1.2.2/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: cli-comet
+Version: 1.2.2
+Summary: A terminal UI that automatically generates git commit messages using local language models via Ollama.
+Home-page: https://github.com/razoring/CometCLI
+Author: razoring
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ollama
+Requires-Dist: textual
+Requires-Dist: colorama
+Requires-Dist: openai
+Dynamic: license-file
+
+# Comet CLI
+
+Comet helps you save tokens! Comet is a terminal user interface application that automatically generates descriptive git commit messages using local language models via Ollama or LMStudio. It analyzes your staged git diffs and provides a clean interface to review, edit, regenerate, and commit your changes instantly.
+
+## Features
+
+- **Instant Boot**: The UI renders instantly with zero latency, utilizing background threading for network auto-detection and initialization.
+- **Provider Auto-Detection**: Automatically detects whether you are running Ollama or LMStudio locally without requiring configuration, while allowing overrides via the `--provider` flag.
+- **Persistent Settings**: Comet remembers your last successfully used provider and model in a `settings.json` file inside the installation directory, skipping auto-detection on future boot-ups.
+- **Local Model Generation**: Connects to your local AI servers to generate commit messages entirely privately.
+- **Model Swapping**: Press `tab` to cycle through available local models directly from the interface. 
+- **Context Aware**: Automatically pulls in the last 5 commits to understand the tone and style of your project.
+- **Terminal User Interface**: Built with Textual. It provides a dedicated text area to edit the generated message.
+- **Dynamic Newlines**: Use the down arrow key on the last line to seamlessly add new lines to your commit message, and the up arrow key to remove them.
+- **Quick Undo**: Press `ctrl+z` to instantly undo the last local commit if you need to make changes.
+- **Direct Syncing**: Commit your changes and immediately push them to your remote repository with a second press of the commit button.
+- **Customizable Prompts**: The instructions provided to the language model are stored in `comet/system.md` and can be edited to fit your specific workflow.
+
+## Requirements
+
+- Python 3.10 or higher
+- Git installed and accessible in your system path
+- Ollama or LMStudio installed and running locally
+
+## Installation
+
+The recommended way to install Comet is globally using `pipx`:
+
+```bash
+pipx install cli-comet
+```
+
+### Installation from Source
+
+Clone the repository and install the required dependencies:
+
+```bash
+git clone https://github.com/razoring/CometCLI.git
+cd CometCLI
+python -m venv .venv
+
+# On Windows
+.venv\Scripts\activate
+
+# On Unix/macOS
+source .venv/bin/activate
+
+pip install -e .
+```
+
+## Usage
+
+Ensure you have staged your changes using `git add` and that Ollama or LMStudio is running in the background.
+
+Run the Comet application:
+
+```bash
+comet
+```
+
+You can optionally force a specific provider:
+```bash
+comet --provider ollama
+comet --provider lmstudio
+```
+
+### Keyboard Shortcuts
+
+- `enter`: Commit the current text. If pressed again, it will push the commit to the remote repository.
+- `tab`: Swap the active language model.
+- `ctrl+r`: Regenerate the commit message with the current model.
+- `ctrl+z`: Undo the most recent local commit.
+- `ctrl+t`: Terminate the application.
+- `down arrow`: Add a new line when at the bottom of the text area.
+- `up arrow`: Remove the previous empty line.
+
+## Architecture
+
+Comet uses the `subprocess` module to run git commands and capture diffs. It reads the local `comet/system.md` file for system instructions and sends the diff to the selected provider's API. The interface is built using Textual, providing responsive keyboard bindings and a resilient terminal layout. All blocking network logic runs in an asynchronous `@work` thread to ensure 0ms UI start latency.
+
+## License
+
+This project is licensed under the GNU General Public License v3.0 (GPL-3.0). See the `LICENSE` file for details.

cli_comet-1.2.2/README.md

@@ -0,0 +1,83 @@
+# Comet CLI
+
+Comet helps you save tokens! Comet is a terminal user interface application that automatically generates descriptive git commit messages using local language models via Ollama or LMStudio. It analyzes your staged git diffs and provides a clean interface to review, edit, regenerate, and commit your changes instantly.
+
+## Features
+
+- **Instant Boot**: The UI renders instantly with zero latency, utilizing background threading for network auto-detection and initialization.
+- **Provider Auto-Detection**: Automatically detects whether you are running Ollama or LMStudio locally without requiring configuration, while allowing overrides via the `--provider` flag.
+- **Persistent Settings**: Comet remembers your last successfully used provider and model in a `settings.json` file inside the installation directory, skipping auto-detection on future boot-ups.
+- **Local Model Generation**: Connects to your local AI servers to generate commit messages entirely privately.
+- **Model Swapping**: Press `tab` to cycle through available local models directly from the interface. 
+- **Context Aware**: Automatically pulls in the last 5 commits to understand the tone and style of your project.
+- **Terminal User Interface**: Built with Textual. It provides a dedicated text area to edit the generated message.
+- **Dynamic Newlines**: Use the down arrow key on the last line to seamlessly add new lines to your commit message, and the up arrow key to remove them.
+- **Quick Undo**: Press `ctrl+z` to instantly undo the last local commit if you need to make changes.
+- **Direct Syncing**: Commit your changes and immediately push them to your remote repository with a second press of the commit button.
+- **Customizable Prompts**: The instructions provided to the language model are stored in `comet/system.md` and can be edited to fit your specific workflow.
+
+## Requirements
+
+- Python 3.10 or higher
+- Git installed and accessible in your system path
+- Ollama or LMStudio installed and running locally
+
+## Installation
+
+The recommended way to install Comet is globally using `pipx`:
+
+```bash
+pipx install cli-comet
+```
+
+### Installation from Source
+
+Clone the repository and install the required dependencies:
+
+```bash
+git clone https://github.com/razoring/CometCLI.git
+cd CometCLI
+python -m venv .venv
+
+# On Windows
+.venv\Scripts\activate
+
+# On Unix/macOS
+source .venv/bin/activate
+
+pip install -e .
+```
+
+## Usage
+
+Ensure you have staged your changes using `git add` and that Ollama or LMStudio is running in the background.
+
+Run the Comet application:
+
+```bash
+comet
+```
+
+You can optionally force a specific provider:
+```bash
+comet --provider ollama
+comet --provider lmstudio
+```
+
+### Keyboard Shortcuts
+
+- `enter`: Commit the current text. If pressed again, it will push the commit to the remote repository.
+- `tab`: Swap the active language model.
+- `ctrl+r`: Regenerate the commit message with the current model.
+- `ctrl+z`: Undo the most recent local commit.
+- `ctrl+t`: Terminate the application.
+- `down arrow`: Add a new line when at the bottom of the text area.
+- `up arrow`: Remove the previous empty line.
+
+## Architecture
+
+Comet uses the `subprocess` module to run git commands and capture diffs. It reads the local `comet/system.md` file for system instructions and sends the diff to the selected provider's API. The interface is built using Textual, providing responsive keyboard bindings and a resilient terminal layout. All blocking network logic runs in an asynchronous `@work` thread to ensure 0ms UI start latency.
+
+## License
+
+This project is licensed under the GNU General Public License v3.0 (GPL-3.0). See the `LICENSE` file for details.

cli_comet-1.2.2/cli_comet.egg-info/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: cli-comet
+Version: 1.2.2
+Summary: A terminal UI that automatically generates git commit messages using local language models via Ollama.
+Home-page: https://github.com/razoring/CometCLI
+Author: razoring
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ollama
+Requires-Dist: textual
+Requires-Dist: colorama
+Requires-Dist: openai
+Dynamic: license-file
+
+# Comet CLI
+
+Comet helps you save tokens! Comet is a terminal user interface application that automatically generates descriptive git commit messages using local language models via Ollama or LMStudio. It analyzes your staged git diffs and provides a clean interface to review, edit, regenerate, and commit your changes instantly.
+
+## Features
+
+- **Instant Boot**: The UI renders instantly with zero latency, utilizing background threading for network auto-detection and initialization.
+- **Provider Auto-Detection**: Automatically detects whether you are running Ollama or LMStudio locally without requiring configuration, while allowing overrides via the `--provider` flag.
+- **Persistent Settings**: Comet remembers your last successfully used provider and model in a `settings.json` file inside the installation directory, skipping auto-detection on future boot-ups.
+- **Local Model Generation**: Connects to your local AI servers to generate commit messages entirely privately.
+- **Model Swapping**: Press `tab` to cycle through available local models directly from the interface. 
+- **Context Aware**: Automatically pulls in the last 5 commits to understand the tone and style of your project.
+- **Terminal User Interface**: Built with Textual. It provides a dedicated text area to edit the generated message.
+- **Dynamic Newlines**: Use the down arrow key on the last line to seamlessly add new lines to your commit message, and the up arrow key to remove them.
+- **Quick Undo**: Press `ctrl+z` to instantly undo the last local commit if you need to make changes.
+- **Direct Syncing**: Commit your changes and immediately push them to your remote repository with a second press of the commit button.
+- **Customizable Prompts**: The instructions provided to the language model are stored in `comet/system.md` and can be edited to fit your specific workflow.
+
+## Requirements
+
+- Python 3.10 or higher
+- Git installed and accessible in your system path
+- Ollama or LMStudio installed and running locally
+
+## Installation
+
+The recommended way to install Comet is globally using `pipx`:
+
+```bash
+pipx install cli-comet
+```
+
+### Installation from Source
+
+Clone the repository and install the required dependencies:
+
+```bash
+git clone https://github.com/razoring/CometCLI.git
+cd CometCLI
+python -m venv .venv
+
+# On Windows
+.venv\Scripts\activate
+
+# On Unix/macOS
+source .venv/bin/activate
+
+pip install -e .
+```
+
+## Usage
+
+Ensure you have staged your changes using `git add` and that Ollama or LMStudio is running in the background.
+
+Run the Comet application:
+
+```bash
+comet
+```
+
+You can optionally force a specific provider:
+```bash
+comet --provider ollama
+comet --provider lmstudio
+```
+
+### Keyboard Shortcuts
+
+- `enter`: Commit the current text. If pressed again, it will push the commit to the remote repository.
+- `tab`: Swap the active language model.
+- `ctrl+r`: Regenerate the commit message with the current model.
+- `ctrl+z`: Undo the most recent local commit.
+- `ctrl+t`: Terminate the application.
+- `down arrow`: Add a new line when at the bottom of the text area.
+- `up arrow`: Remove the previous empty line.
+
+## Architecture
+
+Comet uses the `subprocess` module to run git commands and capture diffs. It reads the local `comet/system.md` file for system instructions and sends the diff to the selected provider's API. The interface is built using Textual, providing responsive keyboard bindings and a resilient terminal layout. All blocking network logic runs in an asynchronous `@work` thread to ensure 0ms UI start latency.
+
+## License
+
+This project is licensed under the GNU General Public License v3.0 (GPL-3.0). See the `LICENSE` file for details.

{cli_comet-1.2.0 → cli_comet-1.2.2}/comet/cli.py

@@ -65,8 +65,10 @@ from textual import work, events
 import subprocess, colorama
 
 class CustomTextArea(TextArea):
-    Binding("ctrl+r", "regenerate_action", "Regenerate", priority=True),
-    Binding("ctrl+t", "exit_action", "Terminate", priority=True)
+    BINDINGS = [
+        Binding("ctrl+r", "regenerate_action", "Regenerate", priority=True),
+        Binding("escape", "exit_action", "Terminate", priority=True)
+    ]
 
     def on_key(self, event: events.Key) -> None:
         if event.key == "enter":
@@ -158,6 +160,14 @@ class CometTUI(App):
         border: none;
     }
 
+    #undoBtn {
+        width: 1fr;
+        margin-left: 1;
+        height: 3;
+        background: $secondary;
+        border: none;
+    }
+
     #cancelBtn {
         margin-left: 1;
         height: 3;
@@ -182,7 +192,7 @@ class CometTUI(App):
 
     BINDINGS = [
         Binding("ctrl+r", "regenerate_action", "Regenerate", priority=True),
-        Binding("ctrl+t", "exit_action", "Terminate", priority=True),
+        Binding("escape", "exit_action", "Quit", priority=True),
         Binding("ctrl+z", "undo_commit", "Undo Commit", priority=True),
         Binding("tab", "swap_model", "Swap Model", priority=True)
     ]
@@ -205,9 +215,12 @@ class CometTUI(App):
                 yield CustomTextArea(self.commit, id="input", show_line_numbers=False)
                 yield Button(" ₊✦  Regenerate  ", id="regenBtn")
             with Horizontal(id="action_row"):
-                yield Button(" ✔   Commit", id="commitBtn")
-                yield Button(" 🗙   Terminate", id="cancelBtn")
-            yield Label("[white][b]ctrl+r[/b][/white] [gray]regenerate[/gray]    [white][b]enter[/b][/white] [gray]continue[/gray]    [white][b]tab[/b][/white] [gray]swap model[/gray]    [white][b]ctrl+z[/b][/white] [gray]undo[/gray]    [white][b]↓/↑[/b][/white] [gray]move lines[/gray]    [white][b]ctrl+t[/b][/white] [gray]terminate[/gray]", id="shortcuts")
+                yield Button(" ✔   Commit ", id="commitBtn")
+                undo = Button(" ↺   Undo ", id="undoBtn")
+                undo.display = False
+                yield undo
+                yield Button(" 🗙   Quit ", id="cancelBtn")
+            yield Label("[white][b]ctrl+r[/b][/white] [gray]regenerate[/gray]    [white][b]enter[/b][/white] [gray]continue[/gray]    [white][b]tab[/b][/white] [gray]swap model[/gray]    [white][b]ctrl+z[/b][/white] [gray]undo[/gray]    [white][b]↓/↑[/b][/white] [gray]move lines[/gray]    [white][b]esc[/b][/white] [gray]quit[/gray]", id="shortcuts")
 
     def action_swap_model(self) -> None:
         if not self.allModels: return
@@ -226,7 +239,7 @@ class CometTUI(App):
             regenBtn.press()
 
     def action_exit_action(self) -> None:
-        self.query_one("#cancelBtn", Button).press()
+        self.exit(f"{colorama.Fore.RED}User cancelled the operation. {colorama.Style.RESET_ALL}")
 
     def action_commit_action(self) -> None:
         commitBtn = self.query_one("#commitBtn", Button)
@@ -237,7 +250,9 @@ class CometTUI(App):
         commitBtn = self.query_one("#commitBtn", Button)
         if str(commitBtn.label).strip() == "Sync  ➤":
             subprocess.run(["git", "reset", "HEAD~1"], capture_output=True)
-            commitBtn.label = " ✔   Commit"
+            commitBtn.label = " ✔   Commit "
+            self.query_one("#undoBtn").display = False
+            self.query_one("#cancelBtn").display = True
 
     def on_mount(self) -> None:
         self.query_one("#input_row").border_title = f"{self.model}"
@@ -303,9 +318,14 @@ class CometTUI(App):
             
             subprocess.run(["git", "commit", "-a", "-m", finalMessage], capture_output=True)
             event.button.label = "Sync  ➤"
+            self.query_one("#undoBtn").display = True
+            self.query_one("#cancelBtn").display = False
             
         elif event.button.id == "cancelBtn":
             self.exit(f"{colorama.Fore.RED}User cancelled the operation. {colorama.Style.RESET_ALL}")
+
+        elif event.button.id == "undoBtn":
+            self.action_undo_commit()
             
         elif event.button.id == "regenBtn":
             event.button.disabled = True

{cli_comet-1.2.0 → cli_comet-1.2.2}/comet/system.md

@@ -33,8 +33,18 @@ Read the diff carefully and choose exactly ONE of the following standard convent
 Analyze the diff to understand the *high-level intent* and *functional purpose* of the changes. Do not just blindly list what lines were added or removed. Instead, explain *what the code actually accomplishes* in the context of the larger project.
 Use the imperative, present tense mood. Be concise but highly descriptive. If the diff shows the introduction of a new library or UI framework, mention its purpose. Keep it abstract and functional rather than a literal line-by-line translation.
 
-### EXPECTED OUTPUT FORMAT
-You must output exactly one line in the following format:
-<type>: <description>
+### CRITICAL OUTPUT FORMAT RULES
+You MUST adhere to the following rules or your output will break the system:
+1. OUTPUT EXACTLY ONE LINE. Do NOT output a list of multiple options or types.
+2. DO NOT use any markdown formatting whatsoever (no bold `**`, no italics, no code blocks ` ``` `).
+3. DO NOT start the line with a bullet point, dash (`-`), or asterisk (`*`).
+4. DO NOT add any introductory or concluding text (e.g. no "Here is the commit message:").
 
-Do not add any additional explanation, markdown formatting, or introductory text. Only output the final commit message. Do not add a dash in the beginning
+The ONLY output you provide should be the raw, plain-text string matching this exact pattern:
+type: description
+
+Example of CORRECT output:
+feat: implement asynchronous network checking for zero latency boot
+
+Example of INCORRECT output:
+- **feat:** implement asynchronous network checking

{cli_comet-1.2.0 → cli_comet-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cli-comet"
-version = "1.2.0"
+version = "1.2.2"
 description = "A terminal UI that automatically generates git commit messages using local language models via Ollama."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -13,7 +13,7 @@ authors = [
 ]
 classifiers = [
     "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
     "Operating System :: OS Independent",
     "Environment :: Console",
 ]

{cli_comet-1.2.0 → cli_comet-1.2.2}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = cli-comet
-version = 1.2.0
+version = 1.2.2
 description = A terminal UI that automatically generates git commit messages using local language models via Ollama.
 long_description = file: README.md
 long_description_content_type = text/markdown
@@ -9,7 +9,7 @@ license = GPL-3.0 license
 url = https://github.com/razoring/CometCLI
 classifiers = 
 	Programming Language :: Python :: 3
-	License :: OSI Approved :: MIT License
+	License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 	Operating System :: OS Independent
 	Environment :: Console
 

cli_comet-1.2.0/PKG-INFO

@@ -1,81 +0,0 @@
-Metadata-Version: 2.4
-Name: cli-comet
-Version: 1.2.0
-Summary: A terminal UI that automatically generates git commit messages using local language models via Ollama.
-Home-page: https://github.com/razoring/CometCLI
-Author: razoring
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Environment :: Console
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: ollama
-Requires-Dist: textual
-Requires-Dist: colorama
-Requires-Dist: openai
-Dynamic: license-file
-
-# Comet
-
-Comet is a terminal user interface application that automatically generates descriptive git commit messages using local language models via Ollama. It analyzes your staged git diffs and provides a clean interface to review, edit, regenerate, and commit your changes.
-
-## Features
-
-- Local Model Generation: Connects to your local Ollama instance to generate commit messages privately.
-- Model Swapping: Press `tab` to cycle through available local models directly from the interface. Comet defaults to your currently loaded model to save time.
-- Context Aware: Automatically pulls in the last 5 commits to understand the tone and style of your project.
-- Terminal User Interface: Built with Textual. It provides a dedicated text area to edit the generated message.
-- Dynamic Newlines: Use the down arrow key on the last line to seamlessly add new lines to your commit message, and the up arrow key to remove them.
-- Quick Undo: Press `ctrl+z` to instantly undo the last local commit if you need to make changes.
-- Direct Syncing: Commit your changes and immediately push them to your remote repository with a second press of the commit button.
-- Customizable Prompts: The instructions provided to the language model are stored in `comet/system.md` and can be edited to fit your specific workflow.
-
-## Requirements
-
-- Python 3.10 or higher
-- Git installed and accessible in your system path
-- Ollama installed and running locally
-
-## Installation
-
-Clone the repository and install the required dependencies:
-
-```bash
-git clone <repository_url>
-cd Comet
-python -m venv .venv
-
-# On Windows
-.venv\Scripts\activate
-
-# On Unix/macOS
-source .venv/bin/activate
-
-pip install -r requirements.txt
-```
-
-## Usage
-
-Ensure you have staged your changes using `git add` and that Ollama is running in the background.
-
-Run the Comet application:
-
-```bash
-comet
-```
-
-### Keyboard Shortcuts
-
-- `enter`: Commit the current text. If pressed again, it will push the commit to the remote repository.
-- `tab`: Swap the active language model.
-- `ctrl+r`: Regenerate the commit message with the current model.
-- `ctrl+z`: Undo the most recent local commit.
-- `ctrl+t`: Terminate the application.
-- `down arrow`: Add a new line when at the bottom of the text area.
-- `up arrow`: Remove the previous empty line.
-
-## Architecture
-
-Comet uses the `subprocess` module to run git commands and capture diffs. It reads the local `comet/system.md` file for system instructions and sends the diff to the Ollama Python client. The interface is built using Textual, providing responsive keyboard bindings and a resilient terminal layout.

cli_comet-1.2.0/README.md

@@ -1,62 +0,0 @@
-# Comet
-
-Comet is a terminal user interface application that automatically generates descriptive git commit messages using local language models via Ollama. It analyzes your staged git diffs and provides a clean interface to review, edit, regenerate, and commit your changes.
-
-## Features
-
-- Local Model Generation: Connects to your local Ollama instance to generate commit messages privately.
-- Model Swapping: Press `tab` to cycle through available local models directly from the interface. Comet defaults to your currently loaded model to save time.
-- Context Aware: Automatically pulls in the last 5 commits to understand the tone and style of your project.
-- Terminal User Interface: Built with Textual. It provides a dedicated text area to edit the generated message.
-- Dynamic Newlines: Use the down arrow key on the last line to seamlessly add new lines to your commit message, and the up arrow key to remove them.
-- Quick Undo: Press `ctrl+z` to instantly undo the last local commit if you need to make changes.
-- Direct Syncing: Commit your changes and immediately push them to your remote repository with a second press of the commit button.
-- Customizable Prompts: The instructions provided to the language model are stored in `comet/system.md` and can be edited to fit your specific workflow.
-
-## Requirements
-
-- Python 3.10 or higher
-- Git installed and accessible in your system path
-- Ollama installed and running locally
-
-## Installation
-
-Clone the repository and install the required dependencies:
-
-```bash
-git clone <repository_url>
-cd Comet
-python -m venv .venv
-
-# On Windows
-.venv\Scripts\activate
-
-# On Unix/macOS
-source .venv/bin/activate
-
-pip install -r requirements.txt
-```
-
-## Usage
-
-Ensure you have staged your changes using `git add` and that Ollama is running in the background.
-
-Run the Comet application:
-
-```bash
-comet
-```
-
-### Keyboard Shortcuts
-
-- `enter`: Commit the current text. If pressed again, it will push the commit to the remote repository.
-- `tab`: Swap the active language model.
-- `ctrl+r`: Regenerate the commit message with the current model.
-- `ctrl+z`: Undo the most recent local commit.
-- `ctrl+t`: Terminate the application.
-- `down arrow`: Add a new line when at the bottom of the text area.
-- `up arrow`: Remove the previous empty line.
-
-## Architecture
-
-Comet uses the `subprocess` module to run git commands and capture diffs. It reads the local `comet/system.md` file for system instructions and sends the diff to the Ollama Python client. The interface is built using Textual, providing responsive keyboard bindings and a resilient terminal layout.

cli_comet-1.2.0/cli_comet.egg-info/PKG-INFO

@@ -1,81 +0,0 @@
-Metadata-Version: 2.4
-Name: cli-comet
-Version: 1.2.0
-Summary: A terminal UI that automatically generates git commit messages using local language models via Ollama.
-Home-page: https://github.com/razoring/CometCLI
-Author: razoring
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Environment :: Console
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: ollama
-Requires-Dist: textual
-Requires-Dist: colorama
-Requires-Dist: openai
-Dynamic: license-file
-
-# Comet
-
-Comet is a terminal user interface application that automatically generates descriptive git commit messages using local language models via Ollama. It analyzes your staged git diffs and provides a clean interface to review, edit, regenerate, and commit your changes.
-
-## Features
-
-- Local Model Generation: Connects to your local Ollama instance to generate commit messages privately.
-- Model Swapping: Press `tab` to cycle through available local models directly from the interface. Comet defaults to your currently loaded model to save time.
-- Context Aware: Automatically pulls in the last 5 commits to understand the tone and style of your project.
-- Terminal User Interface: Built with Textual. It provides a dedicated text area to edit the generated message.
-- Dynamic Newlines: Use the down arrow key on the last line to seamlessly add new lines to your commit message, and the up arrow key to remove them.
-- Quick Undo: Press `ctrl+z` to instantly undo the last local commit if you need to make changes.
-- Direct Syncing: Commit your changes and immediately push them to your remote repository with a second press of the commit button.
-- Customizable Prompts: The instructions provided to the language model are stored in `comet/system.md` and can be edited to fit your specific workflow.
-
-## Requirements
-
-- Python 3.10 or higher
-- Git installed and accessible in your system path
-- Ollama installed and running locally
-
-## Installation
-
-Clone the repository and install the required dependencies:
-
-```bash
-git clone <repository_url>
-cd Comet
-python -m venv .venv
-
-# On Windows
-.venv\Scripts\activate
-
-# On Unix/macOS
-source .venv/bin/activate
-
-pip install -r requirements.txt
-```
-
-## Usage
-
-Ensure you have staged your changes using `git add` and that Ollama is running in the background.
-
-Run the Comet application:
-
-```bash
-comet
-```
-
-### Keyboard Shortcuts
-
-- `enter`: Commit the current text. If pressed again, it will push the commit to the remote repository.
-- `tab`: Swap the active language model.
-- `ctrl+r`: Regenerate the commit message with the current model.
-- `ctrl+z`: Undo the most recent local commit.
-- `ctrl+t`: Terminate the application.
-- `down arrow`: Add a new line when at the bottom of the text area.
-- `up arrow`: Remove the previous empty line.
-
-## Architecture
-
-Comet uses the `subprocess` module to run git commands and capture diffs. It reads the local `comet/system.md` file for system instructions and sends the diff to the Ollama Python client. The interface is built using Textual, providing responsive keyboard bindings and a resilient terminal layout.