devcommit 0.1.5.6__tar.gz → 0.1.5.7__tar.gz

{devcommit-0.1.5.6 → devcommit-0.1.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devcommit
-Version: 0.1.5.6
+Version: 0.1.5.7
 Summary: AI-powered git commit message generator
 License: GNU GENERAL PUBLIC LICENSE
                                 Version 3, 29 June 2007
@@ -1184,6 +1184,8 @@ devcommit --stageAll --changelog
 - `--files` or `-f`: Stage and commit specific files or folders (can specify multiple)
 - `--push` or `-p`: Push commits to remote after committing
 - `--changelog` or `-c`: Generate changelog file from changes
+- `--models`: Fetch and list models from the configured `AI_PROVIDER`
+- `--free` / `--paid`: With `--models`, limit OpenRouter results to free or paid models
 
 ### Examples
 
@@ -1262,6 +1264,19 @@ export OPENROUTER_MODEL='meta-llama/llama-3.3-70b-instruct:free'
 devcommit
 ```
 
+To fetch the live model catalogue for your configured provider without opening a browser:
+
+```bash
+AI_PROVIDER=openrouter devcommit --models
+
+# Only free OpenRouter models
+AI_PROVIDER=openrouter devcommit --models --free
+```
+
+For OpenRouter, the table identifies free and paid models and shows their live token prices. For other providers, it lists the models accessible with that provider's configured API key; Ollama lists models installed locally. Copy an ID into the matching provider model setting, such as `OPENROUTER_MODEL`.
+
+Set `REASONING_EFFORT=none` to disable reasoning where the selected model supports it and favor faster commit messages. The default is `auto`; `low`, `medium`, `high`, `xhigh`, and `max` are also accepted where supported.
+
 **Popular free models on OpenRouter (add `:free` suffix):**
 
 **Recommended Models:**
@@ -1363,7 +1378,8 @@ All configuration can be set via **environment variables** or **`.dcommit` file*
 | `MAX_NO`        | Number of commit message suggestions | `1`                                                    | Any positive integer                     |
 | `COMMIT_TYPE`   | Style of commit messages             | `general`                                              | `general`, `conventional`, etc.          |
 | `COMMIT_MODE`   | Default commit strategy              | `auto`                                                 | `auto`, `directory`, `global`, `related` |
-| `EXCLUDE_FILES` | Files to exclude from diff           | `package-lock.json, pnpm-lock.yaml, yarn.lock, *.lock` | Comma-separated file patterns            |
+| `REASONING_EFFORT` | Reasoning effort for supported models | `auto`                                              | `auto`, `none`, `low`, `medium`, `high`, `xhigh`, `max` |
+| `EXCLUDE_FILES` | Files to exclude from diff           | `package-lock.json, pnpm-lock.yaml, yarn.lock, *.lock` | Comma-separated patterns or absolute paths within one repo |
 | `MAX_TOKENS`    | Maximum tokens for AI response       | `8192`                                                 | Any positive integer                     |
 | `CHANGELOG_DIR` | Directory for changelog files        | `changelogs`                                           | Any directory path                       |
 | `CHANGELOG_MODE` | Changelog file strategy             | `timestamped`                                          | `timestamped`, `branch`                  |

{devcommit-0.1.5.6 → devcommit-0.1.5.7}/README.md

@@ -479,6 +479,8 @@ devcommit --stageAll --changelog
 - `--files` or `-f`: Stage and commit specific files or folders (can specify multiple)
 - `--push` or `-p`: Push commits to remote after committing
 - `--changelog` or `-c`: Generate changelog file from changes
+- `--models`: Fetch and list models from the configured `AI_PROVIDER`
+- `--free` / `--paid`: With `--models`, limit OpenRouter results to free or paid models
 
 ### Examples
 
@@ -557,6 +559,19 @@ export OPENROUTER_MODEL='meta-llama/llama-3.3-70b-instruct:free'
 devcommit
 ```
 
+To fetch the live model catalogue for your configured provider without opening a browser:
+
+```bash
+AI_PROVIDER=openrouter devcommit --models
+
+# Only free OpenRouter models
+AI_PROVIDER=openrouter devcommit --models --free
+```
+
+For OpenRouter, the table identifies free and paid models and shows their live token prices. For other providers, it lists the models accessible with that provider's configured API key; Ollama lists models installed locally. Copy an ID into the matching provider model setting, such as `OPENROUTER_MODEL`.
+
+Set `REASONING_EFFORT=none` to disable reasoning where the selected model supports it and favor faster commit messages. The default is `auto`; `low`, `medium`, `high`, `xhigh`, and `max` are also accepted where supported.
+
 **Popular free models on OpenRouter (add `:free` suffix):**
 
 **Recommended Models:**
@@ -658,7 +673,8 @@ All configuration can be set via **environment variables** or **`.dcommit` file*
 | `MAX_NO`        | Number of commit message suggestions | `1`                                                    | Any positive integer                     |
 | `COMMIT_TYPE`   | Style of commit messages             | `general`                                              | `general`, `conventional`, etc.          |
 | `COMMIT_MODE`   | Default commit strategy              | `auto`                                                 | `auto`, `directory`, `global`, `related` |
-| `EXCLUDE_FILES` | Files to exclude from diff           | `package-lock.json, pnpm-lock.yaml, yarn.lock, *.lock` | Comma-separated file patterns            |
+| `REASONING_EFFORT` | Reasoning effort for supported models | `auto`                                              | `auto`, `none`, `low`, `medium`, `high`, `xhigh`, `max` |
+| `EXCLUDE_FILES` | Files to exclude from diff           | `package-lock.json, pnpm-lock.yaml, yarn.lock, *.lock` | Comma-separated patterns or absolute paths within one repo |
 | `MAX_TOKENS`    | Maximum tokens for AI response       | `8192`                                                 | Any positive integer                     |
 | `CHANGELOG_DIR` | Directory for changelog files        | `changelogs`                                           | Any directory path                       |
 | `CHANGELOG_MODE` | Changelog file strategy             | `timestamped`                                          | `timestamped`, `branch`                  |

{devcommit-0.1.5.6 → devcommit-0.1.5.7}/devcommit/app/ai_providers.py

@@ -34,6 +34,19 @@ except ImportError:
 sys.stderr = _stderr
 _devnull.close()
 
+REASONING_EFFORTS = {"auto", "none", "low", "medium", "high", "xhigh", "max"}
+
+
+def normalize_reasoning_effort(value: str) -> str:
+    effort = value.lower()
+    if effort not in REASONING_EFFORTS:
+        raise ValueError("REASONING_EFFORT must be auto, none, low, medium, high, xhigh, or max")
+    return effort
+
+
+def reasoning_extra_body(effort: str) -> dict:
+    return {} if effort == "auto" else {"reasoning_effort": effort}
+
 
 class AIProvider(ABC):
     """Base class for AI providers"""
@@ -106,11 +119,12 @@ class GeminiProvider(AIProvider):
 class OpenAIProvider(AIProvider):
     """OpenAI GPT provider"""
 
-    def __init__(self, api_key: str, model: str = "gpt-4o-mini"):
+    def __init__(self, api_key: str, model: str = "gpt-4o-mini", reasoning_effort: str = "auto"):
         if not openai:
             raise ImportError("openai not installed. Run: pip install openai")
         self.client = openai.OpenAI(api_key=api_key)
         self.model = model
+        self.reasoning_effort = normalize_reasoning_effort(reasoning_effort)
 
     def generate_commit_message(
         self, diff: str, prompt: str, max_tokens: int
@@ -123,6 +137,7 @@ class OpenAIProvider(AIProvider):
             ],
             max_tokens=max_tokens,
             temperature=0.7,
+            extra_body=reasoning_extra_body(self.reasoning_effort),
         )
         if not response or not response.choices:
             raise ValueError("OpenAI returned empty response (no choices).")
