diffsage 1.2.0__py3-none-any.whl

diffsage/config/paths.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+
+from platformdirs import user_config_path, user_log_path
+
+APP_NAME = "DiffSage"
+
+
+def get_global_config_path() -> Path:
+    """Return the global DiffSage configuration file path."""
+
+    return user_config_path("DiffSage") / "config.toml"
+
+
+def find_repository_root() -> Path | None:
+    """Return the Git repository root or None if not inside a repository."""
+    current = Path.cwd()
+
+    while True:
+        if (current / ".git").is_dir():
+            return current
+
+        if current.parent == current:
+            return None
+
+        current = current.parent
+
+
+def get_local_config_path() -> Path | None:
+    """Return the local repository configuration file path."""
+
+    root = find_repository_root()
+
+    if root is None:
+        return None
+
+    return root / ".diffsage.toml"
+
+
+def get_log_directory() -> Path:
+    path = user_log_path(APP_NAME)
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def get_log_file_path() -> Path:
+    return get_log_directory() / "diffsage.log"
+
+
+def ensure_global_config_dir() -> None:
+    """Create the global configuration directory if it does not exist."""
+
+    get_global_config_path().parent.mkdir(
+        parents=True,
+        exist_ok=True,
+    )
+
+
+def get_credentials_path() -> Path:
+    """Return the global DiffSage credentials file path."""
+
+    return user_config_path(APP_NAME) / "credentials.toml"

diffsage/config/resolver.py

@@ -0,0 +1,118 @@
+import os
+from collections.abc import Mapping
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from diffsage.config.defaults import DEFAULT_CONFIG
+from diffsage.config.file_loader import load_config
+from diffsage.config.paths import get_global_config_path, get_local_config_path
+from diffsage.config.schema import DiffSageConfig, PartialDiffSageConfig
+from diffsage.config.scope import ConfigScope
+from diffsage.config.settings import Settings
+from diffsage.exceptions import ConfigError
+
+
+def _merge_dict(
+    base: dict,
+    override: dict,
+) -> dict:
+    """Recursively merge two dictionaries."""
+
+    merged = base.copy()
+
+    for key, value in override.items():
+        if key in merged and isinstance(merged[key], Mapping) and isinstance(value, Mapping):
+            merged[key] = _merge_dict(merged[key], value)
+        else:
+            merged[key] = value
+
+    return merged
+
+
+def _merge_config(
+    base: DiffSageConfig,
+    override: PartialDiffSageConfig,
+) -> DiffSageConfig:
+    """Merge two configuration models."""
+
+    merged = _merge_dict(
+        base.model_dump(),
+        override.model_dump(exclude_unset=True),
+    )
+
+    return DiffSageConfig.model_validate(merged)
+
+
+def _to_settings(config: DiffSageConfig) -> Settings:
+    """Convert a configuration model into runtime settings."""
+
+    return Settings(
+        provider=config.ai.provider,
+        ai_model=config.ai.model,
+        timeout=config.network.timeout,
+        max_retries=config.network.max_retries,
+        log_level=config.logging.level,
+    )
+
+
+def resolve_settings() -> Settings:
+    """Resolve application settings from all configuration sources."""
+
+    load_dotenv()
+
+    config = DEFAULT_CONFIG
+    global_config_path = get_global_config_path()
+
+    if global_config_path.exists():
+        config = _merge_config(
+            config,
+            load_config(global_config_path),
+        )
+
+    local_config_path = get_local_config_path()
+
+    if local_config_path is not None and local_config_path.exists():
+        config = _merge_config(config, load_config(local_config_path))
+
+    settings = _to_settings(config)
+
+    try:
+        return Settings(
+            provider=os.getenv(
+                "DIFFSAGE_PROVIDER",
+                settings.provider,
+            ),
+            ai_model=os.getenv(
+                "DIFFSAGE_AI_MODEL",
+                settings.ai_model,
+            ),
+            timeout=int(
+                os.getenv(
+                    "DIFFSAGE_TIMEOUT",
+                    str(settings.timeout),
+                )
+            ),
+            max_retries=int(
+                os.getenv(
+                    "DIFFSAGE_MAX_RETRIES",
+                    str(settings.max_retries),
+                )
+            ),
+            log_level=os.getenv(
+                "DIFFSAGE_LOG_LEVEL",
+                settings.log_level,
+            ),
+        )
+
+    except ValueError as error:
+        raise ConfigError("Invalid configuration value.") from error
+
+
+def resolve_config_path(scope: ConfigScope) -> Path:
+    """Return the configuration path for the given scope"""
+
+    if scope is ConfigScope.GLOBAL:
+        return get_global_config_path()
+
+    return get_local_config_path()

