codeframe-ai 0.9.0__py3-none-any.whl

codeframe/ui/routers/review_v2.py

@@ -0,0 +1,360 @@
+"""V2 Review router - delegates to core modules.
+
+This module provides v2-style API endpoints for code review operations
+that delegate to core modules. It uses the v2 Workspace model.
+
+The v1 router (review.py) remains for backwards compatibility.
+"""
+
+import logging
+from typing import Literal, 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 import review, git
+from codeframe.ui.dependencies import get_v2_workspace
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v2/review", tags=["review-v2"])
+
+
+# ============================================================================
+# Response Models
+# ============================================================================
+
+
+class ReviewFindingResponse(BaseModel):
+    """Response model for a review finding."""
+
+    category: str
+    severity: Literal["critical", "high", "medium", "low", "info"]
+    message: str
+    file_path: str
+    line_number: Optional[int] = None
+    suggestion: Optional[str] = None
+
+
+class ReviewResultResponse(BaseModel):
+    """Response model for review result."""
+
+    status: Literal["approved", "changes_requested", "rejected"]
+    overall_score: float
+    findings: list[ReviewFindingResponse]
+    summary: str
+
+
+class ReviewSummaryResponse(BaseModel):
+    """Response model for review summary."""
+
+    status: str
+    overall_score: float
+    total_findings: int
+    severity_counts: dict[str, int]
+    summary: str
+    has_blocking_issues: bool
+
+
+class ReviewFilesRequest(BaseModel):
+    """Request model for reviewing files."""
+
+    files: list[str] = Field(..., min_length=1, description="Files to review")
+
+
+class ReviewTaskRequest(BaseModel):
+    """Request model for reviewing a task's files."""
+
+    task_id: str = Field(..., description="Task ID")
+    files_modified: list[str] = Field(..., min_length=1, description="Modified files to review")
+
+
+class FileChangeResponse(BaseModel):
+    """Per-file change statistics."""
+
+    path: str
+    change_type: str
+    insertions: int
+    deletions: int
+
+
+class DiffStatsResponse(BaseModel):
+    """Response model for diff with statistics."""
+
+    diff: str
+    files_changed: int
+    insertions: int
+    deletions: int
+    changed_files: list[FileChangeResponse]
+
+
+class PatchResponse(BaseModel):
+    """Response model for patch export."""
+
+    patch: str
+    filename: str
+
+
+class CommitMessageResponse(BaseModel):
+    """Response model for generated commit message."""
+
+    message: str
+
+
+# ============================================================================
+# Review Endpoints
+# ============================================================================
+
+
+@router.post("/files", response_model=ReviewResultResponse)
+@rate_limit_standard()
+async def review_files(
+    request: Request,
+    body: ReviewFilesRequest,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> ReviewResultResponse:
+    """Run code review on specified files.
+
+    Performs complexity analysis, security scanning, and OWASP pattern
+    detection on the given files.
+
+    Args:
+        request: HTTP request for rate limiting
+        body: ReviewFilesRequest with file list
+        workspace: v2 Workspace
+
+    Returns:
+        ReviewResultResponse with findings and score
+    """
+    try:
+        result = review.review_files(workspace, body.files)
+
+        return ReviewResultResponse(
+            status=result.status,
+            overall_score=result.overall_score,
+            findings=[
+                ReviewFindingResponse(
+                    category=f.category,
+                    severity=f.severity,
+                    message=f.message,
+                    file_path=f.file_path,
+                    line_number=f.line_number,
+                    suggestion=f.suggestion,
+                )
+                for f in result.findings
+            ],
+            summary=result.summary,
+        )
+
+    except Exception as e:
+        logger.error(f"Failed to review files: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/task", response_model=ReviewResultResponse)
+@rate_limit_standard()
+async def review_task(
+    request: Request,
+    body: ReviewTaskRequest,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> ReviewResultResponse:
+    """Run code review for a task's modified files.
+
+    Convenience endpoint that wraps file review with task context.
+
+    Args:
+        request: HTTP request for rate limiting
+        body: ReviewTaskRequest with task ID and modified files
+        workspace: v2 Workspace
+
+    Returns:
+        ReviewResultResponse with findings and score
+    """
+    try:
+        result = review.review_task(
+            workspace,
+            task_id=body.task_id,
+            files_modified=body.files_modified,
+        )
+
+        return ReviewResultResponse(
+            status=result.status,
+            overall_score=result.overall_score,
+            findings=[
+                ReviewFindingResponse(
+                    category=f.category,
+                    severity=f.severity,
+                    message=f.message,
+                    file_path=f.file_path,
+                    line_number=f.line_number,
+                    suggestion=f.suggestion,
+                )
+                for f in result.findings
+            ],
+            summary=result.summary,
+        )
+
+    except Exception as e:
+        logger.error(f"Failed to review task: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/files/summary", response_model=ReviewSummaryResponse)
+@rate_limit_standard()
+async def review_files_summary(
+    request: Request,
+    body: ReviewFilesRequest,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> ReviewSummaryResponse:
+    """Run code review and return summary only.
+
+    Similar to review_files but returns a condensed summary without
+    individual findings. Useful for quick status checks.
+
+    Args:
+        request: HTTP request for rate limiting
+        body: ReviewFilesRequest with file list
+        workspace: v2 Workspace
+
+    Returns:
+        ReviewSummaryResponse with aggregated metrics
+    """
+    try:
+        result = review.review_files(workspace, body.files)
+        summary = review.get_review_summary(result)
+
+        return ReviewSummaryResponse(
+            status=summary["status"],
+            overall_score=summary["overall_score"],
+            total_findings=summary["total_findings"],
+            severity_counts=summary["severity_counts"],
+            summary=summary["summary"],
+            has_blocking_issues=summary["has_blocking_issues"],
+        )
+
+    except Exception as e:
+        logger.error(f"Failed to get review summary: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ============================================================================
+# Diff & Patch Endpoints (for Review & Commit View)
+# ============================================================================
+
+
+@router.get("/diff", response_model=DiffStatsResponse)
+@rate_limit_standard()
+async def get_review_diff(
+    request: Request,
+    staged: bool = False,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> DiffStatsResponse:
+    """Get unified diff with parsed statistics.
+
+    Returns the raw diff plus per-file change counts for display
+    in the Review & Commit View.
+
+    Args:
+        request: HTTP request for rate limiting
+        staged: If True, show staged changes; if False, show unstaged
+        workspace: v2 Workspace
+
+    Returns:
+        DiffStatsResponse with diff text and statistics
+    """
+    try:
+        stats = git.get_diff_stats(workspace, staged=staged)
+
+        return DiffStatsResponse(
+            diff=stats.diff,
+            files_changed=stats.files_changed,
+            insertions=stats.insertions,
+            deletions=stats.deletions,
+            changed_files=[
+                FileChangeResponse(
+                    path=f.path,
+                    change_type=f.change_type,
+                    insertions=f.insertions,
+                    deletions=f.deletions,
+                )
+                for f in stats.changed_files
+            ],
+        )
+
+    except ValueError as e:
+        logger.error(f"Get review diff failed: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Failed to get review diff: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/patch", response_model=PatchResponse)
+@rate_limit_standard()
+async def get_review_patch(
+    request: Request,
+    staged: bool = False,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> PatchResponse:
+    """Get patch-formatted diff for export.
+
+    Returns the diff in patch format suitable for `git apply`.
+
+    Args:
+        request: HTTP request for rate limiting
+        staged: If True, show staged changes; if False, show unstaged
+        workspace: v2 Workspace
+
+    Returns:
+        PatchResponse with patch content and suggested filename
+    """
+    try:
+        patch_content = git.get_patch(workspace, staged=staged)
+        branch = git.get_current_branch(workspace)
+        filename = f"{branch.replace('/', '-')}.patch"
+
+        return PatchResponse(
+            patch=patch_content,
+            filename=filename,
+        )
+
+    except ValueError as e:
+        logger.error(f"Get patch failed: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Failed to get patch: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/commit-message", response_model=CommitMessageResponse)
+@rate_limit_standard()
+async def generate_commit_message(
+    request: Request,
+    staged: bool = False,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> CommitMessageResponse:
+    """Generate a commit message from the current diff.
+
+    Analyzes changed files to suggest a conventional commit message.
+
+    Args:
+        request: HTTP request for rate limiting
+        staged: If True, analyze staged changes; if False, unstaged
+        workspace: v2 Workspace
+
+    Returns:
+        CommitMessageResponse with suggested message
+    """
+    try:
+        message = git.generate_commit_message(workspace, staged=staged)
+
+        return CommitMessageResponse(message=message)
+
+    except ValueError as e:
+        logger.error(f"Generate commit message failed: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Failed to generate commit message: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))

codeframe/ui/routers/schedule_v2.py

@@ -0,0 +1,214 @@
+"""V2 Schedule router - delegates to core modules.
+
+This module provides v2-style API endpoints for schedule management that
+delegate to core/schedule.py. It uses the v2 Workspace model.
+
+The v1 router (schedule.py) remains for backwards compatibility.
+"""
+
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from pydantic import BaseModel
+
+from codeframe.core.workspace import Workspace
+from codeframe.lib.rate_limiter import rate_limit_standard
+from codeframe.core import schedule
+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/schedule", tags=["schedule-v2"])
+
+
+# ============================================================================
+# Request/Response Models
+# ============================================================================
+
+
+class TaskAssignmentResponse(BaseModel):
+    """Response model for a single task assignment."""
+
+    task_id: str
+    title: str
+    start_time: float
+    end_time: float
+    assigned_agent: Optional[int] = None
+
+
+class ScheduleResponse(BaseModel):
+    """Response model for project schedule."""
+
+    task_assignments: list[TaskAssignmentResponse]
+    total_duration: float
+    agents_used: int
+
+
+class CompletionPredictionResponse(BaseModel):
+    """Response model for completion prediction."""
+
+    predicted_date: str
+    remaining_hours: float
+    completed_percentage: float
+    confidence_interval: dict[str, str]
+
+
+class BottleneckResponse(BaseModel):
+    """Response model for a scheduling bottleneck."""
+
+    task_id: str
+    task_title: str
+    bottleneck_type: str
+    impact_hours: float
+    recommendation: str
+
+
+# ============================================================================
+# Schedule Endpoints
+# ============================================================================
+
+
+@router.get("", response_model=ScheduleResponse)
+@rate_limit_standard()
+async def get_schedule(
+    request: Request,
+    agents: int = Query(1, ge=1, le=10, description="Number of parallel agents/workers"),
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> ScheduleResponse:
+    """Get the schedule for a workspace.
+
+    Uses Critical Path Method to assign start/end times while
+    respecting dependency constraints and agent availability.
+
+    This is the v2 equivalent of `cf schedule show`.
+
+    Args:
+        agents: Number of parallel agents/workers (default: 1)
+        workspace: v2 Workspace
+
+    Returns:
+        Schedule with task assignments
+    """
+    try:
+        result = schedule.get_schedule(workspace, agents=agents)
+
+        return ScheduleResponse(
+            task_assignments=[
+                TaskAssignmentResponse(
+                    task_id=a.task_id,
+                    title=a.title,
+                    start_time=a.start_time,
+                    end_time=a.end_time,
+                    assigned_agent=a.assigned_agent,
+                )
+                for a in result.task_assignments
+            ],
+            total_duration=result.total_duration,
+            agents_used=result.agents_used,
+        )
+
+    except ValueError as e:
+        raise HTTPException(
+            status_code=404,
+            detail=api_error("Schedule not found", ErrorCodes.NOT_FOUND, str(e)),
+        )
+    except Exception as e:
+        logger.error(f"Failed to get schedule: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=api_error("Failed to get schedule", ErrorCodes.INTERNAL_ERROR, str(e)),
+        )
+
+
+@router.get("/predict", response_model=CompletionPredictionResponse)
+@rate_limit_standard()
+async def predict_completion(
+    request: Request,
+    hours_per_day: float = Query(8.0, gt=0, le=24, description="Working hours per day"),
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> CompletionPredictionResponse:
+    """Predict project completion date.
+
+    This is the v2 equivalent of `cf schedule predict`.
+
+    Args:
+        hours_per_day: Working hours per day (default: 8)
+        workspace: v2 Workspace
+
+    Returns:
+        Completion prediction with confidence interval
+    """
+    try:
+        result = schedule.predict_completion(workspace, hours_per_day=hours_per_day)
+
+        return CompletionPredictionResponse(
+            predicted_date=result.predicted_date.isoformat(),
+            remaining_hours=result.remaining_hours,
+            completed_percentage=result.completed_percentage,
+            confidence_interval={
+                "early": result.confidence_early.isoformat(),
+                "late": result.confidence_late.isoformat(),
+            },
+        )
+
+    except ValueError as e:
+        raise HTTPException(
+            status_code=404,
+            detail=api_error("Prediction failed", ErrorCodes.NOT_FOUND, str(e)),
+        )
+    except Exception as e:
+        logger.error(f"Failed to predict completion: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=api_error("Failed to predict completion", ErrorCodes.INTERNAL_ERROR, str(e)),
+        )
+
+
+@router.get("/bottlenecks", response_model=list[BottleneckResponse])
+@rate_limit_standard()
+async def get_bottlenecks(
+    request: Request,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> list[BottleneckResponse]:
+    """Identify scheduling bottlenecks for a workspace.
+
+    Identifies:
+    - Long duration tasks on critical path
+    - Tasks with many dependents causing delays
+    - Resource constraints limiting parallelization
+
+    This is the v2 equivalent of `cf schedule bottlenecks`.
+
+    Args:
+        workspace: v2 Workspace
+
+    Returns:
+        List of identified bottlenecks with recommendations
+    """
+    try:
+        bottlenecks = schedule.get_bottlenecks(workspace)
+
+        return [
+            BottleneckResponse(
+                task_id=bn.task_id,
+                task_title=bn.task_title,
+                bottleneck_type=bn.bottleneck_type,
+                impact_hours=bn.impact_hours,
+                recommendation=bn.recommendation,
+            )
+            for bn in bottlenecks
+        ]
+
+    except ValueError as e:
+        raise HTTPException(
+            status_code=404,
+            detail=api_error("Bottlenecks not found", ErrorCodes.NOT_FOUND, str(e)),
+        )
+    except Exception as e:
+        logger.error(f"Failed to get bottlenecks: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=api_error("Failed to get bottlenecks", ErrorCodes.INTERNAL_ERROR, str(e)),
+        )