commitwise-review 0.1.0__py3-none-any.whl

commitwise_review-0.1.0.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: commitwise-review
+Version: 0.1.0
+Summary: Git staged-change AI review helper
+Author: Gokulakrishnan
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: keyring
+Dynamic: license-file
+
+# Commit-wise
+
+Open Source Commit and PR reviewer.
+
+## Install
+
+Install the library from PyPI:
+
+```bash
+pip install commitwise-review
+```
+
+Install directly from the source repository:
+
+```bash
+pip install .
+```
+
+Install from GitHub:
+
+```bash
+pip install git+https://github.com/gokul-1998/Commit-wise.git
+```
+
+To force reinstall:
+
+```bash
+pip install --force-reinstall --no-cache-dir git+https://github.com/gokul-1998/Commit-wise.git
+```
+
+## Versioning
+
+This project uses Semantic Versioning:
+
+```bash
+MAJOR.MINOR.PATCH
+```
+
+Example release plan:
+
+- `0.1.0` — initial release
+- `0.2.0` — new features
+- `0.2.1` — bug fixes and prompt improvements
+- `1.0.0` — stable public release
+
+## CLI MVP (`commit-wise`)
+
+This repository now includes a minimal local CLI for staged-change review.
+
+### Commands
+
+```bash
+commit-wise init
+commit-wise review
+commit-wise explain
+commit-wise commit
+commit-wise hooks install
+```
+
+The old `gai` alias is still available:
+
+```bash
+gai init
+gai review
+gai explain
+gai commit
+gai hooks install
+```
+
+### What `commit-wise review` does
+
+- Reads staged files from `git diff --cached --name-only`
+- Reads staged diff from `git diff --cached`
+- Runs local analyzers when installed (`ruff`, `mypy`, `pytest`, `bandit`)
+- Prints actionable review suggestions and score in terminal
+
+### Security
+
+`gai init` stores provider tokens in the system keyring (`keyring` package), not in plain-text config.

commitwise_review-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+commitwise_review-0.1.0.dist-info/licenses/LICENSE,sha256=-ggiz8LjSj4d3hpG04rZNpJItsWBRwrVPnbFCKHRxO4,1094
+gai/__init__.py,sha256=68lF8K7l_2VZxs1qgpAcUV54oNaE-5av2yCAClcqN9A,20
+gai/__main__.py,sha256=5164d53qIXkvzGC4evy5wq-ZKE1eQkfw1huUfO_6Hs8,91
+gai/analyzers/local.py,sha256=nNQQo2zijf51ROmUJVMC1MgrUVQ9P6kBOu6lNBzEdbc,948
+gai/cli/main.py,sha256=Ke6nNwLD0QiFHJelUrz4KSJpsGYJC1CM_LX_2aKotj8,6287
+gai/config/settings.py,sha256=GOVLQ3t3SNbGf-eE_fulYzvGdeuKMkkOklk9K5wcFQg,1612
+gai/git/staged.py,sha256=01WoWLhuhGsfThquxbh2fjZ6d3TEjCzNaFv0xOSsDcQ,1138
+gai/hooks/install.py,sha256=4nIhCNky7F6q0MsAAQODY9Ixedj5vIMvKC9lx88msik,459
+gai/prompts/review_prompt.py,sha256=WZ5r4fG9_mySWMxZEFBIYUs9GWPAdvEhv0rsEmK1-1Y,539
+gai/providers/reviewer.py,sha256=EkGGm55Wjpcnmvx3u-fdUMxay-v-ailppEDfL2ednes,3004
+commitwise_review-0.1.0.dist-info/METADATA,sha256=iz3ot_xiB_RmJffnJ-nmJ2Y3ZIq-QSWDm0n8VFTv0rI,1779
+commitwise_review-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+commitwise_review-0.1.0.dist-info/entry_points.txt,sha256=ZGE8xHFhG2USA_cxBc5xmm8vG_jnXCBk8OnWpBTp71Y,74
+commitwise_review-0.1.0.dist-info/top_level.txt,sha256=6xwodMh-vDJyWtXK1HUAhKGl7vn0wbfHDqzdJnLKwVU,4
+commitwise_review-0.1.0.dist-info/RECORD,,

commitwise_review-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

commitwise_review-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+commit-wise = gai.cli.main:main
+gai = gai.cli.main:main

commitwise_review-0.1.0.dist-info/licenses/LICENSE

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

commitwise_review-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gai

gai/__init__.py

@@ -0,0 +1 @@
+"""gai package."""

gai/__main__.py

