emdash-core 0.1.7__py3-none-any.whl

emdash_core/api/embed.py

@@ -0,0 +1,131 @@
+"""Embedding endpoints."""
+
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+router = APIRouter(prefix="/embed", tags=["embeddings"])
+
+
+class EmbedIndexRequest(BaseModel):
+    """Request to index embeddings."""
+    repo_path: str = Field(..., description="Path to repository")
+    include_prs: bool = Field(default=True, description="Index PR embeddings")
+    include_functions: bool = Field(default=True, description="Index function embeddings")
+    include_classes: bool = Field(default=True, description="Index class embeddings")
+    reindex: bool = Field(default=False, description="Reindex all embeddings")
+
+
+class EmbedStatus(BaseModel):
+    """Embedding status."""
+    total_entities: int
+    embedded_entities: int
+    coverage_percent: float
+    pr_count: int
+    function_count: int
+    class_count: int
+
+
+class EmbedModel(BaseModel):
+    """Embedding model info."""
+    name: str
+    dimension: int
+    description: str
+
+
+@router.get("/status", response_model=EmbedStatus)
+async def get_embed_status():
+    """Get embedding coverage statistics."""
+    try:
+        from ..embeddings.service import EmbeddingService
+
+        service = EmbeddingService()
+        stats = service.get_coverage_stats()
+
+        total = stats.get("total", 1)
+        embedded = stats.get("embedded", 0)
+
+        return EmbedStatus(
+            total_entities=total,
+            embedded_entities=embedded,
+            coverage_percent=(embedded / total * 100) if total > 0 else 0,
+            pr_count=stats.get("pr_count", 0),
+            function_count=stats.get("function_count", 0),
+            class_count=stats.get("class_count", 0),
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/index")
+async def index_embeddings(request: EmbedIndexRequest):
+    """Generate embeddings for graph entities."""
+    from pathlib import Path
+    from ..graph.connection import configure_for_repo
+    from ..embeddings.indexer import EmbeddingIndexer
+
+    try:
+        # Configure database for the repo
+        repo_root = Path(request.repo_path).resolve()
+        configure_for_repo(repo_root)
+
+        indexer = EmbeddingIndexer()
+        total_indexed = 0
+
+        if request.include_prs:
+            total_indexed += indexer.index_pull_requests()
+        if request.include_functions:
+            total_indexed += indexer.index_functions(reindex=request.reindex)
+        if request.include_classes:
+            total_indexed += indexer.index_classes(reindex=request.reindex)
+
+        return {
+            "success": True,
+            "indexed": total_indexed,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/models")
+async def list_models():
+    """List available embedding models."""
+    return {
+        "models": [
+            EmbedModel(
+                name="all-MiniLM-L6-v2",
+                dimension=384,
+                description="Fast, general purpose (default)",
+            ),
+            EmbedModel(
+                name="all-mpnet-base-v2",
+                dimension=768,
+                description="Higher quality, slower",
+            ),
+            EmbedModel(
+                name="paraphrase-multilingual-MiniLM-L12-v2",
+                dimension=384,
+                description="Multilingual support",
+            ),
+        ]
+    }
+
+
+@router.post("/test")
+async def test_embedding(text: str, model: Optional[str] = None):
+    """Test embedding generation with sample text."""
+    try:
+        from ..embeddings.service import EmbeddingService
+
+        service = EmbeddingService(model_name=model)
+        embedding = service.embed(text)
+
+        return {
+            "text": text[:100] + "..." if len(text) > 100 else text,
+            "dimension": len(embedding),
+            "model": model or "default",
+            "preview": embedding[:5],  # First 5 dimensions
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

emdash_core/api/feature.py

@@ -0,0 +1,143 @@
+"""Feature analysis endpoints."""
+
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+router = APIRouter(prefix="/feature", tags=["feature"])
+
+
+class FeatureContextRequest(BaseModel):
+    """Request for feature context."""
+    query: str = Field(..., description="Feature query")
+    hops: int = Field(default=2, description="Graph traversal hops")
+
+
+class FeatureEntity(BaseModel):
+    """An entity related to a feature."""
+    qualified_name: str
+    name: str
+    entity_type: str
+    file_path: str
+    relationship: str  # calls, called_by, imports, etc.
+
+
+class FeatureContextResponse(BaseModel):
+    """Feature context response."""
+    query: str
+    root_entities: list[FeatureEntity]
+    related_entities: list[FeatureEntity]
+    files: list[str]
+
+
+class FeatureExplainRequest(BaseModel):
+    """Request for LLM feature explanation."""
+    query: str = Field(..., description="Feature query")
+    hops: int = Field(default=2, description="Graph traversal hops")
+    style: str = Field(default="technical", description="Style: technical, simple, detailed")
+    model: Optional[str] = Field(default=None, description="LLM model")
+
+
+@router.post("/context", response_model=FeatureContextResponse)
+async def get_feature_context(request: FeatureContextRequest):
+    """Find a feature and expand its AST graph.
+
+    Searches for code matching the query and expands the graph
+    to find related entities.
+    """
+    try:
+        import sys
+        from pathlib import Path
+
+        from ..agent.toolkit import AgentToolkit
+
+        toolkit = AgentToolkit()
+
+        # Search for matching entities
+        search_result = toolkit.search(query=request.query, limit=5)
+
+        if not search_result.success:
+            raise HTTPException(status_code=500, detail=search_result.error)
+
+        root_entities = []
+        related_entities = []
+        files = set()
+
+        for r in search_result.data.get("results", []):
+            entity = FeatureEntity(
+                qualified_name=r.get("qualified_name", ""),
+                name=r.get("name", ""),
+                entity_type=r.get("type", ""),
+                file_path=r.get("file_path", ""),
+                relationship="root",
+            )
+            root_entities.append(entity)
+            files.add(r.get("file_path", ""))
+
+            # Expand each entity
+            if request.hops > 0:
+                expand_result = toolkit.expand(
+                    entity_type=r.get("type", "Function"),
+                    qualified_name=r.get("qualified_name", ""),
+                )
+
+                if expand_result.success:
+                    for rel_type in ["callers", "callees", "dependencies"]:
+                        for related in expand_result.data.get(rel_type, []):
+                            related_entities.append(FeatureEntity(
+                                qualified_name=related.get("qualified_name", ""),
+                                name=related.get("name", ""),
+                                entity_type=related.get("type", ""),
+                                file_path=related.get("file_path", ""),
+                                relationship=rel_type,
+                            ))
+                            files.add(related.get("file_path", ""))
+
+        return FeatureContextResponse(
+            query=request.query,
+            root_entities=root_entities,
+            related_entities=related_entities[:20],  # Limit
+            files=list(files)[:20],
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/explain")
+async def explain_feature(request: FeatureExplainRequest):
+    """Explain a feature using LLM based on AST graph."""
+    try:
+        import sys
+        from pathlib import Path
+
+        from ..planning.llm_explainer import LLMExplainer
+
+        explainer = LLMExplainer(model=request.model)
+
+        # Get context first
+        context_request = FeatureContextRequest(
+            query=request.query,
+            hops=request.hops,
+        )
+        context = await get_feature_context(context_request)
+
+        # Generate explanation
+        explanation = explainer.explain(
+            query=request.query,
+            context=context.model_dump(),
+            style=request.style,
+        )
+
+        return {
+            "query": request.query,
+            "explanation": explanation,
+            "entities_analyzed": len(context.root_entities) + len(context.related_entities),
+            "files_analyzed": len(context.files),
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

emdash_core/api/health.py

@@ -0,0 +1,93 @@
+"""Health check endpoint."""
+
+import time
+from datetime import datetime
+from typing import Optional
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from ..config import get_config
+
+router = APIRouter(prefix="/health", tags=["health"])
+
+# Server start time for uptime calculation
+_start_time: float = time.time()
+
+
+class DatabaseStatus(BaseModel):
+    """Database connection status."""
+
+    connected: bool
+    node_count: Optional[int] = None
+    relationship_count: Optional[int] = None
+    error: Optional[str] = None
+
+
+class HealthResponse(BaseModel):
+    """Health check response."""
+
+    status: str  # "healthy", "starting", "unhealthy"
+    version: str
+    uptime_seconds: float
+    repo_root: Optional[str]
+    database: DatabaseStatus
+    timestamp: datetime
+
+
+def _check_database() -> DatabaseStatus:
+    """Check database connection status."""
+    config = get_config()
+
+    try:
+        # Try to import and connect to database
+        # This will be replaced with actual database check once services are moved
+        db_path = config.database_full_path
+        if db_path.exists():
+            return DatabaseStatus(
+                connected=True,
+                node_count=0,  # TODO: Get actual counts
+                relationship_count=0,
+            )
+        else:
+            return DatabaseStatus(
+                connected=False,
+                error="Database not initialized"
+            )
+    except Exception as e:
+        return DatabaseStatus(
+            connected=False,
+            error=str(e)
+        )
+
+
+@router.get("", response_model=HealthResponse)
+async def health_check() -> HealthResponse:
+    """Check server health status."""
+    from .. import __version__
+
+    config = get_config()
+    db_status = _check_database()
+
+    status = "healthy" if db_status.connected else "starting"
+
+    return HealthResponse(
+        status=status,
+        version=__version__,
+        uptime_seconds=time.time() - _start_time,
+        repo_root=config.repo_root,
+        database=db_status,
+        timestamp=datetime.now(),
+    )
+
+
+@router.get("/ready")
+async def readiness_check() -> dict:
+    """Simple readiness probe for container orchestration."""
+    return {"ready": True}
+
+
+@router.get("/live")
+async def liveness_check() -> dict:
+    """Simple liveness probe for container orchestration."""
+    return {"alive": True}

emdash_core/api/index.py

@@ -0,0 +1,162 @@
+"""Indexing 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="/index", tags=["indexing"])
+
+_executor = ThreadPoolExecutor(max_workers=2)
+
+
+class IndexOptions(BaseModel):
+    """Options for indexing operation."""
+    changed_only: bool = Field(default=False, description="Only index changed files")
+    index_git: bool = Field(default=False, description="Index git history")
+    index_github: int = Field(default=0, description="Number of GitHub PRs to index")
+    detect_communities: bool = Field(default=True, description="Run community detection")
+    describe_communities: bool = Field(default=False, description="Use LLM to describe communities")
+    community_limit: int = Field(default=20, description="Max communities to describe")
+    model: Optional[str] = Field(default=None, description="Model for descriptions")
+
+
+class IndexRequest(BaseModel):
+    """Request to start indexing."""
+    repo_path: str = Field(..., description="Path to repository")
+    options: IndexOptions = Field(default_factory=IndexOptions)
+
+
+class IndexStatus(BaseModel):
+    """Current indexing status."""
+    is_indexed: bool
+    last_indexed: Optional[str]
+    last_commit: Optional[str]
+    file_count: int
+    function_count: int
+    class_count: int
+    community_count: int
+
+
+def _run_index_sync(
+    repo_path: str,
+    options: IndexOptions,
+    sse_handler: SSEHandler,
+):
+    """Run indexing synchronously in thread pool."""
+    from pathlib import Path
+
+    try:
+        from ..graph.connection import configure_for_repo
+        from ..ingestion.orchestrator import IngestionOrchestrator
+
+        sse_handler.emit(EventType.PROGRESS, {"step": "Starting indexing", "percent": 0})
+
+        # Configure database for target repo
+        repo_root = Path(repo_path).resolve()
+        configure_for_repo(repo_root)
+
+        # Create orchestrator (uses configured connection)
+        orchestrator = IngestionOrchestrator()
+
+        sse_handler.emit(EventType.PROGRESS, {"step": "Parsing codebase", "percent": 10})
+
+        # Progress callback to emit SSE events during parsing
+        def progress_callback(step: str, percent: float):
+            sse_handler.emit(EventType.PROGRESS, {"step": step, "percent": percent})
+
+        # Run indexing with progress callback
+        result = orchestrator.index(
+            repo_path=repo_path,
+            changed_only=options.changed_only,
+            skip_git=not options.index_git,
+            pr_limit=options.index_github,
+            progress_callback=progress_callback,
+        )
+
+        sse_handler.emit(EventType.PROGRESS, {"step": "Building graph", "percent": 75})
+
+        if options.detect_communities:
+            sse_handler.emit(EventType.PROGRESS, {"step": "Detecting communities", "percent": 85})
+
+        sse_handler.emit(EventType.PROGRESS, {"step": "Indexing complete", "percent": 100})
+
+        sse_handler.emit(EventType.RESPONSE, {
+            "success": True,
+            "stats": result if isinstance(result, dict) else {},
+        })
+
+    except Exception as e:
+        sse_handler.emit(EventType.ERROR, {
+            "message": str(e),
+        })
+    finally:
+        sse_handler.close()
+
+
+@router.post("/start")
+async def index_start(request: IndexRequest):
+    """Start indexing a repository with SSE streaming progress.
+
+    Returns a Server-Sent Events stream with progress updates.
+    """
+    sse_handler = SSEHandler(agent_name="Indexer")
+
+    async def run_indexing():
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(
+            _executor,
+            _run_index_sync,
+            request.repo_path,
+            request.options,
+            sse_handler,
+        )
+
+    asyncio.create_task(run_indexing())
+
+    return StreamingResponse(
+        sse_handler,
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+        },
+    )
+
+
+@router.get("/status", response_model=IndexStatus)
+async def index_status(repo_path: str):
+    """Get current indexing status for a repository."""
+    try:
+        from pathlib import Path
+        from ..graph.connection import configure_for_repo
+
+        # Configure database for the target repo
+        repo_root = Path(repo_path).resolve()
+        conn = configure_for_repo(repo_root)
+        info = conn.get_database_info()
+
+        return IndexStatus(
+            is_indexed=info.get("node_count", 0) > 0,
+            last_indexed=None,  # TODO: Track this
+            last_commit=None,
+            file_count=info.get("file_count", 0),
+            function_count=info.get("function_count", 0),
+            class_count=info.get("class_count", 0),
+            community_count=info.get("community_count", 0),
+        )
+    except Exception:
+        return IndexStatus(
+            is_indexed=False,
+            last_indexed=None,
+            last_commit=None,
+            file_count=0,
+            function_count=0,
+            class_count=0,
+            community_count=0,
+        )

emdash_core/api/plan.py

@@ -0,0 +1,110 @@
+"""Planning endpoints."""
+
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+router = APIRouter(prefix="/plan", tags=["planning"])
+
+
+class PlanContextRequest(BaseModel):
+    """Request for planning context."""
+    repo_path: str = Field(..., description="Path to repository")
+    description: str = Field(..., description="Feature description")
+    similar_prs: int = Field(default=5, description="Number of similar PRs to find")
+
+
+class SimilarPR(BaseModel):
+    """A similar PR."""
+    number: int
+    title: str
+    score: float
+    files: list[str] = Field(default_factory=list)
+
+
+class PlanContextResponse(BaseModel):
+    """Planning context response."""
+    description: str
+    similar_prs: list[SimilarPR]
+    relevant_files: list[str]
+    relevant_functions: list[str]
+    suggested_approach: Optional[str] = None
+
+
+def _get_toolkit():
+    """Get agent toolkit."""
+    from ..agent.toolkit import AgentToolkit
+    return AgentToolkit()
+
+
+@router.post("/context", response_model=PlanContextResponse)
+async def get_plan_context(request: PlanContextRequest):
+    """Get planning context for a feature.
+
+    Returns similar PRs, relevant files, and suggested approach.
+    """
+    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()
+
+        # Search for relevant code
+        search_result = toolkit.search(query=request.description, limit=10)
+
+        relevant_files = []
+        relevant_functions = []
+        if search_result.success:
+            for r in search_result.data.get("results", []):
+                if r.get("type") == "File":
+                    relevant_files.append(r.get("file_path", ""))
+                else:
+                    relevant_functions.append(r.get("qualified_name", ""))
+
+        # TODO: Find similar PRs using embedding search
+        similar_prs = []
+
+        return PlanContextResponse(
+            description=request.description,
+            similar_prs=similar_prs,
+            relevant_files=relevant_files[:10],
+            relevant_functions=relevant_functions[:10],
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/similar")
+async def find_similar_prs(repo_path: str, description: str, limit: int = 5):
+    """Find PRs similar to a feature description."""
+    from pathlib import Path
+    from ..graph.connection import configure_for_repo
+
+    try:
+        # Configure database for the repo
+        repo_root = Path(repo_path).resolve()
+        configure_for_repo(repo_root)
+
+        from ..planning.similarity import SimilaritySearch
+
+        search = SimilaritySearch()
+        results = search.find_similar_prs(description, limit=limit)
+
+        return {
+            "similar_prs": [
+                SimilarPR(
+                    number=pr.get("number", 0),
+                    title=pr.get("title", ""),
+                    score=pr.get("score", 0.0),
+                    files=pr.get("files", []),
+                )
+                for pr in results
+            ]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))