devgen-cli 0.3.0__tar.gz → 0.3.1__tar.gz

{devgen_cli-0.3.0/devgen_cli.egg-info → devgen_cli-0.3.1}/PKG-INFO

@@ -1,22 +1,19 @@
 Metadata-Version: 2.4
 Name: devgen-cli
-Version: 0.3.0
+Version: 0.3.1
 Summary: A collection of developer tools
-Home-page: https://github.com/S4NKALP/devgen
-Author: Sankalp Tharu
 Author-email: Sankalp Tharu <sankalptharu50028@gmail.com>
-License: GPL-3.0-or-later
+License-Expression: GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/S4NKALP/devgen
 Keywords: devgen,cli,git,changelog,gitignore,license,commit-generator,commit
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -29,10 +26,7 @@ Requires-Dist: requests>=2.34.2
 Requires-Dist: rich>=15.0.0
 Requires-Dist: toml>=0.10.2
 Requires-Dist: typer>=0.26.8
-Dynamic: author
-Dynamic: home-page
 Dynamic: license-file
-Dynamic: requires-python
 
 # DevGen
 
@@ -64,7 +58,7 @@ DevGen is a CLI for the parts of development that should be invisible. It writes
 - **Conventional Changelogs** — `feat`, `fix`, `refactor`, `perf`, `docs`, `test`, `build`, `ci`, `chore`, `style`, and a `BREAKING CHANGES` section.
 - **Project Scaffolding** — Pull `.gitignore` from GitHub's collection and drop in SPDX license files (MIT, Apache-2.0, GPL-3.0, AGPL-3.0, BSD, MPL-2.0, …).
 - **Custom Templates** — Override the commit-message prompt via a `.tpl` file in your config.
-- **Interactive Setup** — `devgen setup` walks you through provider + API key + options.
+- **Interactive Setup** — `devgen setup config` walks you through provider + API key + options.
 - **Undo Support** — `devgen commit undo` rolls back the last AI commit while keeping changes staged.
 - **Token-Limit Aware** — When a diff exceeds a model's context window, you get a single actionable error with `--max-groups` and `--max-diff-size` hints.
 
@@ -119,14 +113,16 @@ devgen commit run --push
 | Command                         | Description                                                                   |
 | ------------------------------- | ----------------------------------------------------------------------------- |
 | `devgen setup config`           | Interactive provider / API key / options wizard                               |
+| `devgen config set`             | Same wizard, available under `config`                                         |
+| `devgen config list`            | Print the current configuration                                               |
+| `devgen config edit <key> [v]`  | Update a single configuration value                                           |
 | `devgen commit run`             | Stage, generate message, commit (optionally `--push`, `--check`, `--dry-run`) |
 | `devgen commit undo`            | Undo the last AI commit, keep changes staged                                  |
-| `devgen changelog`              | Generate a Conventional Commits changelog from recent history                 |
-| `devgen release-notes`          | Generate release notes for a version range                                    |
+| `devgen changelog generate`     | Generate a Conventional Commits changelog from recent history                 |
+| `devgen release notes`          | Generate release notes for a version range                                    |
 | `devgen gitignore list`         | List available GitHub `.gitignore` templates                                  |
-| `devgen gitignore add <name> …` | Add `.gitignore` entries to the current project                               |
-| `devgen license list`           | List available SPDX licenses                                                  |
-| `devgen license add <spdx>`     | Add a LICENSE file to the current project                                     |
+| `devgen gitignore generate …`   | Add `.gitignore` entries to the current project                               |
+| `devgen license generate`       | Interactively add a LICENSE file to the current project                       |
 
 Run `devgen <command> --help` for full options on any subcommand.
 

{devgen_cli-0.3.0 → devgen_cli-0.3.1}/README.md

@@ -28,7 +28,7 @@ DevGen is a CLI for the parts of development that should be invisible. It writes
 - **Conventional Changelogs** — `feat`, `fix`, `refactor`, `perf`, `docs`, `test`, `build`, `ci`, `chore`, `style`, and a `BREAKING CHANGES` section.
 - **Project Scaffolding** — Pull `.gitignore` from GitHub's collection and drop in SPDX license files (MIT, Apache-2.0, GPL-3.0, AGPL-3.0, BSD, MPL-2.0, …).
 - **Custom Templates** — Override the commit-message prompt via a `.tpl` file in your config.
