diffsage 1.2.0__py3-none-any.whl

diffsage/storage/config_repository.py

@@ -0,0 +1,85 @@
+from pathlib import Path
+
+from tomlkit import TOMLDocument, document, parse, table
+
+
+class ConfigRepository:
+    """Persists DiffSage configuration."""
+
+    _PATH_MAP = {
+        "provider": ("ai", "provider"),
+        "model": ("ai", "model"),
+        "timeout": ("network", "timeout"),
+        "max_retries": ("network", "max_retries"),
+        "log_level": ("logging", "level"),
+    }
+
+    def __init__(self, path: Path) -> None:
+        self._path = path
+
+    def _load(self) -> TOMLDocument:
+        if not self._path.exists():
+            return document()
+
+        content = self._path.read_text()
+        doc = parse(content)
+
+        return doc
+
+    def _save(self, doc: TOMLDocument) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+
+        content = doc.as_string()
+        self._path.write_text(content)
+
+    def list(self) -> dict[str, str | int]:
+        doc = self._load()
+
+        config = {}
+
+        for key, (section, option) in self._PATH_MAP.items():
+            if section in doc and option in doc[section]:
+                config[key] = doc[section][option]
+
+        return config
+
+    def get(self, key: str) -> str | int | None:
+        doc = self._load()
+
+        section, option = self._PATH_MAP[key]
+
+        if section not in doc:
+            return None
+
+        if option not in doc[section]:
+            return None
+
+        return doc[section][option]
+
+    def set(self, key: str, value: str | int) -> None:
+        doc = self._load()
+        section, option = self._PATH_MAP[key]
+
+        if section not in doc:
+            doc[section] = table()
+
+        doc[section][option] = value
+
+        self._save(doc)
+
+    def unset(self, key: str) -> None:
+        doc = self._load()
+        section, option = self._PATH_MAP[key]
+
+        if section not in doc:
+            return
+
+        if option not in doc[section]:
+            return
+
+        del doc[section][option]
+
+        if not doc[section]:
+            del doc[section]
+
+        self._save(doc)

diffsage/storage/credentials_repository.py

@@ -0,0 +1,121 @@
+from pathlib import Path
+
+from tomlkit import document, parse, table
+
+from diffsage.models.credentials import Credential
+
+
+class CredentialsRepository:
+    """Persists DiffSage API keys configuration."""
+
+    def __init__(self, path: Path) -> None:
+        self._path = path
+
+    def save(self, credential: Credential) -> None:
+        if self._path.exists():
+            doc = parse(self._path.read_text())
+        else:
+            doc = document()
+
+        credentials = doc.get("credentials")
+
+        if "credentials" not in doc:
+            credentials = table()
+            doc["credentials"] = credentials
+
+        provider = credentials.get(credential.provider)
+
+        if provider is None:
+            provider = table()
+            credentials[credential.provider] = provider
+
+        profile = provider.get(credential.name)
+
+        if profile is None:
+            profile = table()
+            provider[credential.name] = profile
+
+        profile["api_key"] = credential.api_key
+
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._path.write_text(doc.as_string())
+
+    def get(self, provider: str, name: str = "default") -> Credential | None:
+        if not self._path.exists():
+            return None
+
+        doc = parse(self._path.read_text())
+        credentials = doc.get("credentials")
+
+        if credentials is None:
+            return None
+
+        provider_table = credentials.get(provider)
+        if provider_table is None:
+            return None
+
+        profile = provider_table.get(name)
+        if profile is None:
+            return None
+
+        api_key = profile.get("api_key")
+        if api_key is None:
+            return None
+
+        return Credential(
+            provider=provider,
+            name=name,
+            api_key=api_key,
+        )
+
+    def list(self) -> list[Credential]:
+        if not self._path.exists():
+            return []
+
+        doc = parse(self._path.read_text())
+        credentials = doc.get("credentials")
+
+        if credentials is None:
+            return []
+
+        result: list[Credential] = []
+
+        for provider_name, provider in credentials.items():
+            for profile_name, profile in provider.items():
+                api_key = profile.get("api_key")
+
+                if api_key is None:
+                    continue
+
+                result.append(
+                    Credential(provider=provider_name, name=profile_name, api_key=api_key)
+                )
+
+        return result
+
+    def delete(self, provider: str, name: str = "default") -> bool:
+        if not self._path.exists():
+            return False
+
+        doc = parse(self._path.read_text())
+        credentials = doc.get("credentials")
+
+        if credentials is None:
+            return False
+
+        provider_table = credentials.get(provider)
+
+        if provider_table is None:
+            return False
+
+        if provider_table.get(name) is None:
+            return False
+
+        del provider_table[name]
+
+        if not provider_table:
+            del credentials[provider]
+
+        self._path.write_text(doc.as_string())
+
+        return True