@@ -132,13 +147,14 @@ class OpenAIProvider(AIProvider):
 class GroqProvider(AIProvider):
     """Groq AI provider (OpenAI-compatible)"""
 
-    def __init__(self, api_key: str, model: str = "llama-3.3-70b-versatile"):
+    def __init__(self, api_key: str, model: str = "llama-3.3-70b-versatile", reasoning_effort: str = "auto"):
         if not openai:
             raise ImportError("openai not installed. Run: pip install openai")
         self.client = openai.OpenAI(
             api_key=api_key, base_url="https://api.groq.com/openai/v1"
         )
         self.model = model
+        self.reasoning_effort = normalize_reasoning_effort(reasoning_effort)
 
     def generate_commit_message(
         self, diff: str, prompt: str, max_tokens: int
@@ -151,6 +167,7 @@ class GroqProvider(AIProvider):
             ],
             max_tokens=max_tokens,
             temperature=0.7,
+            extra_body=reasoning_extra_body(self.reasoning_effort),
         )
         if not response or not response.choices:
             raise ValueError("Groq returned empty response (no choices).")
@@ -164,6 +181,7 @@ class OpenRouterProvider(AIProvider):
         self,
         api_key: str,
         model: str = "meta-llama/llama-3.3-70b-instruct:free",
