emdash-core 0.1.7__py3-none-any.whl

emdash_core/api/review.py

@@ -0,0 +1,161 @@
+"""PR review endpoints with SSE streaming."""
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+from ..sse.stream import SSEHandler, EventType
+
+router = APIRouter(prefix="/review", tags=["review"])
+
+_executor = ThreadPoolExecutor(max_workers=2)
+
+
+class ReviewRequest(BaseModel):
+    """Request for PR review."""
+    pr_number: Optional[int] = Field(default=None, description="PR number")
+    pr_url: Optional[str] = Field(default=None, description="PR URL")
+    search: Optional[str] = Field(default=None, description="Search for PR by text")
+    state: str = Field(default="open", description="PR state filter: open, closed, all")
+    model: Optional[str] = Field(default=None, description="LLM model to use")
+    post_review: bool = Field(default=False, description="Post review to GitHub")
+    verdict: bool = Field(default=False, description="Include APPROVE/REQUEST_CHANGES")
+
+
+class ReviewComment(BaseModel):
+    """A review comment."""
+    file: str
+    line: int
+    comment: str
+    severity: str  # info, suggestion, warning, error
+
+
+class ReviewResponse(BaseModel):
+    """PR review response."""
+    pr_number: int
+    pr_title: str
+    summary: str
+    comments: list[ReviewComment]
+    verdict: Optional[str] = None  # APPROVE, REQUEST_CHANGES, COMMENT
+
+
+def _run_review_sync(
+    pr_number: Optional[int],
+    model: Optional[str],
+    sse_handler: SSEHandler,
+):
+    """Run PR review synchronously."""
+    try:
+        from ..agent.code_reviewer import CodeReviewer
+        from ..agent.events import AgentEventEmitter
+
+        class SSEBridge:
+            def __init__(self, handler):
+                self._handler = handler
+
+            def handle(self, event):
+                self._handler.handle(event)
+
+        emitter = AgentEventEmitter(agent_name="Review")
+        emitter.add_handler(SSEBridge(sse_handler))
+
+        reviewer = CodeReviewer(model=model, emitter=emitter)
+
+        sse_handler.emit(EventType.PROGRESS, {
+            "step": "Fetching PR",
+            "percent": 10,
+        })
+
+        result = reviewer.review(pr_number=pr_number)
+
+        sse_handler.emit(EventType.RESPONSE, {
+            "pr_number": pr_number,
+            "pr_title": result.get("title", ""),
+            "summary": result.get("summary", ""),
+            "comments": result.get("comments", []),
+            "verdict": result.get("verdict"),
+        })
+
+    except Exception as e:
+        sse_handler.emit(EventType.ERROR, {"message": str(e)})
+    finally:
+        sse_handler.close()
+
+
+@router.post("")
+async def review_pr(request: ReviewRequest):
+    """Generate a PR review.
+
+    Analyzes the PR diff and generates review comments.
+    """
+    if not request.pr_number and not request.pr_url and not request.search:
+        from fastapi import HTTPException
+        raise HTTPException(
+            status_code=400,
+            detail="Must provide pr_number, pr_url, or search"
+        )
+
+    sse_handler = SSEHandler(agent_name="Review")
+
+    sse_handler.emit(EventType.SESSION_START, {
+        "agent_name": "Review",
+        "pr_number": request.pr_number,
+    })
+
+    async def run():
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(
+            _executor,
+            _run_review_sync,
+            request.pr_number,
+            request.model,
+            sse_handler,
+        )
+
+    asyncio.create_task(run())
+
+    return StreamingResponse(
+        sse_handler,
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
+    )
+
+
+@router.post("/create-profile")
+async def create_reviewer_profile(
+    top_reviewers: int = 5,
+    top_contributors: int = 10,
+    max_prs: int = 50,
+    model: Optional[str] = None,
+):
+    """Create a reviewer profile by analyzing repository reviewers."""
+    sse_handler = SSEHandler(agent_name="ReviewerProfile")
+
+    async def run():
+        try:
+            from ..agent.reviewer_profile import ReviewerProfileBuilder
+
+            builder = ReviewerProfileBuilder(model=model)
+            result = builder.build(
+                top_reviewers=top_reviewers,
+                top_contributors=top_contributors,
+                max_prs=max_prs,
+            )
+
+            sse_handler.emit(EventType.RESPONSE, result)
+        except Exception as e:
+            sse_handler.emit(EventType.ERROR, {"message": str(e)})
+        finally:
+            sse_handler.close()
+
+    asyncio.create_task(run())
+
+    return StreamingResponse(
+        sse_handler,
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
+    )

emdash_core/api/router.py

