steerdev 0.4.27__py3-none-any.whl

steerdev_agent/integration.py

@@ -0,0 +1,334 @@
+"""Integration test harness for steerdev.
+
+Creates a fresh Python project and adds tasks for building a todo-list API with SQLite.
+"""
+
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+import httpx
+import typer
+from rich import print as rprint
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+# Default test tasks for todo-list API
+DEFAULT_TASKS = [
+    {
+        "title": "Set up project with FastAPI and SQLite dependencies",
+        "prompt": """Set up the Python project for a todo-list API:
+1. Add dependencies to pyproject.toml: fastapi, uvicorn, sqlalchemy, pydantic
+2. Run `uv sync` to install them
+3. Create a basic src/todo_api/__init__.py file""",
+        "priority": 3,
+    },
+    {
+        "title": "Create SQLite database models",
+        "prompt": """Create the database layer in src/todo_api/database.py:
+1. Set up SQLAlchemy with SQLite (use 'todos.db' as the database file)
+2. Create a Todo model with fields: id (int, primary key), title (str), description (str, optional), completed (bool, default False), created_at (datetime)
+3. Add a function to initialize the database and create tables""",
+        "priority": 2,
+    },
+    {
+        "title": "Create Pydantic schemas",
+        "prompt": """Create Pydantic schemas in src/todo_api/schemas.py:
+1. TodoCreate schema for creating todos (title required, description optional)
+2. TodoUpdate schema for updating todos (all fields optional)
+3. TodoResponse schema for API responses (includes id, created_at, completed)""",
+        "priority": 2,
+    },
+    {
+        "title": "Implement CRUD API endpoints",
+        "prompt": """Create the FastAPI application in src/todo_api/main.py:
+1. Initialize FastAPI app with title "Todo API"
+2. Add startup event to initialize database
+3. Implement endpoints:
+   - GET /todos - list all todos
+   - POST /todos - create a todo
+   - GET /todos/{id} - get a single todo
+   - PATCH /todos/{id} - update a todo
+   - DELETE /todos/{id} - delete a todo
+4. Add proper error handling (404 for not found)""",
+        "priority": 2,
+    },
+    {
+        "title": "Add tests for the API",
+        "prompt": """Create tests in tests/test_api.py:
+1. Add pytest and httpx as dev dependencies
+2. Use FastAPI TestClient to test all endpoints
+3. Test cases: create todo, list todos, get single todo, update todo, delete todo, 404 handling
+4. Make sure tests are isolated (clean database between tests)""",
+        "priority": 1,
+    },
+]
+
+
+def log_info(msg: str) -> None:
+    rprint(f"[blue][INFO][/blue] {msg}")
+
+
+def log_success(msg: str) -> None:
+    rprint(f"[green][OK][/green] {msg}")
+
+
+def log_warn(msg: str) -> None:
+    rprint(f"[yellow][WARN][/yellow] {msg}")
+
+
+def log_error(msg: str) -> None:
+    rprint(f"[red][ERROR][/red] {msg}")
+
+
+def run_cmd(
+    cmd: list[str],
+    cwd: Path | None = None,
+    check: bool = True,
+    capture: bool = True,
+) -> subprocess.CompletedProcess:
+    """Run a command and return the result."""
+    return subprocess.run(
+        cmd,
+        cwd=cwd,
+        check=check,
+        capture_output=capture,
+        text=True,
+    )
+
+
+def create_project(project_dir: Path) -> None:
+    """Create a new Python project using uv init."""
+    log_info(f"Creating project at {project_dir}...")
+
+    if project_dir.exists():
+        log_warn(f"Directory exists, removing: {project_dir}")
+        shutil.rmtree(project_dir)
+
+    # Create with uv init
+    project_dir.parent.mkdir(parents=True, exist_ok=True)
+    run_cmd(["uv", "init", "--lib", str(project_dir)])
+
+    # Rename the default package to todo_api
+    src_dir = project_dir / "src"
+    default_pkg = src_dir / project_dir.name.replace("-", "_")
+    todo_pkg = src_dir / "todo_api"
+
+    if default_pkg.exists() and default_pkg != todo_pkg:
+        default_pkg.rename(todo_pkg)
+
+    # Update pyproject.toml to use todo_api
+    pyproject = project_dir / "pyproject.toml"
+    content = pyproject.read_text()
+    content = content.replace(
+        f'"{project_dir.name.replace("-", "_")}"',
+        '"todo_api"',
+    )
+    pyproject.write_text(content)
+
+    # Create tests directory
+    (project_dir / "tests").mkdir(exist_ok=True)
+    (project_dir / "tests" / "__init__.py").touch()
+
+    # Create .env.example
+    env_example = """\
+# SteerDev Agent Configuration
+# Copy this file to .env and fill in your values
+
+# Required: Your SteerDev API key (get from steerdev.com dashboard)
+STEERDEV_API_KEY=
+
+# Required: Project ID to fetch tasks from
+STEERDEV_PROJECT_ID=
+
+# Optional: API endpoint (defaults to production)
+# STEERDEV_API_ENDPOINT=https://steerdev.com/api/v1
+
+# Optional: Agent identification
+# STEERDEV_AGENT_ID=
+# STEERDEV_AGENT_NAME=
+
+# Optional: LLM API keys (for Claude Code / other agents)
+# ANTHROPIC_API_KEY=
+# OPENAI_API_KEY=
+
+# Optional: Notifications
+# DISCORD_BOT_TOKEN=
+# DISCORD_CHANNEL_ID=
+# SLACK_WEBHOOK_URL=
+"""
+    (project_dir / ".env.steerdev.example").write_text(env_example)
+
+    # Create .gitignore with common patterns
+    gitignore = """\
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+venv/
+*.egg-info/
+dist/
+build/
+
+# Environment
+.env
+.env.local
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+"""
+    (project_dir / ".gitignore").write_text(gitignore)
+
+    # Initialize git
+    run_cmd(["git", "init"], cwd=project_dir)
+    run_cmd(["git", "add", "-A"], cwd=project_dir)
+    run_cmd(["git", "commit", "-m", "Initial commit"], cwd=project_dir)
+
+    log_success("Project created")
+
+
+def add_tasks(
+    project_id: str,
+    tasks: list[dict],
+    api_key: str,
+    api_endpoint: str,
+) -> list[str]:
+    """Add tasks via the SteerDev API. Returns list of created task IDs."""
+    log_info(f"Adding {len(tasks)} tasks to project {project_id}...")
+
+    created_ids = []
+
+    for task in tasks:
+        title = task["title"]
+        prompt = task["prompt"]
+        priority = task.get("priority", 1)
+
+        log_info(f"Creating: {title}")
+
+        try:
+            response = httpx.post(
+                f"{api_endpoint}/tasks",
+                headers={
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "project_id": project_id,
+                    "title": title,
+                    "prompt": prompt,
+                    "priority": priority,
+                },
+                timeout=30,
+            )
+
+            if response.status_code == 201:
+                data = response.json()
+                task_id = data.get("id", "unknown")
+                created_ids.append(task_id)
+                log_success(f"Created: {task_id[:8]}...")
+            else:
+                log_error(f"Failed: {response.text}")
+
+        except httpx.RequestError as e:
+            log_error(f"Request failed: {e}")
+
+    return created_ids
+
+
+def start_agent(project_id: str, project_dir: Path) -> None:
+    """Start the steerdev."""
+    log_info("Starting steerdev...")
+
+    os.chdir(project_dir)
+    os.environ["STEERDEV_PROJECT_ID"] = project_id
+
+    subprocess.run(
+        ["steerdev", "run", "--project-id", project_id, "--workdir", str(project_dir)],
+        check=False,
+    )
+
+
+def run_integration_test(
+    project_id: str,
+    project_dir: Path,
+    tasks_file: Path | None = None,
+    skip_tasks: bool = False,
+    auto_start: bool = False,
+) -> None:
+    """Run the full integration test."""
+    # Get environment
+    api_key = os.environ.get("STEERDEV_API_KEY")
+    if not api_key:
+        log_error("STEERDEV_API_KEY environment variable is required")
+        raise typer.Exit(1)
+
+    api_endpoint = os.environ.get("STEERDEV_API_ENDPOINT", "https://steerdev.com/api/v1")
+
+    # Show config
+    rprint("")
+    rprint(Panel.fit("SteerDev Integration Test", style="bold blue"))
+    rprint("")
+
+    table = Table(show_header=False, box=None)
+    table.add_column("Key", style="dim")
+    table.add_column("Value")
+    table.add_row("Project ID", project_id)
+    table.add_row("Project Dir", str(project_dir))
+    table.add_row("API Endpoint", api_endpoint)
+    console.print(table)
+    rprint("")
+
+    # Check uv is installed
+    if shutil.which("uv") is None:
+        log_error("uv is required but not installed")
+        raise typer.Exit(1)
+
+    # Create project
+    create_project(project_dir)
+
+    # Add tasks
+    if not skip_tasks:
+        if tasks_file and tasks_file.exists():
+            tasks = json.loads(tasks_file.read_text())
+        else:
+            tasks = DEFAULT_TASKS
+
+        add_tasks(project_id, tasks, api_key, api_endpoint)
+    else:
+        log_warn("Skipping task creation (--skip-tasks)")
+
+    log_success("Integration test environment ready!")
+    rprint("")
+    rprint(f"Project created at: [bold]{project_dir}[/bold]")
+    rprint("")
+
+    # Start agent
+    if auto_start or typer.confirm("Start the agent now?", default=True):
+        start_agent(project_id, project_dir)
+    else:
+        log_info("Run manually with:")
+        rprint(f"  cd {project_dir}")
+        rprint(f"  steerdev run --project-id {project_id}")

