diffron 0.1.0__py3-none-any.whl

diffron/lemonade.py

@@ -0,0 +1,192 @@
+"""
+Lemonade integration for Diffron.
+
+Provides automatic port detection and API client for Lemonade LLM server.
+"""
+
+import os
+from typing import Optional, List
+from openai import OpenAI
+
+from .utils import scan_ports, is_port_open
+
+
+DEFAULT_HOST = "localhost"
+DEFAULT_PORT = 8020  # Default Lemonade port
+DEFAULT_PORTS = [8020, 8000, 8001, 8080, 8081, 5000, 5001]
+LEMONADE_API_KEY = "lemonade"  # Default API key for Lemonade
+DEFAULT_MODEL = "qwen2.5-it-3b-FLM"  # Default Lemonade model
+
+
+def detect_lemonade_port(
+    host: Optional[str] = None,
+    ports: Optional[List[int]] = None
+) -> Optional[int]:
+    """
+    Auto-detect the port where Lemonade is running.
+
+    Checks LEMONADE_SERVER_URL environment variable first, then scans common ports.
+
+    Args:
+        host: Host to check. Defaults to DIFFRON_LEMONADE_HOST or localhost.
+        ports: List of ports to scan. Defaults to common Lemonade ports.
+
+    Returns:
+        Port number if found, None otherwise.
+    """
+    # Check LEMONADE_SERVER_URL environment variable first (standard Lemonade env)
+    server_url = os.environ.get("LEMONADE_SERVER_URL")
+    if server_url:
+        try:
+            # Parse URL like "http://localhost:8020"
+            from urllib.parse import urlparse
+            parsed = urlparse(server_url)
+            if parsed.port:
+                port = parsed.port
+                if is_port_open(parsed.hostname or DEFAULT_HOST, port):
+                    return port
+        except Exception:
+            pass
+
+    # Check DIFFRON_LEMONADE_PORT (Diffron-specific)
+    env_port = os.environ.get("DIFFRON_LEMONADE_PORT")
+    if env_port:
+        try:
+            port = int(env_port)
+            if is_port_open(host or DEFAULT_HOST, port):
+                return port
+        except ValueError:
+            pass
+
+    # Scan common ports
+    host = host or os.environ.get("DIFFRON_LEMONADE_HOST", DEFAULT_HOST)
+    ports_to_scan = ports or DEFAULT_PORTS
+
+    open_ports = scan_ports(ports_to_scan, host)
+
+    if open_ports:
+        return open_ports[0]  # Return first open port
+
+    return None
+
+
+def get_lemonade_url() -> str:
+    """
+    Get the Lemonade server URL from environment or default.
+
+    Returns:
+        Lemonade server URL.
+    """
+    # Check LEMONADE_SERVER_URL first (standard)
+    server_url = os.environ.get("LEMONADE_SERVER_URL")
+    if server_url:
+        return server_url.strip().rstrip("/")
+
+    # Build URL from host/port
+    host = os.environ.get("DIFFRON_LEMONADE_HOST", DEFAULT_HOST)
+    port = detect_lemonade_port(host)
+
+    if port:
+        return f"http://{host}:{port}"
+
+    # Fallback to default
+    return f"http://{DEFAULT_HOST}:{DEFAULT_PORT}"
+
+
+def is_lemonade_running(
+    host: Optional[str] = None,
+    port: Optional[int] = None
+) -> bool:
+    """
+    Check if Lemonade is running.
+
+    Args:
+        host: Host to check. Defaults to DIFFRON_LEMONADE_HOST or localhost.
+        port: Port to check. Auto-detects if not provided.
+
+    Returns:
+        True if Lemonade is running, False otherwise.
+    """
+    if port is None:
+        port = detect_lemonade_port(host)
+        if port is None:
+            return False
+
+    host = host or os.environ.get("DIFFRON_LEMONADE_HOST", DEFAULT_HOST)
+    return is_port_open(host, port)
+
+
+class LemonadeClient:
+    """
+    Client for interacting with Lemonade LLM server.
+
+    Automatically detects the running Lemonade instance and provides
+    a convenient interface for chat completions.
+    """
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        model: Optional[str] = None,
+    ):
+        """
+        Initialize the Lemonade client.
+
+        Args:
+            base_url: Lemonade server URL. Auto-detects from LEMONADE_SERVER_URL or defaults to http://localhost:8020.
+            api_key: API key. Defaults to "lemonade".
+            model: Model name to use. Defaults to qwen2.5-it-3b-FLM.
+        """
+        # Get base URL from parameter, environment, or default
+        if base_url:
+            self.base_url = base_url.rstrip("/")
+        else:
+            self.base_url = get_lemonade_url()
+
+        # Parse host and port from base_url
+        from urllib.parse import urlparse
+        parsed = urlparse(self.base_url)
+        self.host = parsed.hostname or DEFAULT_HOST
+        self.port = parsed.port or DEFAULT_PORT
+
+        self.api_key = api_key or LEMONADE_API_KEY
+
+        # Model: parameter > environment > default
+        self.model = model or os.environ.get("DIFFRON_MODEL") or DEFAULT_MODEL
+
+        self.client = OpenAI(
+            base_url=f"{self.base_url}/api/v1",
+            api_key=self.api_key,
+        )
+
+    def chat_completion(
+        self,
+        messages: List[dict],
+        max_tokens: int = 100,
+        temperature: float = 0.2,
+        **kwargs
+    ) -> str:
+        """
+        Generate a chat completion.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'.
+            max_tokens: Maximum tokens to generate.
+            temperature: Sampling temperature.
+            **kwargs: Additional arguments to pass to the API.
+
+        Returns:
+            Generated response content.
+        """
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            **kwargs,
+        )
+        return response.choices[0].message.content
+
+    def __repr__(self) -> str:
+        return f"LemonadeClient(base_url='{self.base_url}', model='{self.model}')"