diffsage/config/schema.py

@@ -0,0 +1,53 @@
+from pydantic import BaseModel
+
+
+class AIConfig(BaseModel):
+    provider: str
+    model: str
+
+
+class NetworkConfig(BaseModel):
+    timeout: int
+    max_retries: int
+
+
+class LoggingConfig(BaseModel):
+    level: str
+
+
+# Reserved for future multi-provider support.
+#
+# class ProviderCredentials(BaseModel):
+#     api_key: str | None = None
+#
+#
+# class ProvidersConfig(BaseModel):
+#     gemini: ProviderCredentials
+#     openai: ProviderCredentials
+#     anthropic: ProviderCredentials
+
+
+class DiffSageConfig(BaseModel):
+    ai: AIConfig
+    network: NetworkConfig
+    logging: LoggingConfig
+
+
+class PartialAIConfig(BaseModel):
+    provider: str | None = None
+    model: str | None = None
+
+
+class PartialNetworkConfig(BaseModel):
+    timeout: int | None = None
+    max_retries: int | None = None
+
+
+class PartialLoggingConfig(BaseModel):
+    level: str | None = None
+
+
+class PartialDiffSageConfig(BaseModel):
+    ai: PartialAIConfig | None = None
+    network: PartialNetworkConfig | None = None
+    logging: PartialLoggingConfig | None = None

diffsage/config/scope.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ConfigScope(str, Enum):
+    """Scope of a configuration operation."""
+
+    GLOBAL = "global"
+    LOCAL = "local"

diffsage/config/settings.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+
+class Settings(BaseModel):
+    provider: str
+    ai_model: str
+    timeout: int
+    max_retries: int
+    log_level: str

diffsage/exceptions/__init__.py

@@ -0,0 +1,34 @@
+from .base import (
+    ConfigError,
+    DiffSageError,
+    GitError,
+    InvalidCommitMessageError,
+    InvalidConfigurationValueError,
+    ProviderError,
+    UnknownConfigurationKeyError,
+)
+from .credentials import CredentialNotFoundError
+from .git import NoStagedChangesError, NotGitRepositoryError
+from .provider import (
+    AuthenticationError,
+    ModelNotFoundError,
+    ProviderUnavailableError,
+    RateLimitError,
+)
+
+__all__ = [
+    "DiffSageError",
+    "ProviderError",
+    "AuthenticationError",
+    "RateLimitError",
+    "ModelNotFoundError",
+    "ProviderUnavailableError",
+    "ConfigError",
+    "GitError",
+    "UnknownConfigurationKeyError",
+    "InvalidConfigurationValueError",
+    "InvalidCommitMessageError",
+    "NoStagedChangesError",
+    "NotGitRepositoryError",
+    "CredentialNotFoundError",
+]

diffsage/exceptions/base.py

@@ -0,0 +1,32 @@
+class DiffSageError(Exception):
+    """Base exception for all DiffSage errors."""
+
+
+class ProviderError(DiffSageError):
+    """Raised when an AI provider fails."""
+
+
+class GitError(DiffSageError):
+    """Raised when git operations fail."""
+
+
+class InvalidCommitMessageError(DiffSageError):
+    """Raised when an AI-generated commit message cannot be parsed."""
+
+
+class ConfigError(DiffSageError):
+    """Raised when configuration is invalid."""
+
+
+class UnknownConfigurationKeyError(ConfigError):
+    """Raised when configuration key does not exist."""
+
+    def __init__(self, key: str) -> None:
+        super().__init__(f"Unknown configuration key: '{key}'")
+
+
+class InvalidConfigurationValueError(ConfigError):
+    """Raised when configuration value is of invalid type."""
+
+    def __init__(self, value: str) -> None:
+        super().__init__(f"Invalid configuration value: '{value}'")

