emdash-core 0.1.7__py3-none-any.whl

emdash_core/api/projectmd.py

@@ -0,0 +1,210 @@
+"""PROJECT.md generation API endpoint 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
+
+from ..sse.stream import SSEHandler, EventType
+
+router = APIRouter(prefix="/projectmd", tags=["projectmd"])
+
+# Thread pool for running blocking agent code
+_executor = ThreadPoolExecutor(max_workers=2)
+
+
+class ProjectMDRequest(BaseModel):
+    """Request for PROJECT.md generation."""
+    output: str = "PROJECT.md"
+    save: bool = True
+    model: Optional[str] = None
+
+
+class ProjectMDResponse(BaseModel):
+    """Response from PROJECT.md generation."""
+    success: bool
+    content: Optional[str] = None
+    output_path: Optional[str] = None
+    error: Optional[str] = None
+
+
+def _generate_projectmd_sync(
+    output: str,
+    save: bool,
+    model: str,
+    sse_handler: SSEHandler,
+):
+    """Run PROJECT.md generation synchronously (in thread pool).
+
+    This function runs in a background thread and emits events
+    to the SSE handler for streaming to the client.
+    """
+    try:
+        # Import discovery agent
+        from ..agent.discovery import ProjectDiscoveryAgent
+
+        # Emit start
+        sse_handler.emit(EventType.SESSION_START, {
+            "agent_name": "Project Discovery",
+            "model": model,
+            "output": output,
+        })
+
+        # Create and run discovery agent
+        agent = ProjectDiscoveryAgent(
+            model=model,
+            verbose=True,
+        )
+
+        # Generate PROJECT.md content
+        content = agent.run()
+
+        # Save if requested
+        output_path = None
+        if save and content:
+            from pathlib import Path
+            output_path = Path(output)
+            output_path.write_text(content)
+            sse_handler.emit(EventType.THINKING, {
+                "message": f"Saved to {output_path}",
+            })
+
+        # Emit final response
+        sse_handler.emit(EventType.RESPONSE, {
+            "content": content,
+            "saved": save,
+            "output_path": str(output_path) if output_path else None,
+        })
+
+        return content
+
+    except ImportError as e:
+        # Discovery agent not available, use simpler approach
+        sse_handler.emit(EventType.WARNING, {
+            "message": f"Discovery agent not available: {e}. Using basic generation.",
+        })
+
+        try:
+            from ..agent.runner import AgentRunner
+            from ..agent.events import AgentEventEmitter
+
+            # Create emitter that forwards to SSE handler
+            class SSEBridgeHandler:
+                def __init__(self, sse_handler: SSEHandler):
+                    self._sse = sse_handler
+
+                def handle(self, event):
+                    self._sse.handle(event)
+
+            emitter = AgentEventEmitter(agent_name="Project Discovery")
+            emitter.add_handler(SSEBridgeHandler(sse_handler))
+
+            runner = AgentRunner(
+                model=model,
+                verbose=True,
+                max_iterations=30,
+                emitter=emitter,
+            )
+
+            # Use a simple prompt for PROJECT.md generation
+            prompt = """Explore this codebase and generate a PROJECT.md document that describes:
+1. What this project is and does
+2. The main architecture and components
+3. Key files and their purposes
+4. How to get started
+
+Use the available tools to explore the codebase, then write a comprehensive PROJECT.md."""
+
+            content = runner.run(prompt)
+
+            if save and content:
+                from pathlib import Path
+                output_path = Path(output)
+                output_path.write_text(content)
+
+            return content
+
+        except Exception as inner_e:
+            sse_handler.emit(EventType.ERROR, {
+                "message": str(inner_e),
+            })
+            raise
+
+    except Exception as e:
+        sse_handler.emit(EventType.ERROR, {
+            "message": str(e),
+        })
+        raise
+
+
+async def _generate_projectmd_async(
+    request: ProjectMDRequest,
+    sse_handler: SSEHandler,
+):
+    """Generate PROJECT.md and stream events."""
+    from ..config import get_config
+
+    config = get_config()
+    model = request.model or config.default_model
+
+    loop = asyncio.get_event_loop()
+
+    try:
+        await loop.run_in_executor(
+            _executor,
+            _generate_projectmd_sync,
+            request.output,
+            request.save,
+            model,
+            sse_handler,
+        )
+
+        sse_handler.emit(EventType.SESSION_END, {
+            "success": True,
+        })
+
+    except Exception as e:
+        sse_handler.emit(EventType.SESSION_END, {
+            "success": False,
+            "error": str(e),
+        })
+
+    finally:
+        sse_handler.close()
+
+
+@router.post("/generate")
+async def generate_projectmd(request: ProjectMDRequest):
+    """Generate PROJECT.md by exploring the codebase.
+
+    Uses AI to analyze the code graph and generate a comprehensive
+    project document that describes architecture, patterns, and
+    key components.
+
+    The response is a Server-Sent Events stream containing:
+    - session_start: Initial session info
+    - tool_start/tool_result: Exploration progress
+    - thinking: Agent reasoning
+    - response: Final PROJECT.md content
+    - session_end: Completion status
+
+    Example:
+        curl -N -X POST http://localhost:8765/api/projectmd/generate \\
+            -H "Content-Type: application/json" \\
+            -d '{"output": "PROJECT.md", "save": true}'
+    """
+    sse_handler = SSEHandler(agent_name="Project Discovery")
+
+    asyncio.create_task(_generate_projectmd_async(request, sse_handler))
+
+    return StreamingResponse(
+        sse_handler,
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+        },
+    )

emdash_core/api/query.py

@@ -0,0 +1,320 @@
+"""Graph query endpoints."""
+
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+router = APIRouter(prefix="/query", tags=["query"])
+
+
+class EntityResult(BaseModel):
+    """A code entity result."""
+    qualified_name: str
+    name: str
+    entity_type: str
+    file_path: str
+    line_number: Optional[int] = None
+    source: Optional[str] = None
+
+
+class ExpandRequest(BaseModel):
+    """Request to expand a node."""
+    entity_type: str = Field(..., description="Type: File, Class, Function")
+    qualified_name: str = Field(..., description="Qualified name of entity")
+    max_hops: int = Field(default=2, description="Max traversal depth")
+    include_source: bool = Field(default=True, description="Include source code")
+
+
+class ExpandResponse(BaseModel):
+    """Expanded node with relationships."""
+    entity: EntityResult
+    callers: list[EntityResult] = Field(default_factory=list)
+    callees: list[EntityResult] = Field(default_factory=list)
+    dependencies: list[EntityResult] = Field(default_factory=list)
+    dependents: list[EntityResult] = Field(default_factory=list)
+
+
+class KnowledgeSilo(BaseModel):
+    """A knowledge silo - critical code with few maintainers."""
+    file_path: str
+    importance_score: float
+    author_count: int
+    authors: list[str]
+    function_count: int
+
+
+def _get_toolkit():
+    """Get agent toolkit."""
+    from ..agent.toolkit import AgentToolkit
+    return AgentToolkit()
+
+
+@router.get("/find-class/{name}")
+async def find_class(name: str):
+    """Find a class by name."""
+    try:
+        toolkit = _get_toolkit()
+        result = toolkit.text_search(query=name, entity_types=["Class"])
+
+        if not result.success:
+            raise HTTPException(status_code=500, detail=result.error)
+
+        return {
+            "results": [
+                EntityResult(
+                    qualified_name=r.get("qualified_name", ""),
+                    name=r.get("name", ""),
+                    entity_type="Class",
+                    file_path=r.get("file_path", ""),
+                    line_number=r.get("line_number"),
+                )
+                for r in result.data.get("results", [])
+            ]
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/find-function/{name}")
+async def find_function(name: str):
+    """Find a function by name."""
+    try:
+        toolkit = _get_toolkit()
+        result = toolkit.text_search(query=name, entity_types=["Function"])
+
+        if not result.success:
+            raise HTTPException(status_code=500, detail=result.error)
+
+        return {
+            "results": [
+                EntityResult(
+                    qualified_name=r.get("qualified_name", ""),
+                    name=r.get("name", ""),
+                    entity_type="Function",
+                    file_path=r.get("file_path", ""),
+                    line_number=r.get("line_number"),
+                )
+                for r in result.data.get("results", [])
+            ]
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/expand", response_model=ExpandResponse)
+async def expand_node(request: ExpandRequest):
+    """Expand a node to see its relationships.
+
+    Returns callers, callees, dependencies, and dependents.
+    """
+    try:
+        toolkit = _get_toolkit()
+        result = toolkit.expand(
+            entity_type=request.entity_type,
+            qualified_name=request.qualified_name,
+        )
+
+        if not result.success:
+            raise HTTPException(status_code=500, detail=result.error)
+
+        data = result.data
+        entity_data = data.get("entity", {})
+
+        return ExpandResponse(
+            entity=EntityResult(
+                qualified_name=entity_data.get("qualified_name", request.qualified_name),
+                name=entity_data.get("name", ""),
+                entity_type=request.entity_type,
+                file_path=entity_data.get("file_path", ""),
+                line_number=entity_data.get("line_number"),
+                source=entity_data.get("source") if request.include_source else None,
+            ),
+            callers=[
+                EntityResult(
+                    qualified_name=c.get("qualified_name", ""),
+                    name=c.get("name", ""),
+                    entity_type=c.get("type", ""),
+                    file_path=c.get("file_path", ""),
+                )
+                for c in data.get("callers", [])
+            ],
+            callees=[
+                EntityResult(
+                    qualified_name=c.get("qualified_name", ""),
+                    name=c.get("name", ""),
+                    entity_type=c.get("type", ""),
+                    file_path=c.get("file_path", ""),
+                )
+                for c in data.get("callees", [])
+            ],
+            dependencies=[
+                EntityResult(
+                    qualified_name=d.get("qualified_name", ""),
+                    name=d.get("name", ""),
+                    entity_type=d.get("type", ""),
+                    file_path=d.get("file_path", ""),
+                )
+                for d in data.get("dependencies", [])
+            ],
+            dependents=[
+                EntityResult(
+                    qualified_name=d.get("qualified_name", ""),
+                    name=d.get("name", ""),
+                    entity_type=d.get("type", ""),
+                    file_path=d.get("file_path", ""),
+                )
+                for d in data.get("dependents", [])
+            ],
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/callers/{qualified_name:path}")
+async def get_callers(qualified_name: str, depth: int = 1):
+    """Get all callers of a function."""
+    try:
+        toolkit = _get_toolkit()
+        result = toolkit.get_callers(qualified_name=qualified_name, depth=depth)
+
+        if not result.success:
+            raise HTTPException(status_code=500, detail=result.error)
+
+        return {
+            "callers": [
+                EntityResult(
+                    qualified_name=c.get("qualified_name", ""),
+                    name=c.get("name", ""),
+                    entity_type=c.get("type", "Function"),
+                    file_path=c.get("file_path", ""),
+                )
+                for c in result.data.get("callers", [])
+            ]
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/callees/{qualified_name:path}")
+async def get_callees(qualified_name: str, depth: int = 1):
+    """Get all callees of a function."""
+    try:
+        toolkit = _get_toolkit()
+        result = toolkit.get_callees(qualified_name=qualified_name, depth=depth)
+
+        if not result.success:
+            raise HTTPException(status_code=500, detail=result.error)
+
+        return {
+            "callees": [
+                EntityResult(
+                    qualified_name=c.get("qualified_name", ""),
+                    name=c.get("name", ""),
+                    entity_type=c.get("type", "Function"),
+                    file_path=c.get("file_path", ""),
+                )
+                for c in result.data.get("callees", [])
+            ]
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/hierarchy/{class_name:path}")
+async def get_class_hierarchy(class_name: str, direction: str = "both"):
+    """Get class inheritance hierarchy.
+
+    Args:
+        class_name: Qualified name of class
+        direction: 'up' (parents), 'down' (children), or 'both'
+    """
+    try:
+        toolkit = _get_toolkit()
+        result = toolkit.get_class_hierarchy(
+            class_name=class_name,
+            direction=direction,
+        )
+
+        if not result.success:
+            raise HTTPException(status_code=500, detail=result.error)
+
+        return result.data
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/dependencies/{file_path:path}")
+async def get_file_dependencies(file_path: str, direction: str = "both"):
+    """Get file import dependencies.
+
+    Args:
+        file_path: Path to file
+        direction: 'imports', 'imported_by', or 'both'
+    """
+    try:
+        toolkit = _get_toolkit()
+        result = toolkit.get_file_dependencies(
+            file_path=file_path,
+            direction=direction,
+        )
+
+        if not result.success:
+            raise HTTPException(status_code=500, detail=result.error)
+
+        return result.data
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/knowledge-silos")
+async def get_knowledge_silos(
+    threshold: float = 0.7,
+    max_authors: int = 2,
+    top: int = 20,
+):
+    """Detect knowledge silos - critical code with few maintainers.
+
+    Args:
+        threshold: Minimum importance score
+        max_authors: Maximum number of authors to be considered a silo
+        top: Number of silos to return
+    """
+    try:
+        from ..analytics.engine import AnalyticsEngine
+
+        engine = AnalyticsEngine()
+        silos = engine.detect_knowledge_silos(
+            importance_threshold=threshold,
+            max_authors=max_authors,
+            top=top,
+        )
+
+        return {
+            "silos": [
+                KnowledgeSilo(
+                    file_path=s.get("file_path", ""),
+                    importance_score=s.get("importance_score", 0.0),
+                    author_count=s.get("author_count", 0),
+                    authors=s.get("authors", []),
+                    function_count=s.get("function_count", 0),
+                )
+                for s in silos
+            ]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

emdash_core/api/research.py

@@ -0,0 +1,122 @@
+"""Research 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="/research", tags=["research"])
+
+_executor = ThreadPoolExecutor(max_workers=2)
+
+
+class ResearchRequest(BaseModel):
+    """Request for deep research."""
+    goal: str = Field(..., description="Research goal")
+    max_iterations: int = Field(default=5, description="Max research iterations")
+    budget: int = Field(default=50000, description="Token budget")
+    model: Optional[str] = Field(default=None, description="LLM model for main tasks")
+    researcher_model: Optional[str] = Field(default=None, description="LLM for research")
+
+
+class ResearchResponse(BaseModel):
+    """Research response."""
+    goal: str
+    findings: str
+    sources: list[str]
+    iterations: int
+
+
+def _run_research_sync(
+    goal: str,
+    max_iterations: int,
+    model: Optional[str],
+    researcher_model: Optional[str],
+    sse_handler: SSEHandler,
+):
+    """Run research synchronously."""
+    import sys
+    from pathlib import Path
+
+    repo_root = Path(__file__).parent.parent.parent.parent.parent
+    if str(repo_root) not in sys.path:
+        sys.path.insert(0, str(repo_root))
+
+    try:
+        from ..agent.research.agent import ResearchAgent
+        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="Research")
+        emitter.add_handler(SSEBridge(sse_handler))
+
+        agent = ResearchAgent(
+            planner_model=model,
+            researcher_model=researcher_model or model,
+            critic_model=model,
+            synthesizer_model=model,
+            emitter=emitter,
+        )
+
+        result = agent.research(goal, max_iterations=max_iterations)
+
+        sse_handler.emit(EventType.RESPONSE, {
+            "goal": goal,
+            "findings": result.get("synthesis", ""),
+            "sources": result.get("sources", []),
+            "iterations": result.get("iterations", 0),
+        })
+
+    except Exception as e:
+        sse_handler.emit(EventType.ERROR, {"message": str(e)})
+    finally:
+        sse_handler.close()
+
+
+@router.post("")
+async def research(request: ResearchRequest):
+    """Deep research with multi-LLM loops and critic evaluation.
+
+    Uses multiple specialized agents:
+    - Planner: Creates research plan
+    - Researcher: Gathers information
+    - Critic: Evaluates findings
+    - Synthesizer: Produces final report
+    """
+    sse_handler = SSEHandler(agent_name="Research")
+
+    sse_handler.emit(EventType.SESSION_START, {
+        "agent_name": "Research",
+        "goal": request.goal,
+    })
+
+    async def run():
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(
+            _executor,
+            _run_research_sync,
+            request.goal,
+            request.max_iterations,
+            request.model,
+            request.researcher_model,
+            sse_handler,
+        )
+
+    asyncio.create_task(run())
+
+    return StreamingResponse(
+        sse_handler,
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
+    )