steerdev 0.4.27__py3-none-any.whl

steerdev_agent/api/configs.py

@@ -0,0 +1,238 @@
+"""Agent configuration sync client for platform configs and workflows."""
+
+from typing import Any, Self
+
+import httpx
+from loguru import logger
+
+from steerdev_agent.api.client import get_api_endpoint, get_api_key, get_project_id
+from steerdev_agent.config.platform import PlatformConfig, WorkflowConfig
+
+
+class ConfigsClient:
+    """Async HTTP client for syncing agent configurations from platform.
+
+    Manages fetching platform configs (system prompts, skills, MCPs, env vars)
+    and workflow definitions for agent startup and execution.
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        project_id: str | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        """Initialize the client.
+
+        Args:
+            api_key: API key for authentication. If not provided, reads from STEERDEV_API_KEY.
+            project_id: Project ID to sync configs for. If not provided, reads from STEERDEV_PROJECT_ID.
+            timeout: Request timeout in seconds.
+        """
+        self.api_key = api_key or get_api_key()
+        self.project_id = project_id or get_project_id()
+        self.api_base = get_api_endpoint()
+        self.timeout = timeout
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def headers(self) -> dict[str, str]:
+        """Get request headers with authentication."""
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create async HTTP client."""
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=self.timeout)
+        return self._client
+
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        if self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    async def __aenter__(self) -> Self:
+        """Enter async context manager."""
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Exit async context manager."""
+        await self.close()
+
+    async def sync_configs(self, project_id: str | None = None) -> PlatformConfig | None:
+        """Sync all active configurations from platform.
+
+        Args:
+            project_id: Override project ID for this request.
+
+        Returns:
+            PlatformConfig with all synced configs, or None on failure.
+        """
+        project_id = project_id or self.project_id
+        if not project_id:
+            logger.error("No project_id provided for config sync")
+            return None
+
+        client = await self._get_client()
+        logger.debug(f"Syncing configs for project {project_id}")
+
+        try:
+            response = await client.get(
+                f"{self.api_base}/configs/sync",
+                headers=self.headers,
+                params={"project_id": project_id},
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                config = PlatformConfig.from_api_response(data)
+                logger.info(
+                    f"Synced configs: {len(config.system_prompts)} prompts, "
+                    f"{len(config.skills)} skills, {len(config.mcps)} MCPs, "
+                    f"{len(config.env_vars)} env var sets"
+                )
+                return config
+
+            logger.error(f"Failed to sync configs: {response.status_code} - {response.text}")
+            return None
+
+        except httpx.RequestError as e:
+            logger.error(f"Request error syncing configs: {e}")
+            return None
+
+    async def get_workflow(
+        self,
+        workflow_id: str,
+    ) -> WorkflowConfig | None:
+        """Get a specific workflow by ID.
+
+        Args:
+            workflow_id: Workflow ID to fetch.
+
+        Returns:
+            WorkflowConfig or None if not found.
+        """
+        client = await self._get_client()
+        logger.debug(f"Fetching workflow {workflow_id}")
+
+        try:
+            response = await client.get(
+                f"{self.api_base}/workflows/{workflow_id}",
+                headers=self.headers,
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                return WorkflowConfig.from_api_response(data)
+
+            if response.status_code == 404:
+                logger.warning(f"Workflow {workflow_id} not found")
+                return None
+
+            logger.error(f"Failed to get workflow: {response.status_code} - {response.text}")
+            return None
+
+        except httpx.RequestError as e:
+            logger.error(f"Request error getting workflow: {e}")
+            return None
+
+    async def get_default_workflow(
+        self,
+        project_id: str | None = None,
+    ) -> WorkflowConfig | None:
+        """Get the default workflow for a project.
+
+        Args:
+            project_id: Override project ID for this request.
+
+        Returns:
+            WorkflowConfig or None if no default workflow exists.
+        """
+        project_id = project_id or self.project_id
+        if not project_id:
+            logger.error("No project_id provided for getting default workflow")
+            return None
+
+        client = await self._get_client()
+        logger.debug(f"Fetching default workflow for project {project_id}")
+
+        try:
+            response = await client.get(
+                f"{self.api_base}/workflows",
+                headers=self.headers,
+                params={"project_id": project_id},
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                workflows = data.get("workflows", [])
+
+                # Find the default workflow
+                for wf in workflows:
+                    if wf.get("is_default"):
+                        return WorkflowConfig.from_api_response(wf)
+
+                # If no default, return the first workflow if any
+                if workflows:
+                    logger.debug("No default workflow found, using first available")
+                    return WorkflowConfig.from_api_response(workflows[0])
+
+                logger.debug("No workflows found for project")
+                return None
+
+            logger.error(f"Failed to list workflows: {response.status_code} - {response.text}")
+            return None
+
+        except httpx.RequestError as e:
+            logger.error(f"Request error listing workflows: {e}")
+            return None
+
+    async def list_workflows(
+        self,
+        project_id: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> list[WorkflowConfig]:
+        """List all workflows for a project.
+
+        Args:
+            project_id: Override project ID for this request.
+            limit: Maximum number of workflows to return.
+            offset: Offset for pagination.
+
+        Returns:
+            List of WorkflowConfig objects.
+        """
+        project_id = project_id or self.project_id
+        if not project_id:
+            logger.error("No project_id provided for listing workflows")
+            return []
+
+        client = await self._get_client()
+        logger.debug(f"Listing workflows for project {project_id}")
+
+        try:
+            response = await client.get(
+                f"{self.api_base}/workflows",
+                headers=self.headers,
+                params={"project_id": project_id, "limit": limit, "offset": offset},
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                workflows = [
+                    WorkflowConfig.from_api_response(wf) for wf in data.get("workflows", [])
+                ]
+                logger.debug(f"Found {len(workflows)} workflows")
+                return workflows
+
+            logger.error(f"Failed to list workflows: {response.status_code} - {response.text}")
+            return []
+
+        except httpx.RequestError as e:
+            logger.error(f"Request error listing workflows: {e}")
+            return []

steerdev_agent/api/context.py

@@ -0,0 +1,306 @@
+"""Context API client for SteerDev Agent.
+
+Provides methods for retrieving and managing project context
+(tech stack, patterns, structure, etc.) for AI agents.
+
+The Codebase Awareness feature provides:
+- Tech stack detection (frameworks, libraries, tools)
+- Directory structure analysis
+- Code patterns and conventions
+- Dependencies mapping
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+from rich.console import Console
+from rich.panel import Panel
+
+from steerdev_agent.api.client import SteerDevClient, get_project_id
+
+console = Console()
+
+
+class TechStackInfo(BaseModel):
+    """Tech stack detection result."""
+
+    framework: dict[str, Any] | None = None
+    language: dict[str, Any] | None = None
+    database: dict[str, Any] | None = None
+    auth: dict[str, Any] | None = None
+    styling: dict[str, Any] | None = None
+    testing: dict[str, Any] | None = None
+    package_manager: str | None = Field(default=None, alias="packageManager")
+    build_tool: str | None = Field(default=None, alias="buildTool")
+
+
+class StructureInfo(BaseModel):
+    """Directory structure analysis."""
+
+    type: str = "single"
+    directories: list[dict[str, Any]] = Field(default_factory=list)
+    entry_points: list[str] = Field(default_factory=list, alias="entryPoints")
+    config_files: list[str] = Field(default_factory=list, alias="configFiles")
+
+
+class PatternsInfo(BaseModel):
+    """Code patterns and conventions."""
+
+    naming: dict[str, str] = Field(default_factory=dict)
+    architecture: list[str] = Field(default_factory=list)
+    conventions: list[dict[str, Any]] = Field(default_factory=list)
+    abstractions: dict[str, list[str]] = Field(default_factory=dict)
+
+
+class CodebaseContext(BaseModel):
+    """Codebase context model - full analysis result."""
+
+    project_id: str
+    repositories: list[dict[str, Any]] = Field(default_factory=list)
+    context: dict[str, Any] | None = None
+    status: str
+    last_analyzed_at: str | None = None
+    error: str | None = None
+
+
+class ContextClient(SteerDevClient):
+    """Client for project context operations.
+
+    Provides methods to retrieve and refresh project context
+    that helps AI agents understand the codebase.
+    """
+
+    def get_context(
+        self, project_id: str | None = None, format: str = "json"
+    ) -> dict[str, Any] | str | None:
+        """Get project context.
+
+        Args:
+            project_id: Project ID. Falls back to STEERDEV_PROJECT_ID env var.
+            format: Response format - "json" or "markdown".
+
+        Returns:
+            Project context (dict for JSON, str for markdown) or None if not found.
+        """
+        effective_project_id = project_id or get_project_id()
+        if not effective_project_id:
+            console.print(
+                "[red]Error: project_id is required. "
+                "Use --project-id or set STEERDEV_PROJECT_ID environment variable[/red]"
+            )
+            return None
+
+        console.print(
+            f"Fetching context for project {effective_project_id} "
+            f"from {self.api_base}/context?project_id={effective_project_id}"
+        )
+        response = self.get(f"/context?project_id={effective_project_id}&format={format}")
+
+        if response.status_code == 404:
+            console.print(f"[yellow]No context found for project {effective_project_id}[/yellow]")
+            return None
+
+        if response.status_code != 200:
+            console.print(f"[red]API Error: {response.status_code} - {response.text}[/red]")
+            return None
+
+        # Return raw text for markdown format
+        if format == "markdown":
+            return response.text
+
+        return response.json()
+
+    def refresh_context(
+        self, project_id: str | None = None, force: bool = False
+    ) -> dict[str, Any] | None:
+        """Force refresh of project context.
+
+        Triggers a re-analysis of the project repositories to update cached context.
+
+        Args:
+            project_id: Project ID. Falls back to STEERDEV_PROJECT_ID env var.
+            force: Force re-analysis even if context is up to date.
+
+        Returns:
+            Analysis result dict or None on failure.
+        """
+        effective_project_id = project_id or get_project_id()
+        if not effective_project_id:
+            console.print(
+                "[red]Error: project_id is required. "
+                "Use --project-id or set STEERDEV_PROJECT_ID environment variable[/red]"
+            )
+            return None
+
+        console.print(
+            f"Refreshing context for project {effective_project_id} "
+            f"at {self.api_base}/context/analyze"
+        )
+        response = self.post(
+            "/context/analyze",
+            json={"project_id": effective_project_id, "force": force},
+        )
+
+        if response.status_code == 404:
+            console.print(f"[red]Error: Project '{effective_project_id}' not found[/red]")
+            return None
+
+        if response.status_code == 400:
+            error_data = response.json()
+            console.print(f"[red]Error: {error_data.get('error', 'Unknown error')}[/red]")
+            return None
+
+        if response.status_code not in (200, 201, 202):
+            console.print(f"[red]API Error: {response.status_code} - {response.text}[/red]")
+            return None
+
+        return response.json()
+
+
+def display_context(context: dict[str, Any]) -> None:
+    """Display project context in a formatted panel.
+
+    Args:
+        context: Project context dict from the API.
+    """
+    project_id = context.get("project_id", "Unknown")
+    status = context.get("status", "unknown")
+    ctx = context.get("context") or {}
+    repos = context.get("repositories", [])
+
+    # Build context info
+    info_lines = []
+
+    # Repositories
+    if repos:
+        info_lines.append("[bold cyan]Repositories:[/bold cyan]")
+        for repo in repos:
+            info_lines.append(f"  • {repo.get('full_name', 'unknown')}")
+        info_lines.append("")
+
+    # Summary (markdown)
+    if ctx.get("summary"):
+        info_lines.append("[bold cyan]Summary:[/bold cyan]")
+        # Truncate long summaries
+        summary = ctx["summary"]
+        lines = summary.split("\n")[:15]
+        for line in lines:
+            info_lines.append(f"  {line}")
+        if len(summary.split("\n")) > 15:
+            info_lines.append("  ...")
+        info_lines.append("")
+
+    # Tech stack
+    tech_stack = ctx.get("tech_stack", {})
+    if tech_stack:
+        info_lines.append("[bold cyan]Tech Stack:[/bold cyan]")
+        if tech_stack.get("framework"):
+            fw = tech_stack["framework"]
+            fw_str = fw.get("name", "")
+            if fw.get("version"):
+                fw_str += f" {fw['version']}"
+            if fw.get("router"):
+                fw_str += f" ({fw['router']})"
+            info_lines.append(f"  • Framework: {fw_str}")
+        if tech_stack.get("language"):
+            info_lines.append(f"  • Language: {tech_stack['language'].get('primary', 'unknown')}")
+        if tech_stack.get("database"):
+            db = tech_stack["database"]
+            db_str = db.get("name", "")
+            if db.get("client"):
+                db_str += f" ({db['client']})"
+            info_lines.append(f"  • Database: {db_str}")
+        if tech_stack.get("auth"):
+            info_lines.append(f"  • Auth: {tech_stack['auth'].get('provider', 'unknown')}")
+        if tech_stack.get("styling"):
+            style = tech_stack["styling"]
+            style_str = style.get("framework", "")
+            if style.get("ui"):
+                style_str += f" + {style['ui']}"
+            info_lines.append(f"  • Styling: {style_str}")
+        if tech_stack.get("testing"):
+            test = tech_stack["testing"]
+            test_parts = []
+            if test.get("framework"):
+                test_parts.append(test["framework"])
+            if test.get("e2e"):
+                test_parts.append(test["e2e"])
+            if test_parts:
+                info_lines.append(f"  • Testing: {' + '.join(test_parts)}")
+        if tech_stack.get("packageManager"):
+            info_lines.append(f"  • Package Manager: {tech_stack['packageManager']}")
+        info_lines.append("")
+
+    # Patterns
+    patterns = ctx.get("patterns", {})
+    if patterns:
+        arch = patterns.get("architecture", [])
+        if arch:
+            info_lines.append("[bold cyan]Architecture:[/bold cyan]")
+            for a in arch[:5]:
+                info_lines.append(f"  • {a}")
+            info_lines.append("")
+
+        conventions = patterns.get("conventions", [])
+        if conventions:
+            info_lines.append("[bold cyan]Conventions:[/bold cyan]")
+            for conv in conventions[:5]:
+                info_lines.append(f"  • {conv.get('pattern', '')}")
+            info_lines.append("")
+
+    # Structure (directories)
+    structure = ctx.get("structure", {})
+    if structure:
+        dirs = structure.get("directories", [])
+        if dirs:
+            info_lines.append("[bold cyan]Key Directories:[/bold cyan]")
+            for d in dirs[:6]:
+                path = d.get("path", "")
+                purpose = d.get("purpose", "")
+                info_lines.append(f"  • {path}: {purpose}")
+            if len(dirs) > 6:
+                info_lines.append(f"  ... and {len(dirs) - 6} more")
+            info_lines.append("")
+
+    # Status and metadata
+    status_color = {
+        "completed": "green",
+        "analyzing": "blue",
+        "pending": "yellow",
+        "failed": "red",
+    }.get(status, "white")
+    info_lines.append(f"[dim]Status: [{status_color}]{status}[/{status_color}][/dim]")
+
+    if context.get("last_analyzed_at"):
+        info_lines.append(f"[dim]Last analyzed: {context['last_analyzed_at']}[/dim]")
+
+    if context.get("error"):
+        info_lines.append(f"[red]Error: {context['error']}[/red]")
+
+    console.print(
+        Panel(
+            "\n".join(info_lines),
+            title=f"Codebase Context: {project_id[:8]}...",
+            border_style="blue",
+        )
+    )
+
+
+def display_context_refresh_success(project_id: str) -> None:
+    """Display context refresh success message.
+
+    Args:
+        project_id: Project ID that was refreshed.
+    """
+    console.print(
+        Panel(
+            f"[bold green]Context refresh initiated[/bold green]\n\n"
+            f"Project: {project_id}\n\n"
+            "The context will be updated in the background. "
+            "Run `steerdev context get` to retrieve the updated context.",
+            title="Success",
+            border_style="green",
+        )
+    )