devgen-cli 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

devgen/ai.py

@@ -21,8 +21,17 @@ def generate_with_ai(
         provider_module = import_module(f"devgen.providers.{provider}")
         class_name = "".join([x.capitalize() for x in provider.split("_")]) + "Provider"
         provider_class = getattr(provider_module, class_name)
-    except (ModuleNotFoundError, AttributeError) as e:
-        raise ImportError(f"Provider `{provider}` not found or invalid: {e}") from e
+    except ModuleNotFoundError as e:
+        raise ImportError(
+            f"Provider `{provider}` is not a built-in module: {e}. "
+            f"Available providers: gemini, openai, anthropic, huggingface, "
+            f"openrouter, ollama."
+        ) from e
+    except AttributeError as e:
+        raise ImportError(
+            f"Provider `{provider}` exists but does not expose a "
+            f"`{class_name}` class. This is a packaging bug."
+        ) from e
 
     provider_instance = provider_class()
     return provider_instance.generate(prompt, api_key=api_key, model=model, **kwargs)

devgen/cli/commit.py

@@ -1,5 +1,6 @@
 from typing import Annotated
 
+import questionary
 import typer
 
 from devgen.modules.commit_generator import run_commit_engine
@@ -50,12 +51,35 @@ def run_commit(
             help="Force regeneration of commit messages.",
         ),
     ] = False,
