codeframe-ai 0.9.0__py3-none-any.whl

codeframe/ui/routers/discovery_v2.py

@@ -0,0 +1,417 @@
+"""V2 Discovery workflow router - delegates to core modules.
+
+This module provides v2-style API endpoints for PRD discovery that delegate
+to core/prd_discovery.py. It uses the v2 Workspace model and is designed
+to work alongside the v1 discovery router during migration.
+
+Key differences from v1:
+- Uses Workspace (path-based) instead of project_id
+- Delegates to core/prd_discovery functions
+- Stateless session management via session_id
+- No LeadAgent dependency
+
+The v1 router (discovery.py) remains for backwards compatibility with
+existing web UI until Phase 3 (Web UI Rebuild).
+"""
+
+import logging
+from typing import Any, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from pydantic import BaseModel, Field
+
+from codeframe.core.workspace import Workspace
+from codeframe.lib.rate_limiter import rate_limit_ai, rate_limit_standard
+from codeframe.core import prd_discovery, prd, tasks
+from codeframe.core.prd_discovery import (
+    NoApiKeyError,
+    ValidationError,
+    IncompleteSessionError,
+)
+from codeframe.ui.dependencies import get_v2_workspace
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v2/discovery", tags=["discovery-v2"])
+
+
+# ============================================================================
+# Request/Response Models
+# ============================================================================
+
+
+class StartDiscoveryResponse(BaseModel):
+    """Response for starting a discovery session."""
+
+    session_id: str
+    state: str
+    question: dict[str, Any]
+
+
+class AnswerRequest(BaseModel):
+    """Request for submitting an answer."""
+
+    answer: str = Field(..., min_length=1, max_length=10000)
+
+
+class AnswerResponse(BaseModel):
+    """Response for submitting an answer."""
+
+    accepted: bool
+    feedback: str
+    follow_up: Optional[str] = None
+    is_complete: bool
+    next_question: Optional[dict[str, Any]] = None
+    coverage: Optional[dict[str, Any]] = None
+
+
+class StatusResponse(BaseModel):
+    """Response for discovery status."""
+
+    state: str
+    session_id: Optional[str] = None
+    progress: dict[str, Any] = {}
+    current_question: Optional[dict[str, Any]] = None
+    error: Optional[str] = None
+
+
+class GeneratePrdRequest(BaseModel):
+    """Request for PRD generation."""
+
+    template_id: Optional[str] = Field(
+        None,
+        description="PRD template to use (standard, lean, enterprise, etc.)",
+    )
+
+
+class GeneratePrdResponse(BaseModel):
+    """Response for PRD generation."""
+
+    prd_id: str
+    title: str
+    preview: str
+
+
+class GenerateTasksResponse(BaseModel):
+    """Response for task generation."""
+
+    task_count: int
+    tasks: list[dict[str, Any]]
+
+
+# ============================================================================
+# Discovery Endpoints
+# ============================================================================
+
+
+@router.post("/start", response_model=StartDiscoveryResponse)
+@rate_limit_ai()
+async def start_discovery(
+    request: Request,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> StartDiscoveryResponse:
+    """Start a new PRD discovery session.
+
+    Creates a new AI-driven discovery session that will ask context-sensitive
+    questions to gather project requirements.
+
+    Args:
+        workspace: v2 Workspace (from workspace_path query param or default)
+
+    Returns:
+        Session ID, state, and first question
+
+    Raises:
+        HTTPException:
+            - 400: Discovery session already active
+            - 500: API key not configured or processing error
+    """
+    try:
+        # Check for existing active session
+        existing = prd_discovery.get_active_session(workspace)
+        if existing and not existing.is_complete():
+            raise HTTPException(
+                status_code=400,
+                detail={
+                    "error": "Discovery session already active",
+                    "session_id": existing.session_id,
+                    "answered_count": existing.answered_count,
+                    "hint": "Use POST /api/v2/discovery/{session_id}/answer to continue",
+                },
+            )
+
+        # Start new session
+        session = prd_discovery.start_discovery_session(workspace)
+        question = session.get_current_question()
+
+        return StartDiscoveryResponse(
+            session_id=session.session_id,
+            state=session.state.value,
+            question=question or {},
+        )
+
+    except NoApiKeyError as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"ANTHROPIC_API_KEY not configured: {e}",
+        )
+    except Exception as e:
+        logger.error(f"Failed to start discovery: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to start discovery: {e}",
+        )
+
+
+@router.get("/status", response_model=StatusResponse)
+@rate_limit_standard()
+async def get_status(
+    request: Request,
+    session_id: Optional[str] = Query(None, description="Specific session ID"),
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> StatusResponse:
+    """Get discovery status for the workspace.
+
+    Returns status for a specific session (if provided) or the most recent
+    active session. If no active session exists, returns idle state.
+
+    Args:
+        session_id: Optional specific session ID to query
+        workspace: v2 Workspace
+
+    Returns:
+        Discovery status including state, progress, and current question
+    """
+    status = prd_discovery.get_discovery_status(
+        workspace,
+        session_id=session_id,
+    )
+    return StatusResponse(**status)
+
+
+@router.post("/{session_id}/answer", response_model=AnswerResponse)
+@rate_limit_ai()
+async def submit_answer(
+    request: Request,
+    session_id: str,
+    body: AnswerRequest,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> AnswerResponse:
+    """Submit an answer to the current discovery question.
+
+    The AI validates the answer for adequacy. If adequate, the answer is
+    recorded and the next question (or completion) is returned. If not
+    adequate, feedback is provided with optional follow-up question.
+
+    Args:
+        request: HTTP request for rate limiting
+        session_id: Discovery session ID
+        body: Answer request with answer text
+        workspace: v2 Workspace
+
+    Returns:
+        Answer response with acceptance status and next steps
+
+    Raises:
+        HTTPException:
+            - 400: Validation error or session not active
+            - 404: Session not found
+            - 500: Processing error
+    """
+    try:
+        result = prd_discovery.process_discovery_answer(
+            workspace,
+            session_id,
+            body.answer,
+        )
+        return AnswerResponse(**result)
+
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except ValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except NoApiKeyError as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Failed to process answer: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/{session_id}/generate-prd", response_model=GeneratePrdResponse)
+@rate_limit_ai()
+async def generate_prd(
+    request: Request,
+    session_id: str,
+    body: GeneratePrdRequest = None,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> GeneratePrdResponse:
+    """Generate a PRD from a completed discovery session.
+
+    Synthesizes the discovery conversation into a structured PRD document
+    using the specified template (or default).
+
+    Args:
+        request: HTTP request for rate limiting
+        session_id: Discovery session ID (must be complete)
+        body: Optional template selection
+        workspace: v2 Workspace
+
+    Returns:
+        Generated PRD with ID, title, and preview
+
+    Raises:
+        HTTPException:
+            - 400: Discovery not complete
+            - 404: Session not found
+            - 500: Generation error
+    """
+    try:
+        template_id = body.template_id if body else None
+        prd_record = prd_discovery.generate_prd_from_discovery(
+            workspace,
+            session_id,
+            template_id=template_id,
+        )
+
+        preview = prd_record.content[:500]
+        if len(prd_record.content) > 500:
+            preview += "..."
+
+        return GeneratePrdResponse(
+            prd_id=prd_record.id,
+            title=prd_record.title,
+            preview=preview,
+        )
+
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except IncompleteSessionError as e:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Discovery not complete: {e}",
+        )
+    except NoApiKeyError as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Failed to generate PRD: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/reset")
+@rate_limit_standard()
+async def reset_discovery(
+    request: Request,
+    session_id: Optional[str] = Query(None, description="Specific session to reset"),
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> dict[str, Any]:
+    """Reset discovery for the workspace.
+
+    Marks the specified session (or most recent active session) as complete/abandoned.
+    Does NOT delete PRDs or tasks.
+
+    Args:
+        session_id: Optional specific session to reset
+        workspace: v2 Workspace
+
+    Returns:
+        Success status and message
+    """
+    reset = prd_discovery.reset_discovery(workspace, session_id=session_id)
+
+    if reset:
+        return {
+            "success": True,
+            "message": "Discovery session reset. Start a new session with POST /api/v2/discovery/start",
+        }
+    else:
+        return {
+            "success": True,
+            "message": "No active discovery session to reset.",
+        }
+
+
+# ============================================================================
+# Task Generation Endpoints (from PRD)
+# ============================================================================
+
+
+@router.post("/generate-tasks", response_model=GenerateTasksResponse)
+@rate_limit_ai()
+async def generate_tasks_from_prd(
+    request: Request,
+    prd_id: Optional[str] = Query(
+        None,
+        description="PRD ID to generate tasks from (defaults to latest)",
+    ),
+    use_llm: bool = Query(
+        True,
+        description="Use LLM for intelligent task generation (vs simple extraction)",
+    ),
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> GenerateTasksResponse:
+    """Generate tasks from a PRD.
+
+    Uses LLM to decompose the PRD into actionable development tasks.
+    Falls back to simple extraction if LLM is unavailable.
+
+    This is the v2 equivalent of `cf tasks generate`.
+
+    Args:
+        prd_id: Optional PRD ID (defaults to latest PRD)
+        use_llm: Whether to use LLM (default True)
+        workspace: v2 Workspace
+
+    Returns:
+        List of generated tasks
+
+    Raises:
+        HTTPException:
+            - 404: PRD not found
+            - 500: Generation error
+    """
+    try:
+        # Get PRD
+        if prd_id:
+            prd_record = prd.get_by_id(workspace, prd_id)
+            if not prd_record:
+                raise HTTPException(
+                    status_code=404,
+                    detail=f"PRD not found: {prd_id}",
+                )
+        else:
+            prd_record = prd.get_latest(workspace)
+            if not prd_record:
+                raise HTTPException(
+                    status_code=404,
+                    detail="No PRD found. Generate a PRD first with POST /api/v2/discovery/start",
+                )
+
+        # Generate tasks
+        generated_tasks = tasks.generate_from_prd(
+            workspace,
+            prd_record,
+            use_llm=use_llm,
+        )
+
+        return GenerateTasksResponse(
+            task_count=len(generated_tasks),
+            tasks=[
+                {
+                    "id": t.id,
+                    "title": t.title,
+                    "description": t.description,
+                    "status": t.status.value,
+                    "priority": t.priority,
+                }
+                for t in generated_tasks
+            ],
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to generate tasks: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to generate tasks: {e}",
+        )

codeframe/ui/routers/environment_v2.py

@@ -0,0 +1,284 @@
+"""V2 Environment router - delegates to core/environment module.
+
+This module provides v2-style API endpoints for environment validation
+and tool management. Used to check if development tools are installed.
+
+Routes:
+    GET  /api/v2/env/check   - Quick environment validation
+    GET  /api/v2/env/doctor  - Comprehensive diagnostics
+    POST /api/v2/env/install - Install a missing tool
+"""
+
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel, Field
+
+from codeframe.core.workspace import Workspace
+from codeframe.lib.rate_limiter import rate_limit_standard
+from codeframe.core.environment import EnvironmentValidator, ValidationResult, ToolInfo
+from codeframe.core.installer import ToolInstaller
+from codeframe.ui.dependencies import get_v2_workspace
+from codeframe.ui.response_models import api_error, ErrorCodes
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v2/env", tags=["environment-v2"])
+
+
+# ============================================================================
+# Request/Response Models
+# ============================================================================
+
+
+class ToolInfoResponse(BaseModel):
+    """Response for a single tool."""
+
+    name: str
+    path: Optional[str]
+    version: Optional[str]
+    status: str  # ToolStatus value
+    is_available: bool
+
+
+class ValidationResultResponse(BaseModel):
+    """Response for environment validation."""
+
+    project_type: str
+    detected_tools: dict[str, ToolInfoResponse]
+    missing_tools: list[str]
+    optional_missing: list[str]
+    health_score: float
+    health_percent: int
+    is_healthy: bool
+    recommendations: list[str]
+    warnings: list[str]
+    conflicts: list[str]
+
+
+class InstallToolRequest(BaseModel):
+    """Request for installing a tool."""
+
+    tool_name: str = Field(..., min_length=1, description="Tool to install")
+
+
+class InstallResultResponse(BaseModel):
+    """Response for tool installation."""
+
+    success: bool
+    tool_name: str
+    message: str
+    command_used: Optional[str]
+
+
+# ============================================================================
+# Helper Functions
+# ============================================================================
+
+
+def _tool_to_response(info: ToolInfo) -> ToolInfoResponse:
+    """Convert a ToolInfo to a ToolInfoResponse."""
+    return ToolInfoResponse(
+        name=info.name,
+        path=info.path,
+        version=info.version,
+        status=info.status.value,
+        is_available=info.is_available,
+    )
+
+
+def _result_to_response(result: ValidationResult) -> ValidationResultResponse:
+    """Convert a ValidationResult to a ValidationResultResponse."""
+    return ValidationResultResponse(
+        project_type=result.project_type,
+        detected_tools={
+            name: _tool_to_response(info)
+            for name, info in result.detected_tools.items()
+        },
+        missing_tools=result.missing_tools,
+        optional_missing=result.optional_missing,
+        health_score=result.health_score,
+        health_percent=int(result.health_score * 100),
+        is_healthy=result.is_healthy,
+        recommendations=result.recommendations,
+        warnings=result.warnings,
+        conflicts=result.conflicts,
+    )
+
+
+# ============================================================================
+# Endpoints
+# ============================================================================
+
+
+@router.get("/check", response_model=ValidationResultResponse)
+@rate_limit_standard()
+async def check_environment(
+    request: Request,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> ValidationResultResponse:
+    """Quick environment validation.
+
+    Checks if required tools are installed and returns health score.
+
+    Args:
+        workspace: v2 Workspace
+
+    Returns:
+        Validation result with tool status and health score
+    """
+    try:
+        validator = EnvironmentValidator()
+        result = validator.validate_environment(workspace.repo_path)
+
+        return _result_to_response(result)
+
+    except Exception as e:
+        logger.error(f"Failed to validate environment: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=api_error("Validation failed", ErrorCodes.EXECUTION_FAILED, str(e)),
+        )
+
+
+@router.get("/doctor", response_model=ValidationResultResponse)
+@rate_limit_standard()
+async def run_doctor(
+    request: Request,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> ValidationResultResponse:
+    """Comprehensive environment diagnostics.
+
+    Performs deeper validation including optional tools, version compatibility,
+    and provides detailed recommendations.
+
+    Args:
+        workspace: v2 Workspace
+
+    Returns:
+        Detailed validation result with recommendations
+    """
+    try:
+        validator = EnvironmentValidator()
+
+        # Doctor mode validates everything including optional tools
+        result = validator.validate_environment(
+            workspace.repo_path,
+            # Include optional tools in the check
+            optional_tools=["ruff", "black", "mypy", "pre-commit"],
+        )
+
+        return _result_to_response(result)
+
+    except Exception as e:
+        logger.error(f"Failed to run doctor: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=api_error("Doctor failed", ErrorCodes.EXECUTION_FAILED, str(e)),
+        )
+
+
+@router.post("/install", response_model=InstallResultResponse)
+@rate_limit_standard()
+async def install_tool(
+    request: Request,
+    body: InstallToolRequest,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> InstallResultResponse:
+    """Install a missing tool.
+
+    Attempts to install the specified tool using the appropriate
+    package manager for the current environment.
+
+    Args:
+        request: Install request with tool name
+        workspace: v2 Workspace
+
+    Returns:
+        Installation result
+
+    Raises:
+        HTTPException: 400 if tool unknown or installation fails
+    """
+    try:
+        installer = ToolInstaller()
+
+        # Check if tool is known
+        if not installer.can_install(body.tool_name):
+            raise HTTPException(
+                status_code=400,
+                detail=api_error(
+                    "Unknown tool",
+                    ErrorCodes.INVALID_REQUEST,
+                    f"Don't know how to install '{body.tool_name}'",
+                ),
+            )
+
+        # Attempt installation (confirm=False for non-interactive server usage)
+        result = installer.install_tool(body.tool_name, confirm=False)
+
+        return InstallResultResponse(
+            success=result.success,
+            tool_name=result.tool_name,
+            message=result.message,
+            command_used=result.command_used,
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to install {body.tool_name}: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=api_error("Installation failed", ErrorCodes.EXECUTION_FAILED, str(e)),
+        )
+
+
+@router.get("/tools")
+@rate_limit_standard()
+async def list_available_tools(
+    request: Request,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> dict:
+    """List tools that can be automatically installed.
+
+    Args:
+        workspace: v2 Workspace
+
+    Returns:
+        List of installable tools with their package managers
+    """
+    try:
+        # List of tools known to be installable by ToolInstaller
+        # These are aggregated from PipInstaller, NpmInstaller, CargoInstaller, SystemInstaller
+        installable_tools = [
+            # Python tools (pip/uv)
+            {"name": "pytest", "category": "python", "description": "Python testing framework"},
+            {"name": "ruff", "category": "python", "description": "Fast Python linter"},
+            {"name": "mypy", "category": "python", "description": "Static type checker"},
+            {"name": "black", "category": "python", "description": "Code formatter"},
+            {"name": "flake8", "category": "python", "description": "Linting tool"},
+            {"name": "pylint", "category": "python", "description": "Code analyzer"},
+            {"name": "bandit", "category": "python", "description": "Security linter"},
+            {"name": "pre-commit", "category": "python", "description": "Git hooks manager"},
+            # Node.js tools (npm)
+            {"name": "eslint", "category": "nodejs", "description": "JavaScript linter"},
+            {"name": "prettier", "category": "nodejs", "description": "Code formatter"},
+            {"name": "typescript", "category": "nodejs", "description": "TypeScript compiler"},
+            # Rust tools (cargo)
+            {"name": "rustfmt", "category": "rust", "description": "Rust formatter"},
+            {"name": "clippy", "category": "rust", "description": "Rust linter"},
+        ]
+
+        return {
+            "tools": installable_tools,
+            "message": "Use POST /api/v2/env/install to install any of these tools",
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to list tools: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=api_error("Failed to list tools", ErrorCodes.EXECUTION_FAILED, str(e)),
+        )