devgen-cli 0.2.9__py3-none-any.whl → 0.3.1__py3-none-any.whl

devgen/ai.py

@@ -1,37 +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, provider="gemini", api_key=None, model="gemini-2.5-flash", **kwargs
-):
-    """Generates AI-based content such as commit messages using the specified provider and model.
-    This function dynamically loads and initializes the provider class, sets the API key, and invokes the provider's generate method with the provided prompt and additional parameters.
-
-    Args:
-        prompt (str): The input prompt used to generate content.
-        provider (str): The name of the provider module and class to use; defaults to "gemini".
-        api_key (str, optional): The API key for authenticating with the provider. Should be provided via config file or kwargs.
-        model (str): The name of the model to use with the provider; defaults to "gemini".
-        **kwargs: Additional keyword arguments to pass to the provider's generate method.
-
-    Returns:
-        str: The generated content produced by the AI provider.
+    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.
     """
-    try:
-        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 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)
+    return _provider_class(provider)().generate(
+        prompt,
+        api_key=api_key,
+        model=model,
+        **kwargs,
+    )
+
+
+__all__ = ["PROVIDERS", "generate_with_ai"]

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/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/config.py

@@ -1,12 +1,12 @@
-from pathlib import Path
-from typing import Any, Optional
+from typing import Annotated, Any
 
 import questionary
 import typer
 import yaml
-from typing_extensions import Annotated
 
-from devgen.utils import get_questionary_style, load_config
+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",
@@ -15,190 +15,88 @@ app = typer.Typer(
     rich_markup_mode="markdown",
 )
 
+_TRUE_VALUES = {"true", "yes", "1"}
+_FALSE_VALUES = {"false", "no", "0"}
 
-def _save_config(config: dict[str, Any]) -> None:
-    config_path = Path.home() / ".devgen.yaml"
-    try:
-        with config_path.open("w", encoding="utf-8") as f:
-            yaml.dump(config, f, default_flow_style=False)
-    except Exception as e:
-        typer.secho(f"❌ Failed to save config: {e}", fg=typer.colors.RED)
-        raise typer.Exit(code=1)
+
+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."""
-    config = load_config()
-    if not config:
-        typer.echo("Configuration is empty.")
-        return
-
-    typer.echo(yaml.dump(config, default_flow_style=False))
+    typer.echo(yaml.safe_dump(load_config(), sort_keys=False))
 
 
 @app.command("edit")
 def edit_config(
-    key: Annotated[Optional[str], typer.Argument(help="Configuration key.")] = None,
-    value: Annotated[Optional[str], typer.Argument(help="New value.")] = None,
+    key: Annotated[str | None, typer.Argument(help="Configuration key.")] = None,
+    value: Annotated[str | None, typer.Argument(help="New value.")] = None,
 ) -> None:
-    """Edit a specific configuration value."""
+    """Edit or add a single configuration value."""
     config = load_config()
     style = get_questionary_style()
 
     if not key:
-        choices = list(config.keys())
-        if not choices:
-            typer.secho(
-                "No configuration keys found. Run `devgen setup config` first.",
-                fg=typer.colors.YELLOW,
+        key = ask(
+            questionary.select(
+                "Select key to update:",
+                choices=list(config),
+                style=style,
             )
-            raise typer.Exit()
-        key = questionary.select(
-            "Select key to update:", choices=choices, style=style
-        ).ask()
-
-        if not key:
-            raise typer.Exit()
+        )
 
     if value is None:
-        # Check if existing value is boolean to offer select
-        current_val = config.get(key)
-
+        current = config.get(key)
         if key == "provider":
-            value = questionary.select(
-                "Select AI Provider:",
-                choices=[
-                    "gemini",
-                    "openai",
-                    "huggingface",
-                    "openrouter",
-                    "anthropic",
-                    "ollama",
-                ],
-                default=str(current_val) if current_val else "gemini",
-                style=style,
-            ).ask()
-            if value is None:
-                raise typer.Exit(code=130)
-        elif isinstance(current_val, bool):
-            val_choice = questionary.select(
-                f"Select value for '{key}':",
-                choices=["True", "False"],
-                default=str(current_val),
-                style=style,
-            ).ask()
-            if val_choice is None:
-                raise typer.Exit(code=130)
-            value = val_choice
-        else:
-            value = questionary.text(
-                f"Enter value for '{key}':",
-                default=str(current_val) if current_val is not None else "",
-                style=style,
-            ).ask()
-
-        if value is None:
-            raise typer.Exit(code=130)
-
-    # Basic type inference
-    if isinstance(value, str):
-        if value.lower() == "true":
-            val = True
-        elif value.lower() == "false":
-            val = False
-        elif value.isdigit():
-            val = int(value)
+            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:
-            val = value
-    else:
-        val = value
+            value = ask(
+                questionary.text(
+                    f"Enter value for '{key}':",
+                    default=str(current) if current is not None else "",
+                    style=style,
+                )
+            )
 
-    config[key] = val
-    _save_config(config)
-    typer.secho(f" Set '{key}' to '{val}'", fg=typer.colors.GREEN)
+    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."""
-    typer.secho("🛠️  Interactive Configuration Setup", fg=typer.colors.CYAN, bold=True)
-
-    config = load_config()
-    style = get_questionary_style()
-
-    # Questions
-    provider = questionary.select(
-        "Select AI Provider:",
-        choices=[
-            "gemini",
-            "openai",
-            "huggingface",
-            "openrouter",
-            "anthropic",
-            "ollama",
-        ],
-        default=config.get("provider", "gemini"),
-        style=style,
-    ).ask()
-    if provider is None:
-        raise typer.Exit(code=130)
-
-    model_default = config.get("model", "gemini-2.5-flash")
-
-    model = questionary.text(
-        "Enter Model Name:", default=model_default, style=style
-    ).ask()
-    if model is None:
-        raise typer.Exit(code=130)
-
-    api_key = questionary.password(
-        "Enter API Key (leave empty to keep existing or none):", style=style
-    ).ask()
-    if api_key is None:
-        raise typer.Exit(code=130)
-
-    if not api_key:
-        api_key = config.get("api_key", "")
-
-    emoji_choice = questionary.select(
-        "Use Emojis in Commit Messages?",
-        choices=["Yes", "No"],
-        default="Yes" if config.get("emoji", True) else "No",
-        style=style,
-    ).ask()
-    if emoji_choice is 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?
-    # The setup wizard usually overwrites or defines the core keys.
-    # Let's preserve other keys.
-    config.update(new_config)
-
-    _save_config(config)
-    typer.secho("\nConfiguration saved.", fg=typer.colors.GREEN)
-    typer.echo(yaml.dump(new_config, default_flow_style=False))
+    run_config_wizard()
 
 
 @app.command("info")
