emdash-core 0.1.7__py3-none-any.whl

emdash_core/models/agent.py

@@ -0,0 +1,68 @@
+"""Pydantic models for agent API."""
+
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class AgentMode(str, Enum):
+    """Agent operation modes."""
+
+    CODE = "code"
+    RESEARCH = "research"
+    REVIEW = "review"
+    SPEC = "spec"
+    PLAN = "plan"
+
+
+class ImageData(BaseModel):
+    """Image data for vision-capable models."""
+
+    data: str = Field(..., description="Base64 encoded image data")
+    format: str = Field(default="png", description="Image format (png, jpg, etc.)")
+
+
+class AgentChatOptions(BaseModel):
+    """Options for agent chat."""
+
+    max_iterations: int = Field(default=50, description="Maximum agent iterations")
+    verbose: bool = Field(default=True, description="Enable verbose output")
+    mode: AgentMode = Field(default=AgentMode.CODE, description="Agent mode")
+    context_threshold: float = Field(
+        default=0.6,
+        description="Context window threshold for summarization (0-1)"
+    )
+
+
+class AgentChatRequest(BaseModel):
+    """Request for agent chat endpoint."""
+
+    message: str = Field(..., description="User message/task")
+    session_id: Optional[str] = Field(
+        default=None,
+        description="Session ID for conversation continuity"
+    )
+    model: Optional[str] = Field(
+        default=None,
+        description="Model to use (defaults to server config)"
+    )
+    images: list[ImageData] = Field(
+        default_factory=list,
+        description="Images for vision-capable models"
+    )
+    options: AgentChatOptions = Field(
+        default_factory=AgentChatOptions,
+        description="Agent options"
+    )
+
+
+class SessionInfo(BaseModel):
+    """Information about an agent session."""
+
+    session_id: str
+    agent_name: str
+    model: str
+    created_at: str
+    message_count: int
+    is_active: bool

emdash_core/models/index.py

@@ -0,0 +1,77 @@
+"""Pydantic models for indexing API."""
+
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class IndexOptions(BaseModel):
+    """Options for indexing operation."""
+
+    incremental: bool = Field(
+        default=False,
+        description="Only index changed files"
+    )
+    changed_only: bool = Field(
+        default=False,
+        description="Detect and index only modified files"
+    )
+    skip_git: bool = Field(
+        default=False,
+        description="Skip git history analysis"
+    )
+    pr_limit: int = Field(
+        default=100,
+        description="Maximum PRs to fetch"
+    )
+    detect_communities: bool = Field(
+        default=True,
+        description="Run community detection"
+    )
+    skip_embeddings: bool = Field(
+        default=False,
+        description="Skip embedding generation"
+    )
+
+
+class IndexRequest(BaseModel):
+    """Request to start indexing."""
+
+    repo_path: str = Field(..., description="Path to repository")
+    options: IndexOptions = Field(
+        default_factory=IndexOptions,
+        description="Indexing options"
+    )
+
+
+class IndexStats(BaseModel):
+    """Statistics about indexed content."""
+
+    files: int = Field(default=0, description="Number of files indexed")
+    functions: int = Field(default=0, description="Number of functions")
+    classes: int = Field(default=0, description="Number of classes")
+    relationships: int = Field(default=0, description="Number of relationships")
+    communities: int = Field(default=0, description="Number of communities detected")
+
+
+class IndexStatus(BaseModel):
+    """Status of indexing operation."""
+
+    is_running: bool = Field(default=False, description="Whether indexing is in progress")
+    last_indexed: Optional[datetime] = Field(
+        default=None,
+        description="Last successful index timestamp"
+    )
+    last_commit: Optional[str] = Field(
+        default=None,
+        description="Last indexed commit hash"
+    )
+    stats: IndexStats = Field(
+        default_factory=IndexStats,
+        description="Index statistics"
+    )
+    error: Optional[str] = Field(
+        default=None,
+        description="Error message if failed"
+    )

emdash_core/models/query.py

