devgen-cli 0.2.0__py3-none-any.whl

devgen/modules/license_generator.py

@@ -0,0 +1,80 @@
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+class LicenseGenerator:
+    """Generates license files from templates."""
+
+    def __init__(self):
+        self.templates_dir = (
+            Path(__file__).parent.parent / "prompt_templates" / "licenses"
+        )
+
+    def list_licenses(self) -> List[Dict[str, str]]:
+        """Lists available license templates."""
+        licenses = []
+        if not self.templates_dir.exists():
+            return []
+
+        for file_path in self.templates_dir.glob("*.json"):
+            try:
+                with file_path.open("r", encoding="utf-8") as f:
+                    data = json.load(f)
+                    licenses.append(
+                        {
+                            "key": data.get("key", file_path.stem),
+                            "name": data.get("name", "Unknown License"),
+                            "description": data.get("description", ""),
+                        }
+                    )
+            except Exception:
+                continue
+
+        # Sort by name
+        return sorted(licenses, key=lambda x: x["name"])
+
+    def get_license_template(self, key: str) -> Optional[Dict]:
+        """Loads a specific license template by key."""
+        # We assume key matches filename for simplicity, or we search.
+        # Based on file listing, filenames match keys (e.g. mit.json -> mit)
+        file_path = self.templates_dir / f"{key}.json"
+        if not file_path.exists():
+            return None
+
+        try:
+            with file_path.open("r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return None
+
+    def render_license(self, key: str, author: str, year: str = "") -> str:
+        """Renders the license content with placeholders replaced."""
+        template_data = self.get_license_template(key)
+        if not template_data:
+            raise ValueError(f"License template '{key}' not found.")
+
+        content = template_data.get("template", "")
+
+        if not year:
+            year = str(datetime.now().year)
+
+        # Replace placeholders
+        # Support various formats found in templates
+        year_placeholders = ["[year]", "[yyyy]", "{{year}}", "<year>"]
+        author_placeholders = [
+            "[fullname]",
+            "[name of copyright owner]",
+            "{{author}}",
+            "<name of author>",
+            "[author]",
+        ]
+
+        for p in year_placeholders:
+            content = content.replace(p, year)
+
+        for p in author_placeholders:
+            content = content.replace(p, author)
+
+        return content

devgen/modules/release_note_generator.py

@@ -0,0 +1,66 @@
+from datetime import datetime
+from pathlib import Path
+
+from devgen.modules.changelog_generator import ChangelogGenerator
+from devgen.utils import configure_logger
+
+
+class ReleaseNotesGenerator(ChangelogGenerator):
+    """Generate short, clean release notes from git history."""
+
+    SECTION_EMOJIS = {
+        "BREAKING CHANGES": "⚠️",
+        "Features": "✨",
+        "Bug Fixes": "🐛",
+        "Documentation": "📚",
+        "Refactor": "♻️",
+        "Tests": "✅",
+        "Chore": "🔧",
+        "Style": "✨",
+        "Other Changes": "🧹",
+    }
+
+    def __init__(self, logger=None):
+        super().__init__(logger or configure_logger("devgen.releasenotes"))
+
+    def generate_release_markdown(self, groups, version="Unreleased"):
+        """Generate human-friendly release notes."""
+        date_str = datetime.now().strftime("%Y-%m-%d")
+        md = [f"## 🚀 Release {version} — {date_str}\n"]
+
+        order = [
+            "BREAKING CHANGES",
+            "Features",
+            "Bug Fixes",
+            "Documentation",
+            "Other Changes",
+        ]
+
+        for section in order:
+            commits = groups.get(section)
+            if not commits:
+                continue
+
+            emoji = self.SECTION_EMOJIS.get(section, "")
+            md.append(f"### {emoji} {section}")
+
+            for c in commits:
+                scope = f"**{c['scope']}**: " if c["scope"] else ""
+                md.append(f"- {scope}{c['subject']}")
+
+            md.append("")
+
+        return "\n".join(md)
+
+    def run(self, output_file="RELEASE-NOTES.md", version="Unreleased", from_ref=""):
+        """Main logic: get commits → parse → generate → write."""
+        raw_commits = self.get_commits(from_ref)
+        if not raw_commits or not raw_commits[0]:
+            print("❗ No commits found for release notes.")
+            return
+
+        parsed = self.parse_commits(raw_commits)
+        md = self.generate_release_markdown(parsed, version=version)
+
+        Path(output_file).write_text(md, encoding="utf-8")
+        print(f" Release notes written to {output_file}")

devgen/providers/__init__.py

@@ -0,0 +1,21 @@
+from devgen.providers.anthropic import AnthropicProvider
+from devgen.providers.gemini import GeminiProvider
+from devgen.providers.huggingface import HuggingfaceProvider
+from devgen.providers.openai import OpenaiProvider
+from devgen.providers.openrouter import OpenrouterProvider
+
+
+def get_provider(name):
+    name_lower = name.lower()
+    if name_lower == "gemini":
+        return GeminiProvider()
+    elif name_lower == "openai":
+        return OpenaiProvider()
+    elif name_lower == "huggingface":
+        return HuggingfaceProvider()
+    elif name_lower == "openrouter":
+        return OpenrouterProvider()
+    elif name_lower == "anthropic":
+        return AnthropicProvider()
+
+    raise NotImplementedError(f"Provider '{name}' is not implemented yet.")

devgen/providers/anthropic.py

@@ -0,0 +1,23 @@
+import anthropic
+
+
+class AnthropicProvider:
+    """Generates content using Anthropic's Claude models."""
+
+    def generate(
+        self, prompt: str, api_key: str, model: str = "claude-3-opus-20240229", **kwargs
+    ) -> str:
+        """Generates a response using the Anthropic API."""
+        if not api_key:
+            raise ValueError("Anthropic API key is required.")
+
+        try:
+            client = anthropic.Anthropic(api_key=api_key)
+            message = client.messages.create(
+                model=model,
+                max_tokens=1024,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            return message.content[0].text.strip()
+        except Exception as e:
+            raise RuntimeError(f"Anthropic generation failed: {e}")

devgen/providers/gemini.py

@@ -0,0 +1,24 @@
+import google.generativeai as genai
+
+
+class GeminiProvider:
+    """Generates content using Google's Gemini models."""
+
+    def generate(
+        self, prompt: str, api_key: str, model: str = "gemini-pro", **kwargs
+    ) -> str:
+        """Generates a response using the Gemini API."""
+        if not api_key:
+            raise ValueError("Gemini API key is required.")
+
+        genai.configure(api_key=api_key)
+
+        # Handle model name mapping if needed, or trust user input
+        # gemini-pro is a common default
+
+        try:
+            model_instance = genai.GenerativeModel(model)
+            response = model_instance.generate_content(prompt)
+            return response.text.strip()
+        except Exception as e:
+            raise RuntimeError(f"Gemini generation failed: {e}")

devgen/providers/huggingface.py

@@ -0,0 +1,45 @@
+import requests
+
+
+class HuggingfaceProvider:
+    """Generates content using Hugging Face Inference API."""
+
+    API_URL_TEMPLATE = "https://api-inference.huggingface.co/models/{model}"
+
+    def generate(
+        self,
+        prompt: str,
+        api_key: str,
+        model: str = "mistralai/Mistral-7B-Instruct-v0.2",
+        **kwargs,
+    ) -> str:
+        """Generates a response using Hugging Face API."""
+        if not api_key:
+            raise ValueError("Hugging Face API token is required.")
+
+        api_url = self.API_URL_TEMPLATE.format(model=model)
+        headers = {"Authorization": f"Bearer {api_key}"}
+
+        # HF models often expect specific prompting formats, but we'll send raw prompt
+        # Some models are text-generation, some are conversational.
+        # Assuming text-generation for generic usage.
+
+        payload = {
+            "inputs": prompt,
+            "parameters": {"max_new_tokens": 500, "return_full_text": False},
+        }
+
+        try:
+            response = requests.post(api_url, headers=headers, json=payload)
+            response.raise_for_status()
+            result = response.json()
+
+            if isinstance(result, list) and "generated_text" in result[0]:
+                return result[0]["generated_text"].strip()
+            elif isinstance(result, dict) and "error" in result:
+                raise RuntimeError(f"Hugging Face API error: {result['error']}")
+            else:
+                return str(result)
+
+        except Exception as e:
+            raise RuntimeError(f"Hugging Face generation failed: {e}")

devgen/providers/openai.py

@@ -0,0 +1,48 @@
+from openai import OpenAI
+
+
+class OpenaiProvider:
+    """Generates a response string using the OpenAI ChatCompletion API based on the provided prompt and parameters. This method initializes an OpenAI client with the given API key, sends a chat completion request with specified model and additional parameters, and returns the content of the generated message.
+
+    Args:
+        prompt (str): The input prompt to generate a response for.
+        api_key (str): The API key used to authenticate with the OpenAI service.
+        model (str, optional): The model to use for generation; defaults to "gpt-4o".
+        **kwargs: Additional keyword arguments to customize the API request (e.g., temperature).
+
+    Returns:
+        str: The content of the generated response message.
+    """
+
+    DEFAULT_MODEL = "gpt-4o"
+
+    def generate(
+        self, prompt: str, api_key: str, model: str | None = None, **kwargs
+    ) -> str:
+        """Generates a response from the OpenAI ChatCompletion API based on the provided prompt and parameters.
+
+        Creates a client instance with the specified API key, sends a chat completion request using the selected model and additional parameters, and returns the generated message content as a string.
+
+        Args:
+            prompt (str): Prompt input.
+            api_key (str): OpenAI API key.
+            model (str, optional): Model to use (default: gpt-4o).
+            **kwargs: Additional OpenAI ChatCompletion parameters (e.g., temperature).
+
+        Returns:
+            str: Generated response content.
+        """
+        # 1. Create a client instance with the API key.
+        try:
+            client = OpenAI(api_key=api_key)
+        except Exception as e:
+            # Add error handling if the client fails to initialize
+            raise RuntimeError(f"Failed to initialize OpenAI client: {e}")
+
+        # 2. Use the modern API syntax: client.chat.completions.create
+        response = client.chat.completions.create(
+            model=model or self.DEFAULT_MODEL,
+            messages=[{"role": "user", "content": prompt}],
+            **kwargs,
+        )
+        return response.choices[0].message.content.strip()

devgen/providers/openrouter.py

@@ -0,0 +1,33 @@
+from openai import OpenAI
+
+
+class OpenrouterProvider:
+    """Generates content using OpenRouter (OpenAI-compatible API)."""
+
+    BASE_URL = "https://openrouter.ai/api/v1"
+
+    def generate(
+        self, prompt: str, api_key: str, model: str = "openai/gpt-3.5-turbo", **kwargs
+    ) -> str:
+        """Generates a response using OpenRouter."""
+        if not api_key:
+            raise ValueError("OpenRouter API key is required.")
+
+        try:
+            client = OpenAI(
+                base_url=self.BASE_URL,
+                api_key=api_key,
+            )
+
+            response = client.chat.completions.create(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+                extra_headers={
+                    "HTTP-Referer": "https://github.com/S4NKALP/devgen",  # Optional
+                    "X-Title": "devgen CLI",  # Optional
+                },
+                **kwargs,
+            )
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            raise RuntimeError(f"OpenRouter generation failed: {e}")

devgen/utils.py

@@ -0,0 +1,198 @@
+import logging
+import re
+import subprocess
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+from jinja2 import Environment, FileSystemLoader
+
+
+def ensure_log_directory() -> Path:
+    log_dir = Path.home() / ".cache" / "devgen"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    return log_dir
+
+
+def get_main_log_path() -> Path:
+    return ensure_log_directory() / "devgen.log"
+
+
+def get_commit_dry_run_path() -> Path:
+    return ensure_log_directory() / "commit_dry_run.md"
+
+
+def is_file_recent(file_path: Path | str, max_age_minutes: int = 120) -> bool:
+    path = Path(file_path)
+    if not path.exists():
+        return False
+    return (time.time() - path.stat().st_mtime) <= max_age_minutes * 60
+
+
+def sanitize_ai_commit_message(raw_text: str) -> str:
+    lines = raw_text.strip().split("\n")
+    cleaned_lines = []
+    in_block = False
+    # Regex for conventional commit header
+    header_pattern = re.compile(
+        r"^(feat|fix|chore|refactor|docs|style|test|build|ci)(\(.*\))?!?: .*"
+    )
+
+    for line in lines:
+        stripped = line.strip()
+        if in_block:
+            if header_pattern.match(stripped) or "**Sponsor**" in line:
+                break
+            cleaned_lines.append(line)
+        elif header_pattern.match(stripped):
+            in_block = True
+            cleaned_lines.append(line)
+
+    return "\n".join(cleaned_lines).strip() if cleaned_lines else ""
+
+
+def parse_markdown_sections(
+    filepath: Path | str, marker_pattern: str
+) -> dict[str, str]:
+    path = Path(filepath)
+    if not path.exists():
+        return {}
+
+    with path.open(encoding="utf-8") as f:
+        content = f.read()
+
+    results = {}
+    matches = re.findall(marker_pattern, content, re.DOTALL)
+    for key, value in matches:
+        results[key] = value.strip()
+    return results
+
+
+def extract_commit_messages(filepath: Path | str) -> dict[str, str]:
+    pattern = r"## Group: `(.*?)`\s*```md\n(.*?)\n```"
+    return parse_markdown_sections(filepath, pattern)
+
+
+def configure_logger(
+    name: str = "devgen", log_file: Optional[Path | str] = None
+) -> logging.Logger:
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+
+    if logger.hasHandlers():
+        logger.handlers.clear()
+
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+
+    # Console handler
+    ch = logging.StreamHandler()
+    ch.setFormatter(formatter)
+    logger.addHandler(ch)
+
+    # File handler
+    if log_file:
+        path = Path(log_file)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        fh = logging.FileHandler(path, mode="w", encoding="utf-8")
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+
+    return logger
+
+
+def get_git_staged_files() -> list[str]:
+    try:
+        res = subprocess.run(
+            ["git", "diff", "--name-only", "--cached"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return [f for f in res.stdout.splitlines() if f.strip()]
+    except subprocess.CalledProcessError:
+        return []
+
+
+def read_file_content(filepath: Path | str) -> Optional[str]:
+    path = Path(filepath)
+    if path.exists():
+        return path.read_text(encoding="utf-8")
+    return None
+
+
+def delete_file(filepath: Path | str) -> bool:
+    path = Path(filepath)
+    if path.exists():
+        path.unlink()
+        return True
+    return False
+
+
+def load_template_env(sub_dir: str) -> Environment:
+    template_dir = Path(__file__).parent / "prompt_templates" / sub_dir
+    return Environment(loader=FileSystemLoader(template_dir))
+
+
+def load_config() -> Dict[str, Any]:
+    config_path = Path.home() / ".devgen.yaml"
+
+    if not config_path.exists():
+        default_config = {
+            "provider": "gemini",
+            "model": "gemini-2.5-flash",
+            "api_key": "",
+            "emoji": True,
+        }
+        try:
+            with config_path.open("w", encoding="utf-8") as f:
+                yaml.dump(default_config, f, default_flow_style=False)
+            # We don't print here to avoid noise during normal execution
+        except Exception as e:
+            print(f"Warning: Failed to create default config at {config_path}: {e}")
+            return {}
+
+    try:
+        with config_path.open("r", encoding="utf-8") as f:
+            return yaml.safe_load(f) or {}
+    except Exception as e:
+        print(f"Warning: Failed to load config from {config_path}: {e}")
+        return {}
+
+
+__all__ = [
+    "ensure_log_directory",
+    "get_main_log_path",
+    "get_commit_dry_run_path",
+    "is_file_recent",
+    "sanitize_ai_commit_message",
+    "extract_commit_messages",
+    "configure_logger",
+    "get_git_staged_files",
+    "read_file_content",
+    "delete_file",
+    "load_template_env",
+    "load_config",
+    "get_questionary_style",
+]
+
+
+def get_questionary_style():
+    from questionary import Style
+
+    return Style(
+        [
+            ("qmark", "fg:#673ab7 bold"),  # Token.QuestionMark
+            ("question", "bold"),  # Token.Question
+            ("answer", "fg:#f44336 bold"),  # Token.Answer
+            ("pointer", "fg:#673ab7 bold"),  # Token.Pointer
+            ("highlighted", "fg:#673ab7 bold"),  # Token.Selected
+            ("selected", "fg:#cc5454"),  # Token.SelectedItem
+            ("separator", "fg:#cc5454"),  # Token.Separator
+            ("instruction", ""),  # Token.Instruction
+            ("text", ""),  # Token.Text
+            ("disabled", "fg:#858585 italic"),  # Token.Disabled
+        ]
+    )