-- **Interactive Setup** — `devgen setup` walks you through provider + API key + options.
+- **Interactive Setup** — `devgen setup config` walks you through provider + API key + options.
 - **Undo Support** — `devgen commit undo` rolls back the last AI commit while keeping changes staged.
 - **Token-Limit Aware** — When a diff exceeds a model's context window, you get a single actionable error with `--max-groups` and `--max-diff-size` hints.
 
@@ -83,14 +83,16 @@ devgen commit run --push
 | Command                         | Description                                                                   |
 | ------------------------------- | ----------------------------------------------------------------------------- |
 | `devgen setup config`           | Interactive provider / API key / options wizard                               |
+| `devgen config set`             | Same wizard, available under `config`                                         |
+| `devgen config list`            | Print the current configuration                                               |
+| `devgen config edit <key> [v]`  | Update a single configuration value                                           |
 | `devgen commit run`             | Stage, generate message, commit (optionally `--push`, `--check`, `--dry-run`) |
 | `devgen commit undo`            | Undo the last AI commit, keep changes staged                                  |
-| `devgen changelog`              | Generate a Conventional Commits changelog from recent history                 |
-| `devgen release-notes`          | Generate release notes for a version range                                    |
+| `devgen changelog generate`     | Generate a Conventional Commits changelog from recent history                 |
+| `devgen release notes`          | Generate release notes for a version range                                    |
 | `devgen gitignore list`         | List available GitHub `.gitignore` templates                                  |
-| `devgen gitignore add <name> …` | Add `.gitignore` entries to the current project                               |
-| `devgen license list`           | List available SPDX licenses                                                  |
-| `devgen license add <spdx>`     | Add a LICENSE file to the current project                                     |
+| `devgen gitignore generate …`   | Add `.gitignore` entries to the current project                               |
+| `devgen license generate`       | Interactively add a LICENSE file to the current project                       |
 
 Run `devgen <command> --help` for full options on any subcommand.
 

devgen_cli-0.3.1/devgen/ai.py

@@ -0,0 +1,51 @@
+"""Provider registry and dispatch for AI generation."""
+
+from importlib import import_module
+from typing import Any
+
+from devgen.providers.base import BaseProvider
+
+# Provider name -> (module, class). Keeping the registry explicit makes
+# adding a provider a one-line change and avoids guessing class names.
+PROVIDERS: dict[str, tuple[str, str]] = {
+    "gemini": ("devgen.providers.gemini", "GeminiProvider"),
+    "openai": ("devgen.providers.openai", "OpenaiProvider"),
+    "anthropic": ("devgen.providers.anthropic", "AnthropicProvider"),
+    "openrouter": ("devgen.providers.openrouter", "OpenrouterProvider"),
+    "huggingface": ("devgen.providers.huggingface", "HuggingfaceProvider"),
+    "ollama": ("devgen.providers.ollama", "OllamaProvider"),
+}
+
+
+def _provider_class(name: str) -> type[BaseProvider]:
+    try:
+        module_name, class_name = PROVIDERS[name.lower()]
+    except KeyError as error:
+        available = ", ".join(sorted(PROVIDERS))
+        raise ValueError(
+            f"Unknown provider `{name}`. Available providers: {available}."
+        ) from error
+
+    return getattr(import_module(module_name), class_name)
+
+
+def generate_with_ai(
+    prompt: str,
+    provider: str = "gemini",
+    api_key: str | None = None,
+    model: str | None = None,
+    **kwargs: Any,
+) -> str:
+    """Generate text with the requested provider.
+
+    ``model=None`` lets the provider pick its own default model.
+    """
+    return _provider_class(provider)().generate(
+        prompt,
+        api_key=api_key,
+        model=model,
+        **kwargs,
+    )
+
+
+__all__ = ["PROVIDERS", "generate_with_ai"]

{devgen_cli-0.3.0 → devgen_cli-0.3.1}/devgen/cli/changelog.py

@@ -1,5 +1,7 @@
+import subprocess
+from typing import Annotated
+
 import typer
-from typing_extensions import Annotated
 
 from devgen.modules.changelog_generator import ChangelogGenerator
 
@@ -30,9 +32,8 @@ def generate_changelog(
         ),
     ] = "",
 ) -> None:
-    generator = ChangelogGenerator()
     try:
-        generator.run(output_file=output, from_ref=from_ref)
-    except Exception as e:
-        typer.secho(f"Error generating changelog: {e}", fg=typer.colors.RED)
+        ChangelogGenerator().run(output_file=output, from_ref=from_ref)
+    except (OSError, RuntimeError, subprocess.CalledProcessError) as error:
+        typer.secho(f"Error generating changelog: {error}", fg=typer.colors.RED)
         raise typer.Exit(code=1)

