diffron 0.1.3__tar.gz → 0.1.4__tar.gz

{diffron-0.1.3 → diffron-0.1.4}/CHANGELOG.md

@@ -17,6 +17,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [0.1.4] - 2026-04-24
+
+### Fixed
+- **Lemonade Model Unresponsive Fix** — Added retry logic with automatic model unload/reload when Lemonade model becomes unresponsive
+- Added `_reload_model()` method that uses lemonade-python-sdk to detect and reconnect to the Lemonade server
+- Added `_init_client()` method to reinitialize the OpenAI client after model reload
+- Handles `'NoneType' object is not subscriptable` error by checking for None responses before accessing `response.choices[0]`
+- Retry mechanism attempts up to 3 times before raising a detailed RuntimeError
+- Added `from urllib.parse import urlparse` import at module level
+
+---
+
 ## [0.1.3] - 2026-04-08
 
 ### Added

{diffron-0.1.3/diffron.egg-info → diffron-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffron
-Version: 0.1.3
+Version: 0.1.4
 Summary: Git commit message and PR description generator using Lemonade
 Home-page: https://github.com/diffron/diffron
 Author: Diffron Contributors

diffron-0.1.4/diffron/__main__.py

@@ -0,0 +1,8 @@
+"""
+Main entry point for running diffron as a module: python -m diffron
+"""
+
+from diffron.cli import main
+
+if __name__ == "__main__":
+    main()

{diffron-0.1.3 → diffron-0.1.4}/diffron/cli.py

@@ -9,26 +9,26 @@ import sys
 from typing import Optional
 
 
-def install_hooks_cli():
+def install_hooks_cli(args: Optional[argparse.Namespace] = None):
     """CLI entry point for installing Git hooks."""
-    parser = argparse.ArgumentParser(
-        description="Install Diffron Git hooks to a repository."
-    )
-    parser.add_argument(
-        "--global",
-        dest="global_install",
-        action="store_true",
-        help="Install hooks globally for all repositories.",
-    )
-    parser.add_argument(
-        "--repo",
-        "-r",
-        type=str,
-        default=".",
-        help="Path to the git repository (default: current directory).",
-    )
-
-    args = parser.parse_args()
+    if args is None:
+        parser = argparse.ArgumentParser(
+            description="Install Diffron Git hooks to a repository."
+        )
+        parser.add_argument(
+            "--global",
+            dest="global_install",
+            action="store_true",
+            help="Install hooks globally for all repositories.",
+        )
+        parser.add_argument(
+            "--repo",
+            "-r",
+            type=str,
+            default=".",
+            help="Path to the git repository (default: current directory).",
+        )
+        args = parser.parse_args()
 
     from .git_hooks import install_hooks
 
@@ -54,26 +54,26 @@ def install_hooks_cli():
         sys.exit(1)
 
 
-def uninstall_hooks_cli():
+def uninstall_hooks_cli(args: Optional[argparse.Namespace] = None):
     """CLI entry point for uninstalling Git hooks."""
-    parser = argparse.ArgumentParser(
-        description="Remove Diffron Git hooks from a repository."
-    )
-    parser.add_argument(
-        "--global",
-        dest="global_install",
-        action="store_true",
-        help="Remove global hooks configuration.",
-    )
-    parser.add_argument(
-        "--repo",
-        "-r",
-        type=str,
-        default=".",
-        help="Path to the git repository (default: current directory).",
-    )
-
-    args = parser.parse_args()
+    if args is None:
+        parser = argparse.ArgumentParser(
+            description="Remove Diffron Git hooks from a repository."
+        )
+        parser.add_argument(
+            "--global",
+            dest="global_install",
+            action="store_true",
+            help="Remove global hooks configuration.",
+        )
+        parser.add_argument(
+            "--repo",
+            "-r",
+            type=str,
+            default=".",
+            help="Path to the git repository (default: current directory).",
+        )
+        args = parser.parse_args()
 
     from .git_hooks import uninstall_hooks
 
@@ -99,32 +99,32 @@ def uninstall_hooks_cli():
         sys.exit(1)
 
 
-def pr_description_cli():
+def pr_description_cli(args: Optional[argparse.Namespace] = None):
     """CLI entry point for generating PR descriptions."""
-    parser = argparse.ArgumentParser(
-        description="Generate GitHub PR title and description."
-    )
-    parser.add_argument(
-        "--branch",
-        "-b",
-        type=str,
-        default=None,
-        help="Branch to analyze (default: current branch).",
-    )
-    parser.add_argument(
-        "--base",
-        type=str,
-        default=None,
-        help="Base branch to compare against (default: main/master).",
-    )
-    parser.add_argument(
-        "--create",
-        "-c",
-        action="store_true",
-        help="Automatically create PR on GitHub (requires gh CLI).",
-    )
-
-    args = parser.parse_args()
+    if args is None:
+        parser = argparse.ArgumentParser(
+            description="Generate GitHub PR title and description."
+        )
+        parser.add_argument(
+            "--branch",
+            "-b",
+            type=str,
+            default=None,
+            help="Branch to analyze (default: current branch).",
+        )
+        parser.add_argument(
+            "--base",
+            type=str,
+            default=None,
+            help="Base branch to compare against (default: main/master).",
+        )
+        parser.add_argument(
+            "--create",
+            "-c",
+            action="store_true",
+            help="Automatically create PR on GitHub (requires gh CLI).",
+        )
+        args = parser.parse_args()
 
     from .pr_gen import generate_pr_description, create_github_pr
     from .lemonade import is_lemonade_running
@@ -169,26 +169,26 @@ def pr_description_cli():
         sys.exit(130)
 
 
-def status_cli():
+def status_cli(args: Optional[argparse.Namespace] = None):
     """CLI entry point for checking Lemonade and hooks status."""
-    parser = argparse.ArgumentParser(
-        description="Check Diffron status (Lemonade connection, hooks installation)."
-    )
-    parser.add_argument(
-        "--repo",
-        "-r",
-        type=str,
-        default=".",
-        help="Path to the git repository (default: current directory).",
-    )
-    parser.add_argument(
-        "--verbose",
-        "-v",
-        action="store_true",
-        help="Show detailed status information.",
-    )
-
-    args = parser.parse_args()
+    if args is None:
+        parser = argparse.ArgumentParser(
+            description="Check Diffron status (Lemonade connection, hooks installation)."
+        )
+        parser.add_argument(
+            "--repo",
+            "-r",
+            type=str,
+            default=".",
+            help="Path to the git repository (default: current directory).",
+        )
+        parser.add_argument(
+            "--verbose",
+            "-v",
+            action="store_true",
+            help="Show detailed status information.",
+        )
+        args = parser.parse_args()
 
     from .lemonade import detect_lemonade_port, is_lemonade_running
     from .git_hooks import get_hooks_status, is_hooks_installed
@@ -331,13 +331,13 @@ def main():
     args = parser.parse_args()
 
     if args.command == "install-hooks":
-        install_hooks_cli()
+        install_hooks_cli(args)
     elif args.command == "uninstall-hooks":
-        uninstall_hooks_cli()
+        uninstall_hooks_cli(args)
     elif args.command == "pr":
-        pr_description_cli()
+        pr_description_cli(args)
     elif args.command == "status":
-        status_cli()
+        status_cli(args)
     else:
         parser.print_help()
         sys.exit(0)

diffron-0.1.4/diffron/lemonade.py

@@ -0,0 +1,246 @@
+"""Lemonade integration for Diffron.
+
+Provides automatic port detection and API client for Lemonade LLM server.
+"""
+
+import os
+import typing
+from typing import Optional, List
+from urllib.parse import urlparse
+
+import openai
+from openai import OpenAI
+
+from .utils import is_port_open
+
+# Import lemonade-python-sdk for verification
+try:
+    from lemonade_sdk.port_scanner import verify_lemonade_server
+    from lemonade_sdk.port_scanner import find_available_lemonade_port
+    HAS_LEMONADE_SDK = True
+except ImportError:
+    HAS_LEMONADE_SDK = False
+
+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 port for running Lemonade server.
+
+    Uses lemonade-python-sdk's verify_lemonade_server to distinguish
+    Lemonade from other services (e.g., Axo Biomarker on port 8000).
+
+    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:
+        from urllib.parse import urlparse
+        parsed = urlparse(server_url)
+        port = parsed.port
+        hostname = parsed.hostname or DEFAULT_HOST
+        # Verify it's actually Lemonade
+        if HAS_LEMONADE_SDK and verify_lemonade_server(port, hostname):
+            return port
+        elif is_port_open(hostname, port):
+            return port
+
+    # Check DIFFRON_LEMONADE_PORT (Diffron-specific)
+    env_port = os.environ.get("DIFFRON_LEMONADE_PORT")
+    if env_port:
+        try:
+            port = int(env_port)
+            hostname = host or DEFAULT_HOST
+            if HAS_LEMONADE_SDK and verify_lemonade_server(port, hostname):
+                return port
+            elif is_port_open(hostname, port):
+                return port
+        except ValueError:
+            pass
+
+    # Use lemonade-python-sdk's find_available_lemonade_port
+    if HAS_LEMONADE_SDK:
+        hostname = host or os.environ.get("DIFFRON_LEMONADE_HOST", DEFAULT_HOST)
+        scan_ports = ports or DEFAULT_PORTS
+        found = find_available_lemonade_port(hostname, scan_ports)
+        if found:
+            return found
+
+    # Fallback: manual scan verification
+    hostname = host or os.environ.get("DIFFRON_LEMONADE_HOST", DEFAULT_HOST)
+    ports_to_scan = ports or DEFAULT_PORTS
+    for port in ports_to_scan:
+        if is_port_open(hostname, port):
+            if HAS_LEMONADE_SDK and verify_lemonade_server(port, hostname):
+                return port
+    # Without SDK, return first open port (legacy behavior)
+    return None
+
+
+def get_lemonade_url() -> str:
+    """Get 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.
+
+    Detects 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
+    ) -> None:
+        """Initialize Lemonade client.
+
+        Args:
+            base_url: Lemonade server URL. Auto-detects from
+                      LEMONADE_SERVER_URL, defaults to http://localhost:8020.
+            api_key: API key. Defaults to "lemonade".
+            model: Model name. Defaults to qwen2.5-it-3b-FLM.
+        """
+        # Get base URL from parameter or environment default
+        self.base_url = (base_url or get_lemonade_url()).rstrip("/")
+        # Parse host and port from base_url
+        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._port = self.port  # Track current port for reload
+        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 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.
+
+        Raises:
+            RuntimeError: If model fails after retry attempts.
+        """
+        max_retries = 3
+        for attempt in range(1, max_retries + 1):
+            try:
+                response = self.client.chat.completions.create(
+                    model=self.model,
+                    messages=messages,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    **kwargs
+                )
+                # Handle None response (model unresponsive)
+                if response is None or not response.choices:
+                    if attempt < max_retries:
+                        self._reload_model()
+                        continue
+                    raise RuntimeError("Lemonade model returned no response")
+                return response.choices[0].message.content
+            except Exception as e:
+                if attempt < max_retries:
+                    self._reload_model()
+                    continue
+                raise RuntimeError(
+                    f"Lemonade model failed after {max_retries} attempts: {e}"
+                )
+
+    def _reload_model(self) -> None:
+        """Unload and reload the Lemonade model when unresponsive.
+
+        Uses lemonade-python-sdk to detect and reconnect to the
+        Lemonade server, which triggers a model reload.
+        """
+        try:
+            if HAS_LEMONADE_SDK:
+                # Find available port (triggers unload/reload via SDK)
+                new_port = find_available_lemonade_port(
+                    hostname=self.host or DEFAULT_HOST,
+                    ports=DEFAULT_PORTS
+                )
+                if new_port and new_port != self._port:
+                    self._port = new_port
+                    # Reinitialize client with new port
+                    self._init_client()
+        except Exception:
+            # Silently continue on reload failure
+            pass
+
+    def _init_client(self) -> None:
+        """Reinitialize the OpenAI client with current configuration."""
+        self.client = OpenAI(
+            base_url=f"{self.base_url}/api/v1",
+            api_key=self.api_key
+        )
+
+    def __repr__(self) -> str:
+        return f"LemonadeClient(base_url='{self.base_url}', model='{self.model}')"

{diffron-0.1.3 → diffron-0.1.4}/diffron/models.py

@@ -42,7 +42,7 @@ AVAILABLE_MODELS: List[ModelConfig] = [
         is_default=True,
     ),
     ModelConfig(
-        name="qwen3.5-0.8b-gguf",
+        name="Qwen3.5-0.8B-GGUF",
         description="Qwen 3.5 — lightweight and fast, low resource usage",
         parameters="0.8B",
         best_for="Quick commits, low-resource PCs, fast iteration",
@@ -95,14 +95,19 @@ def get_model_config(model_name: str) -> Optional[ModelConfig]:
     Get configuration for a specific model by name.
 
     Args:
-        model_name: Model name (e.g., 'qwen3.5-0.8b-gguf').
+        model_name: Model name (e.g., 'Qwen3.5-0.8B-GGUF').
 
     Returns:
         ModelConfig if found, None otherwise.
     """
+    # Exact match first
     for model in AVAILABLE_MODELS:
         if model.name == model_name:
             return model
+    # Case-insensitive fallback
+    for model in AVAILABLE_MODELS:
+        if model.name.lower() == model_name.lower():
+            return model
     return None
 
 
@@ -151,7 +156,7 @@ def setup_model_cli():
         sys.exit(0)
 
     if args.model:
-        # Validate model name
+        # Validate model name (case-insensitive)
         config = get_model_config(args.model)
         if config is None:
             available = ", ".join(m.name for m in AVAILABLE_MODELS)
@@ -159,7 +164,7 @@ def setup_model_cli():
             print(f"Available models: {available}", file=sys.stderr)
             sys.exit(1)
 
-        # Set DIFFRON_MODEL environment variable permanently
+        # Use the canonical name from config (not user input)
         os.environ["DIFFRON_MODEL"] = config.name
 
         try:

{diffron-0.1.3 → diffron-0.1.4/diffron.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffron
-Version: 0.1.3
+Version: 0.1.4
 Summary: Git commit message and PR description generator using Lemonade
 Home-page: https://github.com/diffron/diffron
 Author: Diffron Contributors

{diffron-0.1.3 → diffron-0.1.4}/diffron.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ requirements.txt
 setup.py
 diffron/__init__.py
 diffron/__init__.pyi
+diffron/__main__.py
 diffron/cli.py
 diffron/cli.pyi
 diffron/client.py
@@ -35,6 +36,9 @@ diffron/hooks/prepare-commit-msg
 diffron/hooks/prepare-commit-msg-global.py
 diffron/hooks/prepare-commit-msg.py
 docs/HOOKS.md
+docs/LEMONADE_PORT_VERIFICATION_FIX.md
+docs/LEMONADE_UNRESPONSIVE_FIX.md
+docs/MODEL_NAME_CASE_FIX.md
 docs/SETUP.md
 docs/USAGE.md
 hooks/aipr.py

{diffron-0.1.3 → diffron-0.1.4}/diffron.egg-info/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
+diffron = diffron.cli:main
 diffron-install-hooks = diffron.cli:install_hooks_cli
 diffron-pr = diffron.cli:pr_description_cli
 diffron-setup-model = diffron.models:setup_model_cli

{diffron-0.1.3 → diffron-0.1.4}/diffron.egg-info/top_level.txt

@@ -1,3 +1,4 @@
+build
 diffron
 dist
 docs

diffron-0.1.4/docs/LEMONADE_PORT_VERIFICATION_FIX.md

@@ -0,0 +1,105 @@
+# Lemonade Port Verification Fix
+
+## Problem
+
+Diffron incorrectly connected to **port 8000** (running Axo Biomarker Analyzer) instead of **port 8020** (running Lemonade), causing:
+
+```
+Error code: 404 - {'detail': 'Not Found'}
+```
+
+### Root Cause
+
+The `detect_lemonade_port()` function in `diffron/lemonade.py` only checked if a **port was open** (`is_port_open`), not whether it was actually a **Lemonade server**.
+
+When port 8000 responded (Axo Biomarker web app), Diffron mistakenly identified it as Lemonade and sent API requests to the wrong service.
+
+| Port | Service | Response |
+|------|---------|----------|
+| 8000 | Axo Biomarker Analyzer | HTML web page |
+| 8020 | **Lemonade** (correct) | `{"data": [...]}` API |
+
+## Solution
+
+### Use lemonade-python-sdk's `verify_lemonade_server`
+
+The **lemonade-python-sdk** provides `verify_lemonade_server(port, host)` which:
+
+1. Queries the native Lemonade API endpoint `/api/v1/models`
+2. Validates the response format (`{"data": [...]}` or list)
+3. Distinguishes Lemonade from other services (Ollama, web apps, etc.)
+
+### Changes
+
+**1. Added `lemonade-sdk` dependency**
+
+Updated `requirements.txt`:
+```txt
+lemonade-sdk>=0.1.0
+```
+
+**2. Updated `detect_lemonade_port()`**
+
+`diffron/lemonade.py` now:
+
+- Imports `verify_lemonade_server` and `find_available_lemonade_port` from `lemonade_sdk.port_scanner`
+- **Verifies** each open port is actually Lemonade before returning it
+- Falls back to legacy `is_port_open` behavior if SDK is not installed
+
+```python
+# Import from lemonade-python-sdk for proper Lemonade verification
+try:
+    from lemonade_sdk.port_scanner import verify_lemonade_server, find_available_lemonade_port
+    HAS_LEMONADE_SDK = True
+except ImportError:
+    HAS_LEMONADE_SDK = False
+
+def detect_lemonade_port(...) -> Optional[int]:
+    # ... existing env var checks ...
+
+    # Try SDK's find_available_lemonade_port first
+    if HAS_LEMONADE_SDK:
+        found = find_available_lemonade_port(hostname, scan_ports)
+        if found:
+            return found
+
+    # Fallback: manual scan with SDK verification
+    for port in ports_to_scan:
+        if is_port_open(hostname, port):
+            if HAS_LEMONADE_SDK:
+                if verify_lemonade_server(port, hostname):  # ← Key fix!
+                    return port
+            else:
+                return port  # Legacy: no verification
+```
+
+**3. Added graceful fallback**
+
+If `lemonade-sdk` is not installed, Diffron falls back to the original `is_port_open` behavior (first open port wins), maintaining backward compatibility.
+
+## Testing
+
+```bash
+# Before fix: returned 8000 (Axo Biomarker)
+# After fix: returns 8020 (Lemonade)
+python -c "from diffron.lemonade import detect_lemonade_port; print(detect_lemonade_port())"
+# Output: 8020
+```
+
+## Impact
+
+- **Fixes 404 errors** when other services run on ports 8000/8080
+- **No breaking changes** - existing setups continue to work
+- **Better diagnostics** - clear separation between Lemonade and non-Lemonade services
+
+## Files Changed
+
+| File | Change |
+|------|--------|
+| `diffron/lemonade.py` | Use `verify_lemonade_server` for port detection |
+| `requirements.txt` | Add `lemonade-sdk>=0.1.0` dependency |
+
+## Version
+
+- **Fixed in**: 0.1.3
+- **Date**: 2026-04-13

diffron-0.1.4/docs/LEMONADE_UNRESPONSIVE_FIX.md

@@ -0,0 +1,100 @@
+# Lemonade Model Unresponsive Fix
+
+## Problem
+
+Das Lemonade-Modell wurde manchmal unresponsive, was zu einem Fehler in Diffron führte:
+
+```
+Diffron error: 'NoneType' object is not subscriptable
+```
+
+Dies trat auf, wenn die Antwort des Modells `None` war oder `response.choices` leer war, was beim Zugriff auf `response.choices[0].message.content` zu einem Fehler führte.
+
+## Lösung
+
+In [`diffron/lemonade.py`](../diffron/lemonade.py:170) wurde eine Retry-Logik mit automatischem Entladen und Neuladen des Modells implementiert.
+
+### Änderungen in `LemonadeClient.chat_completion()`
+
+```python
+max_retries = 3
+for attempt in range(1, max_retries + 1):
+    try:
+        response = self.client.chat.completions.create(...)
+        # Handle None response (model unresponsive)
+        if response is None or not response.choices:
+            if attempt < max_retries:
+                self._reload_model()
+                continue
+            raise RuntimeError("Lemonade model returned no response")
+        return response.choices[0].message.content
+    except Exception as e:
+        if attempt < max_retries:
+            self._reload_model()
+            continue
+        raise RuntimeError(
+            f"Lemonade model failed after {max_retries} attempts: {e}"
+        )
+```
+
+### Neue Methoden
+
+#### `_reload_model()`
+
+Entlädt und lädt das Lemonade-Modell neu, wenn es unresponsive ist:
+
+```python
+def _reload_model(self) -> None:
+    """Unload and reload the Lemonade model when unresponsive."""
+    try:
+        if HAS_LEMONADE_SDK:
+            new_port = find_available_lemonade_port(
+                hostname=self.host or DEFAULT_HOST,
+                ports=DEFAULT_PORTS
+            )
+            if new_port and new_port != self._port:
+                self._port = new_port
+                self._init_client()
+    except Exception:
+        pass
+```
+
+#### `_init_client()`
+
+Initialisiert den OpenAI-Client neu mit der aktuellen Konfiguration:
+
+```python
+def _init_client(self) -> None:
+    """Reinitialize the OpenAI client with current configuration."""
+    self.client = OpenAI(
+        base_url=f"{self.base_url}/api/v1",
+        api_key=self.api_key
+    )
+```
+
+## Ablauf bei Unresponsiveness
+
+1. **Erster Versuch**: Modell antwortet nicht → `_reload_model()` aufgerufen
+2. **Zweiter Versuch**: Modell antwortet immer noch nicht → `_reload_model()` erneut aufgerufen
+3. **Dritter Versuch**: Erfolgt mit neu geladenem Modell
+4. **Falls alle Versuche fehlschlagen**: `RuntimeError` mit detaillierter Fehlermeldung
+
+## Voraussetzungen
+
+Die automatische Wiederherstellung erfordert das `lemonade-python-sdk`:
+
+```python
+try:
+    from lemonade_sdk.port_scanner import verify_lemonade_server
+    from lemonade_sdk.port_scanner import find_available_lemonade_port
+    HAS_LEMONADE_SDK = True
+except ImportError:
+    HAS_LEMONADE_SDK = False
+```
+
+Ohne das SDK wird weiterhin versucht, einen offenen Port zu finden, aber die automatische Wiederherstellung ist eingeschränkt.
+
+## Siehe auch
+
+- [LEMONADE_PORT_VERIFICATION_FIX.md](LEMONADE_PORT_VERIFICATION_FIX.md) - Port-Erkennungsfix
+- [MODEL_NAME_CASE_FIX.md](MODEL_NAME_CASE_FIX.md) - Modellnamen-Fallfix

diffron-0.1.4/docs/MODEL_NAME_CASE_FIX.md

@@ -0,0 +1,88 @@
+# Model Name Case Sensitivity Fix
+
+## Problem
+
+Diffron returned a **404 Not Found** error from the Lemonade server when using the `Qwen3.5-0.8B-GGUF` model.
+
+### Root Cause
+
+The Lemonade server is **case-sensitive** when matching model names. Diffron's curated model configuration used the wrong casing:
+
+| Location | Model Name (Before) | Model Name (Expected) |
+|----------|---------------------|------------------------|
+| `diffron/models.py` | `qwen3.5-0.8b-gguf` | `Qwen3.5-0.8B-GGUF` |
+
+This caused the OpenAI SDK to send a request with the wrong model identifier, resulting in:
+
+```
+Error code: 404 - {'detail': 'Not Found'}
+```
+
+## Solution
+
+### 1. Corrected Model Name
+
+Updated the canonical model name in `diffron/models.py`:
+
+```python
+# Before
+ModelConfig(name="qwen3.5-0.8b-gguf", ...)
+
+# After
+ModelConfig(name="Qwen3.5-0.8B-GGUF", ...)
+```
+
+### 2. Case-Insensitive Model Lookup
+
+Enhanced `get_model_config()` to accept case-insensitive input while always returning the **canonical name**:
+
+```python
+def get_model_config(model_name: str) -> Optional[ModelConfig]:
+    # Exact match first
+    for model in AVAILABLE_MODELS:
+        if model.name == model_name:
+            return model
+    # Case-insensitive fallback
+    for model in AVAILABLE_MODEOLS:
+        if model.name.lower() == model_name.lower():
+            return model
+    return None
+```
+
+This allows users to type `qwen3.5-0.8b-gguf`, `QWEN3.5-0.8B-GGUF`, etc., but Diffron always sends the correct name to the server.
+
+### 3. CLI Canonical Name Enforcement
+
+The `setup_model_cli()` now stores the **canonical name** from the config, not the user's raw input:
+
+```python
+# Always uses config.name (canonical) instead of args.model (user input)
+os.environ["DIFFRON_MODEL"] = config.name
+subprocess.run(["setx", "DIFFRON_MODEL", config.name], check=True)
+```
+
+## Testing
+
+```bash
+# All of these now work correctly:
+diffron-setup-model --model Qwen3.5-0.8B-GGUF   # exact
+diffron-setup-model --model qwen3.5-0.8b-gguf   # lowercase (fallback)
+diffron-setup-model --model QWEN3.5-0.8B-GGUF   # uppercase (fallback)
+```
+
+## Impact
+
+- **No breaking changes** - existing `DIFFRON_MODEL` values with wrong casing are now resolved correctly
+- **Improved UX** - users don't need to memorize exact casing
+- **Server compatibility** - correct model name is always sent to Lemonade
+
+## Files Changed
+
+| File | Change |
+|------|--------|
+| `diffron/models.py` | Fixed `Qwen3.5-0.8B-GGUF` name, added case-insensitive lookup |
+
+## Version
+
+- **Fixed in**: 0.1.3
+- **Date**: 2026-04-13

{diffron-0.1.3 → diffron-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "diffron"
-version = "0.1.3"
+version = "0.1.4"
 description = "Git commit message and PR description generator using Lemonade"
 readme = "README.md"
 license = {text = "MIT"}
@@ -44,6 +44,7 @@ dev = [
 ]
 
 [project.scripts]
+diffron = "diffron.cli:main"
 diffron-install-hooks = "diffron.cli:install_hooks_cli"
 diffron-uninstall-hooks = "diffron.cli:uninstall_hooks_cli"
 diffron-pr = "diffron.cli:pr_description_cli"

{diffron-0.1.3 → diffron-0.1.4}/requirements.txt

@@ -1,2 +1,3 @@
 openai>=1.0.0
 psutil>=5.9.0
+lemonade-sdk>=0.1.0

{diffron-0.1.3 → diffron-0.1.4}/setup.py

@@ -10,7 +10,7 @@ with open("requirements.txt", "r", encoding="utf-8") as fh:
 
 setup(
     name="diffron",
-    version="0.1.3",
+    version="0.1.4",
     author="Diffron Contributors",
     author_email="diffron@example.com",
     description="Git commit message and PR description generator using Lemonade",
@@ -51,6 +51,7 @@ setup(
     },
     entry_points={
         "console_scripts": [
+            "diffron=diffron.cli:main",
             "diffron-install-hooks=diffron.cli:install_hooks_cli",
             "diffron-uninstall-hooks=diffron.cli:uninstall_hooks_cli",
             "diffron-pr=diffron.cli:pr_description_cli",

diffron-0.1.3/diffron/lemonade.py

@@ -1,192 +0,0 @@
-"""
-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}')"