deepctl-core 0.2.0__tar.gz → 0.2.2__tar.gz

{deepctl_core-0.2.0 → deepctl_core-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepctl-core
-Version: 0.2.0
+Version: 0.2.2
 Summary: Core components for deepctl
 Author-email: Deepgram <devrel@deepgram.com>
 Maintainer-email: Deepgram <devrel@deepgram.com>

{deepctl_core-0.2.0 → deepctl_core-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepctl-core"
-version = "0.2.0" # x-release-please-version
+version = "0.2.2" # x-release-please-version
 description = "Core components for deepctl"
 readme = "README.md"
 license = "MIT"

{deepctl_core-0.2.0 → deepctl_core-0.2.2}/src/deepctl_core/__init__.py

@@ -16,6 +16,7 @@ from .output import (
     OutputFormatter,
     get_console,
     get_output_format,
+    is_agentic,
     print_error,
     print_info,
     print_output,
@@ -50,6 +51,7 @@ __all__ = [
     "enable_timing",
     "get_console",
     "get_timing_summary",
+    "is_agentic",
     "is_timing_enabled",
     "print_error",
     "print_info",

{deepctl_core-0.2.0 → deepctl_core-0.2.2}/src/deepctl_core/base_command.py

@@ -189,7 +189,11 @@ class BaseCommand(ABC):
                 result = [item.model_dump() for item in result]
 
         with TimingContext(f"output_{output_format}"):
-            if output_format in ("json", "default"):
+            if output_format == "default":
+                # Commands handle their own display in default mode;
+                # only emit structured output when explicitly requested.
+                return
+            elif output_format == "json":
                 self._output_json(result)
             elif output_format == "yaml":
                 self._output_yaml(result)

deepctl_core-0.2.2/src/deepctl_core/client.py

@@ -0,0 +1,542 @@
+"""Deepgram SDK wrapper for deepctl with authentication integration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
+
+from deepgram import DeepgramClient as DGClient
+from deepgram import DeepgramClientEnvironment
+from deepgram.core.api_error import ApiError
+from rich.console import Console
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from datetime import datetime
+
+    from .auth import AuthManager
+    from .config import Config
+
+console = Console()
+
+
+class DeepgramClient:
+    """Wrapper around Deepgram SDK with authentication integration."""
+
+    def __init__(self, config: Config, auth_manager: AuthManager):
+        self.config = config
+        self.auth_manager = auth_manager
+        self._client: DGClient | None = None
+        self._project_id: str | None = None
+
+    @property
+    def client(self) -> DGClient:
+        """Get authenticated Deepgram client."""
+        if self._client is None:
+            self._client = self._create_client()
+        return self._client
+
+    def _resolve_project_id(self, project_id: str | None = None) -> str:
+        """Resolve project ID from argument, config, or auth manager."""
+        if project_id:
+            return project_id
+        _ = self.client  # ensure client is initialized
+        resolved = self._project_id or self.auth_manager.get_project_id()
+        if not resolved:
+            raise ApiError(body="No project ID available")
+        return resolved
+
+    def _create_client(self) -> DGClient:
+        """Create authenticated Deepgram client."""
+        self.auth_manager.guard()
+        api_key = self.auth_manager.get_api_key()
+        project_id = self.auth_manager.get_project_id()
+
+        if not api_key:
+            raise ApiError(body="No API key available")
+
+        current_profile = self.config.get_profile()
+
+        try:
+            kwargs: dict[str, Any] = {"api_key": api_key}
+
+            if (
+                current_profile.base_url
+                and current_profile.base_url != "https://api.deepgram.com"
+            ):
+                kwargs["environment"] = DeepgramClientEnvironment(
+                    base=current_profile.base_url,
+                    production=current_profile.base_url,
+                    agent=current_profile.base_url,
+                )
+
+            client = DGClient(**kwargs)
+            self._project_id = project_id
+            return client
+
+        except Exception as e:
+            console.print(f"[red]Error creating Deepgram client:[/red] {e}")
+            raise ApiError(body=f"Failed to create client: {e}")
+
+    # ── Speech-to-Text (pre-recorded) ──────────────────────────────
+
+    def transcribe_file(
+        self,
+        file_path: str | Path,
+        options: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Transcribe an audio file."""
+        file_path = Path(file_path)
+        if not file_path.exists():
+            raise FileNotFoundError(f"Audio file not found: {file_path}")
+
+        default_options: dict[str, Any] = {
+            "model": "nova-3",
+            "smart_format": True,
+            "language": "en-US",
+        }
+        if options:
+            default_options.update(options)
+
+        try:
+            with open(file_path, "rb") as audio_file:
+                audio_data = audio_file.read()
+
+            response = self.client.listen.v1.media.transcribe_file(
+                request=audio_data, **default_options
+            )
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Transcription failed: {e}")
+
+    def transcribe_url(
+        self, url: str, options: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        """Transcribe audio from URL."""
+        default_options: dict[str, Any] = {
+            "model": "nova-3",
+            "smart_format": True,
+            "language": "en-US",
+        }
+        if options:
+            default_options.update(options)
+
+        try:
+            response = self.client.listen.v1.media.transcribe_url(
+                url=url, **default_options
+            )
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Transcription failed: {e}")
+
+    # ── Text-to-Speech ─────────────────────────────────────────────
+
+    def speak_text(
+        self,
+        text: str,
+        model: str = "aura-2-asteria-en",
+        encoding: str | None = None,
+        container: str | None = None,
+        sample_rate: float | None = None,
+    ) -> Iterator[bytes]:
+        """Generate speech audio from text. Returns an iterator of bytes."""
+        try:
+            kwargs: dict[str, Any] = {"text": text, "model": model}
+            if encoding:
+                kwargs["encoding"] = encoding
+            if container:
+                kwargs["container"] = container
+            if sample_rate:
+                kwargs["sample_rate"] = sample_rate
+
+            return cast(
+                "Iterator[bytes]", self.client.speak.v1.audio.generate(**kwargs)
+            )
+
+        except Exception as e:
+            raise ApiError(body=f"Text-to-speech failed: {e}")
+
+    # ── Text Intelligence (Read) ───────────────────────────────────
+
+    def analyze_text(
+        self,
+        text: str,
+        sentiment: bool = False,
+        summarize: bool = False,
+        topics: bool = False,
+        intents: bool = False,
+        language: str | None = None,
+    ) -> dict[str, Any]:
+        """Analyze text for sentiment, topics, intents, summary."""
+        try:
+            from deepgram.requests.read_v1request_text import ReadV1RequestTextParams
+
+            kwargs: dict[str, Any] = {
+                "request": ReadV1RequestTextParams(text=text),
+            }
+            if sentiment:
+                kwargs["sentiment"] = True
+            if summarize:
+                kwargs["summarize"] = "v2"
+            if topics:
+                kwargs["topics"] = True
+            if intents:
+                kwargs["intents"] = True
+            kwargs["language"] = language or "en"
+
+            response = self.client.read.v1.text.analyze(**kwargs)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Text analysis failed: {e}")
+
+    # ── Models ─────────────────────────────────────────────────────
+
+    def list_models(self, include_outdated: bool = False) -> dict[str, Any]:
+        """List all public models."""
+        try:
+            kwargs: dict[str, Any] = {}
+            if include_outdated:
+                kwargs["include_outdated"] = True
+
+            response = self.client.manage.v1.models.list(**kwargs)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to list models: {e}")
+
+    def get_model(self, model_id: str) -> dict[str, Any]:
+        """Get a specific model by ID."""
+        try:
+            response = self.client.manage.v1.models.get(model_id)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to get model: {e}")
+
+    # ── Projects ───────────────────────────────────────────────────
+
+    def get_projects(self) -> dict[str, Any]:
+        """Get user's projects."""
+        try:
+            response = self.client.manage.v1.projects.list()
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to get projects: {e}")
+
+    def get_project(self, project_id: str | None = None) -> dict[str, Any]:
+        """Get specific project."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.get(pid)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to get project: {e}")
+
+    def create_project(self, name: str, company: str | None = None) -> dict[str, Any]:
+        """Create a new project."""
+        try:
+            project_data: dict[str, str] = {"name": name}
+            if company:
+                project_data["company"] = company
+
+            response = self.client.manage.v1.projects.update(request=project_data)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to create project: {e}")
+
+    # ── Usage ──────────────────────────────────────────────────────
+
+    def get_usage(
+        self,
+        project_id: str | None = None,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> dict[str, Any]:
+        """Get usage statistics."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            kwargs: dict[str, Any] = {}
+            if start_date:
+                kwargs["start"] = start_date
+            if end_date:
+                kwargs["end"] = end_date
+
+            response = self.client.manage.v1.projects.usage.get(pid, **kwargs)
+            result = cast("dict[str, Any]", response.model_dump())
+            result["project_id"] = pid
+            return result
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to get usage: {e}")
+
+    # ── API Keys ───────────────────────────────────────────────────
+
+    def list_keys(
+        self,
+        project_id: str | None = None,
+        status: str | None = None,
+    ) -> dict[str, Any]:
+        """List API keys for a project."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            kwargs: dict[str, Any] = {}
+            if status:
+                kwargs["status"] = status
+
+            response = self.client.manage.v1.projects.keys.list(pid, **kwargs)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to list keys: {e}")
+
+    def create_key(
+        self,
+        project_id: str | None = None,
+        comment: str = "",
+        scopes: list[str] | None = None,
+        expiration_date: str | None = None,
+        time_to_live: int | None = None,
+        tags: list[str] | None = None,
+    ) -> dict[str, Any]:
+        """Create a new API key."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            request_data: dict[str, Any] = {
+                "comment": comment,
+                "scopes": scopes or ["member"],
+            }
+            if expiration_date:
+                request_data["expiration_date"] = expiration_date
+            if time_to_live:
+                request_data["time_to_live_in_seconds"] = time_to_live
+            if tags:
+                request_data["tags"] = tags
+
+            response = self.client.manage.v1.projects.keys.create(
+                pid, request=request_data
+            )
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to create key: {e}")
+
+    def get_key(self, key_id: str, project_id: str | None = None) -> dict[str, Any]:
+        """Get a specific API key."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.keys.get(pid, key_id)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to get key: {e}")
+
+    def delete_key(self, key_id: str, project_id: str | None = None) -> dict[str, Any]:
+        """Delete an API key."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.keys.delete(pid, key_id)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to delete key: {e}")
+
+    # ── Requests ───────────────────────────────────────────────────
+
+    def list_requests(
+        self,
+        project_id: str | None = None,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        limit: int | None = None,
+        page: int | None = None,
+        status: str | None = None,
+        endpoint: str | None = None,
+        method: str | None = None,
+    ) -> dict[str, Any]:
+        """List API requests for a project."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            kwargs: dict[str, Any] = {}
+            if start:
+                kwargs["start"] = start
+            if end:
+                kwargs["end"] = end
+            if limit:
+                kwargs["limit"] = limit
+            if page:
+                kwargs["page"] = page
+            if status:
+                kwargs["status"] = status
+            if endpoint:
+                kwargs["endpoint"] = endpoint
+            if method:
+                kwargs["method"] = method
+
+            response = self.client.manage.v1.projects.requests.list(pid, **kwargs)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to list requests: {e}")
+
+    def get_request(
+        self, request_id: str, project_id: str | None = None
+    ) -> dict[str, Any]:
+        """Get a specific API request."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.requests.get(pid, request_id)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to get request: {e}")
+
+    # ── Billing ────────────────────────────────────────────────────
+
+    def get_billing_breakdown(
+        self,
+        project_id: str | None = None,
+        start: str | None = None,
+        end: str | None = None,
+        grouping: str | None = None,
+    ) -> dict[str, Any]:
+        """Get billing breakdown for a project."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            kwargs: dict[str, Any] = {}
+            if start:
+                kwargs["start"] = start
+            if end:
+                kwargs["end"] = end
+            if grouping:
+                kwargs["grouping"] = grouping
+
+            response = self.client.manage.v1.projects.billing.breakdown.list(
+                pid, **kwargs
+            )
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to get billing breakdown: {e}")
+
+    def get_balances(self, project_id: str | None = None) -> dict[str, Any]:
+        """Get project balances."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.billing.balances.list(pid)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to get balances: {e}")
+
+    # ── Members ────────────────────────────────────────────────────
+
+    def list_members(self, project_id: str | None = None) -> dict[str, Any]:
+        """List project members."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.members.list(pid)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to list members: {e}")
+
+    def remove_member(
+        self, member_id: str, project_id: str | None = None
+    ) -> dict[str, Any]:
+        """Remove a member from the project."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.members.delete(pid, member_id)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to remove member: {e}")
+
+    def list_member_scopes(
+        self, member_id: str, project_id: str | None = None
+    ) -> dict[str, Any]:
+        """List scopes for a project member."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.members.scopes.list(
+                pid, member_id
+            )
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to list member scopes: {e}")
+
+    def update_member_scopes(
+        self, member_id: str, scope: str, project_id: str | None = None
+    ) -> dict[str, Any]:
+        """Update scopes for a project member."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.members.scopes.update(
+                pid, member_id, scope=scope
+            )
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to update member scopes: {e}")
+
+    # ── Invites ────────────────────────────────────────────────────
+
+    def list_invites(self, project_id: str | None = None) -> dict[str, Any]:
+        """List project invites."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.members.invites.list(pid)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to list invites: {e}")
+
+    def create_invite(
+        self, email: str, scope: str, project_id: str | None = None
+    ) -> dict[str, Any]:
+        """Invite a member to the project."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.members.invites.create(
+                pid, email=email, scope=scope
+            )
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to create invite: {e}")
+
+    def delete_invite(
+        self, email: str, project_id: str | None = None
+    ) -> dict[str, Any]:
+        """Delete a project invite."""
+        pid = self._resolve_project_id(project_id)
+        try:
+            response = self.client.manage.v1.projects.members.invites.delete(pid, email)
+            return cast("dict[str, Any]", response.model_dump())
+
+        except Exception as e:
+            raise ApiError(body=f"Failed to delete invite: {e}")
+
+    # ── Utilities ──────────────────────────────────────────────────
+
+    def validate_api_key(self, api_key: str | None = None) -> bool:
+        """Validate API key by making a simple API call."""
+        project_id = self.auth_manager.get_project_id()
+        success, _, _ = self.auth_manager.verify_credentials(
+            api_key=api_key, project_id=project_id
+        )
+        return success
+
+    def test_connection(self) -> bool:
+        """Test connection to Deepgram API."""
+        success, message, _ = self.auth_manager.verify_credentials()
+        if not success:
+            console.print(f"[red]Connection test failed:[/red] {message}")
+        return success

