emdash-core 0.1.7__py3-none-any.whl

emdash_core/planning/context_builder.py

@@ -0,0 +1,265 @@
+"""Build comprehensive planning context for feature implementation."""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from ..graph.connection import KuzuConnection, get_connection
+from .similarity import SimilaritySearch
+from ..analytics.engine import AnalyticsEngine
+from ..utils.logger import log
+
+
+@dataclass
+class PlanningContext:
+    """Complete context for feature planning."""
+
+    query: str
+    similar_prs: list[dict] = field(default_factory=list)
+    affected_communities: list[dict] = field(default_factory=list)
+    key_entry_points: list[dict] = field(default_factory=list)
+    domain_experts: list[dict] = field(default_factory=list)
+    related_files: list[str] = field(default_factory=list)
+    similar_code: list[dict] = field(default_factory=list)
+    suggested_tasks: list[dict] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for serialization."""
+        return {
+            "query": self.query,
+            "similar_prs": self.similar_prs,
+            "affected_communities": self.affected_communities,
+            "key_entry_points": self.key_entry_points,
+            "domain_experts": self.domain_experts,
+            "related_files": self.related_files,
+            "similar_code": self.similar_code,
+            "suggested_tasks": self.suggested_tasks,
+        }
+
+
+class ContextBuilder:
+    """Builds comprehensive planning context for features."""
+
+    def __init__(
+        self,
+        connection: Optional[KuzuConnection] = None,
+        similarity_search: Optional[SimilaritySearch] = None,
+    ):
+        """Initialize context builder.
+
+        Args:
+            connection: Neo4j connection. If None, uses global connection.
+            similarity_search: Similarity search service.
+        """
+        self.connection = connection or get_connection()
+        self.similarity = similarity_search or SimilaritySearch(self.connection)
+
+    def build_context(
+        self,
+        feature_description: str,
+        similar_pr_limit: int = 5,
+        code_limit: int = 10,
+        expert_limit: int = 5,
+    ) -> PlanningContext:
+        """Build complete planning context for a feature.
+
+        Args:
+            feature_description: Description of the feature to implement
+            similar_pr_limit: Max number of similar PRs to include
+            code_limit: Max number of similar code entities to include
+            expert_limit: Max number of domain experts to include
+
+        Returns:
+            PlanningContext with all relevant information
+        """
+        log.info(f"Building planning context for: {feature_description}")
+
+        context = PlanningContext(query=feature_description)
+
+        # 1. Find similar PRs
+        context.similar_prs = self.similarity.find_similar_prs(
+            feature_description,
+            limit=similar_pr_limit,
+        )
+        log.info(f"Found {len(context.similar_prs)} similar PRs")
+
+        # 2. Find similar code
+        context.similar_code = self.similarity.find_similar_code(
+            feature_description,
+            limit=code_limit,
+        )
+        log.info(f"Found {len(context.similar_code)} similar code entities")
+
+        # 3. Collect related files from similar PRs and code
+        related_files = set()
+        for pr in context.similar_prs:
+            if pr.get("files_changed"):
+                related_files.update(pr["files_changed"])
+        for code in context.similar_code:
+            if code.get("file_path"):
+                related_files.add(code["file_path"])
+        context.related_files = list(related_files)
+
+        # 4. Find affected communities
+        if context.related_files:
+            context.affected_communities = self._find_affected_communities(
+                context.related_files
+            )
+
+        # 5. Find key entry points
+        context.key_entry_points = self._find_entry_points(context.similar_prs)
+
+        # 6. Find domain experts
+        if context.related_files:
+            context.domain_experts = self._find_domain_experts(
+                context.related_files,
+                limit=expert_limit,
+            )
+
+        # 7. Extract suggested tasks from similar PRs
+        context.suggested_tasks = self._extract_tasks_from_prs(context.similar_prs)
+
+        return context
+
+    def _find_affected_communities(self, file_paths: list[str]) -> list[dict]:
+        """Find communities that contain the given files.
+
+        Args:
+            file_paths: List of file paths
+
+        Returns:
+            List of community summaries
+        """
+        if not file_paths:
+            return []
+
+        with self.connection.session() as session:
+            result = session.run("""
+                UNWIND $file_paths as fp
+                MATCH (f:File)-[:CONTAINS_CLASS|CONTAINS_FUNCTION]->(entity)
+                WHERE f.path ENDS WITH fp
+                AND entity.community IS NOT NULL
+                WITH entity.community as community_id, collect(DISTINCT entity.name) as members
+                RETURN community_id,
+                       size(members) as member_count,
+                       members[0:5] as sample_members
+                ORDER BY member_count DESC
+                LIMIT 10
+            """, file_paths=file_paths)
+
+            return [dict(record) for record in result]
+
+    def _find_entry_points(self, similar_prs: list[dict]) -> list[dict]:
+        """Find key functions that were modified in similar PRs.
+
+        Args:
+            similar_prs: List of similar PRs
+
+        Returns:
+            List of key entry points (functions/classes)
+        """
+        # Collect all files from similar PRs
+        all_files = set()
+        for pr in similar_prs:
+            if pr.get("files_changed"):
+                all_files.update(pr["files_changed"])
+
+        if not all_files:
+            return []
+
+        with self.connection.session() as session:
+            # Query functions and classes separately (Kuzu doesn't support | in rel types)
+            functions_result = session.run("""
+                UNWIND $file_paths as fp
+                MATCH (f:File)-[:CONTAINS_FUNCTION]->(entity:Function)
+                WHERE f.path ENDS WITH fp
+                AND entity.pagerank IS NOT NULL
+                RETURN 'Function' as type,
+                       entity.name as name,
+                       entity.qualified_name as qualified_name,
+                       entity.pagerank as pagerank,
+                       f.path as file_path
+            """, file_paths=list(all_files))
+
+            classes_result = session.run("""
+                UNWIND $file_paths as fp
+                MATCH (f:File)-[:CONTAINS_CLASS]->(entity:Class)
+                WHERE f.path ENDS WITH fp
+                AND entity.pagerank IS NOT NULL
+                RETURN 'Class' as type,
+                       entity.name as name,
+                       entity.qualified_name as qualified_name,
+                       entity.pagerank as pagerank,
+                       f.path as file_path
+            """, file_paths=list(all_files))
+
+            # Combine and sort by pagerank
+            all_results = [dict(r) for r in functions_result] + [dict(r) for r in classes_result]
+            all_results.sort(key=lambda x: x.get("pagerank", 0) or 0, reverse=True)
+            return all_results[:10]
+
+    def _find_domain_experts(
+        self,
+        file_paths: list[str],
+        limit: int = 5,
+    ) -> list[dict]:
+        """Find authors with most commits to the given files.
+
+        Args:
+            file_paths: List of file paths
+            limit: Maximum number of experts to return
+
+        Returns:
+            List of domain experts with commit counts
+        """
+        if not file_paths:
+            return []
+
+        with self.connection.session() as session:
+            result = session.run("""
+                UNWIND $file_paths as fp
+                MATCH (f:File)<-[:COMMIT_MODIFIES]-(c:GitCommit)-[:AUTHORED_BY]->(a:Author)
+                WHERE f.path ENDS WITH fp
+                WITH a.name as author_name,
+                     a.email as author_email,
+                     count(DISTINCT c) as commit_count,
+                     collect(DISTINCT f.path) as files_touched
+                RETURN author_name,
+                       author_email,
+                       commit_count,
+                       size(files_touched) as files_count,
+                       files_touched[0:5] as sample_files
+                ORDER BY commit_count DESC
+                LIMIT $limit
+            """, file_paths=file_paths, limit=limit)
+
+            return [dict(record) for record in result]
+
+    def _extract_tasks_from_prs(self, similar_prs: list[dict]) -> list[dict]:
+        """Extract tasks from similar PRs.
+
+        Args:
+            similar_prs: List of similar PRs
+
+        Returns:
+            List of tasks from the PRs
+        """
+        if not similar_prs:
+            return []
+
+        pr_numbers = [pr["number"] for pr in similar_prs if pr.get("number")]
+
+        if not pr_numbers:
+            return []
+
+        with self.connection.session() as session:
+            result = session.run("""
+                UNWIND $pr_numbers as pr_num
+                MATCH (pr:PullRequest {number: pr_num})-[:HAS_TASK]->(t:Task)
+                RETURN pr.number as pr_number,
+                       pr.title as pr_title,
+                       t.description as task_description,
+                       t.is_completed as is_completed
+                ORDER BY pr.number, t.order
+            """, pr_numbers=pr_numbers)
+
+            return [dict(record) for record in result]

emdash_core/planning/feature_context.py

@@ -0,0 +1,232 @@
+"""Feature context builder using semantic search and AST expansion."""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from ..graph.connection import KuzuConnection, get_connection
+from .similarity import SimilaritySearch
+from .feature_expander import FeatureExpander, FeatureGraph
+from ..utils.logger import log
+
+
+@dataclass
+class FeatureContext:
+    """Complete context for a feature query."""
+
+    query: str
+    root_node: dict = field(default_factory=dict)
+    feature_graph: FeatureGraph = field(default_factory=FeatureGraph)
+    similar_nodes: list[dict] = field(default_factory=list)
+    related_prs: list[dict] = field(default_factory=list)
+    authors: list[dict] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "query": self.query,
+            "root_node": self.root_node,
+            "feature_graph": self.feature_graph.to_dict(),
+            "similar_nodes": self.similar_nodes,
+            "related_prs": self.related_prs,
+            "authors": self.authors,
+        }
+
+
+class FeatureContextBuilder:
+    """Builds complete feature context from a query."""
+
+    def __init__(
+        self,
+        connection: Optional[KuzuConnection] = None,
+        similarity_search: Optional[SimilaritySearch] = None,
+        feature_expander: Optional[FeatureExpander] = None,
+    ):
+        """Initialize feature context builder.
+
+        Args:
+            connection: Neo4j connection. If None, uses global connection.
+            similarity_search: Similarity search instance. If None, creates new one.
+            feature_expander: Feature expander instance. If None, creates new one.
+        """
+        self.connection = connection or get_connection()
+        self.similarity_search = similarity_search or SimilaritySearch(self.connection)
+        self.expander = feature_expander or FeatureExpander(self.connection)
+
+    def build_context(
+        self,
+        query: str,
+        max_hops: int = 2,
+        include_prs: bool = True,
+        include_authors: bool = True,
+        use_importance_ranking: bool = True,
+    ) -> FeatureContext:
+        """Build full feature context.
+
+        1. Semantic search for most relevant node (optionally importance-weighted)
+        2. Expand AST graph from that node
+        3. Find related PRs and authors
+
+        Args:
+            query: Feature description to search for
+            max_hops: Maximum relationship hops to traverse
+            include_prs: Whether to include related PRs
+            include_authors: Whether to include authors
+            use_importance_ranking: If True, use importance-weighted search
+                                   (combines semantic + activity + PageRank)
+
+        Returns:
+            FeatureContext with expanded AST graph
+        """
+        log.info(f"Building feature context for: {query}")
+
+        # Step 1: Find most relevant node via semantic search
+        if use_importance_ranking:
+            log.info("Using importance-weighted search (semantic + activity + PageRank)")
+            similar_code = self.similarity_search.importance_weighted_search(
+                query, limit=5, min_score=0.3
+            )
+        else:
+            similar_code = self.similarity_search.find_similar_code(
+                query, limit=5, min_score=0.3
+            )
+
+        if not similar_code:
+            log.warning("No relevant code found via semantic search, trying text search")
+            # Fall back to text search
+            similar_code = self._fallback_text_search(query)
+
+        if not similar_code:
+            log.warning("No relevant code found")
+            return FeatureContext(query=query)
+
+        root = similar_code[0]
+        if use_importance_ranking and "combined_score" in root:
+            log.info(
+                f"Found root node: {root.get('type')} - {root.get('name')} "
+                f"(combined: {root.get('combined_score', 0):.2f}, "
+                f"semantic: {root.get('norm_semantic', 0):.2f}, "
+                f"importance: {root.get('norm_importance', 0):.2f}, "
+                f"pagerank: {root.get('norm_pagerank', 0):.2f})"
+            )
+        else:
+            log.info(f"Found root node: {root.get('type')} - {root.get('name')} (score: {root.get('score', 'N/A')})")
+
+        # Step 2: Expand AST graph based on node type
+        node_type = root.get("type", "").lower()
+        qualified_name = root.get("qualified_name", "")
+        file_path = root.get("file_path", "")
+
+        if node_type == "function":
+            graph = self.expander.expand_from_function(qualified_name, max_hops)
+        elif node_type == "class":
+            graph = self.expander.expand_from_class(qualified_name, max_hops)
+        else:
+            graph = self.expander.expand_from_file(file_path, max_hops)
+
+        # Update root node in graph
+        graph.root_node = root
+
+        log.info(f"Expanded graph: {len(graph.functions)} functions, {len(graph.classes)} classes")
+
+        # Step 3: Enrich with PR/author data
+        related_prs = []
+        if include_prs:
+            related_prs = self._find_related_prs(graph)
+
+        authors = []
+        if include_authors:
+            authors = self._find_authors(graph)
+
+        return FeatureContext(
+            query=query,
+            root_node=root,
+            feature_graph=graph,
+            similar_nodes=similar_code[1:],
+            related_prs=related_prs,
+            authors=authors,
+        )
+
+    def _fallback_text_search(self, query: str) -> list[dict]:
+        """Fall back to text search when vector search unavailable."""
+        with self.connection.session() as session:
+            # Search functions by name or docstring
+            result = session.run("""
+                MATCH (f:Function)
+                WHERE toLower(f.name) CONTAINS toLower($query)
+                   OR toLower(f.docstring) CONTAINS toLower($query)
+                RETURN 'Function' as type,
+                       f.name as name,
+                       f.qualified_name as qualified_name,
+                       f.file_path as file_path,
+                       f.docstring as docstring,
+                       1.0 as score
+                LIMIT 5
+            """, query=query)
+
+            results = [dict(r) for r in result]
+
+            if not results:
+                # Try class search
+                result = session.run("""
+                    MATCH (c:Class)
+                    WHERE toLower(c.name) CONTAINS toLower($query)
+                       OR toLower(c.docstring) CONTAINS toLower($query)
+                    RETURN 'Class' as type,
+                           c.name as name,
+                           c.qualified_name as qualified_name,
+                           c.file_path as file_path,
+                           c.docstring as docstring,
+                           1.0 as score
+                    LIMIT 5
+                """, query=query)
+                results = [dict(r) for r in result]
+
+            return results
+
+    def _find_related_prs(self, graph: FeatureGraph) -> list[dict]:
+        """Find PRs that modified files in the feature graph."""
+        if not graph.files:
+            return []
+
+        file_paths = [f.get("path") for f in graph.files if f.get("path")]
+        if not file_paths:
+            return []
+
+        with self.connection.session() as session:
+            result = session.run("""
+                UNWIND $file_paths as fp
+                MATCH (pr:PullRequest)-[:PR_MODIFIES]->(f:File)
+                WHERE f.path ENDS WITH fp OR f.path = fp
+                RETURN DISTINCT pr.number as number,
+                       pr.title as title,
+                       pr.author as author,
+                       pr.state as state,
+                       count(DISTINCT f) as files_touched
+                ORDER BY files_touched DESC
+                LIMIT 5
+            """, file_paths=file_paths)
+
+            return [dict(r) for r in result]
+
+    def _find_authors(self, graph: FeatureGraph) -> list[dict]:
+        """Find authors who worked on files in the feature graph."""
+        if not graph.files:
+            return []
+
+        file_paths = [f.get("path") for f in graph.files if f.get("path")]
+        if not file_paths:
+            return []
+
+        with self.connection.session() as session:
+            result = session.run("""
+                UNWIND $file_paths as fp
+                MATCH (a:Author)<-[:AUTHORED_BY]-(c:GitCommit)-[:COMMIT_MODIFIES]->(f:File)
+                WHERE f.path ENDS WITH fp OR f.path = fp
+                RETURN DISTINCT a.name as name,
+                       a.email as email,
+                       count(DISTINCT c) as commit_count
+                ORDER BY commit_count DESC
+                LIMIT 5
+            """, file_paths=file_paths)
+
+            return [dict(r) for r in result]