emdash-core 0.1.7__py3-none-any.whl

emdash_core/api/analyze.py

@@ -0,0 +1,264 @@
+"""Analytics endpoints."""
+
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+router = APIRouter(prefix="/analyze", tags=["analytics"])
+
+
+class PageRankResult(BaseModel):
+    """PageRank result for an entity."""
+    qualified_name: str
+    name: str
+    entity_type: str
+    file_path: str
+    score: float
+
+
+class PageRankResponse(BaseModel):
+    """PageRank response."""
+    results: list[PageRankResult]
+    damping: float
+
+
+class CommunityMember(BaseModel):
+    """A member of a community."""
+    qualified_name: str
+    name: str
+    entity_type: str
+    file_path: str
+
+
+class Community(BaseModel):
+    """A detected community."""
+    id: int
+    size: int
+    description: Optional[str] = None
+    members: list[CommunityMember] = Field(default_factory=list)
+    top_files: list[str] = Field(default_factory=list)
+
+
+class CommunityResponse(BaseModel):
+    """Community detection response."""
+    communities: list[Community]
+    total: int
+
+
+class AreaImportance(BaseModel):
+    """Importance metrics for a directory/file."""
+    path: str
+    commit_count: int
+    author_count: int
+    churn: int
+    importance_score: float
+
+
+class AreasResponse(BaseModel):
+    """Areas importance response."""
+    areas: list[AreaImportance]
+
+
+class BetweennessResult(BaseModel):
+    """Betweenness centrality result."""
+    qualified_name: str
+    name: str
+    entity_type: str
+    score: float
+
+
+def _get_analytics():
+    """Get analytics engine."""
+    from ..analytics.engine import AnalyticsEngine
+    return AnalyticsEngine()
+
+
+@router.get("/pagerank", response_model=PageRankResponse)
+async def get_pagerank(top: int = 20, damping: float = 0.85):
+    """Compute PageRank scores to identify important code.
+
+    PageRank identifies code that is heavily depended upon.
+    """
+    try:
+        engine = _get_analytics()
+        results = engine.compute_pagerank(top=top, damping=damping)
+
+        return PageRankResponse(
+            results=[
+                PageRankResult(
+                    qualified_name=r.get("qualified_name", ""),
+                    name=r.get("name", ""),
+                    entity_type=r.get("type", ""),
+                    file_path=r.get("file_path", ""),
+                    score=r.get("score", 0.0),
+                )
+                for r in results
+            ],
+            damping=damping,
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/communities", response_model=CommunityResponse)
+async def get_communities(
+    top: int = 10,
+    resolution: float = 1.0,
+    include_members: bool = False,
+    query: Optional[str] = None,
+):
+    """Detect code communities using Louvain algorithm.
+
+    Communities are clusters of tightly related code.
+
+    Args:
+        top: Number of top communities to return
+        resolution: Louvain resolution parameter
+        include_members: Include community members in response
+        query: Filter communities by semantic query
+    """
+    try:
+        engine = _get_analytics()
+        communities = engine.detect_communities(
+            resolution=resolution,
+            top=top,
+        )
+
+        result = []
+        for c in communities:
+            community = Community(
+                id=c.get("id", 0),
+                size=c.get("size", 0),
+                description=c.get("description"),
+                top_files=c.get("top_files", []),
+            )
+            if include_members:
+                community.members = [
+                    CommunityMember(
+                        qualified_name=m.get("qualified_name", ""),
+                        name=m.get("name", ""),
+                        entity_type=m.get("type", ""),
+                        file_path=m.get("file_path", ""),
+                    )
+                    for m in c.get("members", [])
+                ]
+            result.append(community)
+
+        return CommunityResponse(
+            communities=result,
+            total=len(result),
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/communities/{community_id}")
+async def get_community(community_id: int):
+    """Get details of a specific community."""
+    try:
+        engine = _get_analytics()
+        community = engine.get_community(community_id)
+
+        if not community:
+            raise HTTPException(status_code=404, detail="Community not found")
+
+        return Community(
+            id=community.get("id", community_id),
+            size=community.get("size", 0),
+            description=community.get("description"),
+            top_files=community.get("top_files", []),
+            members=[
+                CommunityMember(
+                    qualified_name=m.get("qualified_name", ""),
+                    name=m.get("name", ""),
+                    entity_type=m.get("type", ""),
+                    file_path=m.get("file_path", ""),
+                )
+                for m in community.get("members", [])
+            ],
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/areas", response_model=AreasResponse)
+async def get_areas(
+    depth: int = 2,
+    days: int = 90,
+    top: int = 20,
+    sort: str = "importance",
+    include_files: bool = False,
+):
+    """Get importance metrics by directory/file.
+
+    Args:
+        depth: Directory depth to analyze
+        days: Number of days of history to consider
+        top: Number of top areas to return
+        sort: Sort by: importance, commits, churn, authors
+        include_files: Include individual files (not just directories)
+    """
+    try:
+        engine = _get_analytics()
+        areas = engine.get_area_importance(
+            depth=depth,
+            days=days,
+            top=top,
+            sort_by=sort,
+            include_files=include_files,
+        )
+
+        return AreasResponse(
+            areas=[
+                AreaImportance(
+                    path=a.get("path", ""),
+                    commit_count=a.get("commit_count", 0),
+                    author_count=a.get("author_count", 0),
+                    churn=a.get("churn", 0),
+                    importance_score=a.get("importance_score", 0.0),
+                )
+                for a in areas
+            ]
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/betweenness")
+async def get_betweenness(top: int = 20):
+    """Compute betweenness centrality.
+
+    Identifies bridge entities that connect different parts of the codebase.
+    """
+    try:
+        engine = _get_analytics()
+        results = engine.compute_betweenness(top=top)
+
+        return {
+            "results": [
+                BetweennessResult(
+                    qualified_name=r.get("qualified_name", ""),
+                    name=r.get("name", ""),
+                    entity_type=r.get("type", ""),
+                    score=r.get("score", 0.0),
+                )
+                for r in results
+            ]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/commit-importance")
+async def get_commit_importance(top: int = 20):
+    """Score files by commit frequency and author diversity."""
+    try:
+        engine = _get_analytics()
+        results = engine.get_commit_importance(top=top)
+
+        return {"results": results}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

emdash_core/api/auth.py

@@ -0,0 +1,173 @@
+"""GitHub OAuth authentication API endpoints."""
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/auth", tags=["auth"])
+
+# Thread pool for blocking operations
+_executor = ThreadPoolExecutor(max_workers=2)
+
+
+class LoginResponse(BaseModel):
+    """Response from login initiation."""
+    user_code: str
+    verification_uri: str
+    expires_in: int
+    interval: int
+
+
+class AuthStatus(BaseModel):
+    """Current authentication status."""
+    authenticated: bool
+    username: Optional[str] = None
+    scope: Optional[str] = None
+
+
+class LoginPollResponse(BaseModel):
+    """Response from login polling."""
+    status: str  # "pending", "success", "expired", "error"
+    username: Optional[str] = None
+    error: Optional[str] = None
+
+
+# Store active device flow states
+_device_flows: dict[str, dict] = {}
+
+
+@router.post("/login", response_model=LoginResponse)
+async def start_login():
+    """Start GitHub OAuth device flow.
+
+    Returns a user code that the user must enter at github.com/login/device.
+    The client should then poll /auth/login/poll until authentication completes.
+
+    Example:
+        curl -X POST http://localhost:8765/api/auth/login
+    """
+    from ..auth.github import GitHubAuth
+
+    loop = asyncio.get_event_loop()
+
+    def _request_device_code():
+        auth = GitHubAuth()
+        return auth.request_device_code()
+
+    try:
+        response = await loop.run_in_executor(_executor, _request_device_code)
+
+        # Store device code for polling
+        _device_flows[response.user_code] = {
+            "device_code": response.device_code,
+            "interval": response.interval,
+            "expires_in": response.expires_in,
+        }
+
+        return LoginResponse(
+            user_code=response.user_code,
+            verification_uri=response.verification_uri,
+            expires_in=response.expires_in,
+            interval=response.interval,
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/login/poll/{user_code}", response_model=LoginPollResponse)
+async def poll_login(user_code: str):
+    """Poll for login completion.
+
+    After starting login, the client should poll this endpoint
+    every `interval` seconds until status is "success" or "expired".
+
+    Args:
+        user_code: The user code returned from /auth/login
+
+    Example:
+        curl -X POST http://localhost:8765/api/auth/login/poll/ABCD-1234
+    """
+    from ..auth.github import GitHubAuth
+
+    if user_code not in _device_flows:
+        raise HTTPException(status_code=404, detail="Device flow not found")
+
+    flow = _device_flows[user_code]
+    device_code = flow["device_code"]
+
+    loop = asyncio.get_event_loop()
+
+    def _poll_for_token():
+        auth = GitHubAuth()
+        return auth.poll_for_token(device_code)
+
+    try:
+        result = await loop.run_in_executor(_executor, _poll_for_token)
+
+        if result is None:
+            # Still pending
+            return LoginPollResponse(status="pending")
+
+        if isinstance(result, str):
+            # Error message
+            if "expired" in result.lower():
+                del _device_flows[user_code]
+                return LoginPollResponse(status="expired", error=result)
+            return LoginPollResponse(status="error", error=result)
+
+        # Success - result is AuthConfig
+        del _device_flows[user_code]
+        return LoginPollResponse(
+            status="success",
+            username=result.username,
+        )
+
+    except Exception as e:
+        return LoginPollResponse(status="error", error=str(e))
+
+
+@router.post("/logout")
+async def logout():
+    """Sign out by removing stored credentials.
+
+    Example:
+        curl -X POST http://localhost:8765/api/auth/logout
+    """
+    from ..auth.github import GitHubAuth
+
+    loop = asyncio.get_event_loop()
+
+    def _clear_auth():
+        auth = GitHubAuth()
+        auth.clear_auth()
+
+    await loop.run_in_executor(_executor, _clear_auth)
+    return {"success": True, "message": "Logged out successfully"}
+
+
+@router.get("/status", response_model=AuthStatus)
+async def get_status():
+    """Get current authentication status.
+
+    Example:
+        curl http://localhost:8765/api/auth/status
+    """
+    from ..auth.github import get_auth_status
+
+    loop = asyncio.get_event_loop()
+
+    def _get_status():
+        return get_auth_status()
+
+    try:
+        status = await loop.run_in_executor(_executor, _get_status)
+        return AuthStatus(
+            authenticated=status.get("authenticated", False),
+            username=status.get("username"),
+            scope=status.get("scope"),
+        )
+    except Exception:
+        return AuthStatus(authenticated=False)

emdash_core/api/context.py

@@ -0,0 +1,77 @@
+"""Session context endpoints."""
+
+from typing import Optional
+
+from fastapi import APIRouter
+from pydantic import BaseModel, Field
+
+router = APIRouter(prefix="/context", tags=["context"])
+
+
+class ContextEntity(BaseModel):
+    """An entity in the context."""
+    qualified_name: str
+    entity_type: str
+    file_path: str
+    relevance: float
+
+
+class SessionContext(BaseModel):
+    """Current session context."""
+    entities: list[ContextEntity] = Field(default_factory=list)
+    files: list[str] = Field(default_factory=list)
+    summary: Optional[str] = None
+
+
+@router.get("", response_model=SessionContext)
+async def get_context():
+    """Get current session context."""
+    try:
+        from ..context.service import ContextService
+
+        service = ContextService()
+        ctx = service.get_context()
+
+        return SessionContext(
+            entities=[
+                ContextEntity(
+                    qualified_name=e.get("qualified_name", ""),
+                    entity_type=e.get("type", ""),
+                    file_path=e.get("file_path", ""),
+                    relevance=e.get("relevance", 0.0),
+                )
+                for e in ctx.get("entities", [])
+            ],
+            files=ctx.get("files", []),
+            summary=ctx.get("summary"),
+        )
+    except Exception:
+        return SessionContext()
+
+
+@router.delete("")
+async def clear_context():
+    """Clear session context."""
+    try:
+        from ..context.service import ContextService
+
+        service = ContextService()
+        service.clear()
+
+        return {"success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@router.get("/prompt")
+async def get_context_prompt():
+    """Get context as a prompt for system prompt injection."""
+    try:
+        from ..context.service import ContextService
+
+        service = ContextService()
+        prompt = service.get_prompt()
+
+        return {"prompt": prompt}
+    except Exception:
+        return {"prompt": ""}

emdash_core/api/db.py

@@ -0,0 +1,121 @@
+"""Database management endpoints."""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/db", tags=["database"])
+
+
+class DbStats(BaseModel):
+    """Database statistics."""
+    node_count: int
+    relationship_count: int
+    file_count: int
+    function_count: int
+    class_count: int
+    community_count: int
+
+
+class DbInitResponse(BaseModel):
+    """Response from database initialization."""
+    success: bool
+    message: str
+
+
+class DbTestResponse(BaseModel):
+    """Response from database test."""
+    connected: bool
+    database_path: str
+    message: str
+
+
+def _get_connection():
+    """Get database connection."""
+    from ..graph.connection import KuzuConnection
+    return KuzuConnection()
+
+
+@router.post("/init", response_model=DbInitResponse)
+async def db_init():
+    """Initialize the Kuzu database schema.
+
+    Creates all node and relationship tables required for the knowledge graph.
+    """
+    try:
+        conn = _get_connection()
+        from ..graph.schema import SchemaManager
+
+        schema = SchemaManager(conn)
+        schema.initialize_schema()
+
+        return DbInitResponse(
+            success=True,
+            message="Database schema initialized successfully"
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/clear", response_model=DbInitResponse)
+async def db_clear(confirm: bool = False):
+    """Clear all data from the database.
+
+    Args:
+        confirm: Must be True to proceed with clearing
+    """
+    if not confirm:
+        raise HTTPException(
+            status_code=400,
+            detail="Must set confirm=true to clear database"
+        )
+
+    try:
+        conn = _get_connection()
+        conn.clear_database()
+
+        return DbInitResponse(
+            success=True,
+            message="Database cleared successfully"
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/stats", response_model=DbStats)
+async def db_stats():
+    """Get database statistics."""
+    try:
+        conn = _get_connection()
+        info = conn.get_database_info()
+
+        return DbStats(
+            node_count=info.get("node_count", 0),
+            relationship_count=info.get("relationship_count", 0),
+            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 as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/test", response_model=DbTestResponse)
+async def db_test():
+    """Test database connection."""
+    try:
+        conn = _get_connection()
+        # Try to connect
+        conn.connect()
+
+        return DbTestResponse(
+            connected=True,
+            database_path=str(conn.database_path),
+            message="Database connection successful"
+        )
+    except Exception as e:
+        return DbTestResponse(
+            connected=False,
+            database_path="",
+            message=str(e)
+        )