gitmeup 1.0.0__tar.gz

gitmeup-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 @ikramagix
+
+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 NON-INFRINGEMENT. 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.

gitmeup-1.0.0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: gitmeup
+Version: 1.0.0
+Summary: LLM-assisted conventional commits generator for git repositories. Automatically generates git add and commit lines based on git diff and status.
+License: MIT License
+        
+        Copyright (c) 2025 @ikramagix
+        
+        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 NON-INFRINGEMENT. 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.
+        
+Project-URL: Homepage, https://github.com/ikramagix/gitmeup
+Project-URL: Source, https://github.com/ikramagix/gitmeup
+Project-URL: Issues, https://github.com/ikramagix/gitmeup/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: google-genai>=0.6.0
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: license-file
+
+# gitmeup
+
+`gitmeup` is a lightweight command-line tool that automates Conventional Commit generation using an LLM.
+It analyses your working tree using `git diff --stat`, `git status`, and a filtered `git diff`, then produces
+atomically grouped `git add` and `git commit` commands with strict path-quoting rules.
+
+This improves commit hygiene in large or fast-moving repositories while reducing cognitive overhead.
+
+## Features
+
+- Extracts:
+  - `git diff --stat`
+  - `git status --short`
+  - `git diff` excluding image and binary noise
+- Sends structured context to an LLM
+- Produces:
+  - Precise Conventional Commits
+  - Batched `git add` / `git commit` sequences
+  - Proper double-quote path escaping
+- Dry-run or apply mode
+- Minimal overhead, only Python and git required
+
+## Installation
+
+### Local development (editable)
+
+```bash
+git clone https://github.com/ikramagix/gitmeup
+cd gitmeup
+
+python3 -m venv .venv
+source .venv/bin/activate
+
+pip install --upgrade pip
+pip install -e .
+```
+
+### System-wide (user environment)
+
+```bash
+pip install git+https://github.com/ikramagix/gitmeup
+```
+
+Ensure `GEMINI_API_KEY` is configured:
+
+```bash
+export GEMINI_API_KEY="your-key"
+```
+
+You also need a model with:
+
+```bash
+export GITMEUP_MODEL="a gemini model"
+```
+
+## Usage
+
+From any git repository with uncommitted changes:
+
+```bash
+gitmeup
+```
+
+Dry-run prints proposed commands. To apply staged operations:
+
+```bash
+gitmeup --apply
+```
+
+Specify a model:
+
+```bash
+gitmeup --model gpt-4.1
+```
+
+Specify an API key manually:
+
+```bash
+gitmeup --api-key sk-....
+```
+
+## Example
+
+```bash
+gitmeup
+```
+
+Sample output:
+
+```bash
+git add src/app/main.py
+git add src/app/utils/helpers.py
+git commit -m "refactor(core): clean helper logic"
+```
+
+## License
+
+MIT License. See `LICENSE` for details.
+
+## Maintainer
+
+Created and maintained by **@ikramagix**.

gitmeup-1.0.0/README.md

@@ -0,0 +1,102 @@
+# gitmeup
+
+`gitmeup` is a lightweight command-line tool that automates Conventional Commit generation using an LLM.
+It analyses your working tree using `git diff --stat`, `git status`, and a filtered `git diff`, then produces
+atomically grouped `git add` and `git commit` commands with strict path-quoting rules.
+
+This improves commit hygiene in large or fast-moving repositories while reducing cognitive overhead.
+
+## Features
+
+- Extracts:
+  - `git diff --stat`
+  - `git status --short`
+  - `git diff` excluding image and binary noise
+- Sends structured context to an LLM
+- Produces:
+  - Precise Conventional Commits
+  - Batched `git add` / `git commit` sequences
+  - Proper double-quote path escaping
+- Dry-run or apply mode
+- Minimal overhead, only Python and git required
+
+## Installation
+
+### Local development (editable)
+
+```bash
+git clone https://github.com/ikramagix/gitmeup
+cd gitmeup
+
+python3 -m venv .venv
+source .venv/bin/activate
+
+pip install --upgrade pip
+pip install -e .
+```
+
+### System-wide (user environment)
+
+```bash
+pip install git+https://github.com/ikramagix/gitmeup
+```
+
+Ensure `GEMINI_API_KEY` is configured:
+
+```bash
+export GEMINI_API_KEY="your-key"
+```
+
+You also need a model with:
+
+```bash
+export GITMEUP_MODEL="a gemini model"
+```
+
+## Usage
+
+From any git repository with uncommitted changes:
+
+```bash
+gitmeup
+```
+
+Dry-run prints proposed commands. To apply staged operations:
+
+```bash
+gitmeup --apply
+```
+
+Specify a model:
+
+```bash
+gitmeup --model gpt-4.1
+```
+
+Specify an API key manually:
+
+```bash
+gitmeup --api-key sk-....
+```
+
+## Example
+
+```bash
+gitmeup
+```
+
+Sample output:
+
+```bash
+git add src/app/main.py
+git add src/app/utils/helpers.py
+git commit -m "refactor(core): clean helper logic"
+```
+
+## License
+
+MIT License. See `LICENSE` for details.
+
+## Maintainer
+
+Created and maintained by **@ikramagix**.