diffron/lemonade.pyi

@@ -0,0 +1,66 @@
+"""
+Lemonade integration for Diffron.
+
+Provides automatic port detection and API client for Lemonade LLM server.
+"""
+
+from typing import Optional, List
+
+
+DEFAULT_HOST: str
+DEFAULT_PORTS: List[int]
+LEMONADE_API_KEY: str
+
+
+def detect_lemonade_port(
+    host: Optional[str] = None,
+    ports: Optional[List[int]] = None
+) -> Optional[int]:
+    """Auto-detect the port where Lemonade is running."""
+    ...
+
+
+def is_lemonade_running(
+    host: Optional[str] = None,
+    port: Optional[int] = None
+) -> bool:
+    """Check if Lemonade is running."""
+    ...
+
+
+class LemonadeClient:
+    """Client for interacting with Lemonade LLM server."""
+
+    host: str
+    port: int
+    api_key: str
+    model: str
+    base_url: str
+    client: OpenAI
+
+    def __init__(
+        self,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        api_key: Optional[str] = None,
+        model: Optional[str] = None,
+    ):
+        """Initialize the Lemonade client."""
+        ...
+
+    def _detect_model(self) -> str:
+        """Auto-detect available models from Lemonade."""
+        ...
+
+    def chat_completion(
+        self,
+        messages: List[dict],
+        max_tokens: int = 100,
+        temperature: float = 0.2,
+        **kwargs
+    ) -> str:
+        """Generate a chat completion."""
+        ...
+
+    def __repr__(self) -> str:
+        ...

diffron/pr_gen.py