@@ -0,0 +1,4 @@
+from gai.cli.main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gai/analyzers/local.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+TOOLS = [
+    ("Ruff", ["ruff", "check", "."]),
+    ("MyPy", ["mypy", "."]),
+    ("Pytest", ["pytest", "tests/"]),
+    ("Bandit", ["bandit", "-r", "."]),
+]
+
+
+def run_local_analyzers(cwd: Path) -> list[tuple[str, str]]:
+    reports: list[tuple[str, str]] = []
+    for name, cmd in TOOLS:
+        if shutil.which(cmd[0]) is None:
+            reports.append((name, "not installed (skipped)"))
+            continue
+
+        proc = subprocess.run(cmd, cwd=str(cwd), check=False, capture_output=True, text=True)
+        status = "passed" if proc.returncode == 0 else "issues found"
+        output = (proc.stdout + "\n" + proc.stderr).strip()
+        if output:
+            output = output[:1500]
+            reports.append((name, f"{status}: {output}"))
+        else:
+            reports.append((name, status))
+    return reports

gai/cli/main.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import argparse
+import subprocess
+from pathlib import Path
+
+from gai.analyzers.local import run_local_analyzers
+from gai.config.settings import get_token, load_config, save_config, set_token
+from gai.git.staged import get_repo_root, get_staged_diff, get_staged_files
+from gai.hooks.install import install_pre_commit_hook
+from gai.prompts.review_prompt import build_explain_prompt
+from gai.providers.reviewer import ReviewResult, review_staged_changes
+
+PROVIDERS = ["github", "openai", "anthropic", "gemini", "ollama"]
+DEFAULT_PROVIDER_MODELS = {
+    "github": "github/copilot",
+    "openai": "openai/gpt-5-mini",
+    "anthropic": "anthropic/claude-3",
+    "gemini": "gemini/1",
+    "ollama": "ollama/ollama-small",
+}
+
+GITHUB_PAT_URL = (
+    "https://github.com/settings/personal-access-tokens/new?"
+    "description=Used+to+call+GitHub+Models+APIs+to+easily+run+LLMs%3A+"
+    "https%3A%2F%2Fdocs.github.com%2Fgithub-models%2Fquickstart%23step-2-make-an-api-call&"
+    "name=GitHub+Models+token&user_models=read"
+)
+
+
+def _status(flag: bool) -> str:
+    return "✓" if flag else "⚠"
+
+
+def _print_review(result: ReviewResult) -> None:
+    print("\nReviewing staged changes...\n")
+    print(f"{_status(result.security)} Security")
+    print(f"{_status(result.performance)} Performance")
+    print(f"{_status(result.maintainability)} Maintainability")
+    print(f"{_status(result.tests)} Tests")
+
+    print("\nSuggestions:\n")
+    if not result.suggestions:
+        print("No critical suggestions found.")
+    else:
+        for idx, suggestion in enumerate(result.suggestions, start=1):
+            print(f"{idx}. {suggestion.file} [{suggestion.severity}]")
+            print(f"   {suggestion.message}")
+            print(f"   Suggested: {suggestion.fix}\n")
+
+    print(f"Overall score: {result.score}/10")
+
+
+def cmd_init(_: argparse.Namespace) -> int:
+    print("Choose provider:\n")
+    for idx, provider in enumerate(PROVIDERS, start=1):
+        print(f"{idx}. {provider}")
+
+    raw_choice = input("\n> ").strip()
+    if raw_choice.isdigit() and 1 <= int(raw_choice) <= len(PROVIDERS):
+        provider = PROVIDERS[int(raw_choice) - 1]
+    elif raw_choice in PROVIDERS:
+        provider = raw_choice
+    else:
+        print("Invalid provider selection.")
+        return 1
+
+    setup_info = _provider_setup_instructions(provider)
+    if setup_info:
+        print(setup_info)
+
+    token = input(f"Enter {provider} token (stored securely with keyring):\n> ").strip()
+    if not token:
+        print("Token is required.")
+        return 1
+
+    set_token(provider, token)
+    save_config({"provider": provider, "model": DEFAULT_PROVIDER_MODELS.get(provider, "openai/gpt-5-mini")})
+
+    print("\nSaved ~/.gai/config.toml (without token).")
+    print("Token saved in keyring.")
+    return 0
+
+
+def _provider_setup_instructions(provider: str) -> str | None:
+    if provider == "github":
+        return (
+            "\nGitHub provider requires a Personal Access Token (PAT).\n"
+            f"Create one at: {GITHUB_PAT_URL}\n"
+            "Select scopes: repo, workflow (and read:org if needed).\n"
+            "Recommended model for GitHub provider: github/copilot\n"
+        )
+    return None
+
+
+def cmd_review(_: argparse.Namespace) -> int:
+    cwd = Path.cwd()
+    staged_files = get_staged_files(cwd)
+    if not staged_files:
+        print("No staged files found. Run `git add` first.")
+        return 1
+
+    staged_diff = get_staged_diff(cwd)
+    _ = load_config()
+
+    print("Running local analyzers (when available)...")
+    analyzer_reports = run_local_analyzers(cwd)
+    for name, report in analyzer_reports:
+        short = report.splitlines()[0] if report else ""
+        print(f"→ {name}: {short}")
+
+    result = review_staged_changes(staged_files, staged_diff)
+    _print_review(result)
+
+    proceed = input("\nProceed with commit? [y/N] ").strip().lower()
+    if proceed in {"y", "yes"}:
+        return 0
+    return 2
+
+
+def cmd_explain(_: argparse.Namespace) -> int:
+    cwd = Path.cwd()
+    staged_diff = get_staged_diff(cwd)
+    if not staged_diff.strip():
+        print("No staged diff found. Run `git add` first.")
+        return 1
+
+    prompt = build_explain_prompt(staged_diff)
+    print(prompt)
+    return 0
+
+
+def cmd_commit(_: argparse.Namespace) -> int:
+    review_code = cmd_review(argparse.Namespace())
+    if review_code != 0:
+        return review_code
+
+    message = input("Commit message (leave empty for auto-generated):\n> ").strip()
+    if not message:
+        message = "chore: apply reviewed staged changes"
+
+    proc = subprocess.run(["git", "commit", "-m", message], check=False)
+    return proc.returncode
+
+
+def cmd_hooks_install(_: argparse.Namespace) -> int:
+    repo_root = get_repo_root(Path.cwd())
+    hook_file = install_pre_commit_hook(repo_root)
+    print(f"Installed pre-commit hook at {hook_file}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="gai", description="Git AI review helper")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    init_parser = subparsers.add_parser("init", help="Configure provider and token storage")
+    init_parser.set_defaults(func=cmd_init)
+
+    review_parser = subparsers.add_parser("review", help="Review staged changes")
+    review_parser.set_defaults(func=cmd_review)
+
+    explain_parser = subparsers.add_parser("explain", help="Print prompt for staged changes")
+    explain_parser.set_defaults(func=cmd_explain)
+
+    commit_parser = subparsers.add_parser("commit", help="Review then commit staged changes")
+    commit_parser.set_defaults(func=cmd_commit)
+
+    hooks_parser = subparsers.add_parser("hooks", help="Manage git hooks")
+    hooks_sub = hooks_parser.add_subparsers(dest="hooks_command", required=True)
+    install_parser = hooks_sub.add_parser("install", help="Install pre-commit hook")
+    install_parser.set_defaults(func=cmd_hooks_install)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)

