git-copilot-commit 0.1.20__tar.gz → 0.2.0__tar.gz

git_copilot_commit-0.2.0/.justfile

@@ -0,0 +1,56 @@
+# List available commands
+[private]
+default:
+    @just --list
+
+# Pass all arguments directly to git-copilot-commit
+commit *args:
+    uv run git-copilot-commit commit {{args}}
+
+
+# Bump version based on GitHub tags and create empty commit
+bump type="patch":
+    #!/usr/bin/env bash
+    set -euo pipefail
+
+    # Get the latest tag from GitHub
+    echo "Fetching latest tag from GitHub..."
+    latest_tag=$(gh release list --limit 1 --json tagName --jq '.[0].tagName // "v0.0.0"')
+
+    # Remove 'v' prefix if present
+    version=${latest_tag#v}
+
+    # Parse version components
+    IFS='.' read -r major minor patch <<< "$version"
+
+    # Bump based on type
+    case "{{type}}" in
+        major)
+            major=$((major + 1))
+            minor=0
+            patch=0
+            ;;
+        minor)
+            minor=$((minor + 1))
+            patch=0
+            ;;
+        patch)
+            patch=$((patch + 1))
+            ;;
+        *)
+            echo "Error: Invalid bump type '{{type}}'. Use: major, minor, or patch"
+            exit 1
+            ;;
+    esac
+
+    # Create new version
+    new_version="v${major}.${minor}.${patch}"
+
+    echo "Current version: $latest_tag"
+    echo "New version: $new_version"
+
+    # Create empty commit
+    git commit --allow-empty -m "Bump version to $new_version"
+
+    echo "✓ Created empty commit for $new_version"
+    echo "  Next: Create and push tag with: git tag $new_version && git push && git push --tags"