@@ -0,0 +1,224 @@
+"""
+PR description generation for Diffron.
+
+Generates PR titles and descriptions from branch diffs.
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+from .lemonade import LemonadeClient
+from .utils import get_branch_diff, get_commit_log, get_current_branch, find_default_branch
+
+
+DEFAULT_MAX_CHARS = 5000
+DEFAULT_MAX_TOKENS = 300
+DEFAULT_TEMPERATURE = 0.3
+
+
+@dataclass
+class PRDescription:
+    """Represents a generated PR title and description."""
+
+    title: str
+    description: str
+
+    def format_output(self) -> str:
+        """
+        Format as TITLE + DESCRIPTION output.
+
+        Returns:
+            Formatted string with TITLE and DESCRIPTION sections.
+        """
+        return f"TITLE: {self.title}\n\nDESCRIPTION:\n{self.description}"
+
+    def to_github_cli(self) -> Tuple[str, str]:
+        """
+        Get title and body for GitHub CLI.
+
+        Returns:
+            Tuple of (title, body).
+        """
+        return self.title, self.description
+
+
+def generate_pr_description(
+    branch: Optional[str] = None,
+    base: Optional[str] = None,
+    max_chars: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    temperature: Optional[float] = None,
+    client: Optional[LemonadeClient] = None,
+) -> PRDescription:
+    """
+    Generate a PR title and description from branch changes.
+
+    Args:
+        branch: Branch name to analyze. Defaults to current branch.
+        base: Base branch to compare against. Defaults to main/master.
+        max_chars: Maximum characters of diff to send. Defaults to 5000.
+        max_tokens: Maximum tokens to generate. Defaults to 300.
+        temperature: Sampling temperature. Defaults to 0.3.
+        client: LemonadeClient instance. Creates new one if not provided.
+
+    Returns:
+        PRDescription with generated title and description.
+
+    Raises:
+        ValueError: If no differences found between branches.
+        ConnectionError: If Lemonade is not running.
+    """
+    max_chars = max_chars or int(os.environ.get("DIFFRON_MAX_DIFF_CHARS", DEFAULT_MAX_CHARS))
+    max_tokens = max_tokens or DEFAULT_MAX_TOKENS
+    temperature = temperature if temperature is not None else DEFAULT_TEMPERATURE
+
+    # Get branch name if not provided
+    if branch is None:
+        branch = get_current_branch()
+        if branch is None:
+            raise ValueError("Not in a git repository or no current branch.")
+
+    # Get base branch if not provided
+    if base is None:
+        base = find_default_branch()
+
+    # Get commit log and diff
+    commit_log = get_commit_log(branch, base)
+    diff = get_branch_diff(branch, base, max_chars=max_chars)
+
+    if not diff.strip() and not commit_log.strip():
+        raise ValueError(f"No differences found between {base} and {branch}.")
+
+    # Create client if not provided
+    if client is None:
+        client = LemonadeClient()
+
+    # Build prompt
+    prompt = (
+        "Generate a GitHub PR title and description based on these changes.\n"
+        "Format strictly as:\n"
+        "TITLE: <concise, descriptive title>\n"
+        "DESCRIPTION: <detailed description with bullet points>\n\n"
+        "Requirements:\n"
+        "- TITLE should be under 80 characters\n"
+        "- DESCRIPTION should summarize the main changes\n"
+        "- Use bullet points for key changes\n"
+        "- Mention any breaking changes if applicable\n\n"
+    )
+
+    if commit_log:
+        prompt += f"Commits:\n{commit_log}\n\n"
+
+    if diff:
+        prompt += f"Diff:\n{diff}"
+
+    messages = [{"role": "user", "content": prompt}]
+
+    # Generate completion
+    response = client.chat_completion(
+        messages=messages,
+        max_tokens=max_tokens,
+        temperature=temperature,
+    )
+
+    # Parse response
+    title, description = _parse_pr_response(response)
+
+    return PRDescription(title=title, description=description)
+
+
+def _parse_pr_response(response: str) -> Tuple[str, str]:
+    """
+    Parse PR response into title and description.
+
+    Args:
+        response: Raw response from LLM.
+
+    Returns:
+        Tuple of (title, description).
+    """
+    lines = response.strip().split("\n")
+
+    title = ""
+    description_lines = []
+    in_description = False
+
+    for line in lines:
+        if line.startswith("TITLE:"):
+            title = line.replace("TITLE:", "").strip()
+        elif line.startswith("DESCRIPTION:"):
+            in_description = True
+            desc_part = line.replace("DESCRIPTION:", "").strip()
+            if desc_part:
+                description_lines.append(desc_part)
+        elif in_description:
+            description_lines.append(line)
+
+    # Fallback: if no TITLE found, use first line
+    if not title and lines:
+        title = lines[0].strip()
+        description_lines = lines[1:]
+
+    # Fallback: if no DESCRIPTION found, use remaining lines
+    if not description_lines and len(lines) > 1:
+        description_lines = lines[1:]
+
+    description = "\n".join(description_lines).strip()
+
+    # Clean up markdown code blocks
+    if description.startswith("```"):
+        lines = description.split("\n")
+        description = "\n".join(
+            line for line in lines
+            if not line.startswith("```")
+        ).strip()
+
+    return title, description
+
+
+def create_github_pr(
+    branch: Optional[str] = None,
+    base: Optional[str] = None,
+    auto_submit: bool = False,
+) -> PRDescription:
+    """
+    Generate PR and optionally create it via GitHub CLI.
+
+    Args:
+        branch: Branch name. Defaults to current branch.
+        base: Base branch. Defaults to main/master.
+        auto_submit: If True, creates PR via gh CLI automatically.
+
+    Returns:
+        Generated PRDescription.
+
+    Raises:
+        RuntimeError: If gh CLI is not available when auto_submit=True.
+    """
+    import subprocess
+
+    # Generate PR description
+    pr = generate_pr_description(branch=branch, base=base)
+
+    if auto_submit:
+        # Check if gh CLI is available
+        try:
+            result = subprocess.run(
+                ["gh", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode != 0:
+                raise RuntimeError("GitHub CLI (gh) is not installed or not in PATH.")
+        except FileNotFoundError:
+            raise RuntimeError("GitHub CLI (gh) is not installed or not in PATH.")
+
+        # Create PR
+        subprocess.run(
+            ["gh", "pr", "create", "--title", pr.title, "--body", pr.description],
+            timeout=60,
+        )
+
+    return pr

diffron/pr_gen.pyi

@@ -0,0 +1,56 @@
+"""
+PR description generation for Diffron.
+
+Generates PR titles and descriptions from branch diffs.
+"""
+
+from dataclasses import dataclass
+from typing import Optional, Tuple
+from .lemonade import LemonadeClient
+
+
+DEFAULT_MAX_CHARS: int
+DEFAULT_MAX_TOKENS: int
+DEFAULT_TEMPERATURE: float
+
+
+@dataclass
+class PRDescription:
+    """Represents a generated PR title and description."""
+
+    title: str
+    description: str
+
+    def format_output(self) -> str:
+        """Format as TITLE + DESCRIPTION output."""
+        ...
+
+    def to_github_cli(self) -> Tuple[str, str]:
+        """Get title and body for GitHub CLI."""
+        ...
+
+
+def generate_pr_description(
+    branch: Optional[str] = None,
+    base: Optional[str] = None,
+    max_chars: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    temperature: Optional[float] = None,
+    client: Optional[LemonadeClient] = None,
+) -> PRDescription:
+    """Generate a PR title and description from branch changes."""
+    ...
+
+
+def _parse_pr_response(response: str) -> Tuple[str, str]:
+    """Parse PR response into title and description."""
+    ...
+
+
+def create_github_pr(
+    branch: Optional[str] = None,
+    base: Optional[str] = None,
+    auto_submit: bool = False,
+) -> PRDescription:
+    """Generate PR and optionally create it via GitHub CLI."""
+    ...