{deepctl_core-0.2.0 → deepctl_core-0.2.2}/src/deepctl_core/output.py

@@ -1,6 +1,8 @@
 """Output formatting utilities for deepctl."""
 
 import json
+import os
+import sys
 from io import StringIO
 from typing import Any
 
@@ -18,16 +20,42 @@ from rich.progress import (
 from rich.syntax import Syntax
 from rich.table import Table
 
-# Global console instance
-console = Console()
-stderr_console = Console(stderr=True)
+# ── Agentic / non-TTY detection ──────────────────────────────────
+
+_AGENTIC_ENV_VARS = (
+    "CLAUDE_CODE",
+    "CODEX_CLI",
+    "GEMINI_CLI",
+    "AIDER",
+    "CONTINUE_GLOBAL_DIR",
+)
+
+
+def is_agentic() -> bool:
+    """Detect if running inside an AI coding tool or non-interactive pipe.
+
+    Returns True when stdout is not a terminal OR a known agentic
+    environment variable is set.  This lets commands produce
+    machine-friendly output automatically.
+    """
+    if not sys.stdout.isatty():
+        return True
+    return any(os.environ.get(v) for v in _AGENTIC_ENV_VARS)
+
+
+_agentic = is_agentic()
+
+# Global console instance — plain when agentic, rich when interactive
+console = Console(no_color=_agentic, highlight=not _agentic)
+stderr_console = Console(stderr=True, no_color=_agentic, highlight=not _agentic)
 
 # Global output configuration
-_output_config = {
+_output_config: dict[str, Any] = {
     "format": "default",
     "quiet": False,
     "verbose": False,
-    "color": True,
+    "color": not _agentic,
+    "agentic": _agentic,
 }
 
 
@@ -36,11 +64,14 @@ def setup_output(
 ) -> None:
     """Setup global output configuration.
 
-    Args:
-        format_type: Output format (json, yaml, table, csv)
-        quiet: Suppress non-essential output
-        verbose: Enable verbose output
+    When running in an agentic/non-TTY context and no explicit format is
+    requested (format_type == "default"), auto-switch to JSON for
+    machine-friendly output.
     """
+    # Auto-default to JSON in agentic mode when user didn't pick a format
+    if format_type == "default" and _output_config["agentic"]:
+        format_type = "json"
+
     _output_config.update({"format": format_type, "quiet": quiet, "verbose": verbose})
 
     # Update console settings
@@ -273,42 +304,38 @@ def print_output(data: Any, format_type: str | None = None) -> None:
 
 
 def print_success(message: str) -> None:
-    """Print success message.
-
-    Args:
-        message: Success message
-    """
+    """Print success message."""
     if not _output_config["quiet"]:
-        console.print(f"[green]✓[/green] {message}")
+        if _output_config["agentic"]:
+            stderr_console.print(f"OK: {message}")
+        else:
+            console.print(f"[green]✓[/green] {message}")
 
 
 def print_error(message: str) -> None:
-    """Print error message.
-
-    Args:
-        message: Error message
-    """
-    stderr_console.print(f"[red]✗[/red] {message}")
+    """Print error message."""
+    if _output_config["agentic"]:
+        stderr_console.print(f"ERROR: {message}")
+    else:
+        stderr_console.print(f"[red]✗[/red] {message}")
 
 
 def print_warning(message: str) -> None:
-    """Print warning message.
-
-    Args:
-        message: Warning message
-    """
+    """Print warning message."""
     if not _output_config["quiet"]:
-        console.print(f"[yellow]⚠[/yellow] {message}")
+        if _output_config["agentic"]:
+            stderr_console.print(f"WARN: {message}")
+        else:
+            console.print(f"[yellow]⚠[/yellow] {message}")
 
 
 def print_info(message: str) -> None:
-    """Print info message.
-
-    Args:
-        message: Info message
-    """
+    """Print info message."""
     if not _output_config["quiet"]:
-        console.print(f"[blue]ℹ[/blue] {message}")
+        if _output_config["agentic"]:
+            stderr_console.print(f"INFO: {message}")
+        else:
+            console.print(f"[blue]ℹ[/blue] {message}")
 
 
 def print_debug(message: str) -> None:

{deepctl_core-0.2.0 → deepctl_core-0.2.2}/src/deepctl_core/skill_generator.py

@@ -43,6 +43,9 @@ class CommandMetadata:
 
 _SKILLS_DIR = Path.home() / ".deepctl" / "skills"
 _STATE_FILE = _SKILLS_DIR / "skills.json"
+_REPO_CACHE_DIR = _SKILLS_DIR / "repo_cache"
+_SKILLS_REPO = "deepgram/skills"
+_SKILLS_BRANCH = "main"
 
 
 def get_skills_state() -> dict[str, Any]:
@@ -60,6 +63,56 @@ def save_skills_state(state: dict[str, Any]) -> None:
     _STATE_FILE.write_text(json.dumps(state, indent=2))
 
 
+def fetch_repo_skills(force: bool = False) -> dict[str, str]:
+    """Download skill markdown files from the deepgram/skills GitHub repo.
+
+    Returns a mapping of skill name -> markdown content.
+    Caches locally to avoid repeated network requests.
+    """
+    import urllib.request
+
+    cache_marker = _REPO_CACHE_DIR / ".fetched"
+    if not force and cache_marker.exists():
+        # Return cached content
+        return _read_cached_skills()
+
+    base = f"https://raw.githubusercontent.com/{_SKILLS_REPO}/{_SKILLS_BRANCH}"
+    skill_names = ["api", "docs", "starters", "mcp"]
+    skills: dict[str, str] = {}
+
+    _REPO_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    for name in skill_names:
+        url = f"{base}/skills/{name}/SKILL.md"
+        try:
+            with urllib.request.urlopen(url, timeout=10) as resp:
+                content = resp.read().decode("utf-8")
+            skills[name] = content
+            (  # Cache to disk
+                _REPO_CACHE_DIR / f"{name}.md"
+            ).write_text(content)
+        except Exception:
+            # Use cached version if available
+            cached = _REPO_CACHE_DIR / f"{name}.md"
+            if cached.exists():
+                skills[name] = cached.read_text()
+
+    if skills:
+        cache_marker.write_text("1")
+
+    return skills
+
+
+def _read_cached_skills() -> dict[str, str]:
+    """Read previously cached repo skills."""
+    skills: dict[str, str] = {}
+    if not _REPO_CACHE_DIR.exists():
+        return skills
+    for md_file in _REPO_CACHE_DIR.glob("*.md"):
+        skills[md_file.stem] = md_file.read_text()
+    return skills
+
+
 def _commands_hash(commands: list[CommandMetadata]) -> str:
     """Compute a deterministic hash of the command set."""
     blob = json.dumps(

{deepctl_core-0.2.0 → deepctl_core-0.2.2}/src/deepctl_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepctl-core
-Version: 0.2.0
+Version: 0.2.2
 Summary: Core components for deepctl
 Author-email: Deepgram <devrel@deepgram.com>
 Maintainer-email: Deepgram <devrel@deepgram.com>

deepctl_core-0.2.0/src/deepctl_core/client.py

@@ -1,305 +0,0 @@
-"""Deepgram SDK wrapper for deepctl with authentication integration."""
-
-from pathlib import Path
-from typing import Any, cast
-
-from deepgram import DeepgramClient as DGClient
-from deepgram import DeepgramClientEnvironment
-from deepgram.core.api_error import ApiError
-from rich.console import Console
-
-from .auth import AuthManager
-from .config import Config
-
-console = Console()
-
-
-class DeepgramClient:
-    """Wrapper around Deepgram SDK with authentication integration."""
-
-    def __init__(self, config: Config, auth_manager: AuthManager):
-        """Initialize Deepgram client.
-
-        Args:
-            config: Configuration manager
-            auth_manager: Authentication manager
-        """
-        self.config = config
-        self.auth_manager = auth_manager
-        self._client: DGClient | None = None
-        self._project_id: str | None = None
-
-    @property
-    def client(self) -> DGClient:
-        """Get authenticated Deepgram client."""
-        if self._client is None:
-            self._client = self._create_client()
-        return self._client
-
-    def _create_client(self) -> DGClient:
-        """Create authenticated Deepgram client."""
-        # Ensure user is authenticated and credentials are valid
-        self.auth_manager.guard()
-
-        # Get API key and project ID
-        api_key = self.auth_manager.get_api_key()
-        project_id = self.auth_manager.get_project_id()
-
-        if not api_key:
-            raise ApiError(body="No API key available")
-
-        # Create client with configuration
-        current_profile = self.config.get_profile()
-
-        try:
-            kwargs: dict[str, Any] = {"api_key": api_key}
-
-            # Use a custom environment when a non-default base URL is
-            # configured.
-            if (
-                current_profile.base_url
-                and current_profile.base_url != "https://api.deepgram.com"
-            ):
-                kwargs["environment"] = DeepgramClientEnvironment(
-                    base=current_profile.base_url,
-                    production=current_profile.base_url,
-                    agent=current_profile.base_url,
-                )
-
-            client = DGClient(**kwargs)
-
-            # Store project ID for later use
-            self._project_id = project_id
-
-            return client
-
-        except Exception as e:
-            console.print(f"[red]Error creating Deepgram client:[/red] {e}")
-            raise ApiError(body=f"Failed to create client: {e}")
-
-    def transcribe_file(
-        self,
-        file_path: str | Path,
-        options: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """Transcribe an audio file.
-
-        Args:
-            file_path: Path to audio file
-            options: Transcription options
-
-        Returns:
-            Transcription results
-        """
-        file_path = Path(file_path)
-
-        if not file_path.exists():
-            raise FileNotFoundError(f"Audio file not found: {file_path}")
-
-        # Default options
-        default_options: dict[str, Any] = {
-            "model": "nova-3",
-            "smart_format": True,
-            "language": "en-US",
-        }
-
-        if options:
-            default_options.update(options)
-
-        try:
-            with open(file_path, "rb") as audio_file:
-                audio_data = audio_file.read()
-
-            response = self.client.listen.v1.media.transcribe_file(
-                request=audio_data, **default_options
-            )
-
-            return cast("dict[str, Any]", response.model_dump())
-
-        except Exception as e:
-            console.print(f"[red]Error transcribing file:[/red] {e}")
-            raise ApiError(body=f"Transcription failed: {e}")
-
-    def transcribe_url(
-        self, url: str, options: dict[str, Any] | None = None
-    ) -> dict[str, Any]:
-        """Transcribe audio from URL.
-
-        Args:
-            url: URL to audio file
-            options: Transcription options
-
-        Returns:
-            Transcription results
-        """
-        # Default options
-        default_options: dict[str, Any] = {
-            "model": "nova-3",
-            "smart_format": True,
-            "language": "en-US",
-        }
-
-        if options:
-            default_options.update(options)
-
-        try:
-            response = self.client.listen.v1.media.transcribe_url(
-                url=url, **default_options
-            )
-
-            return cast("dict[str, Any]", response.model_dump())
-
-        except Exception as e:
-            console.print(f"[red]Error transcribing URL:[/red] {e}")
-            raise ApiError(body=f"Transcription failed: {e}")
-
-    def get_projects(self) -> dict[str, Any]:
-        """Get user's projects.
-
-        Returns:
-            Projects data
-        """
-        try:
-            response = self.client.manage.v("1").get_projects()
-            return cast("dict[str, Any]", response.model_dump())
-
-        except Exception as e:
-            console.print(f"[red]Error getting projects:[/red] {e}")
-            raise ApiError(body=f"Failed to get projects: {e}")
-
-    def get_project(self, project_id: str | None = None) -> dict[str, Any]:
-        """Get specific project.
-
-        Args:
-            project_id: Project ID (uses configured project if not
-                provided)
-
-        Returns:
-            Project data
-        """
-        if not project_id:
-            # Ensure client is initialized which sets _project_id
-            _ = self.client
-            project_id = self._project_id or self.auth_manager.get_project_id()
-
-        if not project_id:
-            raise ApiError(body="No project ID available")
-
-        try:
-            response = self.client.manage.v("1").get_project(project_id)
-            return cast("dict[str, Any]", response.model_dump())
-
-        except Exception as e:
-            console.print(f"[red]Error getting project:[/red] {e}")
-            raise ApiError(body=f"Failed to get project: {e}")
-
-    def create_project(self, name: str, company: str | None = None) -> dict[str, Any]:
-        """Create a new project.
-
-        Args:
-            name: Project name
-            company: Company name
-
-        Returns:
-            Created project data
-        """
-        try:
-            project_data = {"name": name}
-            if company:
-                project_data["company"] = company
-
-            response = self.client.manage.v("1").create_project(project_data)
-            return cast("dict[str, Any]", response.model_dump())
-
-        except Exception as e:
-            console.print(f"[red]Error creating project:[/red] {e}")
-            raise ApiError(body=f"Failed to create project: {e}")
-
-    def get_usage(
-        self,
-        project_id: str | None = None,
-        start_date: str | None = None,
-        end_date: str | None = None,
-    ) -> dict[str, Any]:
-        """Get usage statistics.
-
-        Args:
-            project_id: Project ID (uses configured project if not
-                provided)
-            start_date: Start date (ISO format)
-            end_date: End date (ISO format)
-
-        Returns:
-            Usage data
-        """
-        if not project_id:
-            _ = self.client
-            project_id = self._project_id or self.auth_manager.get_project_id()
-
-        if not project_id:
-            raise ApiError(body="No project ID available")
-
-        try:
-            params: dict[str, str] = {}
-            if start_date:
-                params["start"] = start_date
-            if end_date:
-                params["end"] = end_date
-
-            response = self.client.manage.v("1").get_usage_summary(project_id, params)
-            result = cast("dict[str, Any]", response.model_dump())
-            result["project_id"] = project_id
-            return result
-
-        except Exception as e:
-            console.print(f"[red]Error getting usage:[/red] {e}")
-            raise ApiError(body=f"Failed to get usage: {e}")
-
-    def get_models(self, project_id: str | None = None) -> dict[str, Any]:
-        """Get available models.
-
-        Args:
-            project_id: Project ID (uses configured project if not
-                provided)
-
-        Returns:
-            Models data
-        """
-        if not project_id:
-            _ = self.client
-            project_id = self._project_id or self.auth_manager.get_project_id()
-
-        try:
-            response = self.client.manage.v("1").get_project(project_id)
-            return cast("dict[str, Any]", response.model_dump())
-
-        except Exception as e:
-            console.print(f"[red]Error getting models:[/red] {e}")
-            raise ApiError(body=f"Failed to get models: {e}")
-
-    def validate_api_key(self, api_key: str | None = None) -> bool:
-        """Validate API key by making a simple API call.
-
-        Args:
-            api_key: API key to validate (uses configured key if not
-                provided)
-
-        Returns:
-            True if valid, False otherwise
-        """
-        project_id = self.auth_manager.get_project_id()
-        success, _, _ = self.auth_manager.verify_credentials(
-            api_key=api_key, project_id=project_id
-        )
-        return success
-
-    def test_connection(self) -> bool:
-        """Test connection to Deepgram API.
-
-        Returns:
-            True if connection successful, False otherwise
-        """
-        success, message, _ = self.auth_manager.verify_credentials()
-        if not success:
-            console.print(f"[red]Connection test failed:[/red] {message}")
-        return success