commitcraft-cli 0.1.0__py3-none-any.whl

commitcraft/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

commitcraft/analysis/classifier.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from commitcraft.analysis.filters import FilteredDiff
+
+
+@dataclass
+class ClassificationResult:
+    score: int
+    is_simple: bool
+    signals: dict[str, int | bool] = field(default_factory=dict)
+
+
+def _count_directories(files: list) -> int:
+    dirs = {str(Path(f.path).parent) for f in files}
+    return len(dirs)
+
+
+def _has_test_alongside_source(files: list) -> bool:
+    paths = [f.path for f in files]
+    has_test = any("test" in p.lower() for p in paths)
+    has_source = any("test" not in p.lower() for p in paths)
+    return has_test and has_source
+
+
+def classify(filtered: FilteredDiff, threshold: int = 30) -> ClassificationResult:
+    if not filtered.files:
+        return ClassificationResult(score=0, is_simple=True, signals={
+            "file_count": 0, "directory_spread": 0,
+            "function_changes": 0, "test_alongside_source": False, "line_count": 0,
+        })
+
+    file_count = len(filtered.files)
+    dir_spread = _count_directories(filtered.files)
+    func_changes = sum(1 for f in filtered.files if f.has_function_changes or f.has_class_changes)
+    test_with_source = _has_test_alongside_source(filtered.files)
+    total_lines = filtered.total_added + filtered.total_removed
+
+    # Weighted scoring (caps at 100)
+    score = 0
+    score += min(file_count * 5, 25)       # up to 25 pts for file count
+    score += min(dir_spread * 5, 20)        # up to 20 pts for directory spread
+    score += min(func_changes * 10, 30)     # up to 30 pts for function/class changes
+    score += 10 if test_with_source else 0  # 10 pts for test+source together
+    score += min(total_lines // 20, 15)     # up to 15 pts for line count
+
+    score = min(score, 100)
+
+    signals = {
+        "file_count": file_count,
+        "directory_spread": dir_spread,
+        "function_changes": func_changes,
+        "test_alongside_source": test_with_source,
+        "line_count": total_lines,
+    }
+
+    return ClassificationResult(score=score, is_simple=score < threshold, signals=signals)

commitcraft/analysis/filters.py

@@ -0,0 +1,67 @@
+import fnmatch
+from dataclasses import dataclass, field
+
+from commitcraft.git.diff_parser import DiffFile, ParsedDiff
+
+DEFAULT_IGNORE_PATTERNS: list[str] = [
+    "package-lock.json",
+    "yarn.lock",
+    "poetry.lock",
+    "Pipfile.lock",
+    "composer.lock",
+    "Gemfile.lock",
+    "pnpm-lock.yaml",
+    "dist/*",
+    "build/*",
+    ".next/*",
+    "node_modules/*",
+    "*.min.js",
+    "*.min.css",
+    "*.map",
+    "__pycache__/*",
+    "*.pyc",
+    ".mypy_cache/*",
+    ".ruff_cache/*",
+    "coverage/*",
+    ".coverage",
+    "*.egg-info/*",
+    "site-packages/*",
+]
+
+
+@dataclass
+class FilteredDiff:
+    files: list[DiffFile] = field(default_factory=list)
+    filtered_out: list[str] = field(default_factory=list)
+    total_added: int = 0
+    total_removed: int = 0
+
+
+def _is_ignored(path: str, patterns: list[str]) -> bool:
+    for pattern in patterns:
+        if fnmatch.fnmatch(path, pattern):
+            return True
+        # also match if path starts with a prefix pattern
+        # e.g. "dist/*" should match "dist/foo/bar.js"
+        prefix = pattern.rstrip("/*")
+        if path.startswith(prefix + "/") or path.startswith(prefix + "\\"):
+            return True
+    return False
+
+
+def filter_diff(
+    parsed: ParsedDiff,
+    extra_patterns: list[str] | None = None,
+) -> FilteredDiff:
+    patterns = DEFAULT_IGNORE_PATTERNS + (extra_patterns or [])
+    result = FilteredDiff()
+
+    for f in parsed.files:
+        if _is_ignored(f.path, patterns):
+            result.filtered_out.append(f.path)
+        else:
+            result.files.append(f)
+            result.total_added += f.added_lines
+            result.total_removed += f.removed_lines
+
+    return result

commitcraft/analysis/rule_engine.py

@@ -0,0 +1,101 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from commitcraft.analysis.filters import FilteredDiff
+
+LOCKFILE_NAMES = {
+    "package-lock.json", "yarn.lock", "poetry.lock",
+    "Pipfile.lock", "composer.lock", "Gemfile.lock", "pnpm-lock.yaml",
+}
+
+DEPENDENCY_MANIFESTS = {
+    "requirements.txt", "requirements-dev.txt", "setup.cfg",
+    "package.json", "Pipfile", "pyproject.toml",
+}
+
+CONFIG_PATTERNS = {".yml", ".yaml", ".json", ".toml", ".ini", ".cfg", ".env"}
+CONFIG_DIRS = {".github", ".circleci", ".gitlab", "config", ".husky"}
+
+
+@dataclass
+class RuleResult:
+    matched: bool
+    message: str | None
+    rule_name: str | None
+
+
+def _all_paths(filtered: FilteredDiff) -> list[str]:
+    return [f.path for f in filtered.files]
+
+
+def _readme_only(paths: list[str]) -> RuleResult | None:
+    if len(paths) == 1 and Path(paths[0]).name.upper().startswith("README"):
+        return RuleResult(matched=True, message="docs: update README", rule_name="readme_only")
+    return None
+
+
+def _lockfile_only(paths: list[str]) -> RuleResult | None:
+    if all(Path(p).name in LOCKFILE_NAMES for p in paths):
+        return RuleResult(matched=True, message="chore: update lockfile", rule_name="lockfile_only")
+    return None
+
+
+def _dependency_bump(paths: list[str]) -> RuleResult | None:
+    if all(Path(p).name in DEPENDENCY_MANIFESTS for p in paths):
+        return RuleResult(
+            matched=True, message="chore: bump dependencies", rule_name="dependency_bump"
+        )
+    return None
+
+
+def _docs_only(paths: list[str]) -> RuleResult | None:
+    doc_exts = {".md", ".rst", ".txt"}
+    doc_dirs = {"docs", "doc", "documentation"}
+    if all(
+        Path(p).suffix.lower() in doc_exts or Path(p).parts[0].lower() in doc_dirs
+        for p in paths
+    ):
+        return RuleResult(matched=True, message="docs: update documentation", rule_name="docs_only")
+    return None
+
+
+def _single_test_file(paths: list[str]) -> RuleResult | None:
+    if len(paths) == 1 and "test" in paths[0].lower():
+        name = Path(paths[0]).stem
+        return RuleResult(
+            matched=True, message=f"test: add tests for {name}", rule_name="single_test_file"
+        )
+    return None
+
+
+def _config_only(paths: list[str]) -> RuleResult | None:
+    def is_config(p: str) -> bool:
+        parts = Path(p).parts
+        return (
+            Path(p).suffix.lower() in CONFIG_PATTERNS
+            and (
+                parts[0] in CONFIG_DIRS
+                or not any("src" in part or "lib" in part for part in parts)
+            )
+        )
+    if paths and all(is_config(p) for p in paths):
+        return RuleResult(matched=True, message="chore: update config", rule_name="config_only")
+    return None
+
+
+_RULES = [
+    _readme_only, _lockfile_only, _dependency_bump, _docs_only, _single_test_file, _config_only
+]
+
+
+def apply_rules(filtered: FilteredDiff) -> RuleResult:
+    if not filtered.files:
+        return RuleResult(matched=False, message=None, rule_name=None)
+
+    paths = _all_paths(filtered)
+    for rule in _RULES:
+        result = rule(paths)
+        if result is not None:
+            return result
+
+    return RuleResult(matched=False, message=None, rule_name=None)

commitcraft/cli.py

@@ -0,0 +1,172 @@
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+app = typer.Typer(
+    name="commitcraft",
+    help="Smart conventional commit messages — rule engine first, LLM only when needed.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+@app.command()
+def init():
+    """First-time setup: choose provider, store config."""
+    from commitcraft.config.wizard import run_wizard
+    run_wizard()
+
+
+@app.command()
+def commit(no_stage: bool = typer.Option(False, "--no-stage", help="Skip git add .")):
+    """Analyze staged diff and generate a conventional commit message."""
+    import subprocess
+
+    from rich.panel import Panel
+    from rich.prompt import Prompt
+
+    from commitcraft.config.store import load_config
+    from commitcraft.generators.commit import generate_commit_message
+    from commitcraft.git.diff_parser import get_staged_diff
+    from commitcraft.utils.token_estimator import estimate_tokens
+
+    cfg = load_config()
+
+    if not no_stage:
+        console.print("[dim]Running git add .[/dim]")
+        subprocess.run(["git", "add", "."], check=True)
+
+    console.print("[dim]Analyzing staged changes...[/dim]")
+    staged_diff = get_staged_diff()
+
+    if not staged_diff.strip():
+        console.print("[yellow]No staged changes found.[/yellow]")
+        raise typer.Exit(1)
+
+    message, source = generate_commit_message(staged_diff, cfg)
+
+    if not message:
+        console.print("[red]Could not generate a commit message.[/red]")
+        raise typer.Exit(1)
+
+    source_label = f"[dim](source: {source})[/dim]"
+    if cfg.show_cost and source not in ("rule_engine", "none"):
+        from commitcraft.analysis.filters import filter_diff
+        from commitcraft.context.builder import build_commit_context
+        from commitcraft.git.diff_parser import parse_diff
+        parsed = parse_diff(staged_diff)
+        filtered = filter_diff(parsed, extra_patterns=cfg.ignore_patterns)
+        ctx = build_commit_context(filtered, [])
+        tokens = estimate_tokens(ctx)
+        source_label += f" [dim](~{tokens} tokens)[/dim]"
+
+    console.print(Panel(f"[bold green]{message}[/bold green]", title="Suggested commit message"))
+    console.print(source_label)
+
+    choice = Prompt.ask("Accept?", choices=["y", "n", "e"], default="y")
+
+    if choice == "n":
+        console.print("[yellow]Cancelled.[/yellow]")
+        raise typer.Exit(0)
+
+    if choice == "e":
+        import os
+        import tempfile
+        editor = os.environ.get("EDITOR", "vi")
+        with tempfile.NamedTemporaryFile(suffix=".txt", mode="w", delete=False) as tmp:
+            tmp.write(message)
+            tmp_path = tmp.name
+        subprocess.run([editor, tmp_path])
+        message = Path(tmp_path).read_text().strip()
+        os.unlink(tmp_path)
+
+    subprocess.run(["git", "commit", "-m", message], check=True)
+    console.print(f"[green]Committed: [bold]{message}[/bold][/green]")
+
+
+@app.command()
+def pr(base: str = typer.Option("main", "--base", "-b", help="Base branch to diff against")):
+    """Generate a PR description from the current branch diff."""
+    from rich.panel import Panel
+
+    from commitcraft.config.store import load_config
+    from commitcraft.generators.pr import generate_pr_description
+
+    cfg = load_config()
+    console.print("[dim]Generating PR description...[/dim]")
+    description = generate_pr_description(cfg, base=base)
+    console.print(Panel(description, title="PR Description"))
+    console.print("\n[dim]Copy the above into your PR description.[/dim]")
+
+
+@app.command("release-notes")
+def release_notes(tag_range: str = typer.Argument(..., help="e.g. v1.0.0..v1.1.0")):
+    """Categorize and summarize changes between two tags."""
+    from rich.panel import Panel
+
+    from commitcraft.config.store import load_config
+    from commitcraft.generators.release_notes import generate_release_notes
+
+    cfg = load_config()
+    console.print(f"[dim]Generating release notes for {tag_range}...[/dim]")
+    notes = generate_release_notes(tag_range, cfg)
+    console.print(Panel(notes, title=f"Release Notes: {tag_range}"))
+
+
+@app.command()
+def history():
+    """Analyze commit history for patterns and generic messages."""
+    from rich.table import Table
+
+    from commitcraft.git.history import (
+        analyze_commit_patterns,
+        detect_generic_commits,
+        get_all_commits,
+    )
+
+    commits = get_all_commits(n=100)
+    if not commits:
+        console.print("[yellow]No commits found.[/yellow]")
+        raise typer.Exit(0)
+
+    generic = detect_generic_commits(commits)
+    patterns = analyze_commit_patterns(commits)
+
+    console.print(f"\n[bold]Analyzed {len(commits)} commits[/bold]\n")
+
+    table = Table(title="Commit Type Distribution")
+    table.add_column("Type", style="cyan")
+    table.add_column("Count", justify="right")
+    for ctype, count in sorted(patterns.items(), key=lambda x: -x[1]):
+        table.add_row(ctype, str(count))
+    console.print(table)
+
+    if generic:
+        console.print(f"\n[yellow]Found {len(generic)} generic commit message(s):[/yellow]")
+        for g in generic:
+            console.print(f"  [red]•[/red] {g}")
+        console.print("\n[dim]Consider using commitcraft to write better commit messages.[/dim]")
+    else:
+        console.print("\n[green]✓[/green] No generic commit messages found. Great commit hygiene!")
+
+
+@app.command()
+def config():
+    """Show or change current settings."""
+    from rich.table import Table
+
+    from commitcraft.config.store import config_path, load_config
+    cfg = load_config()
+    table = Table(title="commitcraft config", show_header=True)
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value")
+    for key, value in cfg.model_dump().items():
+        display = "***" if "api_key" in key and value else str(value)
+        table.add_row(key, display)
+    console.print(table)
+    console.print(f"\n[dim]Config file: {config_path()}[/dim]")
+
+
+if __name__ == "__main__":
+    app()

commitcraft/config/models.py

@@ -0,0 +1,25 @@
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class ProviderName(str, Enum):
+    OLLAMA = "ollama"
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    GEMINI = "gemini"
+
+
+class CommitcraftConfig(BaseModel):
+    provider: ProviderName = ProviderName.OLLAMA
+    ollama_model: str = "llama3.2"
+    ollama_base_url: str = "http://localhost:11434"
+    openai_api_key: str | None = None
+    openai_model: str = "gpt-4o-mini"
+    anthropic_api_key: str | None = None
+    anthropic_model: str = "claude-haiku-4-5-20251001"
+    gemini_api_key: str | None = None
+    gemini_model: str = "gemini-1.5-flash"
+    complexity_threshold: int = Field(default=30, ge=0, le=100)
+    ignore_patterns: list[str] = Field(default_factory=list)
+    show_cost: bool = False

commitcraft/config/store.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+
+import yaml
+
+from commitcraft.config.models import CommitcraftConfig, ProviderName
+from commitcraft.providers.base import Provider
+
+CONFIG_DIR = Path.home() / ".commitcraft"
+_CONFIG_FILE = "config.yaml"
+
+
+def config_path() -> Path:
+    return CONFIG_DIR / _CONFIG_FILE
+
+
+def load_config() -> CommitcraftConfig:
+    path = config_path()
+    if not path.exists():
+        return CommitcraftConfig()
+    with path.open() as f:
+        data = yaml.safe_load(f) or {}
+    return CommitcraftConfig(**data)
+
+
+def save_config(config: CommitcraftConfig) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    path = config_path()
+    with path.open("w") as f:
+        yaml.safe_dump(config.model_dump(mode="json"), f, default_flow_style=False)
+
+
+def get_provider(config: CommitcraftConfig) -> Provider:
+    from commitcraft.providers.anthropic_provider import AnthropicProvider
+    from commitcraft.providers.gemini_provider import GeminiProvider
+    from commitcraft.providers.ollama_provider import OllamaProvider
+    from commitcraft.providers.openai_provider import OpenAIProvider
+
+    match config.provider:
+        case ProviderName.OLLAMA:
+            return OllamaProvider(config)
+        case ProviderName.ANTHROPIC:
+            return AnthropicProvider(config)
+        case ProviderName.OPENAI:
+            return OpenAIProvider(config)
+        case ProviderName.GEMINI:
+            return GeminiProvider(config)
+        case _:
+            raise ValueError(f"Unknown provider: {config.provider}")

commitcraft/config/wizard.py

@@ -0,0 +1,44 @@
+from rich.console import Console
+from rich.prompt import Prompt
+
+from commitcraft.config.models import CommitcraftConfig, ProviderName
+from commitcraft.config.store import save_config
+
+console = Console()
+
+_PROVIDER_CHOICES = {
+    "1": (ProviderName.OLLAMA, "Ollama (free, runs locally — requires Ollama installed)"),
+    "2": (ProviderName.OPENAI, "OpenAI (requires your own API key)"),
+    "3": (ProviderName.GEMINI, "Google Gemini (requires your own API key)"),
+    "4": (ProviderName.ANTHROPIC, "Anthropic Claude (requires your own API key)"),
+}
+
+
+def run_wizard() -> CommitcraftConfig:
+    console.print("\n[bold cyan]Welcome to commitcraft![/bold cyan]\n")
+    console.print("Which provider would you like to use?\n")
+
+    for key, (_, label) in _PROVIDER_CHOICES.items():
+        console.print(f"  [bold]{key})[/bold] {label}")
+
+    choice = Prompt.ask("\nEnter choice", choices=list(_PROVIDER_CHOICES.keys()), default="1")
+    provider, _ = _PROVIDER_CHOICES[choice]
+
+    cfg = CommitcraftConfig(provider=provider)
+
+    if provider == ProviderName.OPENAI:
+        cfg.openai_api_key = Prompt.ask("Enter your OpenAI API key", password=True)
+        cfg.openai_model = Prompt.ask("Model", default="gpt-4o-mini")
+    elif provider == ProviderName.ANTHROPIC:
+        cfg.anthropic_api_key = Prompt.ask("Enter your Anthropic API key", password=True)
+        cfg.anthropic_model = Prompt.ask("Model", default="claude-haiku-4-5-20251001")
+    elif provider == ProviderName.GEMINI:
+        cfg.gemini_api_key = Prompt.ask("Enter your Gemini API key", password=True)
+        cfg.gemini_model = Prompt.ask("Model", default="gemini-1.5-flash")
+    elif provider == ProviderName.OLLAMA:
+        cfg.ollama_base_url = Prompt.ask("Ollama base URL", default="http://localhost:11434")
+        cfg.ollama_model = Prompt.ask("Model", default="llama3.2")
+
+    save_config(cfg)
+    console.print(f"\n[green]✓[/green] Config saved. Provider: [bold]{provider.value}[/bold]")
+    return cfg

commitcraft/context/builder.py

@@ -0,0 +1,59 @@
+from commitcraft.analysis.filters import FilteredDiff
+
+
+def build_commit_context(filtered: FilteredDiff, recent_commits: list[str]) -> str:
+    lines: list[str] = []
+
+    lines.append("=== Changed Files ===")
+    for f in filtered.files:
+        markers = []
+        if f.is_new:
+            markers.append("NEW")
+        if f.is_deleted:
+            markers.append("DELETED")
+        if f.has_function_changes:
+            markers.append("has function/def changes")
+        if f.has_class_changes:
+            markers.append("has class changes")
+        marker_str = f" [{', '.join(markers)}]" if markers else ""
+        lines.append(f"  {f.path} (+{f.added_lines}/-{f.removed_lines}){marker_str}")
+
+    lines.append(
+        f"\nTotal: +{filtered.total_added}/-{filtered.total_removed}"
+        f" lines across {len(filtered.files)} file(s)"
+    )
+
+    if recent_commits:
+        lines.append("\n=== Recent Commit Style (follow this format) ===")
+        for c in recent_commits[:5]:
+            lines.append(f"  {c}")
+
+    lines.append("\n=== Task ===")
+    lines.append("Write a single conventional commit message for the changes above.")
+    lines.append("Output ONLY the commit message. No explanation.")
+
+    return "\n".join(lines)
+
+
+def build_pr_context(branch_diff: str, branch_name: str, recent_commits: list[str]) -> str:
+    lines: list[str] = []
+    lines.append(f"Branch: {branch_name}")
+    lines.append("\nRecent commits on this branch:")
+    for c in recent_commits[:10]:
+        lines.append(f"  {c}")
+    lines.append("\n=== Task ===")
+    lines.append(
+        "Write a GitHub PR description for this branch."
+        " Use markdown with ## Summary and ## Changes sections."
+    )
+    return "\n".join(lines)
+
+
+def build_release_context(tag_diff: str, tag_range: str) -> str:
+    lines: list[str] = [
+        f"Release range: {tag_range}",
+        "\n=== Task ===",
+        "Write structured release notes grouped by: Features, Bug Fixes, Documentation, Other."
+        " Use markdown.",
+    ]
+    return "\n".join(lines)

commitcraft/generators/commit.py

@@ -0,0 +1,33 @@
+from commitcraft.analysis.classifier import classify
+from commitcraft.analysis.filters import filter_diff
+from commitcraft.analysis.rule_engine import apply_rules
+from commitcraft.config.models import CommitcraftConfig
+from commitcraft.config.store import get_provider
+from commitcraft.context.builder import build_commit_context
+from commitcraft.git.diff_parser import parse_diff
+from commitcraft.git.history import get_recent_commits
+
+
+def generate_commit_message(staged_diff: str, config: CommitcraftConfig) -> tuple[str, str]:
+    if not staged_diff.strip():
+        return "", "none"
+
+    parsed = parse_diff(staged_diff)
+    filtered = filter_diff(parsed, extra_patterns=config.ignore_patterns)
+
+    if not filtered.files:
+        return "chore: update generated/dependency files", "rule_engine"
+
+    rule_result = apply_rules(filtered)
+    if rule_result.matched:
+        return rule_result.message, "rule_engine"
+
+    classification = classify(filtered, threshold=config.complexity_threshold)
+    if classification.is_simple:
+        return "chore: minor changes", "rule_engine"
+
+    recent = get_recent_commits(n=5)
+    context = build_commit_context(filtered, recent)
+    provider = get_provider(config)
+    message = provider.generate_commit_message(context)
+    return message, provider.name

commitcraft/generators/pr.py

@@ -0,0 +1,12 @@
+from commitcraft.config.models import CommitcraftConfig
+from commitcraft.config.store import get_provider
+from commitcraft.context.builder import build_pr_context
+from commitcraft.git.history import get_branch_commits, get_current_branch
+
+
+def generate_pr_description(config: CommitcraftConfig, base: str = "main") -> str:
+    branch = get_current_branch()
+    commits = get_branch_commits(base=base)
+    context = build_pr_context("", branch, commits)
+    provider = get_provider(config)
+    return provider.generate_pr_description(context)

commitcraft/generators/release_notes.py

@@ -0,0 +1,26 @@
+import subprocess
+
+from commitcraft.config.models import CommitcraftConfig
+from commitcraft.config.store import get_provider
+from commitcraft.context.builder import build_release_context
+from commitcraft.git.diff_parser import get_tag_diff
+
+
+def _get_commits_in_range(tag_range: str) -> list[str]:
+    try:
+        result = subprocess.run(
+            ["git", "log", tag_range, "--pretty=format:%s"],
+            capture_output=True, text=True, check=True,
+        )
+        return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+    except subprocess.CalledProcessError:
+        return []
+
+
+def generate_release_notes(tag_range: str, config: CommitcraftConfig) -> str:
+    commits = _get_commits_in_range(tag_range)
+    tag_diff = get_tag_diff(tag_range)
+    context = build_release_context(tag_diff, tag_range)
+    context += "\n\n=== Commits in range ===\n" + "\n".join(f"  {c}" for c in commits)
+    provider = get_provider(config)
+    return provider.generate_release_notes(context)

commitcraft/git/diff_parser.py

@@ -0,0 +1,132 @@
+import re
+import subprocess
+from dataclasses import dataclass, field
+
+FUNCTION_PATTERNS = [
+    re.compile(r"^\+\s*(def |async def )\w+"),        # Python
+    re.compile(r"^\+\s*(function |const \w+ = |let \w+ = |var \w+ = )\w*\s*[\(\{]"),  # JS/TS
+    re.compile(r"^\+\s*(public|private|protected|static)?\s+\w+\s+\w+\s*\("),  # Java/C#
+    re.compile(r"^\+\s*func \w+"),                     # Go
+]
+
+CLASS_PATTERNS = [
+    re.compile(r"^\+\s*class \w+"),                    # Python/JS/TS
+    re.compile(r"^\+\s*(public|private)?\s*class \w+"), # Java/C#
+    re.compile(r"^\+\s*type \w+ struct"),              # Go
+]
+
+EXTENSION_TO_TYPE: dict[str, str] = {
+    ".py": "python", ".js": "javascript", ".ts": "typescript",
+    ".tsx": "typescript", ".jsx": "javascript", ".go": "go",
+    ".rs": "rust", ".java": "java", ".cs": "csharp", ".rb": "ruby",
+    ".php": "php", ".cpp": "cpp", ".c": "c", ".h": "c",
+    ".md": "markdown", ".json": "json", ".yaml": "yaml", ".yml": "yaml",
+    ".toml": "toml", ".sh": "shell", ".bash": "shell",
+    ".html": "html", ".css": "css", ".scss": "css",
+    ".txt": "text", ".lock": "lock",
+}
+
+
+@dataclass
+class DiffFile:
+    path: str
+    file_type: str
+    is_new: bool
+    is_deleted: bool
+    added_lines: int
+    removed_lines: int
+    raw_hunks: str
+    has_function_changes: bool
+    has_class_changes: bool
+
+
+@dataclass
+class ParsedDiff:
+    files: list[DiffFile] = field(default_factory=list)
+    total_added: int = 0
+    total_removed: int = 0
+
+
+def _file_type(path: str) -> str:
+    from pathlib import Path
+    suffix = Path(path).suffix.lower()
+    return EXTENSION_TO_TYPE.get(suffix, "unknown")
+
+
+def _detect_changes(hunk_text: str) -> tuple[bool, bool]:
+    has_func = any(p.search(line) for line in hunk_text.splitlines() for p in FUNCTION_PATTERNS)
+    has_class = any(p.search(line) for line in hunk_text.splitlines() for p in CLASS_PATTERNS)
+    return has_func, has_class
+
+
+def parse_diff(raw: str) -> ParsedDiff:
+    if not raw.strip():
+        return ParsedDiff()
+
+    result = ParsedDiff()
+    file_blocks = re.split(r"(?=^diff --git )", raw, flags=re.MULTILINE)
+
+    for block in file_blocks:
+        if not block.startswith("diff --git "):
+            continue
+
+        header_match = re.match(r"diff --git a/(.+?) b/(.+)", block)
+        if not header_match:
+            continue
+
+        path = header_match.group(2)
+        is_new = bool(
+            re.search(r"^new file mode", block, re.MULTILINE)
+            or re.search(r"^--- /dev/null", block, re.MULTILINE)
+        )
+        is_deleted = bool(re.search(r"^deleted file mode", block, re.MULTILINE))
+
+        added = len(re.findall(r"^\+(?!\+\+)", block, re.MULTILINE))
+        removed = len(re.findall(r"^-(?!--)", block, re.MULTILINE))
+
+        hunk_text = "\n".join(
+            line for line in block.splitlines()
+            if line.startswith("+") or line.startswith("-")
+        )
+        has_func, has_class = _detect_changes(hunk_text)
+
+        diff_file = DiffFile(
+            path=path,
+            file_type=_file_type(path),
+            is_new=is_new,
+            is_deleted=is_deleted,
+            added_lines=added,
+            removed_lines=removed,
+            raw_hunks=block,
+            has_function_changes=has_func,
+            has_class_changes=has_class,
+        )
+        result.files.append(diff_file)
+        result.total_added += added
+        result.total_removed += removed
+
+    return result
+
+
+def get_staged_diff() -> str:
+    result = subprocess.run(
+        ["git", "diff", "--cached"],
+        capture_output=True, text=True, check=True,
+    )
+    return result.stdout
+
+
+def get_branch_diff(base: str = "main") -> str:
+    result = subprocess.run(
+        ["git", "diff", f"{base}...HEAD"],
+        capture_output=True, text=True, check=True,
+    )
+    return result.stdout
+
+
+def get_tag_diff(tag_range: str) -> str:
+    result = subprocess.run(
+        ["git", "diff", tag_range],
+        capture_output=True, text=True, check=True,
+    )
+    return result.stdout

commitcraft/git/history.py

@@ -0,0 +1,73 @@
+import re
+import subprocess
+from collections import Counter
+
+
+def get_recent_commits(n: int = 10) -> list[str]:
+    try:
+        result = subprocess.run(
+            ["git", "log", f"--max-count={n}", "--pretty=format:%s"],
+            capture_output=True, text=True, check=True,
+        )
+        return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+    except subprocess.CalledProcessError:
+        return []
+
+
+def get_branch_commits(base: str = "main", n: int = 20) -> list[str]:
+    try:
+        result = subprocess.run(
+            ["git", "log", f"{base}...HEAD", f"--max-count={n}", "--pretty=format:%s"],
+            capture_output=True, text=True, check=True,
+        )
+        return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+    except subprocess.CalledProcessError:
+        return []
+
+
+def get_current_branch() -> str:
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True, text=True, check=True,
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError:
+        return "HEAD"
+
+
+def analyze_commit_patterns(commits: list[str]) -> dict[str, int]:
+    types = []
+    for msg in commits:
+        m = re.match(r"^(\w+)[\(:]", msg)
+        if m:
+            types.append(m.group(1))
+    return dict(Counter(types))
+
+
+_GENERIC_PATTERNS = [
+    re.compile(r"^initial commit$", re.IGNORECASE),
+    re.compile(r"^wip$", re.IGNORECASE),
+    re.compile(r"^fix$", re.IGNORECASE),
+    re.compile(r"^update$", re.IGNORECASE),
+    re.compile(r"^changes?$", re.IGNORECASE),
+    re.compile(r"^misc$", re.IGNORECASE),
+    re.compile(r"^temp$", re.IGNORECASE),
+    re.compile(r"^\.+$"),
+    re.compile(r"^commit \d+$", re.IGNORECASE),
+]
+
+
+def detect_generic_commits(commits: list[str]) -> list[str]:
+    return [c for c in commits if any(p.match(c.strip()) for p in _GENERIC_PATTERNS)]
+
+
+def get_all_commits(n: int = 100) -> list[str]:
+    try:
+        result = subprocess.run(
+            ["git", "log", f"--max-count={n}", "--pretty=format:%s"],
+            capture_output=True, text=True, check=True,
+        )
+        return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+    except subprocess.CalledProcessError:
+        return []

commitcraft/providers/anthropic_provider.py

@@ -0,0 +1,44 @@
+import anthropic
+
+from commitcraft.config.models import CommitcraftConfig
+from commitcraft.providers.base import Provider
+from commitcraft.providers.ollama_provider import _COMMIT_SYSTEM, _PR_SYSTEM, _RELEASE_SYSTEM
+
+
+class AnthropicProvider(Provider):
+    def __init__(self, config: CommitcraftConfig) -> None:
+        self._config = config
+        self._client = anthropic.Anthropic(api_key=config.anthropic_api_key)
+        self._model = config.anthropic_model
+
+    @property
+    def name(self) -> str:
+        return "anthropic"
+
+    def _generate(self, system: str, prompt: str) -> str:
+        message = self._client.messages.create(
+            model=self._model,
+            max_tokens=512,
+            system=system,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        return message.content[0].text.strip()
+
+    def generate_commit_message(self, context: str) -> str:
+        return self._generate(_COMMIT_SYSTEM, context)
+
+    def generate_pr_description(self, context: str) -> str:
+        return self._generate(_PR_SYSTEM, context)
+
+    def generate_release_notes(self, context: str) -> str:
+        return self._generate(_RELEASE_SYSTEM, context)
+
+    def health_check(self) -> bool:
+        try:
+            self._client.messages.create(
+                model=self._model, max_tokens=1,
+                messages=[{"role": "user", "content": "ping"}],
+            )
+            return True
+        except Exception:
+            return False

commitcraft/providers/base.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+
+
+class Provider(ABC):
+    @property
+    @abstractmethod
+    def name(self) -> str: ...
+
+    @abstractmethod
+    def generate_commit_message(self, context: str) -> str: ...
+
+    @abstractmethod
+    def generate_pr_description(self, context: str) -> str: ...
+
+    @abstractmethod
+    def generate_release_notes(self, context: str) -> str: ...
+
+    @abstractmethod
+    def health_check(self) -> bool: ...

commitcraft/providers/gemini_provider.py

@@ -0,0 +1,40 @@
+import google.generativeai as genai
+
+from commitcraft.config.models import CommitcraftConfig
+from commitcraft.providers.base import Provider
+from commitcraft.providers.ollama_provider import _COMMIT_SYSTEM, _PR_SYSTEM, _RELEASE_SYSTEM
+
+
+class GeminiProvider(Provider):
+    def __init__(self, config: CommitcraftConfig) -> None:
+        self._config = config
+        genai.configure(api_key=config.gemini_api_key)
+        self._model_name = config.gemini_model
+
+    @property
+    def name(self) -> str:
+        return "gemini"
+
+    def _generate(self, system: str, prompt: str) -> str:
+        model = genai.GenerativeModel(
+            model_name=self._model_name,
+            system_instruction=system,
+        )
+        response = model.generate_content(prompt)
+        return response.text.strip()
+
+    def generate_commit_message(self, context: str) -> str:
+        return self._generate(_COMMIT_SYSTEM, context)
+
+    def generate_pr_description(self, context: str) -> str:
+        return self._generate(_PR_SYSTEM, context)
+
+    def generate_release_notes(self, context: str) -> str:
+        return self._generate(_RELEASE_SYSTEM, context)
+
+    def health_check(self) -> bool:
+        try:
+            genai.list_models()
+            return True
+        except Exception:
+            return False

commitcraft/providers/ollama_provider.py

@@ -0,0 +1,61 @@
+import httpx
+
+from commitcraft.config.models import CommitcraftConfig
+from commitcraft.providers.base import Provider
+
+_COMMIT_SYSTEM = (
+    "You are an expert at writing conventional commit messages. "
+    "Given a summary of code changes, write a single conventional commit message. "
+    "Format: <type>(<optional scope>): <description>. "
+    "Types: feat, fix, docs, style, refactor, test, chore, perf, ci, build. "
+    "Output ONLY the commit message — no explanation, no markdown, no quotes."
+)
+
+_PR_SYSTEM = (
+    "You are an expert at writing GitHub pull request descriptions. "
+    "Given a summary of code changes, write a clear PR description in markdown with: "
+    "a '## Summary' section (3-5 bullet points) and a '## Changes' section. "
+    "Be concise and factual."
+)
+
+_RELEASE_SYSTEM = (
+    "You are an expert at writing software release notes. "
+    "Given a list of commits or change summaries, produce structured release notes "
+    "grouped by: Features, Bug Fixes, Documentation, Other. Use markdown."
+)
+
+
+class OllamaProvider(Provider):
+    def __init__(self, config: CommitcraftConfig) -> None:
+        self._config = config
+        self._base_url = config.ollama_base_url
+        self._model = config.ollama_model
+
+    @property
+    def name(self) -> str:
+        return "ollama"
+
+    def _generate(self, system: str, prompt: str) -> str:
+        response = httpx.post(
+            f"{self._base_url}/api/generate",
+            json={"model": self._model, "system": system, "prompt": prompt, "stream": False},
+            timeout=60.0,
+        )
+        response.raise_for_status()
+        return response.json()["response"].strip()
+
+    def generate_commit_message(self, context: str) -> str:
+        return self._generate(_COMMIT_SYSTEM, context)
+
+    def generate_pr_description(self, context: str) -> str:
+        return self._generate(_PR_SYSTEM, context)
+
+    def generate_release_notes(self, context: str) -> str:
+        return self._generate(_RELEASE_SYSTEM, context)
+
+    def health_check(self) -> bool:
+        try:
+            httpx.get(f"{self._base_url}/api/tags", timeout=5.0).raise_for_status()
+            return True
+        except Exception:
+            return False

commitcraft/providers/openai_provider.py

@@ -0,0 +1,43 @@
+from openai import OpenAI
+
+from commitcraft.config.models import CommitcraftConfig
+from commitcraft.providers.base import Provider
+from commitcraft.providers.ollama_provider import _COMMIT_SYSTEM, _PR_SYSTEM, _RELEASE_SYSTEM
+
+
+class OpenAIProvider(Provider):
+    def __init__(self, config: CommitcraftConfig) -> None:
+        self._config = config
+        self._client = OpenAI(api_key=config.openai_api_key)
+        self._model = config.openai_model
+
+    @property
+    def name(self) -> str:
+        return "openai"
+
+    def _generate(self, system: str, prompt: str) -> str:
+        response = self._client.chat.completions.create(
+            model=self._model,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": prompt},
+            ],
+            max_tokens=512,
+        )
+        return (response.choices[0].message.content or "").strip()
+
+    def generate_commit_message(self, context: str) -> str:
+        return self._generate(_COMMIT_SYSTEM, context)
+
+    def generate_pr_description(self, context: str) -> str:
+        return self._generate(_PR_SYSTEM, context)
+
+    def generate_release_notes(self, context: str) -> str:
+        return self._generate(_RELEASE_SYSTEM, context)
+
+    def health_check(self) -> bool:
+        try:
+            self._client.models.list()
+            return True
+        except Exception:
+            return False

commitcraft/utils/token_estimator.py

@@ -0,0 +1,3 @@
+def estimate_tokens(text: str) -> int:
+    # Rough approximation: 1 token ≈ 4 characters (widely used heuristic)
+    return max(1, len(text) // 4)

commitcraft_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: commitcraft-cli
+Version: 0.1.0
+Summary: Smart conventional commit messages with a rule engine + minimal-context LLM
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: anthropic>=0.30.0
+Requires-Dist: google-generativeai>=0.7.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# commitcraft
+
+> Smart conventional commit messages — a rule engine decides when AI is even needed.
+
+[![CI](https://github.com/mavsensei/commitcraft/actions/workflows/ci.yml/badge.svg)](https://github.com/mavesensei/commitcraft/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## What makes it different
+
+Most "AI commit message" tools blindly send your entire diff to an LLM. commitcraft doesn't.
+
+It first runs a **local rule engine** on your diff. README-only change? Lockfile bump? Single test file? Those get a conventional commit message generated instantly, locally, with zero AI cost. Only when changes are genuinely complex does it reach out to an LLM — and even then it sends a condensed summary, not the full diff.
+
+**The story isn't "I used AI." It's "I built a system that decides when AI should be used."**
+
+## Pipeline
+
+```
+git diff (staged)
+    │
+    ▼
+Parser → extract changed files, line counts, file types
+    │
+    ▼
+Filter → strip lockfiles, dist/, build/, *.min.js, etc.
+    │
+    ▼
+Rule Engine → simple change? generate commit locally (zero cost)
+    │              e.g. README-only → "docs: update README"
+    │              lockfile-only → "chore: update lockfile"
+    │
+    ▼ (complex change only)
+Classifier → complexity score 0-100 from:
+             • file count and directory spread
+             • function/class definition changes (regex)
+             • test files alongside source files
+             • total line count
+    │
+    ▼
+Context Builder → condensed summary (not the full diff)
+    │              ~100-500 tokens instead of thousands
+    ▼
+Your chosen Provider (Ollama / OpenAI / Gemini / Anthropic)
+    │
+    ▼
+Conventional commit message
+```
+
+## Installation
+
+```bash
+pip install commitcraft
+commitcraft init   # one-time setup: choose your provider
+```
+
+## Quickstart
+
+```bash
+# Make some changes, then:
+commitcraft commit
+
+# Generate a PR description for the current branch:
+commitcraft pr
+
+# Generate release notes between two tags:
+commitcraft release-notes v1.0.0..v1.1.0
+
+# Analyze your commit history:
+commitcraft history
+```
+
+## Provider setup
+
+On first run (`commitcraft init`), you choose your provider:
+
+| Provider | Cost | Requires |
+|---|---|---|
+| **Ollama** | Free (local) | Ollama installed + a model pulled |
+| **OpenAI** | Your API key | `openai_api_key` in config |
+| **Anthropic Claude** | Your API key | `anthropic_api_key` in config |
+| **Google Gemini** | Your API key | `gemini_api_key` in config |
+
+Your API key is stored locally at `~/.commitcraft/config.yaml`. It never leaves your machine except to call your chosen provider directly.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) and [docs/adding_a_provider.md](docs/adding_a_provider.md).
+
+## License
+
+MIT © mavesensei
+

commitcraft_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+commitcraft/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+commitcraft/cli.py,sha256=XksgFlnwMfARFuPrDyocxmXwg8hIt44oowGCy6qR1N0,5959
+commitcraft/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commitcraft/analysis/classifier.py,sha256=OBTsHbiYsa0_sKY2DtU2ZszvCmqnaD2Ypc_M1ozs9WQ,2062
+commitcraft/analysis/filters.py,sha256=xBOnRlLqEehGpus36EAlegJXQiF7CBQWCAdtVAtgg9Y,1676
+commitcraft/analysis/rule_engine.py,sha256=vW8N26iUjhK1ZcQSF2AxGuPaK23ZXUBWbPc-Wr_LrwY,3184
+commitcraft/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commitcraft/config/models.py,sha256=e9pIh7auLf4cbskmhcAEgGzKEXrDkXTdzlVlj4W5Iig,768
+commitcraft/config/store.py,sha256=VeJPu6QHmmWxmdy2NGwMO9hJFleD1ABL388aJf4N-58,1533
+commitcraft/config/wizard.py,sha256=misy4ajxQ5nHLisPdmXQi0SoXmOMkxS608RVUlKDco8,1981
+commitcraft/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commitcraft/context/builder.py,sha256=gJN_d5hwZ3GvP5rCQfU40qBVz6O41kG1R4DlprrwUFE,2043
+commitcraft/generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commitcraft/generators/commit.py,sha256=2i4vrCNRArvooOdXbw45MII3chLB7H_tmMt6QT7yJxw,1304
+commitcraft/generators/pr.py,sha256=vz3opiaT9NaaZ-Iigfvo9SBI9Ad9LZ6Ab5Hr1tgut9U,542
+commitcraft/generators/release_notes.py,sha256=-nPhJUeJveNz-wCl_JCjzNq7QZcf4yWrG5RdhZ9JX-M,1010
+commitcraft/git/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commitcraft/git/diff_parser.py,sha256=cw1gejJty7J2MsMGJPRLuGMvgoKa_M3XS0GrFeTCLAQ,4018
+commitcraft/git/history.py,sha256=PPNv7lASAoiYwjAD3wIVCy_3cPZnYF2XS0TOW06itD0,2313
+commitcraft/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commitcraft/providers/anthropic_provider.py,sha256=rKg1e3TC2oqUuYpaw27nwmnFhXjKKKIt65tYJRSSLPE,1481
+commitcraft/providers/base.py,sha256=Axnq_fd1SgvBvX2z0FAQyeKWfncfvd_mDWO4P4kQC9U,439
+commitcraft/providers/gemini_provider.py,sha256=uELZK81MQzkNAsFdev5kxqCwWcrb66vAoNcCRAk2YMs,1302
+commitcraft/providers/ollama_provider.py,sha256=hNzuqzXsUhXn3CCKzZWlX0goXMPPLP6dF1WxkjAT1aw,2216
+commitcraft/providers/openai_provider.py,sha256=yLt4w3lhRwsmhiGu7ci19V6ZNU8aMzEisWMVY5hkAzU,1423
+commitcraft/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commitcraft/utils/token_estimator.py,sha256=VCL6Vl2sAnZFTlEQz5KeBXWAM9HTaOT3w93aFgU8KCU,149
+commitcraft_cli-0.1.0.dist-info/METADATA,sha256=XuqbytEOM-oXYOfrmyU7t3F0CXwxPBv8HKyzcCB5_PE,3505
+commitcraft_cli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+commitcraft_cli-0.1.0.dist-info/entry_points.txt,sha256=b-w1XlpnrfOwWJ8P5YHtyWQjTeFZsFt8pIh23iKz8nY,52
+commitcraft_cli-0.1.0.dist-info/licenses/LICENSE,sha256=HeWpEYKYnDAM0XJEdR6q2HU2XjfKW4VFkunJLLEv7yY,1067
+commitcraft_cli-0.1.0.dist-info/RECORD,,

commitcraft_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

commitcraft_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+commitcraft = commitcraft.cli:app

commitcraft_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mavesensei
+
+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.