diffsage/exceptions/credentials.py

@@ -0,0 +1,8 @@
+from diffsage.exceptions.base import DiffSageError
+
+
+class CredentialNotFoundError(DiffSageError):
+    """Raised when a required provider credential cannot be found."""
+
+    def __init__(self, provider: str, name: str = "default") -> None:
+        super().__init__(f"Credential not found for provider '{provider}' and profile '{name}'.")

diffsage/exceptions/git.py

@@ -0,0 +1,9 @@
+from diffsage.exceptions.base import GitError
+
+
+class NotGitRepositoryError(GitError):
+    """Raised when the current directory is not a Git repository."""
+
+
+class NoStagedChangesError(GitError):
+    """Raised when there are no staged changes to commit."""

diffsage/exceptions/provider.py

@@ -0,0 +1,17 @@
+from diffsage.exceptions.base import ProviderError
+
+
+class AuthenticationError(ProviderError):
+    """Raised when authentication with a provider fails."""
+
+
+class RateLimitError(ProviderError):
+    """Raised when a provider rate limit is exceeded."""
+
+
+class ModelNotFoundError(ProviderError):
+    """Raised when the requested model is unavailable."""
+
+
+class ProviderUnavailableError(ProviderError):
+    """Raised when the provider service is unavailable."""

diffsage/git/client.py