gitmeup-1.0.0/gitmeup/__init__.py

@@ -0,0 +1 @@
+__all__ = ["main"]

gitmeup-1.0.0/gitmeup/cli.py

@@ -0,0 +1,271 @@
+import argparse
+import os
+import shlex
+import subprocess
+import sys
+from textwrap import dedent
+from pathlib import Path
+
+from google import genai
+from dotenv import load_dotenv
+
+
+SYSTEM_PROMPT = dedent(
+    """
+You are a Conventional Commits writer. You generate precise commit messages that follow Conventional Commits 1.0.0:
+
+<type>[optional scope]: <description>
+
+Valid types include: feat, fix, chore, docs, style, refactor, perf, test, ci, and revert.
+Use "!" or a BREAKING CHANGE footer for breaking changes.
+Avoid non-standard types.
+Suggest splitting changes into multiple commits when appropriate, and reflect that by outputting multiple git commit commands.
+
+You receive:
+- A `git diff --stat` output
+- A `git status` output
+- A `git diff` output where binary/image formats may have been excluded from the diff body
+
+RULES FOR DECIDING COMMITS:
+- Keep each commit atomic and semantically focused (feature, refactor, docs, locales, tests, CI, assets, etc.).
+- Never invent files; operate only on files that appear in the provided git status or diff.
+- If staged vs unstaged is unclear, assume everything is unstaged and must be added.
+- If the changes are heterogeneous, split them into multiple commits and multiple batches.
+
+STRICT PATH QUOTING (MANDATORY):
+You output git commands that the user will paste directly in a POSIX shell.
+
+For every path in git add/rm/mv:
+- Quote the path with double quotes only if it contains characters outside the safe set [A-Za-z0-9._/\\-].
+- Always quote paths containing: space, tab, (, ), [, ], {, }, &, |, ;, *, ?, !, ~, $, `, ', ", <, >, #, %, or any non-ASCII character.
+- Never quote safe paths unnecessarily.
+- Do not invent or "fix" paths; use exactly the paths you see, correctly quoted.
+
+COMMAND GROUPING AND ORDER:
+- Group files into small, meaningful batches.
+- For each batch:
+  - First output one or more git add/rm/mv commands.
+  - Immediately after those, output one git commit -m "type[optional scope]: description" for that batch.
+- Do not include git push or any remote-related commands.
+
+OUTPUT FORMAT (VERY IMPORTANT):
+- Respond with one fenced code block with language "bash".
+- Inside that block, output only executable commands, one per line.
+- No prose or comments.
+- You may separate batches with a single blank line between them.
+
+STYLE OF COMMIT MESSAGES:
+- Descriptions are short, imperative, and specific.
+"""
+)
+
+
+def load_env() -> None:
+    """
+    Load configuration from env files, without committing secrets.
+
+    Precedence:
+    - Existing environment variables are kept.
+    - ~/.gitmeup.env (global, for secrets)
+    - ./.env in the current working directory (per-project overrides)
+    - CLI --api-key and --model override everything.
+    """
+    # Global secrets and defaults: ~/.gitmeup.env
+    load_dotenv(dotenv_path=Path.home() / ".gitmeup.env", override=False)
+    # Project local overrides: .env in the repo where gitmeup is run
+    load_dotenv(dotenv_path=Path.cwd() / ".env", override=False)
+
+
+def run_git(args, check=True):
+    result = subprocess.run(
+        ["git"] + args,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+    if check and result.returncode != 0:
+        print(f"git {' '.join(args)} failed:\n{result.stderr}", file=sys.stderr)
+        sys.exit(result.returncode)
+    return result.stdout
+
+
+def ensure_repo():
+    try:
+        out = run_git(["rev-parse", "--is-inside-work-tree"], check=True).strip()
+    except SystemExit:
+        print("gitmeup: not inside a git repository.", file=sys.stderr)
+        sys.exit(1)
+    if out != "true":
+        print("gitmeup: not inside a git repository.", file=sys.stderr)
+        sys.exit(1)
+
+
+def collect_context():
+    diff_stat = run_git(["diff", "--stat"], check=False)
+    status = run_git(["status", "--short"], check=False)
+    diff_args = [
+        "diff",
+        "--",
+        ".",
+        ":(exclude)*.png",
+        ":(exclude)*.jpg",
+        ":(exclude)*.jpeg",
+        ":(exclude)*.gif",
+        ":(exclude)*.svg",
+        ":(exclude)*.webp",
+    ]
+    diff = run_git(diff_args, check=False)
+    return diff_stat, status, diff
+
+
+def build_user_prompt(diff_stat, status, diff):
+    parts = [
+        "# git diff --stat",
+        diff_stat.strip() or "(no diff stat)",
+        "",
+        "# git status --short",
+        status.strip() or "(no status)",
+        "",
+        "# git diff (images/binaries may be excluded)",
+        diff.strip() or "(no textual diff)",
+        "",
+        "# TASK",
+        "Based on the changes above, propose git add/rm/mv and git commit commands as per the instructions.",
+    ]
+    return "\n".join(parts)
+
+
+def call_llm(model, api_key, user_prompt):
+    client = genai.Client(api_key=api_key)
+    resp = client.models.generate_content(
+        model=model,
+        contents=user_prompt,
+        config={
+            "system_instruction": SYSTEM_PROMPT,
+            "temperature": 0.0,
+        },
+    )
+    return resp.text
+
+
+def extract_bash_block(text):
+    """Extract first ```bash ... ``` block. Return its inner content."""
+    in_block = False
+    lang_ok = False
+    lines = []
+
+    for line in text.splitlines():
+        if line.startswith("```"):
+            fence = line.strip()
+            if not in_block:
+                lang = fence[3:].strip()
+                lang_ok = lang == "" or lang.lower() in {"bash", "sh", "shell"}
+                in_block = True
+                continue
+            else:
+                break
+        elif in_block and lang_ok:
+            lines.append(line)
+
+    return "\n".join(lines).strip()
+
+
+def parse_commands(block):
+    commands = []
+    for raw in block.splitlines():
+        line = raw.strip()
+        if not line:
+            continue
+        commands.append(shlex.split(line))
+    return commands
+
+
+def run_commands(commands, apply):
+    print("Proposed commands:\n")
+    for cmd in commands:
+        print(" ".join(shlex.quote(part) for part in cmd))
+
+    if not apply:
+        print("\nDry run: not executing commands. Re-run with --apply to execute.")
+        return
+
+    print("\nExecuting commands...\n")
+    for cmd in commands:
+        print("+", " ".join(shlex.quote(part) for part in cmd))
+        result = subprocess.run(cmd)
+        if result.returncode != 0:
+            print(
+                f"Command failed with exit code {result.returncode}. Aborting.",
+                file=sys.stderr,
+            )
+            sys.exit(result.returncode)
+
+    print("\nCommands executed.\n")
+
+
+def main(argv=None):
+    # Load env from ~/.gitmeup.env and ./ .env before reading os.environ
+    load_env()
+
+    parser = argparse.ArgumentParser(
+        prog="gitmeup",
+        description="Generate Conventional Commits from current git changes using Gemini.",
+    )
+    parser.add_argument(
+        "--model",
+        default=os.environ.get("GITMEUP_MODEL", "gemini-2.0-flash-001"),
+        help="Gemini model name (default: gemini-2.0-flash-001 or $GITMEUP_MODEL).",
+    )
+    parser.add_argument(
+        "--apply",
+        action="store_true",
+        help="Execute generated git commands. Without this flag, just print them.",
+    )
+    parser.add_argument(
+        "--api-key",
+        default=os.environ.get("GEMINI_API_KEY"),
+        help="Gemini API key (default: $GEMINI_API_KEY).",
+    )
+
+    args = parser.parse_args(argv)
+
+    if not args.api_key:
+        print(
+            "Missing Gemini API key. Set GEMINI_API_KEY or use --api-key.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    ensure_repo()
+
+    porcelain = run_git(["status", "--porcelain"], check=False)
+    if porcelain.strip() == "":
+        print("Working tree clean. Nothing to commit.")
+        sys.exit(0)
+
+    diff_stat, status, diff = collect_context()
+    prompt = build_user_prompt(diff_stat, status, diff)
+    raw_output = call_llm(args.model, args.api_key, prompt)
+
+    bash_block = extract_bash_block(raw_output)
+
+    if not bash_block:
+        print(
+            "gitmeup: failed to extract bash command block from model output.",
+            file=sys.stderr,
+        )
+        print("Raw output:\n", raw_output)
+        sys.exit(1)
+
+    commands = parse_commands(bash_block)
+    run_commands(commands, apply=args.apply)
+
+    print("\nFinal git status:\n")
+    print(run_git(["status", "-sb"], check=False))
+
+    print("Review your history with:")
+    print("  git log --oneline --graph --decorate -n 10")
+
+
+if __name__ == "__main__":
+    main()

gitmeup-1.0.0/gitmeup.egg-info/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: gitmeup
+Version: 1.0.0
+Summary: LLM-assisted conventional commits generator for git repositories. Automatically generates git add and commit lines based on git diff and status.
+License: MIT License
+        
+        Copyright (c) 2025 @ikramagix
+        
+        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 NON-INFRINGEMENT. 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.
+        
+Project-URL: Homepage, https://github.com/ikramagix/gitmeup
+Project-URL: Source, https://github.com/ikramagix/gitmeup
+Project-URL: Issues, https://github.com/ikramagix/gitmeup/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: google-genai>=0.6.0
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: license-file
+
+# gitmeup
+
+`gitmeup` is a lightweight command-line tool that automates Conventional Commit generation using an LLM.
+It analyses your working tree using `git diff --stat`, `git status`, and a filtered `git diff`, then produces
+atomically grouped `git add` and `git commit` commands with strict path-quoting rules.
+
+This improves commit hygiene in large or fast-moving repositories while reducing cognitive overhead.
+
+## Features
+
+- Extracts:
+  - `git diff --stat`
+  - `git status --short`
+  - `git diff` excluding image and binary noise
+- Sends structured context to an LLM
+- Produces:
+  - Precise Conventional Commits
+  - Batched `git add` / `git commit` sequences
+  - Proper double-quote path escaping
+- Dry-run or apply mode
+- Minimal overhead, only Python and git required
+
+## Installation
+
+### Local development (editable)
+
+```bash
+git clone https://github.com/ikramagix/gitmeup
+cd gitmeup
+
+python3 -m venv .venv
+source .venv/bin/activate
+
+pip install --upgrade pip
+pip install -e .
+```
+
+### System-wide (user environment)
+
+```bash
+pip install git+https://github.com/ikramagix/gitmeup
+```
+
+Ensure `GEMINI_API_KEY` is configured:
+
+```bash
+export GEMINI_API_KEY="your-key"
+```
+
+You also need a model with:
+
+```bash
+export GITMEUP_MODEL="a gemini model"
+```
+
+## Usage
+
+From any git repository with uncommitted changes:
+
+```bash
+gitmeup
+```
+
+Dry-run prints proposed commands. To apply staged operations:
+
+```bash
+gitmeup --apply
+```
+
+Specify a model:
+
+```bash
+gitmeup --model gpt-4.1
+```
+
+Specify an API key manually:
+
+```bash
+gitmeup --api-key sk-....
+```
+
+## Example
+
+```bash
+gitmeup
+```
+
+Sample output:
+
+```bash
+git add src/app/main.py
+git add src/app/utils/helpers.py
+git commit -m "refactor(core): clean helper logic"
+```
+
+## License
+
+MIT License. See `LICENSE` for details.
+
+## Maintainer
+
+Created and maintained by **@ikramagix**.

gitmeup-1.0.0/gitmeup.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+gitmeup/__init__.py
+gitmeup/cli.py
+gitmeup.egg-info/PKG-INFO
+gitmeup.egg-info/SOURCES.txt
+gitmeup.egg-info/dependency_links.txt
+gitmeup.egg-info/entry_points.txt
+gitmeup.egg-info/requires.txt
+gitmeup.egg-info/top_level.txt

gitmeup-1.0.0/gitmeup.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gitmeup-1.0.0/gitmeup.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gitmeup = gitmeup.cli:main

gitmeup-1.0.0/gitmeup.egg-info/requires.txt

@@ -0,0 +1,2 @@
+google-genai>=0.6.0
+python-dotenv>=1.0.0

gitmeup-1.0.0/gitmeup.egg-info/top_level.txt

@@ -0,0 +1 @@
+gitmeup

gitmeup-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "gitmeup"
+version = "1.0.0"
+description = "LLM-assisted conventional commits generator for git repositories. Automatically generates git add and commit lines based on git diff and status."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { file = "LICENSE" }
+dependencies = [
+    "google-genai>=0.6.0",
+    "python-dotenv>=1.0.0",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+gitmeup = "gitmeup.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/ikramagix/gitmeup"
+Source = "https://github.com/ikramagix/gitmeup"
+Issues = "https://github.com/ikramagix/gitmeup/issues"
+
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"

gitmeup-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+