diffsage/ui/ask_view.py

@@ -0,0 +1,10 @@
+from diffsage.models.provider import ProviderResponse
+from diffsage.ui.base import BaseView
+
+
+class AskView(BaseView):
+    """Handles terminal rendering for the ask command."""
+
+    def show_response(self, response: ProviderResponse) -> None:
+        self._console.print(f"[green]{response.content}[/green]")
+        self._console.print()

diffsage/ui/auth_view.py

@@ -0,0 +1,51 @@
+from rich.panel import Panel
+from rich.table import Table
+
+from diffsage.models.credentials import Credential
+from diffsage.ui.base import BaseView
+
+
+class AuthView(BaseView):
+    """Handles terminal rendering for the auth command."""
+
+    def show_success(self, message: str) -> None:
+        self._console.print(f"[bold green]✓ {message}[bold green]")
+
+    def show_credential(self, credential: Credential) -> None:
+        table = Table(show_header=False, box=False, expand=False)
+
+        table.add_row("Provider", credential.provider)
+        table.add_row("Profile", credential.name)
+        table.add_row("API Key", self._mask_api_key(credential.api_key))
+
+        self._console.print(
+            Panel(
+                table,
+                title="[bold cyan]DiffSage Credential[/bold cyan]",
+                expand=False,
+            )
+        )
+
+    def show_credentials(self, credentials: list[Credential]) -> None:
+        table = Table(show_header=False, box=False, expand=False)
+
+        for credential in credentials:
+            table.add_row(
+                credential.provider,
+                credential.name,
+            )
+
+        self._console.print(
+            Panel(
+                table,
+                title="[bold cyan]DiffSage Credential[/bold cyan]",
+                expand=False,
+            )
+        )
+
+    @staticmethod
+    def _mask_api_key(api_key: str) -> str:
+        if len(api_key) <= 8:
+            return "••••••••"
+
+        return f"{api_key[:4]}••••••••{api_key[-4:]}"

diffsage/ui/base.py

@@ -0,0 +1,15 @@
+from rich.console import Console
+
+
+class BaseView:
+    def __init__(self) -> None:
+        self._console = Console()
+
+    def show_error(self, message: str) -> None:
+        self._console.print(f"[red]✗ {message}[/red]")
+
+    def show_warning(self, message: str) -> None:
+        self._console.print(f"[yellow]! {message}[/yellow]")
+
+    def show_info(self, message: str) -> None:
+        self._console.print(message)

diffsage/ui/commit_view.py

@@ -0,0 +1,100 @@
+from contextlib import contextmanager
+
+from rich.console import Group
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.table import Table
+from rich.text import Text
+
+from diffsage.models.commit_message import CommitMessage
+from diffsage.ui.base import BaseView
+
+
+class CommitView(BaseView):
+    """Handles terminal rendering for the commit command."""
+
+    @contextmanager
+    def generating(self):
+        with self._console.status("Generating commit message..."):
+            yield
+
+    def show_generated(self) -> None:
+        self._console.print("[green]✓ Commit message generated successfully.[/green]")
+
+    def show_not_git_repository(self):
+        self._console.print("[red]Not inside a Git repository[/red]")
+
+    def show_no_staged_changes(self):
+        self._console.print("[yellow]No staged changes found[/yellow]")
+
+    def show_commit(self, message: CommitMessage) -> None:
+        grid = Table.grid(expand=True)
+        grid.add_column(style="cyan", width=10)
+        grid.add_column()
+
+        if message.type:
+            grid.add_row("Type", message.type)
+
+        if message.scope:
+            grid.add_row("Scope", message.scope)
+
+        grid.add_row("Subject", message.subject)
+
+        body = Text()
+
+        if message.body:
+            for i, line in enumerate(message.body):
+                line = line.strip()
+                if not line:
+                    continue
+
+                if line.startswith("- "):
+                    line = line.removeprefix("- ")
+
+                body.append(f"• {line}")
+                if i < len(message.body) - 1:
+                    body.append("\n")
+
+            content = Group(
+                grid,
+                Rule(style="cyan"),
+                body,
+            )
+            panel = Panel(
+                content,
+                title="[bold cyan]Commit Message[/bold cyan]",
+                expand=False,
+            )
+        else:
+            panel = Panel(
+                grid,
+                title="[bold cyan]Suggested Commit Message[/bold cyan]",
+                expand=False,
+            )
+
+        self._console.print()
+        self._console.print(panel)
+
+    def prompt_action(self) -> str:
+        self._console.print()
+
+        return self._console.input(
+            "[bold cyan][Y][/bold cyan] Commit (default)   "
+            "[bold cyan][E][/bold cyan] Edit   "
+            "[bold cyan][R][/bold cyan] Regenerate   "
+            "[bold cyan][N][/bold cyan] Cancel:  "
+        )
+
+    def show_success(self, message: str) -> None:
+        self._console.print()
+        self._console.print("[bold green]✓ Commit created successfully.[/bold green]")
+        self._console.print()
+        self._console.print("[dim]Commit:[/dim]")
+        self._console.print(message)
+        self._console.print()
+
+    def show_cancelled(self) -> None:
+        self._console.print("[yellow]Cancelled.[/yellow]")
+
+    def show_invalid_option(self) -> None:
+        self._console.print("[red]Invalid option. Please choose Y, E, R or N.[/red]")