@@ -0,0 +1,155 @@
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+from diffsage.models.git import GitCommit, GitStatus
+
+
+class GitClient:
+    """Low-level client for executing Git commands."""
+
+    def __init__(self, repo_path: Path | str | None = None) -> None:
+        self._repo_path = Path(repo_path) if repo_path else Path.cwd()
+
+    def _run_git_command(self, args: list[str]) -> subprocess.CompletedProcess[str]:
+        """Execute a Git command and return the completed process."""
+
+        return subprocess.run(
+            ["git", *args],
+            cwd=self._repo_path,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+    def is_git_repository(self) -> bool:
+        """Return True if the repository path is inside a Git working tree."""
+        try:
+            result = self._run_git_command(["rev-parse", "--is-inside-work-tree"])
+            return result.stdout.strip() == "true"
+
+        except subprocess.CalledProcessError:
+            return False
+
+    def repository_root(self) -> Path:
+        """Return the root directory of the Git repository."""
+
+        result = self._run_git_command(["rev-parse", "--show-toplevel"])
+        return Path(result.stdout.strip())
+
+    def current_branch(self) -> str:
+        """Return the name of the current Git branch."""
+
+        result = self._run_git_command(
+            ["branch", "--show-current"],
+        )
+        return result.stdout.strip()
+
+    def current_commit(self) -> str:
+        """Return the hash of the current commit."""
+
+        result = self._run_git_command(
+            ["rev-parse", "HEAD"],
+        )
+        return result.stdout.strip()
+
+    def status(self) -> GitStatus:
+        """Return the current repository status."""
+
+        result = self._run_git_command(
+            ["status", "--porcelain"],
+        )
+
+        untracked = []
+        modified = []
+        added = []
+        deleted = []
+
+        # Parse Git porcelain status codes.
+        for line in result.stdout.splitlines():
+            status = line[:2]
+            path = line[3:]
+
+            match status:
+                case "??":
+                    untracked.append(path)
+                case " M":
+                    modified.append(path)
+                case "A ":
+                    added.append(path)
+                case " D":
+                    deleted.append(path)
+
+        return GitStatus(
+            modified=modified,
+            added=added,
+            deleted=deleted,
+            untracked=untracked,
+        )
+
+    def staged_diff(self) -> str:
+        """Returns the staged diff"""
+
+        result = self._run_git_command(
+            ["diff", "--staged"],
+        )
+        return result.stdout.strip()
+
+    def unstaged_diff(self) -> str:
+        """Returns the unstaged diff"""
+
+        result = self._run_git_command(
+            ["diff"],
+        )
+        return result.stdout.strip()
+
+    def recent_commits(self, limit: int = 10) -> list[GitCommit]:
+        """Return the most recent commits."""
+
+        result = self._run_git_command(
+            ["log", f"-{limit}", "--pretty=format:%H%x09%an%x09%s%x09%aI"],
+        )
+
+        commits: list[GitCommit] = []
+
+        for line in result.stdout.splitlines():
+            hash_, author, message, date = line.split("\t")
+
+            commit = GitCommit(
+                hash=hash_, author=author, message=message, date=datetime.fromisoformat(date)
+            )
+            commits.append(commit)
+
+        return commits
+
+    def branches(self) -> list[str]:
+        """Return local branch names."""
+
+        result = self._run_git_command(
+            ["branch", "--format=%(refname:short)"],
+        )
+
+        return result.stdout.splitlines()
+
+    def tags(self) -> list[str]:
+        """Return tag names."""
+
+        result = self._run_git_command(
+            ["tag", "--format=%(refname:short)"],
+        )
+        return result.stdout.splitlines()
+
+    def commit(self, message: str) -> None:
+        """Create a git commit with the provided commit message."""
+
+        lines = message.split("\n", 1)
+
+        subject = lines[0]
+        body = lines[1].strip() if len(lines) > 1 else ""
+
+        command = ["commit", "-m", subject]
+
+        if body:
+            command.extend(["-m", body])
+
+        self._run_git_command(command)

diffsage/logging/logger.py

@@ -0,0 +1,41 @@
+import logging
+
+from diffsage.config.paths import get_log_directory
+
+_CONFIGURED = False
+
+
+def configure_logging(level: int = logging.INFO) -> None:
+    """Configure the application's logging."""
+
+    global _CONFIGURED
+
+    if _CONFIGURED:
+        return
+
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+
+    log_file = get_log_directory() / "diffsage.log"
+
+    # console_handler = logging.StreamHandler()
+    file_handler = logging.FileHandler(log_file)
+
+    formatter = logging.Formatter("%(asctime)s | %(levelname)s | %(name)s | %(message)s")
+
+    # console_handler.setFormatter(formatter)
+    file_handler.setFormatter(formatter)
+
+    # root_logger.addHandler(console_handler)
+    root_logger.addHandler(file_handler)
+
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("google_genai").setLevel(logging.WARNING)
+
+    _CONFIGURED = True
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Return a logger."""
+
+    return logging.getLogger(name)

diffsage/models/commit_message.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass, field
+
+
+@dataclass(slots=True)
+class CommitMessage:
+    type: str | None = None
+    scope: str | None = None
+    subject: str = ""
+    body: list[str] = field(default_factory=list)

diffsage/models/config.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class ConfigReport:
+    provider: str | None
+    model: str | None
+    timeout: int | None
+    max_retries: int | None
+    log_level: str | None
+
+
+@dataclass(slots=True)
+class ConfigValueReport:
+    key: str
+    value: str | int | None

diffsage/models/credentials.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class Credential:
+    provider: str
+    name: str
+    api_key: str

diffsage/models/doctor.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+
+class DoctorReport(BaseModel):
+    python_version: str
+    git_installed: bool
+    git_version: str | None
+    provider: str
+    timeout: int
+    max_retries: int
+    log_level: str
+    virtual_environment: bool
+    configuration_loaded: bool

diffsage/models/git.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass(slots=True)
+class GitStatus:
+    """Represents the current status of a Git repository."""
+
+    modified: list[str]
+    added: list[str]
+    deleted: list[str]
+    untracked: list[str]
+
+
+@dataclass(slots=True)
+class GitCommit:
+    """Represents a commit history in a Git repository"""
+
+    hash: str
+    author: str
+    message: str
+    date: datetime
+
+
+@dataclass(slots=True)
+class CommitContext:
+    """Represents the information needed to generate a commit message."""
+
+    branch: str
+    staged_diff: str
+    unstaged_diff: str
+    recent_commits: list[GitCommit]

diffsage/models/provider.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class ProviderRequest:
+    prompt: str
+    model: str
+    temperature: float
+    max_tokens: int
+
+
+@dataclass(slots=True)
+class ProviderResponse:
+    content: str
+    provider: str
+    model: str
+    input_tokens: int
+    output_tokens: int
+    finish_reason: str
+    latency_ms: int