@@ -0,0 +1,113 @@
+"""Pydantic models for query API."""
+
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class EntityType(str, Enum):
+    """Types of code entities."""
+
+    FILE = "File"
+    CLASS = "Class"
+    FUNCTION = "Function"
+    METHOD = "Method"
+    MODULE = "Module"
+
+
+class SearchType(str, Enum):
+    """Types of search operations."""
+
+    SEMANTIC = "semantic"
+    TEXT = "text"
+    GREP = "grep"
+
+
+class SearchFilters(BaseModel):
+    """Filters for search results."""
+
+    entity_types: list[EntityType] = Field(
+        default_factory=list,
+        description="Filter by entity types"
+    )
+    limit: int = Field(default=20, description="Maximum results to return")
+    min_score: float = Field(default=0.0, description="Minimum similarity score")
+    file_patterns: list[str] = Field(
+        default_factory=list,
+        description="Glob patterns to filter files"
+    )
+
+
+class SearchRequest(BaseModel):
+    """Request for search endpoint."""
+
+    query: str = Field(..., description="Search query")
+    type: SearchType = Field(default=SearchType.SEMANTIC, description="Search type")
+    filters: SearchFilters = Field(
+        default_factory=SearchFilters,
+        description="Search filters"
+    )
+
+
+class SearchResult(BaseModel):
+    """A single search result."""
+
+    qualified_name: str = Field(..., description="Fully qualified name")
+    name: str = Field(..., description="Short name")
+    type: EntityType = Field(..., description="Entity type")
+    file_path: str = Field(..., description="File path relative to repo")
+    line_number: Optional[int] = Field(default=None, description="Line number")
+    score: float = Field(..., description="Relevance score (0-1)")
+    snippet: Optional[str] = Field(default=None, description="Code snippet")
+
+
+class SearchResponse(BaseModel):
+    """Response from search endpoint."""
+
+    results: list[SearchResult] = Field(default_factory=list)
+    total: int = Field(..., description="Total number of matches")
+    query: str = Field(..., description="Original query")
+
+
+class ExpandRequest(BaseModel):
+    """Request to expand a node."""
+
+    node_type: EntityType = Field(..., description="Type of node to expand")
+    identifier: str = Field(..., description="Qualified name or identifier")
+    max_hops: int = Field(default=2, description="Maximum traversal depth")
+    include_source: bool = Field(default=True, description="Include source code")
+
+
+class CallersRequest(BaseModel):
+    """Request to get callers of a function."""
+
+    qualified_name: str = Field(..., description="Qualified name of function")
+    max_depth: int = Field(default=1, description="Maximum call depth")
+
+
+class CalleesRequest(BaseModel):
+    """Request to get callees of a function."""
+
+    qualified_name: str = Field(..., description="Qualified name of function")
+    max_depth: int = Field(default=1, description="Maximum call depth")
+
+
+class HierarchyRequest(BaseModel):
+    """Request to get class hierarchy."""
+
+    class_name: str = Field(..., description="Qualified name of class")
+    direction: str = Field(
+        default="both",
+        description="Direction: 'up' (parents), 'down' (children), 'both'"
+    )
+
+
+class DependenciesRequest(BaseModel):
+    """Request to get file dependencies."""
+
+    file_path: str = Field(..., description="File path to analyze")
+    direction: str = Field(
+        default="both",
+        description="Direction: 'imports', 'imported_by', 'both'"
+    )

emdash_core/planning/__init__.py

@@ -0,0 +1,7 @@
+"""Planning and context building for AI agents."""
+
+from .similarity import SimilaritySearch
+from .context_builder import ContextBuilder, PlanningContext
+from .agent_api import AgentAPI
+
+__all__ = ["SimilaritySearch", "ContextBuilder", "PlanningContext", "AgentAPI"]

emdash_core/planning/agent_api.py