+    check: Annotated[
+        bool,
+        typer.Option(
+            "--check",
+            help="Review/edit commit message before committing.",
+        ),
+    ] = False,
+    max_groups: Annotated[
+        int | None,
+        typer.Option(
+            "--max-groups",
+            help="Maximum number of commit groups. Lower this if you hit token-limit errors.",
+        ),
+    ] = None,
+    max_diff_size: Annotated[
+        int | None,
+        typer.Option(
+            "--max-diff-size",
+            help="Maximum diff size in chars per group (default 8000). "
+            "Lower this if you hit token-limit errors.",
+        ),
+    ] = None,
 ) -> None:
     log_file = get_main_log_path()
     logger = configure_logger("devgen.cli.commit", log_file, console=debug)
     logger.info(f"Log file: {log_file}")
     logger.info(
-        f"Options: dry_run={dry_run}, push={push}, debug={debug}, force={force_rebuild}"
+        f"Options: dry_run={dry_run}, push={push}, debug={debug}, force={force_rebuild}, "
+        f"check={check}, max_groups={max_groups}, max_diff_size={max_diff_size}"
     )
 
     run_commit_engine(
@@ -63,7 +87,10 @@ def run_commit(
         push=push,
         debug=debug,
         force_rebuild=force_rebuild,
+        check=check,
         logger=logger,
+        max_groups=max_groups,
+        max_diff_size=max_diff_size,
     )
 
 
@@ -94,3 +121,28 @@ def validate() -> None:
             typer.echo(f"- {f}")
     else:
         typer.secho("[i] No staged files.", fg=typer.colors.RED)
+
+
+@app.command("undo")
+def undo_commit() -> None:
+    """Undoes the last commit but keeps changes staged."""
+    from devgen.utils import run_git_command
+
+    try:
+        # Check if there's at least one commit
+        run_git_command(["git", "rev-parse", "HEAD"])
+    except Exception:
+        typer.secho("No commits found to undo.", fg=typer.colors.RED)
+        return
+
+    if questionary.confirm(
+        "Are you sure you want to undo the last commit? (Changes will remain staged)",
+        default=False,
+    ).ask():
+        try:
+            run_git_command(["git", "reset", "--soft", "HEAD~1"])
+            typer.secho(
+                "Last commit undone. Changes are still staged.", fg=typer.colors.GREEN
+            )
+        except Exception as e:
+            typer.secho(f"Failed to undo commit: {e}", fg=typer.colors.RED)

devgen/cli/config.py

@@ -62,7 +62,14 @@ def edit_config(
         if key == "provider":
             value = questionary.select(
                 "Select AI Provider:",
-                choices=["gemini", "openai", "huggingface", "openrouter", "anthropic"],
+                choices=[
+                    "gemini",
+                    "openai",
+                    "huggingface",
+                    "openrouter",
+                    "anthropic",
+                    "ollama",
+                ],
                 default=str(current_val) if current_val else "gemini",
                 style=style,
             ).ask()
@@ -117,7 +124,14 @@ def set_config() -> None:
     # Questions
     provider = questionary.select(
         "Select AI Provider:",
-        choices=["gemini", "openai", "huggingface", "openrouter", "anthropic"],
+        choices=[
+            "gemini",
+            "openai",
+            "huggingface",
+            "openrouter",
+            "anthropic",
+            "ollama",
+        ],
         default=config.get("provider", "gemini"),
         style=style,
     ).ask()
@@ -151,12 +165,24 @@ def set_config() -> None:
         raise typer.Exit(code=130)
     emoji = emoji_choice == "Yes"
 
+    ollama_host = config.get("ollama_host", "http://localhost:11434")
+    if provider == "ollama":
+        ollama_host_input = questionary.text(
+            "Ollama server URL:",
+            default=ollama_host,
+            style=style,
+        ).ask()
+        if ollama_host_input is None:
+            raise typer.Exit(code=130)
+        ollama_host = ollama_host_input.strip() or ollama_host
+
     # Save Config
     new_config = {
         "provider": provider,
         "model": model,
         "api_key": api_key,
         "emoji": emoji,
+        "ollama_host": ollama_host,
     }
 
     # Merge with existing config to preserve other keys?
@@ -167,3 +193,30 @@ def set_config() -> None:
     _save_config(config)
     typer.secho("\nConfiguration saved.", fg=typer.colors.GREEN)
     typer.echo(yaml.dump(new_config, default_flow_style=False))
+
+
+@app.command("info")
+def config_info() -> None:
+    """Show information about configuration options and templates."""
+    from rich.console import Console
+    from rich.table import Table
+
+    console = Console()
+    table = Table(title="Custom Template Variables", box=None)
+    table.add_column("Variable", style="cyan")
+    table.add_column("Description", style="white")
+
+    table.add_row("{{ group_name }}", "The folder name being committed (or 'root').")
+    table.add_row("{{ diff_text }}", "The git diff of the changes.")
+    table.add_row("{{ context }}", "Project context (manifest files content).")
+
+    console.print(table)
+    console.print(
+        "\n[bold]Tip:[/bold] If you hardcode emojis in your template, the AI will likely include them regardless of the 'emoji' setting.",
+        style="yellow",
+    )
+    console.print("\n[bold]Example Template:[/bold]")
+    console.print(
+        "custom_template: |\n  [type]: [desc]\n  \n  Diff: {{ diff_text }}\n",
+        style="dim",
+    )

devgen/cli/main.py

@@ -15,7 +15,7 @@ from devgen.cli.setup import app as setup_app
 app = typer.Typer(
     name="devgen",
     help="devgen-py: AI-Powered Git Commit & Release Automation.",
-    add_completion=False,
+    add_completion=True,
     no_args_is_help=True,
     rich_markup_mode="markdown",
 )
@@ -48,13 +48,21 @@ def _version_callback(value: bool) -> None:
                 typer.echo(f"devgen version: {version}")
             else:
                 typer.secho(
-                    "Error: Version not found in pyproject.toml",
+                    "Could not determine version: no `project.version` or "
+                    "`tool.poetry.version` found in pyproject.toml.",
                     fg=typer.colors.RED,
                     err=True,
                 )
-        except (FileNotFoundError, KeyError, Exception) as e:
+        except FileNotFoundError:
             typer.secho(
-                f"Error: Could not determine version: {e}",
+                f"pyproject.toml not found at {pyproject_path}. "
+                "The installation may be corrupt.",
+                fg=typer.colors.RED,
+                err=True,
+            )
+        except toml.TomlDecodeError as e:
+            typer.secho(
+                f"pyproject.toml is not valid TOML: {e}",
                 fg=typer.colors.RED,
                 err=True,
             )

devgen/cli/setup.py

@@ -33,7 +33,14 @@ def setup_config() -> None:
     # Questions
     provider = questionary.select(
         "Select AI Provider:",
-        choices=["gemini", "openai", "huggingface", "openrouter", "anthropic"],
+        choices=[
+            "gemini",
+            "openai",
+            "huggingface",
+            "openrouter",
+            "anthropic",
+            "ollama",
+        ],
         default=current_config.get("provider", "gemini"),
         style=style,
     ).ask()
@@ -67,12 +74,24 @@ def setup_config() -> None:
         raise typer.Exit(code=130)
     emoji = emoji_choice == "Yes"
 
+    ollama_host = current_config.get("ollama_host", "http://localhost:11434")
+    if provider == "ollama":
+        ollama_host_input = questionary.text(
+            "Ollama server URL:",
+            default=ollama_host,
+            style=style,
+        ).ask()
+        if ollama_host_input is None:
+            raise typer.Exit(code=130)
+        ollama_host = ollama_host_input.strip() or ollama_host
+
     # Save Config
     new_config = {
         "provider": provider,
         "model": model,
         "api_key": api_key,
         "emoji": emoji,
+        "ollama_host": ollama_host,
     }
 
     try:

devgen/modules/changelog_generator.py

@@ -5,174 +5,151 @@ from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Optional
 
+from devgen.modules.changelog_sections import (
+    DEFAULT_STYLES,
+    Section,
+    section_for_type,
+)
 from devgen.utils import configure_logger, run_git_command
 
 
 class ChangelogGenerator:
     """Generates a changelog from git history using Semantic Release style."""
 
+    #: Conventional commit header: ``type(scope)!: subject``
+    _CC_PATTERN = re.compile(r"^(\w+)(?:\(([^)]+)\))?(!?):\s+(.*)")
+
     def __init__(self, logger=None):
         self.logger = logger or configure_logger("devgen.changelog")
 
-    def get_commits(self, from_ref: str = "", to_ref: str = "HEAD") -> List[str]:
-        """Fetches commit messages in the specified range."""
-        range_spec = f"{from_ref}..{to_ref}" if from_ref else to_ref
-        # Format: hash|author|date|subject|body
-        fmt = "%H|%an|%ad|%s|%b"
-        cmd = ["git", "log", f"--format={fmt}", "--date=short", range_spec]
-
-        if not from_ref:
-            # If no start ref, try to find the last tag
-            try:
-                last_tag = run_git_command(["git", "describe", "--tags", "--abbrev=0"])
-                cmd = [
-                    "git",
-                    "log",
-                    f"--format={fmt}",
-                    "--date=short",
-                    f"{last_tag}..HEAD",
-                ]
-                self.logger.info(f"Generating changelog from last tag: {last_tag}")
-            except (RuntimeError, subprocess.CalledProcessError):
-                self.logger.info("No tags found, generating for all commits.")
-                cmd = ["git", "log", f"--format={fmt}", "--date=short"]
+    # ------------------------------------------------------------------ commits
 
+    def get_commits(self, from_ref: str = "", to_ref: str = "HEAD") -> List[str]:
+        """Fetch commit lines in the requested range."""
+        if from_ref:
+            range_spec = f"{from_ref}..{to_ref}"
+            cmd = self._log_cmd(range_spec)
+        else:
+            cmd = self._resolve_range(to_ref)
         try:
             return run_git_command(cmd).split("\n")
         except subprocess.CalledProcessError as e:
             self.logger.error(f"Git command failed: {e}")
-            raise RuntimeError(f"Git command failed: {e}")
+            raise RuntimeError(f"Git command failed: {e}") from e
 
-    def parse_commits(self, raw_commits: List[str]) -> Dict[str, List[Dict]]:
-        """Parses raw commit strings into structured data."""
-        groups = defaultdict(list)
-        # Conventional Commit Regex: type(scope)!: subject
-        cc_pattern = re.compile(r"^(\w+)(?:\(([^)]+)\))?(!?):\s+(.*)")
+    def _log_cmd(self, range_spec: str) -> List[str]:
+        # Format: hash|author|date|subject|body
+        return [
+            "git",
+            "log",
+            "--format=%H|%an|%ad|%s|%b",
+            "--date=short",
+            range_spec,
+        ]
 
+    def _resolve_range(self, to_ref: str) -> List[str]:
+        try:
+            last_tag = run_git_command(["git", "describe", "--tags", "--abbrev=0"])
+            self.logger.info(f"Generating changelog from last tag: {last_tag}")
+            return self._log_cmd(f"{last_tag}..HEAD")
+        except (RuntimeError, subprocess.CalledProcessError):
+            self.logger.info("No tags found, generating for all commits.")
+            return ["git", "log", "--format=%H|%an|%ad|%s|%b", "--date=short"]
+
+    # ----------------------------------------------------------------- parsing
+
+    def parse_commits(self, raw_commits: List[str]) -> Dict[Section, List[Dict]]:
+        """Group raw commit lines into :class:`Section` buckets."""
+        groups: Dict[Section, List[Dict]] = defaultdict(list)
         for line in raw_commits:
-            if not line.strip():
-                continue
-
-            parts = line.split("|", 4)
-            if len(parts) < 4:
+            entry = self._parse_line(line)
+            if entry is None:
                 continue
+            section = section_for_type(entry["type"])
+            entry["section"] = section
+            if entry["breaking"]:
+                groups[Section.BREAKING].append(entry)
+            groups[section].append(entry)
+        return dict(groups)
+
+    def _parse_line(self, line: str) -> Dict | None:
+        if not line.strip():
+            return None
+        parts = line.split("|", 4)
+        if len(parts) < 4:
+            return None
+        commit_hash, author, date, subject = parts[:4]
+        body = parts[4] if len(parts) > 4 else ""
+
+        match = self._CC_PATTERN.match(subject)
+        if match:
+            c_type, c_scope, breaking, c_subject = match.groups()
+            return {
+                "type": c_type,
+                "hash": commit_hash,
+                "author": author,
+                "date": date,
+                "scope": c_scope,
+                "subject": c_subject,
+                "body": body,
+                "breaking": bool(breaking),
+            }
+        return {
+            "type": "",
+            "hash": commit_hash,
+            "author": author,
+            "date": date,
+            "scope": None,
+            "subject": subject,
+            "body": body,
+            "breaking": False,
+        }
 
-            commit_hash, author, date, subject, body = (
-                parts[0],
-                parts[1],
-                parts[2],
-                parts[3],
-                parts[4] if len(parts) > 4 else "",
-            )
-
-            match = cc_pattern.match(subject)
-            if match:
-                c_type, c_scope, breaking, c_subject = match.groups()
-                entry = {
-                    "hash": commit_hash,
-                    "author": author,
-                    "date": date,
-                    "scope": c_scope,
-                    "subject": c_subject,
-                    "body": body,
-                    "breaking": bool(breaking),
-                }
-
-                if breaking:
-                    groups["BREAKING CHANGES"].append(entry)
-
-                if c_type in ["feat", "feature"]:
-                    groups["Features"].append(entry)
-                elif c_type in ["fix", "bug"]:
-                    groups["Bug Fixes"].append(entry)
-                elif c_type in ["docs"]:
-                    groups["Documentation"].append(entry)
-                elif c_type in [
-                    "style",
-                    "refactor",
-                    "perf",
-                    "test",
-                    "build",
-                    "ci",
-                    "chore",
-                ]:
-                    groups["Other Changes"].append(entry)
-                else:
-                    groups["Other Changes"].append(entry)
-            else:
-                # Non-conventional commits
-                groups["Other Changes"].append(
-                    {
-                        "hash": commit_hash,
-                        "author": author,
-                        "date": date,
-                        "scope": None,
-                        "subject": subject,
-                        "body": body,
-                        "breaking": False,
-                    }
-                )
-
-        return groups
+    # ------------------------------------------------------------------ output
 
     def generate_markdown(
-        self, groups: Dict[str, List[Dict]], version: str = "Unreleased"
+        self,
+        groups: Dict[Section, List[Dict]],
+        version: str = "Unreleased",
     ) -> str:
-        """Generates markdown changelog from parsed commits."""
+        """Render groups as a markdown changelog block."""
         date_str = datetime.now().strftime("%Y-%m-%d")
-        md = [f"# {version} ({date_str})\n"]
-
-        # Order: Breaking, Features, Fixes, Docs, Others
-        order = [
-            "BREAKING CHANGES",
-            "Features",
-            "Bug Fixes",
-            "Documentation",
-            "Other Changes",
-        ]
-
-        emoji_map = {
-            "BREAKING CHANGES": "💥 BREAKING CHANGES",
-            "Features": "✨ Features",
-            "Bug Fixes": "🐛 Bug Fixes",
-            "Documentation": "📚 Documentation",
-            "Other Changes": "🔨 Other Changes",
-        }
-
-        for section in order:
+        out = [f"## {version} ({date_str})\n"]
+        for section in Section.ordered():
             commits = groups.get(section)
-            if commits:
-                header = emoji_map.get(section, section)
-                md.append(f"## {header}\n")
-                for c in commits:
-                    scope = f"**{c['scope']}**: " if c["scope"] else ""
-                    md.append(f"- {scope}{c['subject']} ({c['hash'][:7]})")
-                md.append("")
-
-        return "\n".join(md)
+            if not commits:
+                continue
+            style = DEFAULT_STYLES[section]
+            out.append(f"## {style.emoji} {style.heading}\n")
+            for c in commits:
+                scope = f"**{c['scope']}**: " if c.get("scope") else ""
+                out.append(f"- {scope}{c['subject']} ({c['hash'][:7]})")
+            out.append("")
+        return "\n".join(out)
 
     def run(self, output_file: Optional[str] = "CHANGELOG.md", from_ref: str = ""):
-        """Main execution method."""
+        """Fetch → parse → write (or print) the changelog."""
         raw_commits = self.get_commits(from_ref)
         if not raw_commits or not raw_commits[0]:
             self.logger.warning("No commits found.")
             return
+        groups = self.parse_commits(raw_commits)
+        md_content = self.generate_markdown(groups)
 
-        parsed = self.parse_commits(raw_commits)
-        md_content = self.generate_markdown(parsed)
-
-        if output_file:
-            path = Path(output_file)
-            # If file exists, prepend? For now, just overwrite or append logic could be complex.
-            # Let's implement prepend logic if file exists.
-            if path.exists():
-                old_content = path.read_text(encoding="utf-8")
-                new_content = old_content + "\n\n" + md_content
-                path.write_text(new_content, encoding="utf-8")
-            else:
-                path.write_text(md_content, encoding="utf-8")
+        if not output_file:
+            print(md_content)
+            return
 
-            self.logger.info(f"Changelog written to {output_file}")
-            print(f" Changelog updated: {output_file}")
+        path = Path(output_file)
+        if path.exists():
+            old = path.read_text(encoding="utf-8")
+            if old.strip().startswith("# CHANGELOG"):
+                header, _, rest = old.partition("\n")
+                new_content = f"{header}\n\n{md_content}\n{rest.lstrip()}"
+            else:
+                new_content = f"# CHANGELOG\n\n{md_content}\n\n{old}"
         else:
-            print(md_content)
+            new_content = f"# CHANGELOG\n\n{md_content}"
+        path.write_text(new_content, encoding="utf-8")
+        self.logger.info(f"Changelog written to {output_file}")
+        print(f" Changelog updated: {output_file}")

devgen/modules/changelog_sections.py

@@ -0,0 +1,79 @@
+"""Shared section definitions for changelog and release-note generators.
+
+Both generators render the same set of Conventional Commit groups; this
+module is the single source of truth for the section name, the emoji,
+and the display order.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Mapping
+
+
+class Section(str, Enum):
+    """Sections in the order they should be rendered."""
+
+    BREAKING = "BREAKING CHANGES"
+    FEATURES = "Features"
+    BUG_FIXES = "Bug Fixes"
+    PERFORMANCE = "Performance"
+    DOCUMENTATION = "Documentation"
+    REFACTOR = "Refactor"
+    TESTS = "Tests"
+    STYLE = "Style"
+    CHORE = "Chore"
+    OTHER = "Other Changes"
+
+    @classmethod
+    def ordered(cls) -> tuple["Section", ...]:
+        return tuple(cls)
+
+
+@dataclass(frozen=True)
+class SectionStyle:
+    """Visual style for a section (emoji + name for the heading)."""
+
+    emoji: str
+    heading: str
+
+
+# Default style for each section. Generators can override per output
+# format (changelog vs. release notes).
+DEFAULT_STYLES: Mapping[Section, SectionStyle] = {
+    Section.BREAKING: SectionStyle("💥", "BREAKING CHANGES"),
+    Section.FEATURES: SectionStyle("✨", "Features"),
+    Section.BUG_FIXES: SectionStyle("🐛", "Bug Fixes"),
+    Section.PERFORMANCE: SectionStyle("⚡", "Performance"),
+    Section.DOCUMENTATION: SectionStyle("📚", "Documentation"),
+    Section.REFACTOR: SectionStyle("♻️", "Refactor"),
+    Section.TESTS: SectionStyle("✅", "Tests"),
+    Section.STYLE: SectionStyle("💄", "Style"),
+    Section.CHORE: SectionStyle("🔧", "Chore"),
+    Section.OTHER: SectionStyle("🧹", "Other Changes"),
+}
+
+
+# Conventional commit type → Section mapping. Long-form aliases ("feature",
+# "bug") are also accepted.
+TYPE_TO_SECTION: Mapping[str, Section] = {
+    "feat": Section.FEATURES,
+    "feature": Section.FEATURES,
+    "fix": Section.BUG_FIXES,
+    "bug": Section.BUG_FIXES,
+    "perf": Section.PERFORMANCE,
+    "docs": Section.DOCUMENTATION,
+    "refactor": Section.REFACTOR,
+    "test": Section.TESTS,
+    "style": Section.STYLE,
+    "build": Section.CHORE,
+    "ci": Section.CHORE,
+    "chore": Section.CHORE,
+}
+
+
+def section_for_type(commit_type: str) -> Section:
+    """Return the Section for a Conventional Commit ``type``.
+
+    Unknown types fall back to :attr:`Section.OTHER`.
+    """
+    return TYPE_TO_SECTION.get(commit_type.lower(), Section.OTHER)