@@ -0,0 +1,76 @@
+"""Main API router combining all routes."""
+
+from fastapi import APIRouter
+
+from . import (
+    health,
+    agent,
+    agents,
+    auth,
+    db,
+    index,
+    search,
+    query,
+    analyze,
+    spec,
+    tasks,
+    plan,
+    team,
+    research,
+    review,
+    embed,
+    swarm,
+    rules,
+    context,
+    feature,
+    projectmd,
+)
+
+api_router = APIRouter(prefix="/api")
+
+# Health & status
+api_router.include_router(health.router)
+
+# Authentication
+api_router.include_router(auth.router)
+
+# Agent operations
+api_router.include_router(agent.router)
+api_router.include_router(agents.router)
+
+# Database management
+api_router.include_router(db.router)
+
+# Indexing
+api_router.include_router(index.router)
+
+# Search & queries
+api_router.include_router(search.router)
+api_router.include_router(query.router)
+
+# Analytics
+api_router.include_router(analyze.router)
+
+# Planning & specifications
+api_router.include_router(spec.router)
+api_router.include_router(tasks.router)
+api_router.include_router(plan.router)
+api_router.include_router(feature.router)
+
+# Team & collaboration
+api_router.include_router(team.router)
+api_router.include_router(research.router)
+api_router.include_router(review.router)
+
+# Embeddings
+api_router.include_router(embed.router)
+
+# Multi-agent
+api_router.include_router(swarm.router)
+
+# Configuration
+api_router.include_router(rules.router)
+api_router.include_router(context.router)
+
+# Documentation generation
+api_router.include_router(projectmd.router)

emdash_core/api/rules.py