{devgen_cli-0.3.0 → devgen_cli-0.3.1}/devgen/cli/commit.py

@@ -1,3 +1,4 @@
+import subprocess
 from typing import Annotated
 
 import questionary
@@ -11,6 +12,7 @@ from devgen.utils import (
     get_git_staged_files,
     get_main_log_path,
     read_file_content,
+    run_git_command,
 )
 
 app = typer.Typer(
@@ -78,8 +80,9 @@ def run_commit(
     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"check={check}, max_groups={max_groups}, max_diff_size={max_diff_size}"
+        f"Options: dry_run={dry_run}, push={push}, debug={debug}, "
+        f"force={force_rebuild}, check={check}, max_groups={max_groups}, "
+        f"max_diff_size={max_diff_size}"
     )
 
     run_commit_engine(
@@ -117,32 +120,34 @@ def validate() -> None:
     staged = get_git_staged_files()
     if staged:
         typer.secho(f"{len(staged)} staged file(s):", fg=typer.colors.GREEN)
-        for f in staged:
-            typer.echo(f"- {f}")
+        for file in staged:
+            typer.echo(f"- {file}")
     else:
         typer.secho("[i] No staged files.", fg=typer.colors.YELLOW)
 
 
 @app.command("undo")
 def undo_commit() -> None:
-    """Undoes the last commit but keeps changes staged."""
-    from devgen.utils import run_git_command
-
+    """Undo the last commit but keep the changes staged."""
     try:
-        # Check if there's at least one commit
         run_git_command(["git", "rev-parse", "HEAD"])
-    except Exception:
+    except (subprocess.CalledProcessError, FileNotFoundError):
         typer.secho("No commits found to undo.", fg=typer.colors.RED)
         return
 
-    if questionary.confirm(
+    if not 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)
+        return
+
+    try:
+        run_git_command(["git", "reset", "--soft", "HEAD~1"])
+    except (subprocess.CalledProcessError, FileNotFoundError) as error:
+        typer.secho(f"Failed to undo commit: {error}", fg=typer.colors.RED)
+        return
+
+    typer.secho(
+        "Last commit undone. Changes are still staged.",
+        fg=typer.colors.GREEN,
+    )

devgen_cli-0.3.1/devgen/cli/config.py

@@ -0,0 +1,127 @@
+from typing import Annotated, Any
+
+import questionary
+import typer
+import yaml
+
+from devgen.ai import PROVIDERS
+from devgen.cli.wizard import ask, run_config_wizard
+from devgen.utils import get_questionary_style, load_config, save_config
+
+app = typer.Typer(
+    name="config",
+    help="🔧 Manage configuration values.",
+    no_args_is_help=True,
+    rich_markup_mode="markdown",
+)
+
+_TRUE_VALUES = {"true", "yes", "1"}
+_FALSE_VALUES = {"false", "no", "0"}
+
+
+def _coerce(value: str) -> Any:
+    """Convert common string values to bool/int; leave everything else alone."""
+    normalized = value.strip().lower()
+    if normalized in _TRUE_VALUES:
+        return True
+    if normalized in _FALSE_VALUES:
+        return False
+    if normalized.lstrip("-").isdigit():
+        return int(normalized)
+    return value
+
+
+@app.command("list")
+def list_config() -> None:
+    """Show all configuration values."""
+    typer.echo(yaml.safe_dump(load_config(), sort_keys=False))
+
+
+@app.command("edit")
+def edit_config(
+    key: Annotated[str | None, typer.Argument(help="Configuration key.")] = None,
+    value: Annotated[str | None, typer.Argument(help="New value.")] = None,
+) -> None:
+    """Edit or add a single configuration value."""
+    config = load_config()
+    style = get_questionary_style()
+
+    if not key:
+        key = ask(
+            questionary.select(
+                "Select key to update:",
+                choices=list(config),
+                style=style,
+            )
+        )
+
+    if value is None:
+        current = config.get(key)
+        if key == "provider":
+            value = ask(
+                questionary.select(
+                    "Select AI Provider:",
+                    choices=sorted(PROVIDERS),
+                    default=str(current or "gemini"),
+                    style=style,
+                )
+            )
+        elif isinstance(current, bool):
+            value = ask(
+                questionary.select(
+                    f"Select value for '{key}':",
+                    choices=["True", "False"],
+                    default=str(current),
+                    style=style,
+                )
+            )
+        else:
+            value = ask(
+                questionary.text(
+                    f"Enter value for '{key}':",
+                    default=str(current) if current is not None else "",
+                    style=style,
+                )
+            )
+
+    config[key] = _coerce(value)
+    try:
+        save_config(config)
+    except OSError as error:
+        typer.secho(f"❌ Failed to save config: {error}", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+    typer.secho(f" Set '{key}' to '{config[key]}'", fg=typer.colors.GREEN)
+
+
+@app.command("set")
+def set_config() -> None:
+    """Run the interactive configuration wizard."""
+    run_config_wizard()
+
+
+@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-0.3.1/devgen/cli/gitignore.py

@@ -0,0 +1,137 @@
+from typing import Annotated
+
+import questionary
+import typer
+
+from devgen.cli.wizard import ask
+from devgen.modules.gitignore_generator import GitignoreGenerator
+from devgen.utils import get_questionary_style
+
+app = typer.Typer(
+    name="gitignore",
+    help="🙈 Generate .gitignore files from GitHub templates.",
+    no_args_is_help=True,
+    rich_markup_mode="markdown",
+)
+
+
+def _select_templates(
+    generator: GitignoreGenerator,
+    offline: bool,
+) -> list[str]:
+    """Interactively build a list of templates to include."""
+    if offline:
+        available = generator.list_cached_templates()
+    else:
+        typer.secho("Fetching templates list...", fg=typer.colors.YELLOW)
+        available = generator.list_available_templates()
+
+    if not available:
+        typer.secho(" No templates available.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    selected: list[str] = []
+    style = get_questionary_style()
+
+    while True:
+        choices = [
+            "Done (Finish selection)",
+            *(name for name in available if name not in selected),
+        ]
+        choice = ask(
+            questionary.autocomplete(
+                "Search for a template (type to search, select 'Done' to finish):",
+                choices=choices,
+                ignore_case=True,
+                match_middle=True,
+                validate=lambda value, options=choices: value in options or value == "",
+                style=style,
+            )
+        )
+
+        if not choice or choice.startswith("Done"):
+            return selected
+
+        selected.append(choice)
+        typer.secho(f"➕ Added '{choice}'", fg=typer.colors.GREEN)
+
+
+@app.command("list")
+def list_templates(
+    cached: Annotated[
+        bool,
+        typer.Option("--cached", "-c", help="List only cached templates."),
+    ] = False,
+) -> None:
+    """List available gitignore templates."""
+    generator = GitignoreGenerator()
+    try:
+        if cached:
+            templates = generator.list_cached_templates()
+            typer.secho(" Cached Templates:", fg=typer.colors.CYAN, bold=True)
+        else:
+            typer.secho("Fetching available templates...", fg=typer.colors.YELLOW)
+            templates = generator.list_available_templates()
+            typer.secho(" Available Templates:", fg=typer.colors.CYAN, bold=True)
+    except RuntimeError as error:
+        typer.secho(f" Error: {error}", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    typer.echo(", ".join(templates) if templates else "No templates found.")
+
+
+@app.command("generate")
+def generate_gitignore(
+    templates: Annotated[
+        list[str] | None,
+        typer.Argument(
+            help="Names of templates to include (e.g. Python Node). "
+            "If empty, interactive mode is used."
+        ),
+    ] = None,
+    output: Annotated[
+        str,
+        typer.Option("--output", "-o", help="Output file path."),
+    ] = ".gitignore",
+    append: Annotated[
+        bool,
+        typer.Option(
+            "--append/--overwrite",
+            "-a/-w",
+            help="Append to existing file or overwrite.",
+        ),
+    ] = True,
+    offline: Annotated[
+        bool,
+        typer.Option("--offline", help="Use only cached templates."),
+    ] = False,
+) -> None:
+    """Generate a .gitignore file."""
+    generator = GitignoreGenerator()
+
+    if not templates:
+        try:
+            templates = _select_templates(generator, offline)
+        except typer.Exit:
+            raise
+        except KeyboardInterrupt:
+            typer.secho("\nCancelled by user", fg=typer.colors.YELLOW)
+            raise typer.Exit()
+        except (OSError, RuntimeError) as error:
+            typer.secho(f"❌ Error fetching templates: {error}", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        if not templates:
+            typer.secho("No templates selected.", fg=typer.colors.YELLOW)
+            raise typer.Exit()
+
+    try:
+        generator.generate(
+            templates,
+            output_file=output,
+            append=append,
+            offline=offline,
+        )
+    except (OSError, RuntimeError, ValueError) as error:
+        typer.secho(f"❌ Error generating .gitignore: {error}", fg=typer.colors.RED)
+        raise typer.Exit(code=1)

devgen_cli-0.3.1/devgen/cli/license.py

@@ -0,0 +1,92 @@
+from datetime import datetime
+from pathlib import Path
+from typing import Annotated
+
+import questionary
+import typer
+
+from devgen.cli.wizard import ask
+from devgen.modules.license_generator import LicenseGenerator
+from devgen.utils import get_questionary_style
+
+app = typer.Typer(
+    name="license",
+    help="📄 Generate open source licenses.",
+    no_args_is_help=True,
+    rich_markup_mode="markdown",
+)
+
+
+@app.command("generate")
+def generate_license(
+    output: Annotated[
+        str,
+        typer.Option(
+            "--output",
+            "-o",
+            help="Output file path.",
+        ),
+    ] = "LICENSE",
+) -> None:
+    """Interactively generate a license file."""
+    generator = LicenseGenerator()
+    licenses = generator.list_licenses()
+
+    if not licenses:
+        typer.secho(" No license templates found.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    style = get_questionary_style()
+    choices = [
+        questionary.Choice(
+            title=f"{license_info['name']} ({license_info['key']})",
+            value=license_info["key"],
+            description=license_info["description"],
+        )
+        for license_info in licenses
+    ]
+
+    license_key = ask(
+        questionary.select(
+            "Select a License:",
+            choices=choices,
+            use_indicator=True,
+            use_shortcuts=True,
+            style=style,
+        )
+    )
+
+    author = ask(questionary.text("Enter Author Name:", style=style)).strip()
+    if not author:
+        typer.secho(" Author name is required.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    year = ask(
+        questionary.text(
+            "Enter Year:",
+            default=str(datetime.now().year),
+            style=style,
+        )
+    ).strip()
+
+    output_path = Path(output)
+    if output_path.exists():
+        overwrite = ask(
+            questionary.confirm(
+                f"File {output} already exists. Overwrite?",
+                default=False,
+                style=style,
+            )
+        )
+        if not overwrite:
+            typer.secho("Operation cancelled.", fg=typer.colors.YELLOW)
+            return
+
+    try:
+        content = generator.render_license(license_key, author, year)
+        output_path.write_text(content, encoding="utf-8")
+    except (OSError, ValueError) as error:
+        typer.secho(f"\n Failed to generate license: {error}", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    typer.secho(f"\n License generated at {output_path}", fg=typer.colors.GREEN)

devgen_cli-0.3.1/devgen/cli/main.py

@@ -0,0 +1,66 @@
+from importlib.metadata import PackageNotFoundError, version
+from typing import Annotated
+
+import typer
+
+from devgen.cli.changelog import app as changelog_app
+from devgen.cli.commit import app as commit_app
+from devgen.cli.config import app as config_app
+from devgen.cli.gitignore import app as gitignore_app
+from devgen.cli.license import app as license_app
+from devgen.cli.release import app as release_app
+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=True,
+    no_args_is_help=True,
+    rich_markup_mode="markdown",
+)
+
+
+def _version_callback(value: bool) -> None:
+    """Print the installed package version and exit."""
+    if not value:
+        return
+
+    try:
+        package_version = version("devgen-cli")
+    except PackageNotFoundError:
+        package_version = "unknown"
+
+    typer.echo(f"devgen version: {package_version}")
+    raise typer.Exit()
+
+
+@app.callback()
+def main_callback(
+    version: Annotated[
+        bool | None,
+        typer.Option(
+            "--version",
+            "-v",
+            callback=_version_callback,
+            is_eager=True,
+            help="Show the application version and exit.",
+        ),
+    ] = None,
+) -> None:
+    """DevGen command-line entry point."""
+
+
+app.add_typer(commit_app, name="commit")
+app.add_typer(setup_app, name="setup")
+app.add_typer(changelog_app, name="changelog")
+app.add_typer(license_app, name="license")
+app.add_typer(gitignore_app, name="gitignore")
+app.add_typer(release_app, name="release")
+app.add_typer(config_app, name="config")
+
+if __name__ == "__main__":
+    try:
+        app()
+    except KeyboardInterrupt:
+        print("\n\n Operation cancelled by user.")
+        raise typer.Exit(code=130)