+        reasoning_effort: str = "auto",
     ):
         if not openai:
             raise ImportError("openai not installed. Run: pip install openai")
@@ -176,6 +194,7 @@ class OpenRouterProvider(AIProvider):
             },
         )
         self.model = model
+        self.reasoning_effort = normalize_reasoning_effort(reasoning_effort)
 
     def generate_commit_message(
         self, diff: str, prompt: str, max_tokens: int
@@ -188,7 +207,7 @@ class OpenRouterProvider(AIProvider):
             ],
             max_tokens=max_tokens,
             temperature=0.7,
-            extra_body={"transforms": ["middle-out"]},
+            extra_body={"transforms": ["middle-out"], **reasoning_extra_body(self.reasoning_effort)},
             extra_headers={
                 "HTTP-Referer": "https://github.com/hordunlarmy/DevCommit",
                 "X-Title": "DevCommit",
@@ -207,23 +226,30 @@ class OpenRouterProvider(AIProvider):
 class AnthropicProvider(AIProvider):
     """Anthropic Claude provider"""
 
-    def __init__(self, api_key: str, model: str = "claude-3-haiku-20240307"):
+    def __init__(self, api_key: str, model: str = "claude-3-haiku-20240307", reasoning_effort: str = "auto"):
         if not anthropic:
             raise ImportError(
                 "anthropic not installed. Run: pip install anthropic"
             )
         self.client = anthropic.Anthropic(api_key=api_key)
         self.model = model
+        self.reasoning_effort = normalize_reasoning_effort(reasoning_effort)
 
     def generate_commit_message(
         self, diff: str, prompt: str, max_tokens: int
     ) -> str:
-        message = self.client.messages.create(
+        request = dict(
             model=self.model,
             max_tokens=max_tokens,
             system=prompt,
             messages=[{"role": "user", "content": diff}],
         )
+        if self.reasoning_effort == "none":
+            request["thinking"] = {"type": "disabled"}
+        elif self.reasoning_effort != "auto":
+            request["thinking"] = {"type": "adaptive"}
+            request["output_config"] = {"effort": self.reasoning_effort}
+        message = self.client.messages.create(**request)
         return message.content[0].text.strip()
 
 
@@ -231,7 +257,7 @@ class OllamaProvider(AIProvider):
     """Ollama local model provider"""
 
     def __init__(
-        self, base_url: str = "http://localhost:11434", model: str = "llama3"
+        self, base_url: str = "http://localhost:11434", model: str = "llama3", reasoning_effort: str = "auto"
     ):
         if not requests:
             raise ImportError(
@@ -239,6 +265,7 @@ class OllamaProvider(AIProvider):
             )
         self.base_url = base_url.rstrip("/")
         self.model = model
+        self.reasoning_effort = normalize_reasoning_effort(reasoning_effort)
 
     def generate_commit_message(
         self, diff: str, prompt: str, max_tokens: int
@@ -250,6 +277,8 @@ class OllamaProvider(AIProvider):
             "stream": False,
             "options": {"temperature": 0.7, "num_predict": max_tokens},
         }
+        if self.reasoning_effort != "auto":
+            data["think"] = False if self.reasoning_effort == "none" else self.reasoning_effort
 
         response = requests.post(url, json=data, timeout=60)
         response.raise_for_status()
@@ -267,6 +296,7 @@ class CustomProvider(AIProvider):
         api_url: str,
         api_key: Optional[str] = None,
         model: str = "default",
+        reasoning_effort: str = "auto",
     ):
         if not openai:
             raise ImportError("openai not installed. Run: pip install openai")
@@ -282,6 +312,7 @@ class CustomProvider(AIProvider):
             api_key=api_key or "dummy-key", base_url=base_url
         )
         self.model = model