steerdev_agent/prompt/__init__.py

@@ -0,0 +1,10 @@
+"""Prompt building module."""
+
+from steerdev_agent.prompt.builder import PromptBuilder, PromptContext
+from steerdev_agent.prompt.templates import PromptTemplates
+
+__all__ = [
+    "PromptBuilder",
+    "PromptContext",
+    "PromptTemplates",
+]

steerdev_agent/prompt/builder.py

@@ -0,0 +1,263 @@
+"""Dynamic prompt builder for agent execution."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from steerdev_agent.prompt.templates import PromptTemplates
+
+
+class ProjectContext(BaseModel):
+    """Project context for prompt building."""
+
+    id: str = Field(description="Project ID")
+    name: str = Field(description="Project name")
+    description: str = Field(default="", description="Project description")
+    working_directory: str = Field(default=".", description="Default working directory")
+    custom_instructions: str | None = Field(
+        default=None, description="Custom instructions for this project"
+    )
+
+
+class WaveContext(BaseModel):
+    """Wave context for prompt building."""
+
+    wave_number: int = Field(description="Current wave number")
+    total_waves: int = Field(description="Total number of waves")
+    wave_description: str = Field(default="", description="Description of this wave")
+    wave_tasks_summary: str = Field(default="", description="Summary of tasks in this wave")
+    completed_waves_summary: str = Field(default="", description="Summary of completed waves")
+
+
+class TaskContext(BaseModel):
+    """Task context for prompt building."""
+
+    id: str = Field(description="Task ID")
+    title: str = Field(description="Task title")
+    prompt: str = Field(description="Task prompt/description")
+    status: str = Field(default="unstarted", description="Task status")
+    priority: int = Field(default=3, description="Task priority (1=urgent, 4=low)")
+    working_directory: str | None = Field(default=None, description="Task working directory")
+    spec: str | None = Field(default=None, description="Technical specification")
+    metadata: dict[str, Any] | None = Field(default=None, description="Additional metadata")
+    wave: WaveContext | None = Field(
+        default=None, description="Wave context if task is part of a wave"
+    )
+
+
+class WorkflowContext(BaseModel):
+    """Workflow phase context for prompt building."""
+
+    phase_name: str = Field(description="Current workflow phase name")
+    phase_description: str = Field(default="", description="Phase description")
+    phase_instructions: str = Field(default="", description="Phase-specific instructions")
+
+
+class PromptContext(BaseModel):
+    """Complete context for building a prompt."""
+
+    project: ProjectContext | None = Field(default=None, description="Project context")
+    task: TaskContext | None = Field(default=None, description="Task context")
+    workflow: WorkflowContext | None = Field(default=None, description="Workflow context")
+    custom_instructions: str | None = Field(
+        default=None, description="Additional custom instructions"
+    )
+    resume_message: str | None = Field(
+        default=None, description="Message for resume (if resuming session)"
+    )
+
+
+class PromptBuilder:
+    """Builds prompts by combining context from various sources.
+
+    The builder combines:
+    - Project metadata and instructions
+    - Task details and requirements
+    - Workflow phase information
+    - Custom instructions
+
+    Into a single coherent prompt for the agent.
+    """
+
+    def __init__(self, templates: PromptTemplates | None = None) -> None:
+        """Initialize the prompt builder.
+
+        Args:
+            templates: Custom templates to use. Defaults to PromptTemplates.
+        """
+        self.templates = templates or PromptTemplates()
+
+    def build(self, context: PromptContext) -> str:
+        """Build a complete prompt from the context.
+
+        Args:
+            context: The prompt context containing all information.
+
+        Returns:
+            A formatted prompt string.
+        """
+        # Handle resume case
+        if context.resume_message:
+            return self._build_resume_prompt(context)
+
+        # Build components
+        project_info = self._build_project_info(context.project)
+        task_info = self._build_task_info(context.task, context.project)
+        instructions = self._build_instructions(context)
+
+        # Add workflow phase if present
+        if context.workflow:
+            workflow_info = self.templates.format_workflow_phase(
+                phase_name=context.workflow.phase_name,
+                phase_description=context.workflow.phase_description,
+                phase_instructions=context.workflow.phase_instructions,
+            )
+            task_info = f"{task_info}\n\n{workflow_info}"
+
+        return self.templates.format_system_prompt(
+            project_info=project_info,
+            task_info=task_info,
+            instructions=instructions,
+        )
+
+    def _build_resume_prompt(self, context: PromptContext) -> str:
+        """Build a prompt for resuming a session.
+
+        Args:
+            context: The prompt context.
+
+        Returns:
+            A resume prompt string.
+        """
+        message = context.resume_message or "Continue working on the task."
+        return self.templates.RESUME_PROMPT.format(message=message)
+
+    def _build_project_info(self, project: ProjectContext | None) -> str:
+        """Build project information section.
+
+        Args:
+            project: Project context or None.
+
+        Returns:
+            Formatted project information.
+        """
+        if project is None:
+            return ""
+
+        return self.templates.format_project(
+            name=project.name,
+            project_id=project.id,
+            description=project.description,
+        )
+
+    def _build_task_info(
+        self,
+        task: TaskContext | None,
+        project: ProjectContext | None,
+    ) -> str:
+        """Build task information section.
+
+        Args:
+            task: Task context or None.
+            project: Project context for working directory fallback.
+
+        Returns:
+            Formatted task information.
+        """
+        if task is None:
+            return ""
+
+        # Determine working directory
+        working_dir = task.working_directory
+        if working_dir is None and project is not None:
+            working_dir = project.working_directory
+        if working_dir is None:
+            working_dir = "."
+
+        task_info = self.templates.format_task(
+            title=task.title,
+            task_id=task.id,
+            prompt=task.prompt,
+            priority=task.priority,
+            status=task.status,
+            working_directory=working_dir,
+        )
+
+        # Add spec if present
+        if task.spec:
+            task_info = f"{task_info}\n\n### Specification\n{task.spec}"
+
+        # Add wave context if present
+        if task.wave:
+            wave_section = (
+                f"\n\n### Wave Context\n"
+                f"**Wave {task.wave.wave_number} of {task.wave.total_waves}**"
+            )
+            if task.wave.wave_description:
+                wave_section += f" — {task.wave.wave_description}"
+            if task.wave.completed_waves_summary:
+                wave_section += f"\n\n**Completed Waves:**\n{task.wave.completed_waves_summary}"
+            if task.wave.wave_tasks_summary:
+                wave_section += f"\n\n**Tasks in This Wave:**\n{task.wave.wave_tasks_summary}"
+            task_info = f"{task_info}{wave_section}"
+
+        return task_info
+
+    def _build_instructions(self, context: PromptContext) -> str:
+        """Build the instructions section.
+
+        Combines default instructions with custom instructions from
+        project and context.
+
+        Args:
+            context: The prompt context.
+
+        Returns:
+            Combined instructions string.
+        """
+        instructions_parts = []
+
+        # Add project custom instructions
+        if context.project and context.project.custom_instructions:
+            instructions_parts.append(context.project.custom_instructions)
+
+        # Add context custom instructions
+        if context.custom_instructions:
+            instructions_parts.append(context.custom_instructions)
+
+        # If no custom instructions, use defaults
+        if not instructions_parts:
+            return self.templates.DEFAULT_INSTRUCTIONS
+
+        return "\n\n".join(instructions_parts)
+
+    def build_from_dict(
+        self,
+        project: dict[str, Any] | None = None,
+        task: dict[str, Any] | None = None,
+        workflow: dict[str, Any] | None = None,
+        custom_instructions: str | None = None,
+        resume_message: str | None = None,
+    ) -> str:
+        """Build a prompt from dictionary inputs.
+
+        Convenience method for building prompts from API responses.
+
+        Args:
+            project: Project data dict.
+            task: Task data dict.
+            workflow: Workflow data dict.
+            custom_instructions: Additional instructions.
+            resume_message: Message for resume.
+
+        Returns:
+            A formatted prompt string.
+        """
+        context = PromptContext(
+            project=ProjectContext(**project) if project else None,
+            task=TaskContext(**task) if task else None,
+            workflow=WorkflowContext(**workflow) if workflow else None,
+            custom_instructions=custom_instructions,
+            resume_message=resume_message,
+        )
+        return self.build(context)