gai/config/settings.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".gai"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+
+def _toml_dumps(data: dict[str, str]) -> str:
+    lines = []
+    for key, value in data.items():
+        escaped = value.replace('"', '\\"')
+        lines.append(f'{key}="{escaped}"')
+    return "\n".join(lines) + "\n"
+
+
+def save_config(config: dict[str, str]) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(_toml_dumps(config), encoding="utf-8")
+
+
+def load_config() -> dict[str, str]:
+    if not CONFIG_FILE.exists():
+        return {}
+
+    text = CONFIG_FILE.read_text(encoding="utf-8")
+    result: dict[str, str] = {}
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, raw_value = line.partition("=")
+        value = raw_value.strip().strip('"')
+        result[key.strip()] = value
+    return result
+
+
+def set_token(provider: str, token: str) -> None:
+    try:
+        import keyring  # type: ignore
+    except Exception as exc:  # pragma: no cover - import guard
+        raise RuntimeError(
+            "keyring is required for secure token storage. Install it with `pip install keyring`."
+        ) from exc
+
+    keyring.set_password("gai", provider, token)
+
+
+def get_token(provider: str) -> str | None:
+    try:
+        import keyring  # type: ignore
+    except Exception:
+        return None
+    return keyring.get_password("gai", provider)

gai/git/staged.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+def _git(args: list[str], cwd: Path | None = None) -> str:
+    proc = subprocess.run(
+        ["git", *args],
+        cwd=str(cwd) if cwd else None,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if proc.returncode != 0:
+        raise RuntimeError(proc.stderr.strip() or "git command failed")
+    return proc.stdout
+
+
+def get_staged_files(cwd: Path | None = None) -> list[str]:
+    out = _git(["diff", "--cached", "--name-only"], cwd=cwd)
+    return [line.strip() for line in out.splitlines() if line.strip()]
+
+
+def get_staged_diff(cwd: Path | None = None) -> str:
+    return _git(["diff", "--cached"], cwd=cwd)
+
+
+def get_repo_root(cwd: Path | None = None) -> Path:
+    out = _git(["rev-parse", "--show-toplevel"], cwd=cwd)
+    return Path(out.strip())
+
+
+def read_file(path: str, cwd: Path | None = None) -> str:
+    root = get_repo_root(cwd)
+    full_path = root / path
+    if not full_path.exists():
+        return ""
+    return full_path.read_text(encoding="utf-8", errors="ignore")

gai/hooks/install.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+HOOK_CONTENT = "#!/usr/bin/env bash\nset -euo pipefail\ngai review\n"
+
+
+def install_pre_commit_hook(repo_root: Path) -> Path:
+    hooks_dir = repo_root / ".git" / "hooks"
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+    hook_file = hooks_dir / "pre-commit"
+    hook_file.write_text(HOOK_CONTENT, encoding="utf-8")
+    os.chmod(hook_file, 0o755)
+    return hook_file

gai/prompts/review_prompt.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+
+def build_explain_prompt(staged_diff: str) -> str:
+    return """You are a Staff Software Engineer.
+
+Review ONLY the staged changes.
+
+Consider:
+1. Bugs
+2. Security
+3. Performance
+4. Readability
+5. Architecture consistency
+6. Error handling
+7. Missing tests
+8. Backward compatibility
+
+Provide:
+- Severity
+- File
+- Explanation
+- Suggested fix
+- Code snippet
+- Overall score (/10)
+
+Do not comment on formatting issues already covered by Ruff.
+
+Staged diff:
+""" + staged_diff

gai/providers/reviewer.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Suggestion:
+    severity: str
+    file: str
+    message: str
+    fix: str
+
+
+@dataclass
+class ReviewResult:
+    security: bool
+    performance: bool
+    maintainability: bool
+    tests: bool
+    suggestions: list[Suggestion]
+    score: float
+
+
+def _suggest_test_file(file_path: str) -> str:
+    stem = file_path.rsplit(".", 1)[0].replace("/", "_")
+    return f"tests/test_{stem}.py"
+
+
+def review_staged_changes(staged_files: list[str], staged_diff: str) -> ReviewResult:
+    suggestions: list[Suggestion] = []
+
+    has_tests = any("test" in path.lower() for path in staged_files)
+    maintainability_ok = True
+    security_ok = True
+    performance_ok = True
+
+    lowered = staged_diff.lower()
+    if "password" in lowered and "hash" not in lowered:
+        security_ok = False
+        suggestions.append(
+            Suggestion(
+                severity="high",
+                file="(staged diff)",
+                message="Potential raw password handling detected.",
+                fix="Ensure password values are hashed and never logged or stored in plain text.",
+            )
+        )
+
+    if "except:" in staged_diff:
+        maintainability_ok = False
+        suggestions.append(
+            Suggestion(
+                severity="medium",
+                file="(staged diff)",
+                message="Bare except detected.",
+                fix="Catch explicit exceptions to avoid hiding unexpected failures.",
+            )
+        )
+
+    if "for " in staged_diff and "append(" in staged_diff and "set(" in staged_diff:
+        performance_ok = False
+        suggestions.append(
+            Suggestion(
+                severity="low",
+                file="(staged diff)",
+                message="Potentially expensive loop pattern found.",
+                fix="Consider using set/dict lookups outside loops where possible.",
+            )
+        )
+
+    if not has_tests:
+        maintainability_ok = False
+        for file_path in staged_files[:3]:
+            if "test" in file_path.lower():
+                continue
+            suggestions.append(
+                Suggestion(
+                    severity="medium",
+                    file=file_path,
+                    message="No test updates detected for this staged change.",
+                    fix=f"Add or update tests, e.g. {_suggest_test_file(file_path)}.",
+                )
+            )
+
+    score = 10.0
+    if not security_ok:
+        score -= 2.0
+    if not performance_ok:
+        score -= 1.0
+    if not maintainability_ok:
+        score -= 1.5
+    if not has_tests:
+        score -= 1.0
+
+    return ReviewResult(
+        security=security_ok,
+        performance=performance_ok,
+        maintainability=maintainability_ok,
+        tests=has_tests,
+        suggestions=suggestions,
+        score=max(0.0, round(score, 1)),
+    )