+        self.reasoning_effort = normalize_reasoning_effort(reasoning_effort)
 
     def generate_commit_message(
         self, diff: str, prompt: str, max_tokens: int
@@ -294,6 +325,7 @@ class CustomProvider(AIProvider):
             ],
             max_tokens=max_tokens,
             temperature=0.7,
+            extra_body=reasoning_extra_body(self.reasoning_effort),
         )
         if not response or not response.choices:
             raise ValueError("Custom API returned empty response (no choices).")
@@ -304,6 +336,7 @@ def get_ai_provider(config) -> AIProvider:
     """Factory function to get the appropriate AI provider based on config"""
 
     provider_name = config("AI_PROVIDER", default="gemini").lower()
+    reasoning_effort = config("REASONING_EFFORT", default="auto")
 
     if provider_name == "gemini":
         api_key = config("GEMINI_API_KEY", default=None)
@@ -313,6 +346,8 @@ def get_ai_provider(config) -> AIProvider:
         model = config("GEMINI_MODEL", default=None) or config(
             "MODEL_NAME", default="gemini-2.0-flash-exp"
         )
+        if normalize_reasoning_effort(reasoning_effort) != "auto":
+            raise ValueError("REASONING_EFFORT is unsupported by the legacy Gemini SDK; use auto")
         return GeminiProvider(api_key, model)
 
     elif provider_name == "openai":
@@ -322,7 +357,7 @@ def get_ai_provider(config) -> AIProvider:
         model = config("OPENAI_MODEL", default=None) or config(
             "MODEL_NAME", default="gpt-4o-mini"
         )
-        return OpenAIProvider(api_key, model)
+        return OpenAIProvider(api_key, model, reasoning_effort)
 
     elif provider_name == "groq":
         api_key = config("GROQ_API_KEY", default=None)
@@ -331,7 +366,7 @@ def get_ai_provider(config) -> AIProvider:
         model = config("GROQ_MODEL", default=None) or config(
             "MODEL_NAME", default="llama-3.3-70b-versatile"
         )
-        return GroqProvider(api_key, model)
+        return GroqProvider(api_key, model, reasoning_effort)
 
     elif provider_name == "openrouter":
         api_key = config("OPENROUTER_API_KEY", default=None)
@@ -340,7 +375,7 @@ def get_ai_provider(config) -> AIProvider:
         model = config("OPENROUTER_MODEL", default=None) or config(
             "MODEL_NAME", default="meta-llama/llama-3.3-70b-instruct:free"
         )
-        return OpenRouterProvider(api_key, model)
+        return OpenRouterProvider(api_key, model, reasoning_effort)
 
     elif provider_name == "anthropic":
         api_key = config("ANTHROPIC_API_KEY", default=None)
@@ -349,14 +384,14 @@ def get_ai_provider(config) -> AIProvider:
         model = config("ANTHROPIC_MODEL", default=None) or config(
             "MODEL_NAME", default="claude-3-haiku-20240307"
         )
-        return AnthropicProvider(api_key, model)
+        return AnthropicProvider(api_key, model, reasoning_effort)
 
     elif provider_name == "ollama":
         base_url = config("OLLAMA_BASE_URL", default="http://localhost:11434")
         model = config("OLLAMA_MODEL", default=None) or config(
             "MODEL_NAME", default="llama3"
         )
-        return OllamaProvider(base_url, model)
+        return OllamaProvider(base_url, model, reasoning_effort)
 
     elif provider_name == "custom":
         api_url = config("CUSTOM_API_URL", default=None)
@@ -366,7 +401,7 @@ def get_ai_provider(config) -> AIProvider:
         model = config("CUSTOM_MODEL", default=None) or config(
             "MODEL_NAME", default="default"
         )