diffsage/ui/config_view.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+
+from rich.panel import Panel
+from rich.table import Table
+
+from diffsage.models.config import ConfigReport, ConfigValueReport
+from diffsage.ui.base import BaseView
+
+
+class ConfigView(BaseView):
+    """Handles terminal rendering for the config command."""
+
+    def _display_value(self, value: str | int | None) -> str:
+        if value is None:
+            return "None"
+
+        return str(value)
+
+    def show_configuration(self, report: ConfigReport) -> None:
+        table = Table(show_header=False, box=False, expand=False)
+
+        table.add_row("Provider", self._display_value(report.provider))
+        table.add_row("Model", self._display_value(report.model))
+        table.add_row("Timeout", self._display_value(report.timeout))
+        table.add_row("Max Retries", self._display_value(report.max_retries))
+        table.add_row("Log Level", self._display_value(report.log_level))
+
+        self._console.print(
+            Panel(
+                table,
+                title="[bold cyan]DiffSage Configuration[/bold cyan]",
+                expand=False,
+            )
+        )
+
+    def show_value(self, report: ConfigValueReport) -> None:
+        self._console.print(
+            Panel(
+                self._display_value(report.value),
+                title=f"[bold cyan]{report.key.replace('_', ' ').title()}[/bold cyan]",
+                expand=False,
+            )
+        )
+
+    def show_success(self, message: str) -> None:
+        self._console.print()
+        self._console.print(f"[bold green]✓ {message}[bold green]")
+        self._console.print()
+
+    def show_path(self, path: Path) -> None:
+        display = str(path).replace(str(Path.home()), "~")
+
+        self._console.print("[dim]Location:[/]")
+        self._console.print(
+            f"[cyan]{display}[/]",
+            no_wrap=True,
+        )
+        self._console.print()

diffsage/ui/doctor_view.py

@@ -0,0 +1,39 @@
+import typer
+
+from diffsage.config.paths import get_log_file_path
+from diffsage.models.doctor import DoctorReport
+
+
+class DoctorView:
+    def _status_icon(self, status: bool) -> str:
+        """Return a status icon for terminal output."""
+
+        return "✓" if status else "✗"
+
+    def show_report(self, report: DoctorReport) -> None:
+        typer.echo()
+        typer.echo("DiffSage Doctor")
+        typer.echo()
+
+        typer.echo(f"{self._status_icon(True)} Python Version : {report.python_version}")
+
+        git_version = report.git_version or "Not Found"
+        typer.echo(f"{self._status_icon(report.git_installed)} Git Installed  : {git_version}")
+
+        virtual_env_status = "Active" if report.virtual_environment else "Inactive"
+        typer.echo(
+            f"{self._status_icon(report.virtual_environment)} Virtual Env.   : {virtual_env_status}"
+        )
+
+        typer.echo(
+            f"{self._status_icon(report.configuration_loaded)} "
+            f"Configuration  : {report.configuration_loaded}"
+        )
+
+        typer.echo()
+
+        typer.echo(f"Provider       : {report.provider}")
+        typer.echo(f"Timeout        : {report.timeout}")
+        typer.echo(f"Max Retries    : {report.max_retries}")
+        typer.echo(f"Log Level      : {report.log_level}")
+        typer.echo(f"Diffsage Log   : {get_log_file_path()}")