{git_copilot_commit-0.1.20 → git_copilot_commit-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-copilot-commit
-Version: 0.1.20
+Version: 0.2.0
 Summary: Automatically generate and commit changes using copilot
 Author-email: Dheepak Krishnamurthy <1813121+kdheepak@users.noreply.github.com>
 License-File: LICENSE

{git_copilot_commit-0.1.20 → git_copilot_commit-0.2.0}/src/git_copilot_commit/cli.py

@@ -14,7 +14,7 @@ from pathlib import Path
 
 from pycopilot.copilot import Copilot, CopilotAPIError  # type: ignore
 from pycopilot.auth import Authentication
-from .git import GitRepository, GitError, NotAGitRepositoryError, GitStatus
+from .git import GitRepository, GitError, NotAGitRepositoryError
 from .settings import Settings
 from .version import __version__
 
@@ -24,7 +24,7 @@ app = typer.Typer(help=__doc__, add_completion=False)
 
 def version_callback(value: bool):
     if value:
-        rich.print(f"git-copilot-commit [bold green]{__version__}[/]")
+        rich.print(f"git-copilot-commit [bold yellow]{__version__}[/]")
         raise typer.Exit()
 
 
@@ -46,7 +46,7 @@ def main(
         # Don't show version for print command to avoid interfering with pipes
         if ctx.invoked_subcommand != "echo":
             console.print(
-                f"[bold]{(__package__ or 'git_copilot_commit').replace('_', '-')}[/] - [bold blue]v{__version__}[/]\n"
+                f"[bold]{(__package__ or 'git_copilot_commit').replace('_', '-')}[/] - [bold green]v{__version__}[/]\n"
             )
 
 
@@ -88,40 +88,53 @@ def load_system_prompt() -> str:
 
 
 def generate_commit_message(
-    repo: GitRepository, status: GitStatus, model: str | None = None
+    repo: GitRepository, model: str | None = None, context: str = ""
 ) -> str:
     """Generate a conventional commit message using Copilot API."""
 
+    # Refresh status after staging
+    status = repo.get_status()
+
+    if not status.has_staged_changes:
+        console.print("[red]No staged changes to commit.[/red]")
+        raise typer.Exit()
+
     system_prompt = load_system_prompt()
     client = Copilot(system_prompt=system_prompt)
 
-    prompt = f"""
-`git status`:
-
-```
-{status.get_porcelain_output()}
-```
+    prompt_parts = [
+        "`git status`:\n",
+        f"```\n{status.get_porcelain_output()}\n```",
+        "\n\n`git diff --staged`:\n",
+        f"```\n{status.staged_diff}\n```",
+    ]
 
-`git diff --staged`:
+    if context.strip():
+        prompt_parts.insert(0, f"User-provided context:\n\n{context.strip()}\n\n")
 
-```
-{status.staged_diff}
-```
+    prompt_parts.append("\nGenerate a conventional commit message:")
 
-Generate a conventional commit message:"""
+    prompt = "\n".join(prompt_parts)
 
     try:
         response = client.ask(prompt, model=model) if model else client.ask(prompt)
         return response.content
     except CopilotAPIError:
-        # Fallback to git status only when diff is too large
-        fallback_prompt = f"""`git status`:
+        fallback_prompt_parts = [
+            "`git status`:\n",
+            f"```\n{status.get_porcelain_output()}\n```",
+        ]
+
+        if context.strip():
+            fallback_prompt_parts.insert(
+                0, f"User-provided context:\n\n{context.strip()}\n\n"
+            )
 
-```
-{status.get_porcelain_output()}
-```
+        fallback_prompt_parts.append(
+            "\nGenerate a conventional commit message based on the git status above:"
+        )
 
-Generate a conventional commit message based on the git status above:"""
+        fallback_prompt = "\n".join(fallback_prompt_parts)
 
         response = (
             client.ask(fallback_prompt, model=model)
@@ -142,6 +155,12 @@ def commit(
     yes: bool = typer.Option(
         False, "--yes", "-y", help="Automatically accept the generated commit message"
     ),
+    context: str = typer.Option(
+        "",
+        "--context",
+        "-c",
+        help="Optional user-provided context to guide commit message",
+    ),
 ):
     """
     Generate commit message based on changes in the current git repository and commit them.
@@ -189,25 +208,29 @@ def commit(
                 repo.stage_files()
                 console.print("[green]Staged untracked files.[/green]")
 
-    # Refresh status after staging
-    status = repo.get_status()
-
-    if not status.has_staged_changes:
-        console.print("[yellow]No staged changes to commit.[/yellow]")
-        raise typer.Exit()
+    if context:
+        console.print(
+            Panel(context.strip(), title="User Context", border_style="magenta")
+        )
 
     # Generate or use provided commit message
     with console.status(
-        "[cyan]Generating commit message based on [bold]`git diff --staged`[/bold] ...[/cyan]"
+        "[yellow]Generating commit message based on [bold]`git diff --staged`[/] ...[/yellow]"
     ):
-        commit_message = generate_commit_message(repo, status, model)
+        commit_message = generate_commit_message(repo, model, context=context)
 
     console.print(
-        "[cyan]Generated commit message based on [bold]`git diff --staged`[/bold] ...[/cyan]"
+        "[yellow]Generated commit message based on [bold]`git diff --staged`[/] ...[/yellow]"
     )
 
     # Display commit message
-    console.print(Panel(commit_message, title="Commit Message", border_style="green"))
+    console.print(
+        Panel(
+            f"[bold]{commit_message}[/]",
+            title="Commit Message",
+            border_style="cyan",
+        )
+    )
 
     # Confirm commit or edit message (skip if --yes flag is used)
     if yes:
@@ -349,7 +372,7 @@ def echo(
 
     # Generate commit message from the input
     prompt = f"""
-git diff:
+`git diff --staged`:
 
 ```
 {input_text.strip()}

git_copilot_commit-0.2.0/src/git_copilot_commit/prompts/commit-message-generator-prompt.md

@@ -0,0 +1,62 @@
+# Commit Message Generator System Prompt
+
+You are a Git commit message assistant trained to write a single clear, structured, and informative commit message following the Conventional Commits specification. You will receive:
+
+1. A `git diff --staged` output (or a summary of changed files)
+2. Optionally, additional **user-provided context**
+
+Your task is to generate a **single-line commit message** in the [Conventional Commits](https://www.conventionalcommits.org/) format based on both inputs. If no context is provided, rely **only** on the diff.
+
+## ✅ Output Format
+
+```
+<type>(<optional scope>): <description>
+```
+
+- Do not include a body or footer.
+- Do not wrap the message in backticks or code blocks.
+- Keep the title line ≤72 characters.
+
+## ✅ Valid Types
+
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code formatting (no logic changes)
+- `refactor`: Code restructuring (no behavior changes)
+- `perf`: Performance improvements
+- `test`: Adding or updating tests
+- `chore`: Maintenance tasks (e.g., CI/CD, dependencies)
+- `revert`: Revert of a previous commit
+
+## ✅ Scope (Optional)
+
+- Lowercase, single word or hyphenated phrase
+- Represents the affected area, module, or file
+- Use broad area if multiple related files are affected
+
+## ✅ Subject Line
+
+- Use imperative mood ("remove" not "removed")
+- Focus on **what** changed, not why or how
+- Be concise and specific
+- Use abbreviations (e.g., "config" not "configuration")
+
+## ✅ Using User-Provided Context
+
+- If additional context is provided by the user, you may **incorporate it** to clarify purpose (e.g., "remove duplicate entry").
+- If no such context is provided, **do not speculate or infer**.
+- Only use terms like "unused", "duplicate", or "deprecated" when explicitly stated by the user or clearly shown in the diff.
+
+## ❌ Do Not
+
+- Do not use vague phrases ("made changes", "updated code")
+- Do not use past tense ("added", "removed")
+- Do not explain implementation or reasoning ("to fix bug", "because of issue")
+- Do not guess purpose based on intuition or incomplete file context
+
+---
+
+Given a Git diff, a list of modified files, or a short description of changes, generate a single, short, clear and structured Conventional Commit message following the above rules. If multiple changes are detected, prioritize the most important changes in a single commit message. Do not add any body or footer. You can only give one reply for each conversation.
+
+Do not wrap the response in triple backticks or single backticks. Return the commit message as the output without any additional text, explanations, or formatting markers.

git_copilot_commit-0.1.20/src/git_copilot_commit/prompts/commit-message-generator-prompt.md

@@ -1,70 +0,0 @@
-# Commit Message Generator System Prompt
-
-You are a Git commit message assistant trained to write a single clear, structured, and informative commit message following the Conventional Commits specification based on the provided `git diff --staged` output.
-
-Output format: Provide only the commit message without any additional text, explanations, or formatting markers.
-
-The guidelines for the commit messages are as follows:
-
-## 1. Format
-
-```
-<type>[optional scope]: <description>
-```
-
-- The first line (title) should be at most 72 characters long.
-- If the natural description exceeds 72 characters, prioritize the most important aspect.
-- Use abbreviations when appropriate: `config` not `configuration`.
-- The body (if present) should be wrapped at 100 characters per line.
-
-## 2. Valid Commit Types:
-
-- `feat`: A new feature
-- `fix`: A bug fix
-- `docs`: Documentation changes
-- `style`: Code formatting (no logic changes)
-- `refactor`: Code restructuring (no behavior changes)
-- `perf`: Performance improvements
-- `test`: Adding or updating tests
-- `chore`: Maintenance tasks (e.g., tooling, CI/CD, dependencies)
-- `revert`: Reverting previous changes
-
-## 3. Scope (Optional but encouraged):
-
-- Enclose in parentheses
-- Use the affected module, component, or area
-- For multiple files in same area, use the broader scope
-- For single files, you may use filename
-- Scope should be a single word or hyphenated phrase describing the affected module
-
-## 4. Description:
-
-- Use imperative mood (e.g., "add feature" instead of "added" or "adds").
-- Be concise yet informative.
-- Focus on the primary change, not all details.
-- Do not make assumptions about why the change was made or how it works.
-- When bumping versions, do not mention the names of the files.
-
-## 5. Analyzing Git Diffs:
-
-- Focus on the logical change, not individual line modifications.
-- Group related file changes under one logical scope.
-- Identify the primary purpose of the change set.
-- If changes span multiple unrelated areas, focus on the most significant one.
-
-## ❌ Strongly Avoid:
-
-- Vague descriptions: "fixed bug", "updated code", "made changes"
-- Past tense: "added feature", "fixed issue"
-- Explanations of why: "to improve performance", "because users requested"
-- Implementation details: "using React hooks", "with try-catch blocks"
-- Not in imperative mood: "new feature", "updates stuff"
-
-Given a Git diff, a list of modified files, or a short description of changes,
-generate a single, short, clear and structured Conventional Commit message following the above rules.
-If multiple changes are detected, prioritize the most important changes in a single commit message.
-Do not add any body or footer.
-You can only give one reply for each conversation.
-
-Do not wrap the response in triple backticks or single backticks.
-Return the commit message as the output without any additional text, explanations, or formatting markers.