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

cli_comet-1.2.3/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: cli-comet
+Version: 1.2.3
+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.3/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.3/cli_comet.egg-info/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: cli-comet
+Version: 1.2.3
+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.3}/comet/cli.py

@@ -7,6 +7,7 @@ import os
 import json
 import urllib.request
 import urllib.error
+import importlib.metadata
 
 def get_settings_path():
     return os.path.join(os.path.dirname(__file__), "settings.json")
@@ -65,13 +66,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)
-
-    def on_key(self, event: events.Key) -> None:
-        if event.key == "enter":
-            self.app.action_commit_action()
-            event.prevent_default()
+    BINDINGS = [
+        Binding("ctrl+r", "regenerate_action", "Regenerate", priority=True),
+        Binding("escape", "exit_action", "Terminate", priority=True)
+    ]
 
     def action_cursor_down(self, select: bool = False) -> None:
         if self.cursor_location[0] == self.document.line_count - 1:
@@ -125,7 +123,18 @@ class CometTUI(App):
         height: auto;
         padding: 1;
         background: $surface;
-        border: $primary;
+        border: solid $panel;
+        border-title-color: $text-muted;
+    }
+
+    #input_row:focus-within {
+        border: solid $primary;
+        border-title-color: $primary;
+    }
+
+    #input_row.committed {
+        border: solid $panel;
+        border-title-color: $text-muted;
     }
 
     #input {
@@ -158,6 +167,14 @@ class CometTUI(App):
         border: none;
     }
 
+    #undoBtn {
+        width: 1fr;
+        margin-left: 1;
+        height: 3;
+        background: $secondary;
+        border: none;
+    }
+
     #cancelBtn {
         margin-left: 1;
         height: 3;
@@ -168,7 +185,7 @@ class CometTUI(App):
     #shortcuts {
         width: 100%;
         text-align: center;
-        color: white;
+        color: $text-muted;
         margin-top: 1;
     }
 
@@ -182,9 +199,10 @@ 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)
+        Binding("tab", "swap_model", "Swap Model", priority=True),
+        Binding("enter", "commit_action", "Continue", priority=True)
     ]
 
     def __init__(self, commit: str, model: str, diff: str, commits: str, allModels: list[str], provider: str = "ollama", client = None):
@@ -205,11 +223,16 @@ 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")
+                undo = Button(" ↺   Undo ", id="undoBtn")
+                yield Button(" ✔   Commit ", id="commitBtn")
+                undo.display = False
+                yield undo
+                yield Button(" 🗙   Quit ", id="cancelBtn")
+            yield Label("[$text][b]ctrl+r[/b][/] regenerate    [$text][b]enter[/b][/] continue    [$text][b]tab[/b][/] swap model    [$text][b]ctrl+z[/b][/] undo    [$text][b]↓/↑[/b][/] move lines    [$text][b]esc[/b][/] quit", id="shortcuts")
 
     def action_swap_model(self) -> None:
+        if self.query_one("#input_row").has_class("committed"):
+            return
         if not self.allModels: return
         try:
             currentIndex = self.allModels.index(self.model)
@@ -226,7 +249,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,13 +260,68 @@ 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
+            
+            textArea = self.query_one("#input", TextArea)
+            textArea.disabled = False
+            input_row = self.query_one("#input_row")
+            input_row.remove_class("committed")
+            self.query_one("#regenBtn").disabled = False
 
     def on_mount(self) -> None:
+        if self.provider == "auto" or self.model == "Loading...":
+            self.notify("Welcome! This is the longest it'll take to load. :D", title="Scanning Providers", severity="information", timeout=3.0)
         self.query_one("#input_row").border_title = f"{self.model}"
         self.query_one("#regenBtn").disabled = True
         self.query_one("#commitBtn").disabled = True
+        
+        try:
+            from textual.color import Color
+            v = self.get_css_variables()
+            
+            def resolve_color(val, default_hex):
+                if val.startswith("auto") or not val: return default_hex
+                return val
+                
+            # Default to dark mode colors (#1e1e1e surface, #ffffff text) if unresolved
+            surface_str = resolve_color(v.get("surface", "#1E1E1E"), "#1E1E1E")
+            text_str = resolve_color(v.get("text", "#ffffff"), "#ffffff")
+            
+            surface = Color.parse(surface_str)
+            text = Color.parse(text_str)
+            blended = surface.blend(text, 0.6)
+            
+            css = f"""
+            #input_row {{ border: solid {blended.hex}; }}
+            #input_row.committed {{ border: solid {blended.hex}; }}
+            #input_row:focus-within {{ border: solid $primary; border-title-color: $primary; }}
+            """
+            self.stylesheet.add_source(css)
+            self.stylesheet.update(self)
+        except Exception:
+            pass
+
         self.initialize_llm()
+        self.check_for_updates()
+
+    @work(thread=True)
+    def check_for_updates(self) -> None:
+        try:
+            current_version = importlib.metadata.version("cli-comet")
+            req = urllib.request.Request("https://pypi.org/pypi/cli-comet/json")
+            with urllib.request.urlopen(req, timeout=2.0) as response:
+                data = json.loads(response.read().decode())
+                latest_version = data["info"]["version"]
+                
+                curr_tuple = tuple(map(int, current_version.split(".")))
+                latest_tuple = tuple(map(int, latest_version.split(".")))
+                
+                if latest_tuple > curr_tuple:
+                    self.call_from_thread(self.notify, f"Update available: v{latest_version}! Run `pipx upgrade cli-comet` to install.", title="Update Available", severity="warning", timeout=15.0)
+        except Exception:
+            pass
 
     @work(thread=True)
     def initialize_llm(self) -> None:
@@ -303,9 +381,19 @@ 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
+            
+            textArea.disabled = True
+            input_row = self.query_one("#input_row")
+            input_row.add_class("committed")
+            self.query_one("#regenBtn").disabled = True
             
         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.3}/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.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cli-comet"
-version = "1.2.0"
+version = "1.2.3"
 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.3}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = cli-comet
-version = 1.2.0
+version = 1.2.3
 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.