graph-dependency-analyzer 0.2.0__py3-none-any.whl

src/domain/services/semantic_chunk_builder.py

@@ -0,0 +1,719 @@
+"""SemanticChunkBuilder domain service - creates semantic code chunks."""
+import re
+from pathlib import Path
+
+from src.domain.entities.ast_node import ASTNode
+from src.domain.entities.code_chunk import CodeChunk
+from src.domain.value_objects.chunk_type import ChunkType
+
+
+class SemanticChunkBuilder:
+    """
+    Domain service for creating semantic code chunks from AST.
+
+    Creates method-based chunks with context enrichment (javadoc, imports, class signature).
+    Groups small methods (<20 lines) together (up to 3 methods).
+    Keeps large methods (>500 lines) as single chunks.
+
+    Extensions for frontend (Tasks 5.1-5.2):
+    - TypeScript/JavaScript functions with JSDoc
+    - React/Angular/Vue components
+    - Hooks detection (use* functions)
+    """
+
+    JAVADOC_PATTERN = re.compile(r'/\*\*.*?\*/', re.DOTALL)
+    JSDOC_PATTERN = re.compile(r'/\*\*.*?\*/', re.DOTALL)  # Same as JavaDoc
+    SMALL_METHOD_THRESHOLD = 20  # lines
+    LARGE_METHOD_THRESHOLD = 500  # lines
+    MAX_METHODS_PER_CHUNK = 3
+
+    def build_chunks(
+        self,
+        ast_nodes: list[ASTNode],
+        source_code: dict[str, str]
+    ) -> list[CodeChunk]:
+        """
+        Build semantic chunks from AST nodes and source code.
+
+        Args:
+            ast_nodes: Parsed AST nodes
+            source_code: Source code by file path
+
+        Returns:
+            List of CodeChunk with metadata
+        """
+        chunks = []
+
+        # Separate nodes by type
+        method_nodes = [n for n in ast_nodes if n.node_type in ("METHOD", "CONSTRUCTOR")]
+        class_nodes = [n for n in ast_nodes if n.node_type == "CLASS"]
+        import_nodes = [n for n in ast_nodes if n.node_type == "IMPORT"]
+
+        # Build chunks from methods
+        chunks.extend(self._build_method_chunks(method_nodes, source_code))
+
+        # Build context chunks if no methods
+        if not method_nodes and (class_nodes or import_nodes):
+            chunks.extend(self._build_context_chunks(class_nodes, import_nodes, source_code))
+
+        return chunks
+
+    def _build_method_chunks(
+        self,
+        method_nodes: list[ASTNode],
+        source_code: dict[str, str]
+    ) -> list[CodeChunk]:
+        """Build chunks from method nodes."""
+        chunks = []
+
+        # Group small methods together
+        small_methods = []
+        large_methods = []
+
+        for node in method_nodes:
+            method_size = node.line_end - node.line_start + 1
+
+            if method_size < self.SMALL_METHOD_THRESHOLD:
+                small_methods.append(node)
+            else:
+                large_methods.append(node)
+
+        # Process small methods (group up to 3)
+        chunks.extend(self._group_small_methods(small_methods, source_code))
+
+        # Process large methods (one per chunk)
+        for node in large_methods:
+            chunk = self._create_chunk_from_method(node, source_code)
+            if chunk:
+                chunks.append(chunk)
+
+        return chunks
+
+    def _group_small_methods(
+        self,
+        small_methods: list[ASTNode],
+        source_code: dict[str, str]
+    ) -> list[CodeChunk]:
+        """Group small methods together (up to 3 per chunk)."""
+        chunks = []
+        i = 0
+
+        while i < len(small_methods):
+            # Take up to 3 methods
+            group = small_methods[i:i + self.MAX_METHODS_PER_CHUNK]
+
+            if len(group) == 1:
+                # Single method
+                chunk = self._create_chunk_from_method(group[0], source_code)
+                if chunk:
+                    chunks.append(chunk)
+            else:
+                # Multiple methods grouped
+                chunk = self._create_grouped_chunk(group, source_code)
+                if chunk:
+                    chunks.append(chunk)
+
+            i += self.MAX_METHODS_PER_CHUNK
+
+        return chunks
+
+    def _create_chunk_from_method(
+        self,
+        node: ASTNode,
+        source_code: dict[str, str]
+    ) -> CodeChunk | None:
+        """Create a chunk from a single method."""
+        # Find source file
+        source_file = self._find_source_file(node, source_code)
+        if not source_file:
+            return None
+
+        content = source_code[source_file]
+        lines = content.split('\n')
+
+        # Extract method content (with bounds checking)
+        # Line numbers in AST are 1-indexed, but list is 0-indexed
+        start_idx = max(0, node.line_start - 1)
+        end_idx = min(len(lines), node.line_end)
+
+        method_content = '\n'.join(lines[start_idx:end_idx])
+
+        # If method content doesn't contain method name, try expanding range
+        if node.name not in method_content and start_idx > 0:
+            start_idx = max(0, start_idx - 5)
+            method_content = '\n'.join(lines[start_idx:end_idx])
+
+        # Try to include javadoc (look backwards from method start)
+        javadoc_start = max(0, start_idx - 10)
+        preceding_lines = '\n'.join(lines[javadoc_start:start_idx])
+        javadoc_match = self.JAVADOC_PATTERN.search(preceding_lines)
+        if javadoc_match:
+            method_content = javadoc_match.group() + '\n' + method_content
+
+        # Determine chunk type
+        chunk_type = ChunkType.CONSTRUCTOR.value if node.node_type == "CONSTRUCTOR" else ChunkType.METHOD.value
+
+        # Build metadata
+        metadata = {
+            "name": node.name,
+            "qualified_name": node.qualified_name,
+            "parameters": node.metadata.get("parameters", []),
+            "return_type": node.metadata.get("return_type"),
+            "parent_class": node.metadata.get("parent_class"),
+            "line_start": node.line_start,
+            "line_end": node.line_end
+        }
+
+        return CodeChunk(
+            content=method_content,
+            chunk_type=chunk_type,
+            metadata=metadata
+        )
+
+    def _create_grouped_chunk(
+        self,
+        nodes: list[ASTNode],
+        source_code: dict[str, str]
+    ) -> CodeChunk | None:
+        """Create a chunk from multiple grouped methods."""
+        if not nodes:
+            return None
+
+        # Find source file from first node
+        source_file = self._find_source_file(nodes[0], source_code)
+        if not source_file:
+            return None
+
+        content = source_code[source_file]
+        lines = content.split('\n')
+
+        # Extract all methods
+        all_content = []
+        for node in nodes:
+            start_idx = max(0, node.line_start - 1)
+            end_idx = min(len(lines), node.line_end)
+            method_content = '\n'.join(lines[start_idx:end_idx])
+            all_content.append(method_content)
+
+        grouped_content = '\n\n'.join(all_content)
+
+        # Use first node's metadata as base
+        first_node = nodes[0]
+        metadata = {
+            "name": f"grouped_{len(nodes)}_methods",
+            "qualified_name": first_node.metadata.get("parent_class", "unknown"),
+            "parent_class": first_node.metadata.get("parent_class"),
+            "line_start": nodes[0].line_start,
+            "line_end": nodes[-1].line_end,
+            "method_count": len(nodes)
+        }
+
+        return CodeChunk(
+            content=grouped_content,
+            chunk_type=ChunkType.METHOD.value,
+            metadata=metadata
+        )
+
+    def _build_context_chunks(
+        self,
+        class_nodes: list[ASTNode],
+        import_nodes: list[ASTNode],
+        source_code: dict[str, str]
+    ) -> list[CodeChunk]:
+        """Build context chunks for files with only imports and class declaration."""
+        chunks = []
+
+        # If we have class nodes but no methods, create CLASS chunk
+        for class_node in class_nodes:
+            source_file = self._find_source_file(class_node, source_code)
+            if not source_file:
+                continue
+
+            content = source_code[source_file]
+            lines = content.split('\n')
+
+            # Extract class declaration and imports
+            start_idx = max(0, class_node.line_start - 1)
+            end_idx = min(len(lines), class_node.line_end)
+
+            class_content = '\n'.join(lines[start_idx:end_idx])
+
+            # Include imports
+            import_content = ""
+            for imp_node in import_nodes:
+                imp_start = max(0, imp_node.line_start - 1)
+                imp_end = min(len(lines), imp_node.line_end)
+                import_content += '\n'.join(lines[imp_start:imp_end]) + '\n'
+
+            full_content = import_content + '\n' + class_content
+
+            metadata = {
+                "name": class_node.name,
+                "qualified_name": class_node.qualified_name,
+                "line_start": class_node.line_start,
+                "line_end": class_node.line_end
+            }
+
+            chunk = CodeChunk(
+                content=full_content,
+                chunk_type=ChunkType.CLASS.value,
+                metadata=metadata
+            )
+            chunks.append(chunk)
+
+        # If only imports, create IMPORT_BLOCK chunk
+        if not class_nodes and import_nodes:
+            source_file = self._find_source_file(import_nodes[0], source_code)
+            if source_file:
+                content = source_code[source_file]
+                lines = content.split('\n')
+
+                import_lines = []
+                for imp_node in import_nodes:
+                    start_idx = max(0, imp_node.line_start - 1)
+                    end_idx = min(len(lines), imp_node.line_end)
+                    import_lines.extend(lines[start_idx:end_idx])
+
+                chunk = CodeChunk(
+                    content='\n'.join(import_lines),
+                    chunk_type=ChunkType.IMPORT_BLOCK.value,
+                    metadata={"import_count": len(import_nodes)}
+                )
+                chunks.append(chunk)
+
+        return chunks
+
+    def _find_source_file(self, node: ASTNode, source_code: dict[str, str]) -> str | None:
+        """Find the source file for a given node."""
+        # Try to match by qualified name
+        qualified_parts = node.qualified_name.split('.')
+
+        for filename in source_code.keys():
+            # Simple heuristic: match class name in filename
+            if any(part in filename for part in qualified_parts):
+                return filename
+
+        # Fallback: return first available file
+        return next(iter(source_code.keys()), None)
+
+
+    def build_typescript_chunks(
+        self,
+        parse_results: list,
+        source_code: dict[str, str]
+    ) -> list[CodeChunk]:
+        """
+        Build semantic chunks from TypeScript/JavaScript parse results (Tasks 5.1-5.2).
+
+        Uses Tree-sitter parsed data to extract REAL code content.
+
+        Args:
+            parse_results: List of ParseResult from TreeSitterTypeScriptParser
+            source_code: Source code by file path {file_path: code_string}
+
+        Returns:
+            List of CodeChunk with actual TypeScript/JavaScript code
+        """
+        chunks = []
+
+        for parse_result in parse_results:
+            file_path = str(parse_result.file_path)
+            code = source_code.get(file_path, "")
+
+            if not code:
+                # Try reading from file if not in dict
+                try:
+                    from pathlib import Path
+                    code = Path(file_path).read_text(encoding='utf-8')
+                except Exception:
+                    continue
+
+            code_lines = code.split('\n')
+
+            # Build chunks from methods/components (extracted by tree-sitter)
+            for method in parse_result.methods:
+                chunk = self._create_typescript_chunk(method, code_lines, file_path)
+                if chunk:
+                    chunks.append(chunk)
+
+        return chunks
+
+    def _create_typescript_chunk(
+        self,
+        method: dict,
+        code_lines: list[str],
+        file_path: str
+    ) -> CodeChunk | None:
+        """
+        Create a single chunk from a TypeScript method/component.
+
+        Args:
+            method: Method metadata from tree-sitter (name, line, type, framework, etc)
+            code_lines: Source code split by lines
+            file_path: Path to source file
+
+        Returns:
+            CodeChunk with real code content
+        """
+        name = method.get('name', 'anonymous')
+        start_line = method.get('line', 1) - 1  # Convert to 0-indexed
+
+        # Estimate end line (in production, tree-sitter should provide this)
+        # For now, extract ~30 lines or until next function/class
+        end_line = self._find_function_end(code_lines, start_line)
+
+        # Extract JSDoc comment if present (look backwards up to 10 lines)
+        comment_start = max(0, start_line - 10)
+        has_jsdoc = False
+        jsdoc_lines = []
+
+        for i in range(start_line - 1, comment_start - 1, -1):
+            if i < 0 or i >= len(code_lines):
+                break
+            line = code_lines[i].strip()
+            if '*/' in line:
+                has_jsdoc = True
+                jsdoc_lines.insert(0, code_lines[i])
+            elif has_jsdoc and ('/**' in line or '*' in line):
+                jsdoc_lines.insert(0, code_lines[i])
+                if '/**' in line:
+                    break
+            elif has_jsdoc:
+                break
+
+        # Extract actual code content using tree-sitter line info
+        if has_jsdoc:
+            content_lines = jsdoc_lines + code_lines[start_line:end_line]
+        else:
+            content_lines = code_lines[start_line:end_line]
+
+        content = '\n'.join(content_lines)
+
+        if not content.strip():
+            return None
+
+        # Detect chunk type based on tree-sitter metadata
+        chunk_type = self._detect_typescript_chunk_type(method)
+
+        # Build rich metadata
+        metadata = {
+            'language': 'typescript',
+            'file_path': file_path,
+            'function_name': name,
+            'start_line': start_line + 1,
+            'end_line': end_line,
+            'has_jsdoc': has_jsdoc
+        }
+
+        # Add framework-specific metadata
+        if method.get('framework'):
+            metadata['framework'] = method['framework']
+
+        if method.get('type'):
+            metadata['component_type'] = method['type']
+
+        # React hooks detection (Task 5.1)
+        if name.startswith('use') and len(name) > 3 and name[3].isupper():
+            metadata['is_hook'] = True
+
+        # JSX children for components (Task 5.2)
+        if 'jsx_children' in method:
+            metadata['jsx_children'] = method['jsx_children']
+
+        chunk = CodeChunk(
+            content=content,
+            chunk_type=chunk_type,
+            metadata=metadata
+        )
+
+        return chunk
+
+    def _find_function_end(self, code_lines: list[str], start_line: int) -> int:
+        """
+        Find the end line of a function (heuristic-based).
+
+        Args:
+            code_lines: Source code lines
+            start_line: Starting line (0-indexed)
+
+        Returns:
+            End line number (0-indexed)
+        """
+        brace_count = 0
+        in_function = False
+
+        for i in range(start_line, min(len(code_lines), start_line + 100)):
+            line = code_lines[i]
+
+            # Count braces to find function end
+            if '{' in line:
+                brace_count += line.count('{')
+                in_function = True
+            if '}' in line:
+                brace_count -= line.count('}')
+
+            # Arrow functions: const X = () => ...
+            if '=>' in line and not in_function:
+                in_function = True
+                if '{' not in line:
+                    # Single-line arrow function
+                    return i + 1
+
+            # Function ended when braces balanced
+            if in_function and brace_count == 0:
+                return i + 1
+
+            # Stop at next function/class declaration
+            if i > start_line and any(keyword in line for keyword in ['function ', 'class ', 'const ', 'export ']):
+                stripped = line.strip()
+                if stripped.startswith(('function', 'class', 'export function', 'export class', 'const')):
+                    return i
+
+        # Default: take 30 lines
+        return min(len(code_lines), start_line + 30)
+
+    def _detect_typescript_chunk_type(self, method: dict) -> str:
+        """
+        Detect chunk type from TypeScript method metadata (Tasks 5.1-5.2).
+
+        Args:
+            method: Method dictionary from TreeSitterTypeScriptParser
+
+        Returns:
+            ChunkType enum value
+        """
+        method_type = method.get('type', '')
+        name = method.get('name', '')
+
+        # React/Angular/Vue components (Task 5.2)
+        if method_type in ('function_component', 'class_component', 'angular_component'):
+            return ChunkType.CLASS.value  # Use CLASS for components
+
+        # React hooks (Task 5.1)
+        if name.startswith('use') and len(name) > 3 and name[3].isupper():
+            return ChunkType.METHOD.value  # Use METHOD for hooks
+
+        # Regular functions
+        return ChunkType.METHOD.value
+
+    def _build_function_chunks(
+        self,
+        function_nodes: list[ASTNode],
+        source_code: dict[str, str]
+    ) -> list[CodeChunk]:
+        """
+        Build chunks from TypeScript/JavaScript functions (Task 15.1).
+
+        Applies same grouping strategy as Java methods:
+        - Small functions (<20 lines): group up to 3 per chunk
+        - Large functions (≥20 lines): one per chunk
+        - React hooks (name starts with 'use'): tagged as HOOK
+
+        Args:
+            function_nodes: List of FUNCTION nodes from AST
+            source_code: Source code by file path
+
+        Returns:
+            List of CodeChunk instances
+        """
+        chunks = []
+
+        # Group by size
+        small_functions = []
+        large_functions = []
+
+        for node in function_nodes:
+            function_size = node.line_end - node.line_start + 1
+
+            if function_size < self.SMALL_METHOD_THRESHOLD:
+                small_functions.append(node)
+            else:
+                large_functions.append(node)
+
+        # Process small functions (group up to 3)
+        i = 0
+        while i < len(small_functions):
+            group = small_functions[i:i + self.MAX_METHODS_PER_CHUNK]
+
+            if len(group) == 1:
+                chunk = self._create_function_chunk(group[0], source_code)
+                if chunk:
+                    chunks.append(chunk)
+            else:
+                chunk = self._create_grouped_function_chunk(group, source_code)
+                if chunk:
+                    chunks.append(chunk)
+
+            i += self.MAX_METHODS_PER_CHUNK
+
+        # Process large functions (one per chunk)
+        for node in large_functions:
+            chunk = self._create_function_chunk(node, source_code)
+            if chunk:
+                chunks.append(chunk)
+
+        return chunks
+
+    def _create_function_chunk(
+        self,
+        node: ASTNode,
+        source_code: dict[str, str]
+    ) -> CodeChunk | None:
+        """Create chunk from a single TypeScript/JavaScript function."""
+        file_path = node.metadata.get("file_path")
+        if not file_path or file_path not in source_code:
+            return None
+
+        content = source_code[file_path]
+        lines = content.split('\n')
+
+        # Extract function content
+        start_idx = max(0, node.line_start - 1)
+        end_idx = min(len(lines), node.line_end)
+        function_content = '\n'.join(lines[start_idx:end_idx])
+
+        # Try to include JSDoc
+        jsdoc_start = max(0, start_idx - 10)
+        preceding_lines = '\n'.join(lines[jsdoc_start:start_idx])
+        jsdoc_match = self.JSDOC_PATTERN.search(preceding_lines)
+        if jsdoc_match:
+            function_content = jsdoc_match.group() + '\n' + function_content
+
+        # Detect React hooks
+        is_hook = node.name.startswith('use') and len(node.name) > 3 and node.name[3].isupper()
+        chunk_type = ChunkType.HOOK.value if is_hook else ChunkType.FUNCTION.value
+
+        metadata = {
+            "name": node.name,
+            "qualified_name": node.qualified_name,
+            "line_start": node.line_start,
+            "line_end": node.line_end,
+            "language": node.metadata.get("language", "typescript"),
+            "is_hook": is_hook
+        }
+
+        return CodeChunk(
+            content=function_content,
+            chunk_type=chunk_type,
+            metadata=metadata
+        )
+
+    def _create_grouped_function_chunk(
+        self,
+        nodes: list[ASTNode],
+        source_code: dict[str, str]
+    ) -> CodeChunk | None:
+        """Create chunk from multiple small functions grouped together."""
+        if not nodes:
+            return None
+
+        file_path = nodes[0].metadata.get("file_path")
+        if not file_path or file_path not in source_code:
+            return None
+
+        content = source_code[file_path]
+        lines = content.split('\n')
+
+        # Extract all functions
+        grouped_content = []
+        for node in nodes:
+            start_idx = max(0, node.line_start - 1)
+            end_idx = min(len(lines), node.line_end)
+            function_content = '\n'.join(lines[start_idx:end_idx])
+            grouped_content.append(function_content)
+
+        metadata = {
+            "name": f"grouped_{len(nodes)}_functions",
+            "qualified_name": nodes[0].qualified_name.rsplit('.', 1)[0],
+            "line_start": nodes[0].line_start,
+            "line_end": nodes[-1].line_end,
+            "function_count": len(nodes),
+            "language": nodes[0].metadata.get("language", "typescript")
+        }
+
+        return CodeChunk(
+            content='\n\n'.join(grouped_content),
+            chunk_type=ChunkType.FUNCTION.value,
+            metadata=metadata
+        )
+
+    def _build_component_chunks(
+        self,
+        component_nodes: list[ASTNode],
+        source_code: dict[str, str]
+    ) -> list[CodeChunk]:
+        """
+        Build chunks from React/Angular/Vue components (Task 15.2).
+
+        Includes:
+        - Props interface for React
+        - @Component decorator for Angular
+        - Script + template for Vue
+        - JSDoc comments
+
+        Args:
+            component_nodes: List of COMPONENT nodes from AST
+            source_code: Source code by file path
+
+        Returns:
+            List of CodeChunk instances
+        """
+        chunks = []
+
+        for node in component_nodes:
+            chunk = self._create_component_chunk(node, source_code)
+            if chunk:
+                chunks.append(chunk)
+
+        return chunks
+
+    def _create_component_chunk(
+        self,
+        node: ASTNode,
+        source_code: dict[str, str]
+    ) -> CodeChunk | None:
+        """Create chunk from a single component."""
+        file_path = node.metadata.get("file_path")
+        if not file_path or file_path not in source_code:
+            return None
+
+        content = source_code[file_path]
+        lines = content.split('\n')
+
+        # Extract component content
+        start_idx = max(0, node.line_start - 1)
+        end_idx = min(len(lines), node.line_end)
+        component_content = '\n'.join(lines[start_idx:end_idx])
+
+        # Try to include JSDoc
+        jsdoc_start = max(0, start_idx - 10)
+        preceding_lines = '\n'.join(lines[jsdoc_start:start_idx])
+        jsdoc_match = self.JSDOC_PATTERN.search(preceding_lines)
+        if jsdoc_match:
+            component_content = jsdoc_match.group() + '\n' + component_content
+
+        framework = node.metadata.get("framework", "unknown")
+
+        metadata = {
+            "name": node.name,
+            "qualified_name": node.qualified_name,
+            "line_start": node.line_start,
+            "line_end": node.line_end,
+            "framework": framework,
+            "language": node.metadata.get("language", "typescript")
+        }
+
+        # Add framework-specific metadata
+        if "props_interface" in node.metadata:
+            metadata["props_interface"] = node.metadata["props_interface"]
+        if "selector" in node.metadata:
+            metadata["selector"] = node.metadata["selector"]
+        if "has_script_setup" in node.metadata:
+            metadata["has_script_setup"] = node.metadata["has_script_setup"]
+
+        return CodeChunk(
+            content=component_content,
+            chunk_type=ChunkType.COMPONENT.value,
+            metadata=metadata
+        )
+