@@ -0,0 +1,413 @@
+"""Graph traversal API for AI agents."""
+
+from typing import Optional
+
+from ..graph.connection import KuzuConnection, get_connection
+from ..utils.logger import log
+
+
+class AgentAPI:
+    """Graph traversal API for AI coding agents."""
+
+    def __init__(self, connection: Optional[KuzuConnection] = None):
+        """Initialize agent API.
+
+        Args:
+            connection: Neo4j connection. If None, uses global connection.
+        """
+        self.connection = connection or get_connection()
+
+    def get_file_dependencies(self, file_path: str) -> dict:
+        """Get files that import/are imported by this file.
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            Dictionary with imports and imported_by lists
+        """
+        with self.connection.session() as session:
+            # Get files this file imports
+            imports_result = session.run("""
+                MATCH (f:File)-[:IMPORTS]->(m:Module)
+                WHERE f.path ENDS WITH $file_path
+                RETURN m.name as module_name,
+                       m.is_external as is_external
+            """, file_path=file_path)
+            imports = [dict(r) for r in imports_result]
+
+            # Get files that import modules from this file
+            # Query functions and classes separately (Kuzu doesn't support | in rel types)
+            func_result = session.run("""
+                MATCH (f:File)-[:CONTAINS_FUNCTION]->(entity:Function)
+                WHERE f.path ENDS WITH $file_path
+                WITH entity.qualified_name as qn
+                MATCH (other:File)-[:IMPORTS]->(m:Module)
+                WHERE m.name CONTAINS qn OR m.import_path CONTAINS qn
+                RETURN DISTINCT other.path as file_path
+            """, file_path=file_path)
+
+            class_result = session.run("""
+                MATCH (f:File)-[:CONTAINS_CLASS]->(entity:Class)
+                WHERE f.path ENDS WITH $file_path
+                WITH entity.qualified_name as qn
+                MATCH (other:File)-[:IMPORTS]->(m:Module)
+                WHERE m.name CONTAINS qn OR m.import_path CONTAINS qn
+                RETURN DISTINCT other.path as file_path
+            """, file_path=file_path)
+
+            imported_by = list(set(
+                [r["file_path"] for r in func_result] +
+                [r["file_path"] for r in class_result]
+            ))
+
+            return {
+                "file_path": file_path,
+                "imports": imports,
+                "imported_by": imported_by,
+            }
+
+    def get_function_callers(self, qualified_name: str) -> list[dict]:
+        """Find all functions that call this function.
+
+        Args:
+            qualified_name: Qualified name of the function
+
+        Returns:
+            List of calling functions with metadata
+        """
+        with self.connection.session() as session:
+            result = session.run("""
+                MATCH (caller:Function)-[:CALLS]->(f:Function {qualified_name: $qualified_name})
+                RETURN caller.name as name,
+                       caller.qualified_name as qualified_name,
+                       caller.file_path as file_path,
+                       caller.is_method as is_method
+                ORDER BY caller.name
+            """, qualified_name=qualified_name)
+
+            return [dict(r) for r in result]
+
+    def get_function_callees(self, qualified_name: str) -> list[dict]:
+        """Find all functions called by this function.
+
+        Args:
+            qualified_name: Qualified name of the function
+
+        Returns:
+            List of called functions with metadata
+        """
+        with self.connection.session() as session:
+            result = session.run("""
+                MATCH (f:Function {qualified_name: $qualified_name})-[:CALLS]->(callee:Function)
+                RETURN callee.name as name,
+                       callee.qualified_name as qualified_name,
+                       callee.file_path as file_path,
+                       callee.is_method as is_method
+                ORDER BY callee.name
+            """, qualified_name=qualified_name)
+
+            return [dict(r) for r in result]
+
+    def get_class_hierarchy(self, class_name: str) -> dict:
+        """Get inheritance tree for a class.
+
+        Args:
+            class_name: Name or qualified name of the class
+
+        Returns:
+            Dictionary with parents and children
+        """
+        with self.connection.session() as session:
+            # Get parent classes
+            parents_result = session.run("""
+                MATCH (c:Class)-[:INHERITS_FROM]->(parent:Class)
+                WHERE c.name = $class_name OR c.qualified_name = $class_name
+                RETURN parent.name as name,
+                       parent.qualified_name as qualified_name,
+                       parent.file_path as file_path
+            """, class_name=class_name)
+            parents = [dict(r) for r in parents_result]
+
+            # Get child classes
+            children_result = session.run("""
+                MATCH (child:Class)-[:INHERITS_FROM]->(c:Class)
+                WHERE c.name = $class_name OR c.qualified_name = $class_name
+                RETURN child.name as name,
+                       child.qualified_name as qualified_name,
+                       child.file_path as file_path
+            """, class_name=class_name)
+            children = [dict(r) for r in children_result]
+
+            return {
+                "class_name": class_name,
+                "parents": parents,
+                "children": children,
+            }
+
+    def get_file_history(self, file_path: str, limit: int = 10) -> dict:
+        """Get recent commits that modified this file.
+
+        Args:
+            file_path: Path to the file
+            limit: Maximum number of commits to return
+
+        Returns:
+            Dictionary with file_path and commits list
+        """
+        with self.connection.session() as session:
+            result = session.run("""
+                MATCH (c:GitCommit)-[mod:COMMIT_MODIFIES]->(f:File)
+                WHERE f.path ENDS WITH $file_path
+                RETURN c.sha as sha,
+                       c.message as message,
+                       c.author_name as author,
+                       c.timestamp as timestamp,
+                       mod.change_type as change_type,
+                       mod.insertions as insertions,
+                       mod.deletions as deletions
+                ORDER BY c.timestamp DESC
+                LIMIT $limit
+            """, file_path=file_path, limit=limit)
+
+            commits = [dict(r) for r in result]
+
+            return {
+                "file_path": file_path,
+                "commits": commits,
+            }
+
+    def get_community_overview(self, community_id: int) -> dict:
+        """Get summary of a code community.
+
+        Args:
+            community_id: The community ID
+
+        Returns:
+            Dictionary with community summary
+        """
+        with self.connection.session() as session:
+            # Get member counts by type
+            result = session.run("""
+                MATCH (n)
+                WHERE n.community = $community_id
+                AND (n:Class OR n:Function)
+                WITH label(n) as type, n
+                RETURN type,
+                       count(n) as count,
+                       collect(n.name)[0:10] as sample_names
+            """, community_id=community_id)
+
+            members_by_type = {r["type"]: {"count": r["count"], "samples": r["sample_names"]}
+                              for r in result}
+
+            # Get files in this community (separate queries for Kuzu compatibility)
+            func_files = session.run("""
+                MATCH (f:File)-[:CONTAINS_FUNCTION]->(n:Function)
+                WHERE n.community = $community_id
+                RETURN DISTINCT f.path as file_path
+                LIMIT 10
+            """, community_id=community_id)
+
+            class_files = session.run("""
+                MATCH (f:File)-[:CONTAINS_CLASS]->(n:Class)
+                WHERE n.community = $community_id
+                RETURN DISTINCT f.path as file_path
+                LIMIT 10
+            """, community_id=community_id)
+
+            files = list(set(
+                [r["file_path"] for r in func_files] +
+                [r["file_path"] for r in class_files]
+            ))[:10]
+
+            return {
+                "community_id": community_id,
+                "members_by_type": members_by_type,
+                "sample_files": files,
+            }
+
+    def get_author_expertise(self, email: str) -> dict:
+        """Get files and areas an author has worked on.
+
+        Args:
+            email: Author's email
+
+        Returns:
+            Dictionary with author expertise summary
+        """
+        with self.connection.session() as session:
+            # Get author info
+            author_result = session.run("""
+                MATCH (a:Author {email: $email})
+                RETURN a.name as name,
+                       a.total_commits as total_commits,
+                       a.total_lines_added as lines_added,
+                       a.total_lines_deleted as lines_deleted
+            """, email=email)
+            author = author_result.single()
+
+            if not author:
+                return {"error": f"Author not found: {email}"}
+
+            # Get most modified files
+            files_result = session.run("""
+                MATCH (a:Author {email: $email})<-[:AUTHORED_BY]-(c:GitCommit)-[:COMMIT_MODIFIES]->(f:File)
+                WITH f.path as file_path, count(c) as commit_count
+                RETURN file_path, commit_count
+                ORDER BY commit_count DESC
+                LIMIT 10
+            """, email=email)
+            top_files = [dict(r) for r in files_result]
+
+            # Get communities the author has worked in (separate queries for Kuzu)
+            func_communities = session.run("""
+                MATCH (a:Author {email: $email})<-[:AUTHORED_BY]-(c:GitCommit)-[:COMMIT_MODIFIES]->(f:File)
+                MATCH (f)-[:CONTAINS_FUNCTION]->(entity:Function)
+                WHERE entity.community IS NOT NULL
+                WITH entity.community as community_id, count(DISTINCT c) as commit_count
+                RETURN community_id, commit_count
+                ORDER BY commit_count DESC
+                LIMIT 5
+            """, email=email)
+
+            class_communities = session.run("""
+                MATCH (a:Author {email: $email})<-[:AUTHORED_BY]-(c:GitCommit)-[:COMMIT_MODIFIES]->(f:File)
+                MATCH (f)-[:CONTAINS_CLASS]->(entity:Class)
+                WHERE entity.community IS NOT NULL
+                WITH entity.community as community_id, count(DISTINCT c) as commit_count
+                RETURN community_id, commit_count
+                ORDER BY commit_count DESC
+                LIMIT 5
+            """, email=email)
+
+            # Combine and deduplicate by community_id, keeping highest commit_count
+            community_map = {}
+            for r in list(func_communities) + list(class_communities):
+                cid = r["community_id"]
+                cc = r["commit_count"]
+                if cid not in community_map or cc > community_map[cid]:
+                    community_map[cid] = cc
+            communities = [
+                {"community_id": cid, "commit_count": cc}
+                for cid, cc in sorted(community_map.items(), key=lambda x: -x[1])[:5]
+            ]
+
+            return {
+                "email": email,
+                "name": author["name"],
+                "total_commits": author["total_commits"],
+                "lines_added": author["lines_added"],
+                "lines_deleted": author["lines_deleted"],
+                "top_files": top_files,
+                "communities": communities,
+            }
+
+    def expand_from_files(
+        self,
+        file_paths: list[str],
+        hops: int = 1,
+    ) -> dict:
+        """Expand to related files within N relationship hops.
+
+        Args:
+            file_paths: Starting file paths
+            hops: Number of relationship hops to follow
+
+        Returns:
+            Dictionary with expanded file set and relationships
+        """
+        with self.connection.session() as session:
+            # Get directly related files (via imports, function calls)
+            result = session.run("""
+                UNWIND $file_paths as fp
+                MATCH (f:File)
+                WHERE f.path ENDS WITH fp
+
+                // Follow imports
+                OPTIONAL MATCH (f)-[:IMPORTS]->(m:Module)<-[:IMPORTS]-(related:File)
+                WHERE related.path <> f.path
+
+                // Follow function calls
+                OPTIONAL MATCH (f)-[:CONTAINS_FUNCTION]->(func:Function)-[:CALLS]->(called:Function)<-[:CONTAINS_FUNCTION]-(related2:File)
+                WHERE related2.path <> f.path
+
+                WITH collect(DISTINCT related.path) + collect(DISTINCT related2.path) as related_paths
+                UNWIND related_paths as rp
+                WITH rp WHERE rp IS NOT NULL
+                RETURN DISTINCT rp as file_path
+                LIMIT 20
+            """, file_paths=file_paths)
+
+            related_files = [r["file_path"] for r in result]
+
+            return {
+                "starting_files": file_paths,
+                "hops": hops,
+                "related_files": related_files,
+                "total_files": len(file_paths) + len(related_files),
+            }
+
+    def get_impact_analysis(self, file_path: str) -> dict:
+        """Analyze potential impact of changing a file.
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            Dictionary with impact analysis
+        """
+        with self.connection.session() as session:
+            # Get functions in this file and their callers
+            callers_result = session.run("""
+                MATCH (f:File)-[:CONTAINS_FUNCTION]->(func:Function)
+                WHERE f.path ENDS WITH $file_path
+                OPTIONAL MATCH (caller:Function)-[:CALLS]->(func)
+                RETURN func.name as function_name,
+                       func.qualified_name as qualified_name,
+                       collect(DISTINCT caller.qualified_name) as called_by
+            """, file_path=file_path)
+
+            functions_impact = []
+            total_callers = set()
+            for r in callers_result:
+                callers = [c for c in r["called_by"] if c is not None]
+                total_callers.update(callers)
+                functions_impact.append({
+                    "name": r["function_name"],
+                    "qualified_name": r["qualified_name"],
+                    "caller_count": len(callers),
+                })
+
+            # Get files that import from this file (separate queries for Kuzu)
+            func_names = session.run("""
+                MATCH (f:File)-[:CONTAINS_FUNCTION]->(entity:Function)
+                WHERE f.path ENDS WITH $file_path
+                RETURN DISTINCT entity.name as name
+            """, file_path=file_path)
+
+            class_names = session.run("""
+                MATCH (f:File)-[:CONTAINS_CLASS]->(entity:Class)
+                WHERE f.path ENDS WITH $file_path
+                RETURN DISTINCT entity.name as name
+            """, file_path=file_path)
+
+            exported_names = [r["name"] for r in func_names] + [r["name"] for r in class_names]
+
+            # Find files that import these names
+            dependent_files = []
+            if exported_names:
+                dependents_result = session.run("""
+                    MATCH (other:File)-[:IMPORTS]->(m:Module)
+                    WHERE any(name IN $exported_names WHERE m.name CONTAINS name)
+                    RETURN DISTINCT other.path as file_path
+                """, exported_names=exported_names)
+                dependent_files = [r["file_path"] for r in dependents_result]
+
+            return {
+                "file_path": file_path,
+                "functions": functions_impact,
+                "total_callers": len(total_callers),
+                "dependent_files": dependent_files,
+                "risk_level": "high" if len(total_callers) > 10 else "medium" if len(total_callers) > 3 else "low",
+            }