-        return CustomProvider(api_url, api_key, model)
+        return CustomProvider(api_url, api_key, model, reasoning_effort)
 
     else:
         raise ValueError(

devcommit-0.1.5.7/devcommit/app/model_catalog.py

@@ -0,0 +1,246 @@
+"""Provider-aware model catalogue helpers."""
+
+import json
+from typing import Callable, Dict, List, Optional
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+
+Model = Dict[str, object]
+Config = Callable[..., Optional[str]]
+
+
+class ModelCatalogError(Exception):
+    """Raised when a provider's model catalogue cannot be read."""
+
+
+def _request_json(
+    url: str, headers: Optional[Dict[str, str]] = None, timeout: int = 10
+) -> Dict[str, object]:
+    request_headers = {"User-Agent": "DevCommit"}
+    if headers:
+        request_headers.update(headers)
+
+    try:
+        with urlopen(Request(url, headers=request_headers), timeout=timeout) as response:
+            payload = json.load(response)
+    except (HTTPError, URLError, TimeoutError, json.JSONDecodeError) as error:
+        raise ModelCatalogError(f"Could not fetch models: {error}") from error
+
+    if not isinstance(payload, dict):
+        raise ModelCatalogError("The provider returned an unexpected models response.")
+    return payload
+
+
+def _api_key(config: Config, key_name: str) -> str:
+    api_key = config(key_name, default=None)
+    if not api_key:
+        raise ModelCatalogError(f"{key_name} is not set.")
+    return api_key
+
+
+def _model(
+    model_id: str,
+    name: Optional[str] = None,
+    context_length: Optional[object] = None,
+    availability: str = "Available",
+    price: str = "-",
+) -> Model:
+    return {
+        "id": model_id,
+        "name": name or model_id,
+        "context_length": context_length,
+        "availability": availability,
+        "price": price,
+    }
+
+
+def _models_from_openai_response(payload: Dict[str, object]) -> List[Model]:
+    data = payload.get("data")
+    if not isinstance(data, list):
+        raise ModelCatalogError("The provider returned an unexpected models response.")
+
+    models = []
+    for item in data:
+        if isinstance(item, dict) and isinstance(item.get("id"), str):
+            models.append(_model(item["id"], item.get("id")))
+    return models
+
+
+def _format_openrouter_price(pricing: object) -> str:
+    if not isinstance(pricing, dict):
+        return "-"
+
+    try:
+        prompt = float(pricing.get("prompt", "0")) * 1_000_000
+        completion = float(pricing.get("completion", "0")) * 1_000_000
+    except (TypeError, ValueError):
+        return "-"
+    if prompt < 0 or completion < 0:
+        return "Variable"
+    return f"${prompt:g} in / ${completion:g} out per M"
+
+
+def _fetch_openrouter_models(config: Config, timeout: int) -> List[Model]:
+    api_key = config("OPENROUTER_API_KEY", default=None)
+    headers = {"Authorization": f"Bearer {api_key}"} if api_key else None
+    payload = _request_json(
+        "https://openrouter.ai/api/v1/models", headers, timeout
+    )
+    data = payload.get("data")
+    if not isinstance(data, list):
+        raise ModelCatalogError("OpenRouter returned an unexpected models response.")
+
+    models = []
+    for item in data:
+        if not isinstance(item, dict) or not isinstance(item.get("id"), str):
+            continue
+        model_id = item["id"]
+        is_free = model_id.endswith(":free") or model_id == "openrouter/free"
+        models.append(
+            _model(
+                model_id,
+                item.get("name"),
+                item.get("context_length"),
+                "Free" if is_free else "Paid",
+                "Free" if is_free else _format_openrouter_price(item.get("pricing")),
+            )
+        )
+    return models
+
+
+def _fetch_gemini_models(config: Config, timeout: int) -> List[Model]:
+    headers = {"x-goog-api-key": _api_key(config, "GEMINI_API_KEY")}
+    page_token = None
+    models = []
+
+    while True:
+        params = {"pageSize": "1000"}
+        if page_token:
+            params["pageToken"] = page_token
+        payload = _request_json(
+            "https://generativelanguage.googleapis.com/v1beta/models?"
+            + urlencode(params),
+            headers,
+            timeout,
+        )
+        data = payload.get("models")
+        if not isinstance(data, list):
+            raise ModelCatalogError("Gemini returned an unexpected models response.")
+
+        for item in data:
+            if not isinstance(item, dict) or "generateContent" not in item.get(
+                "supportedGenerationMethods", []
+            ):
+                continue
+            resource_name = item.get("name")
+            if not isinstance(resource_name, str):
+                continue
+            models.append(
+                _model(
+                    resource_name.removeprefix("models/"),
+                    item.get("displayName"),
+                    item.get("inputTokenLimit"),
+                )
+            )
+
+        page_token = payload.get("nextPageToken")
+        if not isinstance(page_token, str) or not page_token:
+            return models
+
+
+def _fetch_anthropic_models(config: Config, timeout: int) -> List[Model]:
+    headers = {
+        "x-api-key": _api_key(config, "ANTHROPIC_API_KEY"),
+        "anthropic-version": "2023-06-01",
+    }
+    after_id = None
+    models = []
+
+    while True:
+        params = {"limit": "1000"}
+        if after_id:
+            params["after_id"] = after_id
+        payload = _request_json(
+            "https://api.anthropic.com/v1/models?" + urlencode(params),
+            headers,
+            timeout,
+        )
+        data = payload.get("data")
+        if not isinstance(data, list):
+            raise ModelCatalogError("Anthropic returned an unexpected models response.")
+
+        for item in data:
+            if isinstance(item, dict) and isinstance(item.get("id"), str):
+                models.append(
+                    _model(
+                        item["id"], item.get("display_name"), item.get("max_input_tokens")
+                    )
+                )
+
+        if not payload.get("has_more"):
+            return models
+        after_id = payload.get("last_id")
+        if not isinstance(after_id, str) or not after_id:
+            raise ModelCatalogError("Anthropic returned an invalid pagination cursor.")
+
+
+def _fetch_ollama_models(config: Config, timeout: int) -> List[Model]:
+    base_url = config("OLLAMA_BASE_URL", default="http://localhost:11434")
+    payload = _request_json(base_url.rstrip("/") + "/api/tags", timeout=timeout)
+    data = payload.get("models")
+    if not isinstance(data, list):
+        raise ModelCatalogError("Ollama returned an unexpected models response.")
+
+    models = []
+    for item in data:
+        if not isinstance(item, dict):
+            continue
+        model_id = item.get("model") or item.get("name")
+        if isinstance(model_id, str):
+            details = item.get("details")
+            size = details.get("parameter_size") if isinstance(details, dict) else None
+            models.append(_model(model_id, item.get("name"), size, "Installed"))
+    return models
+
+
+def _fetch_custom_models(config: Config, timeout: int) -> List[Model]:
+    base_url = config("CUSTOM_API_URL", default=None)
+    if not base_url:
+        raise ModelCatalogError("CUSTOM_API_URL is not set.")
+    api_key = config("CUSTOM_API_KEY", default=None)
+    headers = {"Authorization": f"Bearer {api_key}"} if api_key else None
+    return _models_from_openai_response(
+        _request_json(base_url.rstrip("/") + "/models", headers, timeout)
+    )
+
+
+def fetch_models(provider: str, config: Config, timeout: int = 10) -> List[Model]:
+    """Fetch the models available from the configured AI provider."""
+    provider = provider.lower()
+    fetchers = {
+        "openrouter": _fetch_openrouter_models,
+        "gemini": _fetch_gemini_models,
+        "openai": lambda config, timeout: _models_from_openai_response(
+            _request_json(
+                "https://api.openai.com/v1/models",
+                {"Authorization": f"Bearer {_api_key(config, 'OPENAI_API_KEY')}"},
+                timeout,
+            )
+        ),
+        "groq": lambda config, timeout: _models_from_openai_response(
+            _request_json(
+                "https://api.groq.com/openai/v1/models",
+                {"Authorization": f"Bearer {_api_key(config, 'GROQ_API_KEY')}"},
+                timeout,
+            )
+        ),
+        "anthropic": _fetch_anthropic_models,
+        "ollama": _fetch_ollama_models,
+        "custom": _fetch_custom_models,
+    }
+    fetcher = fetchers.get(provider)
+    if not fetcher:
+        raise ModelCatalogError(f"Unsupported AI_PROVIDER: {provider}")
+    return sorted(fetcher(config, timeout), key=lambda model: str(model["id"]).casefold())

{devcommit-0.1.5.6 → devcommit-0.1.5.7}/devcommit/create_config.py

@@ -68,6 +68,9 @@ MAX_NO = 1
 # Options: general, conventional, etc.
 COMMIT_TYPE = conventional
 
+# Reasoning: auto, none, low, medium, high, xhigh, max. Use none for faster commits.
+REASONING_EFFORT = auto
+
 # Gemini model to use (default: gemini-1.5-flash)
 MODEL_NAME = gemini-1.5-flash
 
@@ -79,7 +82,7 @@ MODEL_NAME = gemini-1.5-flash
 COMMIT_MODE = auto
 
 # Files to exclude from diff (default: package-lock.json, pnpm-lock.yaml, yarn.lock, *.lock)
-# Comma-separated list of file patterns
+# Comma-separated patterns or absolute paths within one repository
 EXCLUDE_FILES = *.lock, dist/*, build/*, node_modules/*
 
 # Directory for changelog files (default: changelogs)

{devcommit-0.1.5.6 → devcommit-0.1.5.7}/devcommit/main.py

@@ -9,10 +9,12 @@ os.environ["GRPC_ENABLE_FORK_SUPPORT"] = "1"
 
 from InquirerPy import get_style, inquirer
 from rich.console import Console
+from rich.table import Table
 
 from devcommit.__version__ import __version__
 from devcommit.app.changelog import generate_changelog, save_changelog
 from devcommit.app.gemini_ai import generateCommitMessage
+from devcommit.app.model_catalog import ModelCatalogError, fetch_models
 from devcommit.utils.git import (KnownError, assert_git_repo,
                                  generate_relation_grouping_prompt,
                                  get_detected_message, get_diff_for_files,
@@ -77,6 +79,49 @@ def main(flags: CommitFlag = None):
         Console().print(f"devcommit version {__version__}")
         return
 
+    if flags.get("models", False):
+        console = Console()
+        provider = config("AI_PROVIDER", default="gemini").lower()
+        try:
+            models = fetch_models(provider, config)
+        except ModelCatalogError as error:
+            console.print(f"[bold red]Error:[/bold red] {error}")
+            return
+
+        if flags.get("freeModels", False):
+            models = [model for model in models if model["availability"] == "Free"]
+        elif flags.get("paidModels", False):
+            models = [model for model in models if model["availability"] == "Paid"]
+
+        if not models:
+            console.print(f"No matching models are available from {provider}.")
+            return
+
+        table = Table(title=f"Available {provider.title()} Models")
+        table.add_column("Model", style="bold cyan")
+        table.add_column("ID", style="green")
+        table.add_column("Context", justify="right")
+        table.add_column("Access")
+        table.add_column("Price")
+        for model in models:
+            context_length = model["context_length"]
+            context = (
+                f"{context_length:,}"
+                if isinstance(context_length, int)
+                else str(context_length or "-")
+            )
+            table.add_row(
+                str(model["name"]),
+                str(model["id"]),
+                context,
+                str(model["availability"]),
+                str(model["price"]),
+            )
+
+        console.print(table)
+        console.print(f"\nSet one with: {provider.upper()}_MODEL='<model-id>'")
+        return
+
     try:
         assert_git_repo()
         console = Console()

{devcommit-0.1.5.6 → devcommit-0.1.5.7}/devcommit/utils/git.py

@@ -35,7 +35,32 @@ def exclude_from_diff(path: str) -> str:
     Prepares a Git exclusion path string for the diff command.
     """
 
-    return f':(exclude){path}'
+    return f':(top,exclude){path}'
+
+
+def normalize_exclude_paths(paths: List[str], repo_root: str) -> List[str]:
+    """Convert absolute exclusions in this repository to root-relative paths."""
+    normalized_paths = []
+    resolved_root = os.path.realpath(repo_root)
+
+    for path in paths:
+        expanded_path = os.path.expanduser(path)
+        if not os.path.isabs(expanded_path):
+            normalized_paths.append(path)
+            continue
+
+        resolved_path = os.path.realpath(expanded_path)
+        try:
+            is_in_repo = os.path.commonpath(
+                [resolved_root, resolved_path]
+            ) == resolved_root
+        except ValueError:
+            is_in_repo = False
+
+        if is_in_repo:
+            normalized_paths.append(os.path.relpath(resolved_path, resolved_root))
+
+    return normalized_paths
 
 
 def get_default_excludes() -> List[str]:
@@ -70,9 +95,12 @@ def get_staged_diff(
     Gets the list of staged files and their diff, excluding specified files.
     """
     exclude_files = exclude_files or []
+    repo_root = assert_git_repo()
     diff_cached = ['git', 'diff', '--cached', '--diff-algorithm=minimal']
-    excluded_from_diff = (
-        [exclude_from_diff(f) for f in files_to_exclude + exclude_files])
+    excludes = normalize_exclude_paths(
+        files_to_exclude + exclude_files, repo_root
+    )
+    excluded_from_diff = [exclude_from_diff(path) for path in excludes]
 
     try:
         # Get the list of staged files excluding specified files
@@ -81,7 +109,8 @@ def get_staged_diff(
             check=True,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
-            text=True
+            text=True,
+            cwd=repo_root
         )
         files_result = (
             files.stdout.strip().split('\n') if files.stdout.strip() else []
@@ -95,7 +124,8 @@ def get_staged_diff(
             check=True,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
-            text=True
+            text=True,
+            cwd=repo_root
         )
         diff_result = diff.stdout.strip()
 
@@ -140,25 +170,21 @@ def get_diff_for_files(files: List[str], exclude_files: Optional[List[str]] = No
     Gets the diff for specific files.
     """
     exclude_files = exclude_files or []
-    
-    # Filter out excluded files from the list
-    all_excluded = files_to_exclude + exclude_files
-    filtered_files = [
-        f for f in files 
-        if not any(f.endswith(excl.replace('*', '')) or excl.replace(':(exclude)', '') in f 
-                   for excl in all_excluded)
-    ]
-    
-    if not filtered_files:
-        return ""
+    repo_root = assert_git_repo()
+    excludes = normalize_exclude_paths(
+        files_to_exclude + exclude_files, repo_root
+    )
+    excluded_from_diff = [exclude_from_diff(path) for path in excludes]
     
     try:
         diff = subprocess.run(
-            ['git', 'diff', '--cached', '--diff-algorithm=minimal', '--'] + filtered_files,
+            ['git', 'diff', '--cached', '--diff-algorithm=minimal', '--']
+            + files + excluded_from_diff,
             check=True,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
-            text=True
+            text=True,
+            cwd=repo_root
         )
         return diff.stdout.strip()
     except subprocess.CalledProcessError:

{devcommit-0.1.5.6 → devcommit-0.1.5.7}/devcommit/utils/parser.py

@@ -12,6 +12,9 @@ class CommitFlag(TypedDict):
     files: List[str]
     push: bool
     changelog: bool
+    models: bool
+    freeModels: bool
+    paidModels: bool
     version: bool
     rawArgv: List[str]
 
@@ -58,6 +61,24 @@ def parse_arguments() -> CommitFlag:
         "--changelog", "-c", action="store_true",
         help="Generate changelog file from changes"
     )
+    parser.add_argument(
+        "--models",
+        action="store_true",
+        help="List models from the configured AI provider and exit",
+    )
+    model_filter = parser.add_mutually_exclusive_group()
+    model_filter.add_argument(
+        "--free",
+        dest="free_models",
+        action="store_true",
+        help="Only show free models with --models",
+    )
+    model_filter.add_argument(
+        "--paid",
+        dest="paid_models",
+        action="store_true",
+        help="Only show paid models with --models",
+    )
     parser.add_argument(
         "--version", "-v", action="store_true",
         help="Show version information"
@@ -77,6 +98,9 @@ def parse_arguments() -> CommitFlag:
         files=args.files or [],
         push=args.push,
         changelog=args.changelog,
+        models=args.models,
+        freeModels=args.free_models,
+        paidModels=args.paid_models,
         version=args.version,
         rawArgv=args.rawArgv,
     )

{devcommit-0.1.5.6 → devcommit-0.1.5.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devcommit"
-version = "0.1.5.6"
+version = "0.1.5.7"
 description = "AI-powered git commit message generator"
 readme = "README.md"
 license = {file = "COPYING"}
@@ -44,7 +44,7 @@ create-dcommit = "devcommit.create_config:create_dcommit"
 
 [tool.poetry]
 name = "devcommit"
-version = "0.1.5.6"
+version = "0.1.5.7"
 description = "AI-powered git commit message generator"
 authors = ["Hordunlarmy <Hordunlarmy@gmail.com>"]