@@ -218,7 +116,8 @@ def config_info() -> None:
 
     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.",
+        "\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]")

devgen/cli/gitignore.py

@@ -1,10 +1,11 @@
-from typing import List, Optional
+from typing import Annotated
 
 import questionary
 import typer
-from typing_extensions import Annotated
 
+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",
@@ -14,10 +15,52 @@ app = typer.Typer(
 )
 
 
+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.")
+        bool,
+        typer.Option("--cached", "-c", help="List only cached templates."),
     ] = False,
 ) -> None:
     """List available gitignore templates."""
@@ -30,25 +73,20 @@ def list_templates(
             typer.secho("Fetching available templates...", fg=typer.colors.YELLOW)
             templates = generator.list_available_templates()
             typer.secho(" Available Templates:", fg=typer.colors.CYAN, bold=True)
-
-        if not templates:
-            typer.echo("No templates found.")
-            return
-
-        # Print in columns or just list
-        typer.echo(", ".join(templates))
-
-    except Exception as e:
-        typer.secho(f" Error: {e}", fg=typer.colors.RED)
+    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[
-        Optional[List[str]],
+        list[str] | None,
         typer.Argument(
-            help="Names of templates to include (e.g. Python Node). If empty, interactive mode is used."
+            help="Names of templates to include (e.g. Python Node). "
+            "If empty, interactive mode is used."
         ),
     ] = None,
     output: Annotated[
@@ -72,67 +110,28 @@ def generate_gitignore(
     generator = GitignoreGenerator()
 
     if not templates:
-        # Interactive mode
         try:
-            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)
-
-            from devgen.utils import get_questionary_style
-
-            style = get_questionary_style()
-
-            # Interactive search loop
-            selected_templates = []
-            while True:
-                # Filter out already selected
-                choices = [t for t in available if t not in selected_templates]
-                # Add "Done" option at the top
-                choices.insert(0, "Done (Finish selection)")
-
-                choice = questionary.autocomplete(
-                    "Search for a template (type to search, select 'Done' to finish):",
-                    choices=choices,
-                    ignore_case=True,
-                    match_middle=True,
-                    validate=lambda x: x in choices or x == "",
-                    style=style,
-                ).ask()
-
-                if choice is None:
-                    raise typer.Exit(code=130)
-
-                if not choice or choice.startswith("Done"):
-                    break
-
-                selected_templates.append(choice)
-                typer.secho(f"➕ Added '{choice}'", fg=typer.colors.GREEN)
-
-            templates = selected_templates
-
-            if not templates:
-                typer.secho("No templates selected.", fg=typer.colors.YELLOW)
-                raise typer.Exit()
-
+            templates = _select_templates(generator, offline)
         except typer.Exit:
             raise
         except KeyboardInterrupt:
             typer.secho("\nCancelled by user", fg=typer.colors.YELLOW)
             raise typer.Exit()
-        except Exception as e:
-            typer.secho(f"❌ Error fetching templates: {e}", fg=typer.colors.RED)
+        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
+            templates,
+            output_file=output,
+            append=append,
+            offline=offline,
         )
-    except Exception as e:
-        typer.secho(f"❌ Error generating .gitignore: {e}", fg=typer.colors.RED)
+    except (OSError, RuntimeError, ValueError) as error:
+        typer.secho(f"❌ Error generating .gitignore: {error}", fg=typer.colors.RED)
         raise typer.Exit(code=1)