@@ -0,0 +1,116 @@
+"""Template/rules management endpoints."""
+
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+router = APIRouter(prefix="/rules", tags=["rules"])
+
+
+class TemplateInfo(BaseModel):
+    """Information about a template."""
+    name: str
+    source: str  # built-in, global, local
+    path: Optional[str] = None
+    description: Optional[str] = None
+
+
+class TemplateContent(BaseModel):
+    """Template content."""
+    name: str
+    content: str
+    source: str
+
+
+@router.get("/list")
+async def list_templates():
+    """List all templates and their active sources."""
+    templates = [
+        TemplateInfo(
+            name="spec",
+            source="built-in",
+            description="Feature specification template",
+        ),
+        TemplateInfo(
+            name="tasks",
+            source="built-in",
+            description="Implementation tasks template",
+        ),
+        TemplateInfo(
+            name="project",
+            source="built-in",
+            description="PROJECT.md template",
+        ),
+        TemplateInfo(
+            name="focus",
+            source="built-in",
+            description="Team focus template",
+        ),
+        TemplateInfo(
+            name="pr-review",
+            source="built-in",
+            description="PR review template",
+        ),
+    ]
+
+    # TODO: Check for custom templates in .emdash-rules
+
+    return {"templates": templates}
+
+
+@router.get("/{template_name}", response_model=TemplateContent)
+async def get_template(template_name: str):
+    """Get a template's content."""
+    try:
+        from ..templates import load_template as get_template
+
+        content = get_template(template_name)
+        if not content:
+            raise HTTPException(status_code=404, detail=f"Template {template_name} not found")
+
+        return TemplateContent(
+            name=template_name,
+            content=content,
+            source="built-in",  # TODO: Detect actual source
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/init")
+async def init_templates(global_templates: bool = False, force: bool = False):
+    """Initialize custom templates in .emdash-rules."""
+    try:
+        from pathlib import Path
+
+        # Determine target directory
+        if global_templates:
+            target = Path.home() / ".emdash-rules"
+        else:
+            target = Path.cwd() / ".emdash-rules"
+
+        if target.exists() and not force:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Templates already exist at {target}. Use force=true to overwrite."
+            )
+
+        target.mkdir(parents=True, exist_ok=True)
+
+        # Copy built-in templates
+        from ..templates.loader import get_defaults_dir, copy_templates_to_dir, TEMPLATE_NAMES
+
+        templates_copied = copy_templates_to_dir(target, overwrite=force)
+
+        return {
+            "success": True,
+            "path": str(target),
+            "templates": templates_copied,
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

emdash_core/api/search.py

@@ -0,0 +1,119 @@
+"""Search endpoints."""
+
+from enum import Enum
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+router = APIRouter(prefix="/search", tags=["search"])
+
+
+class SearchType(str, Enum):
+    """Type of search to perform."""
+    SEMANTIC = "semantic"
+    TEXT = "text"
+
+
+class SearchRequest(BaseModel):
+    """Search request."""
+    repo_path: str = Field(..., description="Path to repository")
+    query: str = Field(..., description="Search query")
+    type: SearchType = Field(default=SearchType.SEMANTIC, description="Search type")
+    limit: int = Field(default=20, description="Maximum results")
+    entity_types: list[str] = Field(default_factory=list, description="Filter by types: File, Function, Class")
+    min_score: float = Field(default=0.0, description="Minimum similarity score")
+    include_importance: bool = Field(default=True, description="Include importance ranking")
+    include_snippets: bool = Field(default=True, description="Include code snippets")
+
+
+class SearchResult(BaseModel):
+    """A single search result."""
+    qualified_name: str
+    name: str
+    entity_type: str
+    file_path: str
+    line_number: Optional[int] = None
+    score: float
+    importance: Optional[float] = None
+    snippet: Optional[str] = None
+
+
+class SearchResponse(BaseModel):
+    """Search response."""
+    results: list[SearchResult]
+    total: int
+    query: str
+    search_type: str
+
+
+def _get_toolkit():
+    """Get agent toolkit for search."""
+    from ..agent.toolkit import AgentToolkit
+    return AgentToolkit()
+
+
+@router.post("", response_model=SearchResponse)
+async def search(request: SearchRequest):
+    """Search the codebase.
+
+    Supports semantic search (by meaning) and text search (exact match).
+    """
+    from pathlib import Path
+    from ..graph.connection import configure_for_repo
+
+    try:
+        # Configure database for the repo
+        repo_root = Path(request.repo_path).resolve()
+        configure_for_repo(repo_root)
+
+        toolkit = _get_toolkit()
+
+        if request.type == SearchType.SEMANTIC:
+            result = toolkit.search(
+                query=request.query,
+                limit=request.limit,
+            )
+        else:
+            result = toolkit.text_search(
+                query=request.query,
+                limit=request.limit,
+            )
+
+        if not result.success:
+            raise HTTPException(status_code=500, detail=result.error)
+
+        # Convert results
+        results = []
+        for item in result.data.get("results", []):
+            results.append(SearchResult(
+                qualified_name=item.get("qualified_name", ""),
+                name=item.get("name", ""),
+                entity_type=item.get("type", ""),
+                file_path=item.get("file_path", ""),
+                line_number=item.get("line_number"),
+                score=item.get("score", 0.0),
+                importance=item.get("importance") if request.include_importance else None,
+                snippet=item.get("snippet") if request.include_snippets else None,
+            ))
+
+        return SearchResponse(
+            results=results,
+            total=len(results),
+            query=request.query,
+            search_type=request.type.value,
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/quick")
+async def quick_search(repo_path: str, q: str, limit: int = 10):
+    """Quick semantic search endpoint.
+
+    Simple GET endpoint for quick searches.
+    """
+    request = SearchRequest(repo_path=repo_path, query=q, limit=limit)
+    return await search(request)

emdash_core/api/spec.py

@@ -0,0 +1,99 @@
+"""Feature specification endpoints with SSE streaming."""
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+from ..sse.stream import SSEHandler, EventType
+
+router = APIRouter(prefix="/spec", tags=["specification"])
+
+_executor = ThreadPoolExecutor(max_workers=2)
+
+
+class SpecRequest(BaseModel):
+    """Request to generate a feature specification."""
+    feature: str = Field(..., description="Feature description")
+    project_md: Optional[str] = Field(default=None, description="PROJECT.md content")
+    model: Optional[str] = Field(default=None, description="LLM model to use")
+    verbose: bool = Field(default=False, description="Verbose output")
+
+
+class SpecResponse(BaseModel):
+    """Feature specification response."""
+    title: str
+    content: str
+    file_path: Optional[str] = None
+
+
+def _run_spec_sync(
+    feature: str,
+    model: Optional[str],
+    sse_handler: SSEHandler,
+):
+    """Run spec generation synchronously."""
+    try:
+        from ..agent.specification import SpecificationAgent
+        from ..agent.events import AgentEventEmitter
+
+        # Bridge events to SSE
+        class SSEBridge:
+            def __init__(self, handler):
+                self._handler = handler
+
+            def handle(self, event):
+                self._handler.handle(event)
+
+        emitter = AgentEventEmitter(agent_name="Specification")
+        emitter.add_handler(SSEBridge(sse_handler))
+
+        # Use default model if not specified
+        from ..agent.providers.factory import DEFAULT_MODEL
+        agent = SpecificationAgent(model=model or DEFAULT_MODEL, emitter=emitter, interactive=False)
+        spec = agent.generate_spec(feature)
+
+        sse_handler.emit(EventType.RESPONSE, {
+            "title": spec.title,
+            "content": spec.content,
+        })
+
+    except Exception as e:
+        sse_handler.emit(EventType.ERROR, {"message": str(e)})
+    finally:
+        sse_handler.close()
+
+
+@router.post("/generate")
+async def generate_spec(request: SpecRequest):
+    """Generate a feature specification with SSE streaming.
+
+    Returns a detailed specification for implementing a feature.
+    """
+    sse_handler = SSEHandler(agent_name="Specification")
+
+    sse_handler.emit(EventType.SESSION_START, {
+        "agent_name": "Specification",
+        "feature": request.feature,
+    })
+
+    async def run():
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(
+            _executor,
+            _run_spec_sync,
+            request.feature,
+            request.model,
+            sse_handler,
+        )
+
+    asyncio.create_task(run())
+
+    return StreamingResponse(
+        sse_handler,
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
+    )