ctrlcode 0.1.0__py3-none-any.whl

ctrlcode/analysis/__init__.py

@@ -0,0 +1,28 @@
+"""Code analysis components for ctrl-code."""
+
+from .ast_diff import ASTAnalyzer, ASTDiff
+from .bug_detector import BugPatternDetector, DetectedPattern
+from .code_graphs import CodeGraphBuilder, CodeGraphs, SymbolInfo
+from .semantic import SemanticAnalyzer, SemanticDiff
+from .static import StaticAnalyzer, StaticAnalysisResult
+from .synthesizer import AnalysisResult, Feedback, FeedbackSynthesizer
+from .tests import TestExecutor, TestResult
+
+__all__ = [
+    "ASTAnalyzer",
+    "ASTDiff",
+    "BugPatternDetector",
+    "DetectedPattern",
+    "CodeGraphBuilder",
+    "CodeGraphs",
+    "SymbolInfo",
+    "SemanticAnalyzer",
+    "SemanticDiff",
+    "TestExecutor",
+    "TestResult",
+    "StaticAnalyzer",
+    "StaticAnalysisResult",
+    "FeedbackSynthesizer",
+    "Feedback",
+    "AnalysisResult",
+]

ctrlcode/analysis/ast_diff.py

@@ -0,0 +1,163 @@
+"""AST-based structural code comparison."""
+
+import ast
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ASTDiff:
+    """Result of AST comparison."""
+
+    variant_id: str
+    has_syntax_error: bool = False
+    error_message: Optional[str] = None
+    function_count: int = 0
+    class_count: int = 0
+    import_count: int = 0
+    complexity_estimate: int = 0
+    structural_similarity: float = 0.0
+    differences: list[str] = field(default_factory=list)
+
+
+class ASTAnalyzer:
+    """Analyzes code structure using Python AST."""
+
+    def compare(self, baseline: str, variant: str, variant_id: str) -> ASTDiff:
+        """
+        Compare AST structures of baseline and variant.
+
+        Args:
+            baseline: Baseline code
+            variant: Variant code
+            variant_id: Identifier for variant
+
+        Returns:
+            ASTDiff with comparison results
+        """
+        # Parse baseline
+        try:
+            baseline_ast = ast.parse(baseline)
+            baseline_stats = self._analyze_ast(baseline_ast)
+        except SyntaxError as e:
+            return ASTDiff(
+                variant_id=variant_id,
+                has_syntax_error=True,
+                error_message=f"Baseline syntax error: {e}"
+            )
+
+        # Parse variant
+        try:
+            variant_ast = ast.parse(variant)
+            variant_stats = self._analyze_ast(variant_ast)
+        except SyntaxError as e:
+            return ASTDiff(
+                variant_id=variant_id,
+                has_syntax_error=True,
+                error_message=f"Variant syntax error: {e}"
+            )
+
+        # Compare structures
+        differences = self._find_differences(baseline_stats, variant_stats)
+        similarity = self._calculate_similarity(baseline_stats, variant_stats)
+
+        return ASTDiff(
+            variant_id=variant_id,
+            has_syntax_error=False,
+            function_count=variant_stats["functions"],
+            class_count=variant_stats["classes"],
+            import_count=variant_stats["imports"],
+            complexity_estimate=variant_stats["complexity"],
+            structural_similarity=similarity,
+            differences=differences,
+        )
+
+    def _analyze_ast(self, tree: ast.AST) -> dict[str, int]:
+        """
+        Analyze AST and extract statistics.
+
+        Args:
+            tree: AST tree
+
+        Returns:
+            Dict with structural stats
+        """
+        stats = {
+            "functions": 0,
+            "classes": 0,
+            "imports": 0,
+            "complexity": 0,
+            "loops": 0,
+            "conditionals": 0,
+            "try_blocks": 0,
+        }
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                stats["functions"] += 1
+            elif isinstance(node, ast.ClassDef):
+                stats["classes"] += 1
+            elif isinstance(node, (ast.Import, ast.ImportFrom)):
+                stats["imports"] += 1
+            elif isinstance(node, (ast.For, ast.While)):
+                stats["loops"] += 1
+                stats["complexity"] += 1
+            elif isinstance(node, ast.If):
+                stats["conditionals"] += 1
+                stats["complexity"] += 1
+            elif isinstance(node, ast.Try):
+                stats["try_blocks"] += 1
+                stats["complexity"] += 1
+
+        return stats
+
+    def _find_differences(
+        self,
+        baseline_stats: dict[str, int],
+        variant_stats: dict[str, int]
+    ) -> list[str]:
+        """Find structural differences between baseline and variant."""
+        differences = []
+
+        for key in baseline_stats:
+            baseline_val = baseline_stats[key]
+            variant_val = variant_stats[key]
+
+            if baseline_val != variant_val:
+                diff = variant_val - baseline_val
+                sign = "+" if diff > 0 else ""
+                differences.append(f"{key}: {baseline_val} → {variant_val} ({sign}{diff})")
+
+        return differences
+
+    def _calculate_similarity(
+        self,
+        baseline_stats: dict[str, int],
+        variant_stats: dict[str, int]
+    ) -> float:
+        """
+        Calculate structural similarity score.
+
+        Returns:
+            Similarity score between 0.0 (completely different) and 1.0 (identical)
+        """
+        total_diff = 0
+        total_magnitude = 0
+
+        for key in baseline_stats:
+            baseline_val = baseline_stats[key]
+            variant_val = variant_stats[key]
+
+            # Absolute difference
+            diff = abs(variant_val - baseline_val)
+            total_diff += diff
+
+            # Maximum of the two values
+            total_magnitude += max(baseline_val, variant_val)
+
+        if total_magnitude == 0:
+            return 1.0  # Both empty
+
+        # Similarity = 1 - (normalized difference)
+        similarity = 1.0 - (total_diff / max(total_magnitude, 1))
+        return max(0.0, min(1.0, similarity))

ctrlcode/analysis/bug_detector.py

@@ -0,0 +1,149 @@
+"""Bug pattern detection using historical fuzzing results."""
+
+import logging
+from dataclasses import dataclass
+from typing import Optional
+
+import numpy as np
+
+from ..embeddings.embedder import CodeEmbedder
+from ..embeddings.vector_store import VectorStore
+from ..storage.history_db import BugPattern, HistoryDB
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DetectedPattern:
+    """A similar bug pattern detected in historical data."""
+
+    bug_id: str
+    description: str
+    code_snippet: str
+    severity: str
+    similarity: float
+    session_id: str
+
+    @property
+    def confidence(self) -> str:
+        """Confidence level based on similarity."""
+        if self.similarity >= 0.9:
+            return "HIGH"
+        elif self.similarity >= 0.8:
+            return "MEDIUM"
+        else:
+            return "LOW"
+
+
+class BugPatternDetector:
+    """Detects similar bug patterns in code using historical fuzzing data.
+
+    Before fuzzing new code, search for similar bugs in history and warn
+    the user if risky patterns are detected. This enables proactive bug
+    prevention based on past failures.
+    """
+
+    def __init__(
+        self,
+        history_db: HistoryDB,
+        embedder: Optional[CodeEmbedder] = None,
+        similarity_threshold: float = 0.75,
+    ):
+        """Initialize bug pattern detector.
+
+        Args:
+            history_db: History database with bug patterns
+            embedder: Optional code embedder (created if not provided)
+            similarity_threshold: Minimum similarity for pattern matching (default: 0.75)
+        """
+        self.history_db = history_db
+        self.embedder = embedder or CodeEmbedder()
+        self.similarity_threshold = similarity_threshold
+
+    def check_patterns(self, code: str) -> list[DetectedPattern]:
+        """Check code for similar historical bug patterns.
+
+        Args:
+            code: Code to check for risky patterns
+
+        Returns:
+            List of similar bug patterns found, sorted by similarity (descending)
+        """
+        # Embed the code
+        code_embedding = self.embedder.embed_code(code)
+
+        # Get all historical bug patterns
+        bug_records = self.history_db.get_all_bug_embeddings(limit=1000)
+
+        if not bug_records:
+            logger.debug("No historical bug patterns in database")
+            return []
+
+        # Build vector store from bug embeddings
+        vector_store = VectorStore(dimension=code_embedding.shape[0])
+
+        embeddings = np.array([bug.embedding for bug in bug_records])
+        ids = [bug.bug_id for bug in bug_records]
+
+        vector_store.add(embeddings, ids)
+
+        # Search for similar bugs
+        results = vector_store.search(
+            code_embedding,
+            k=10,
+            min_similarity=self.similarity_threshold,
+        )
+
+        if not results:
+            logger.debug(f"No similar bugs found above threshold {self.similarity_threshold}")
+            return []
+
+        # Convert to DetectedPattern instances
+        detected_patterns = []
+
+        for bug_id, similarity in results:
+            # Find the bug record
+            bug_record = next((b for b in bug_records if b.bug_id == bug_id), None)
+            if not bug_record:
+                continue
+
+            pattern = DetectedPattern(
+                bug_id=bug_record.bug_id,
+                description=bug_record.bug_description,
+                code_snippet=bug_record.code_snippet,
+                severity=bug_record.severity,
+                similarity=similarity,
+                session_id=bug_record.session_id,
+            )
+            detected_patterns.append(pattern)
+
+        logger.info(f"Detected {len(detected_patterns)} similar bug patterns")
+        return detected_patterns
+
+    def format_warnings(self, patterns: list[DetectedPattern]) -> str:
+        """Format detected patterns as human-readable warnings.
+
+        Args:
+            patterns: List of detected patterns
+
+        Returns:
+            Formatted warning message
+        """
+        if not patterns:
+            return ""
+
+        lines = ["⚠️  SIMILAR BUG PATTERNS DETECTED", ""]
+
+        for i, pattern in enumerate(patterns[:5], 1):  # Limit to top 5
+            lines.append(f"{i}. {pattern.description}")
+            lines.append(f"   Severity: {pattern.severity}")
+            lines.append(f"   Confidence: {pattern.confidence} ({pattern.similarity:.1%} similar)")
+            lines.append(f"   Code snippet:")
+            lines.append(f"   ```")
+            for line in pattern.code_snippet.split("\n")[:5]:  # First 5 lines
+                lines.append(f"   {line}")
+            lines.append(f"   ```")
+            lines.append("")
+
+        lines.append("Consider reviewing these patterns before proceeding with fuzzing.")
+        return "\n".join(lines)

ctrlcode/analysis/code_graphs.py

@@ -0,0 +1,329 @@
+"""Code relationship graphs using AST analysis and NetworkX."""
+
+import ast
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import networkx as nx
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SymbolInfo:
+    """Information about a code symbol (function, class, variable)."""
+
+    name: str
+    symbol_type: str  # 'function', 'class', 'import', 'variable'
+    file: str
+    line: int
+    scope: str  # 'module', 'class', 'function'
+    parent: Optional[str] = None  # Parent class/function name
+
+
+@dataclass
+class CodeGraphs:
+    """Collection of code relationship graphs and symbol maps."""
+
+    # Symbol resolution maps (O(1) lookup)
+    file_map: dict[str, list[str]] = field(default_factory=dict)  # file -> symbols
+    export_map: dict[str, SymbolInfo] = field(default_factory=dict)  # symbol -> info
+    import_map: dict[str, list[str]] = field(default_factory=dict)  # file -> imported modules
+
+    # Relationship graphs (NetworkX directed graphs)
+    call_graph: nx.DiGraph = field(default_factory=nx.DiGraph)  # function -> called functions
+    dependency_graph: nx.DiGraph = field(default_factory=nx.DiGraph)  # file -> imported files
+
+    @property
+    def function_count(self) -> int:
+        """Total number of functions."""
+        return sum(1 for s in self.export_map.values() if s.symbol_type == "function")
+
+    @property
+    def class_count(self) -> int:
+        """Total number of classes."""
+        return sum(1 for s in self.export_map.values() if s.symbol_type == "class")
+
+    @property
+    def file_count(self) -> int:
+        """Total number of files analyzed."""
+        return len(self.file_map)
+
+    def get_functions_in_file(self, file: str) -> list[str]:
+        """Get all function names defined in a file."""
+        symbols = self.file_map.get(file, [])
+        return [s for s in symbols if self.export_map[s].symbol_type == "function"]
+
+    def get_callers(self, function: str) -> list[str]:
+        """Get all functions that call the given function."""
+        if function not in self.call_graph:
+            return []
+        return list(self.call_graph.predecessors(function))
+
+    def get_callees(self, function: str) -> list[str]:
+        """Get all functions called by the given function."""
+        if function not in self.call_graph:
+            return []
+        return list(self.call_graph.successors(function))
+
+    def get_dependencies(self, file: str) -> list[str]:
+        """Get all files imported by the given file."""
+        if file not in self.dependency_graph:
+            return []
+        return list(self.dependency_graph.successors(file))
+
+    def get_dependents(self, file: str) -> list[str]:
+        """Get all files that import the given file."""
+        if file not in self.dependency_graph:
+            return []
+        return list(self.dependency_graph.predecessors(file))
+
+
+class CodeGraphBuilder:
+    """Build code graphs from Python source code using AST analysis."""
+
+    def build_from_code(self, code: str, file_path: str = "<string>") -> CodeGraphs:
+        """Build graphs from a single Python source file.
+
+        Args:
+            code: Python source code
+            file_path: Path to the file (for tracking)
+
+        Returns:
+            CodeGraphs with symbol maps and relationship graphs
+        """
+        graphs = CodeGraphs()
+
+        try:
+            tree = ast.parse(code, filename=file_path)
+        except SyntaxError as e:
+            logger.warning(f"Syntax error in {file_path}: {e}")
+            return graphs
+
+        # Build symbol maps and graphs
+        visitor = _SymbolVisitor(file_path, graphs)
+        visitor.visit(tree)
+
+        return graphs
+
+    def build_from_files(self, file_paths: list[str | Path]) -> CodeGraphs:
+        """Build graphs from multiple Python files.
+
+        Args:
+            file_paths: List of file paths to analyze
+
+        Returns:
+            CodeGraphs combining all files
+        """
+        graphs = CodeGraphs()
+
+        for path in file_paths:
+            path = Path(path)
+            if not path.exists():
+                logger.warning(f"File not found: {path}")
+                continue
+
+            try:
+                code = path.read_text()
+                file_graphs = self.build_from_code(code, str(path))
+
+                # Merge into combined graphs
+                self._merge_graphs(graphs, file_graphs)
+
+            except Exception as e:
+                logger.error(f"Error processing {path}: {e}")
+
+        return graphs
+
+    def _merge_graphs(self, target: CodeGraphs, source: CodeGraphs) -> None:
+        """Merge source graphs into target graphs.
+
+        Args:
+            target: Target graphs to merge into
+            source: Source graphs to merge from
+        """
+        # Merge symbol maps
+        for file, symbols in source.file_map.items():
+            target.file_map.setdefault(file, []).extend(symbols)
+
+        target.export_map.update(source.export_map)
+
+        for file, imports in source.import_map.items():
+            target.import_map.setdefault(file, []).extend(imports)
+
+        # Merge graphs
+        target.call_graph = nx.compose(target.call_graph, source.call_graph)
+        target.dependency_graph = nx.compose(target.dependency_graph, source.dependency_graph)
+
+
+class _SymbolVisitor(ast.NodeVisitor):
+    """AST visitor that extracts symbols and builds relationship graphs."""
+
+    def __init__(self, file_path: str, graphs: CodeGraphs):
+        self.file_path = file_path
+        self.graphs = graphs
+        self.current_scope = "module"
+        self.current_function: Optional[str] = None
+        self.current_class: Optional[str] = None
+        self.scope_stack: list[str] = []
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        """Visit function definition."""
+        # Determine full qualified name
+        if self.current_class:
+            full_name = f"{self.current_class}.{node.name}"
+            parent = self.current_class
+            scope = "class"
+        else:
+            full_name = node.name
+            parent = None
+            scope = "module"
+
+        # Record symbol
+        symbol = SymbolInfo(
+            name=full_name,
+            symbol_type="function",
+            file=self.file_path,
+            line=node.lineno,
+            scope=scope,
+            parent=parent,
+        )
+        self.graphs.export_map[full_name] = symbol
+        self.graphs.file_map.setdefault(self.file_path, []).append(full_name)
+
+        # Add node to call graph
+        self.graphs.call_graph.add_node(full_name)
+
+        # Visit function body to find calls
+        prev_function = self.current_function
+        self.current_function = full_name
+        self.scope_stack.append(scope)
+
+        self.generic_visit(node)
+
+        self.current_function = prev_function
+        self.scope_stack.pop()
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        """Visit async function definition."""
+        # Treat same as regular function
+        self.visit_FunctionDef(node)  # type: ignore
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        """Visit class definition."""
+        full_name = node.name
+
+        # Record symbol
+        symbol = SymbolInfo(
+            name=full_name,
+            symbol_type="class",
+            file=self.file_path,
+            line=node.lineno,
+            scope="module",
+            parent=None,
+        )
+        self.graphs.export_map[full_name] = symbol
+        self.graphs.file_map.setdefault(self.file_path, []).append(full_name)
+
+        # Visit class body
+        prev_class = self.current_class
+        self.current_class = full_name
+        self.scope_stack.append("class")
+
+        self.generic_visit(node)
+
+        self.current_class = prev_class
+        self.scope_stack.pop()
+
+    def visit_Import(self, node: ast.Import) -> None:
+        """Visit import statement."""
+        for alias in node.names:
+            module = alias.name
+            self.graphs.import_map.setdefault(self.file_path, []).append(module)
+
+            # Record import symbol
+            import_name = alias.asname if alias.asname else alias.name
+            symbol = SymbolInfo(
+                name=import_name,
+                symbol_type="import",
+                file=self.file_path,
+                line=node.lineno,
+                scope=self.current_scope,
+            )
+            self.graphs.export_map[import_name] = symbol
+
+            # Add to dependency graph
+            self.graphs.dependency_graph.add_edge(self.file_path, module)
+
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        """Visit from...import statement."""
+        if node.module:
+            self.graphs.import_map.setdefault(self.file_path, []).append(node.module)
+
+            # Add to dependency graph
+            self.graphs.dependency_graph.add_edge(self.file_path, node.module)
+
+            # Record imported symbols
+            for alias in node.names:
+                import_name = alias.asname if alias.asname else alias.name
+                symbol = SymbolInfo(
+                    name=import_name,
+                    symbol_type="import",
+                    file=self.file_path,
+                    line=node.lineno,
+                    scope=self.current_scope,
+                )
+                self.graphs.export_map[import_name] = symbol
+
+        self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call) -> None:
+        """Visit function call."""
+        if self.current_function is None:
+            # Call outside function (module-level)
+            self.generic_visit(node)
+            return
+
+        # Extract called function name
+        called_name = self._extract_call_name(node)
+
+        if called_name:
+            # Add edge in call graph
+            self.graphs.call_graph.add_edge(self.current_function, called_name)
+
+        self.generic_visit(node)
+
+    def _extract_call_name(self, node: ast.Call) -> Optional[str]:
+        """Extract function name from call node.
+
+        Args:
+            node: Call AST node
+
+        Returns:
+            Function name or None
+        """
+        func = node.func
+
+        if isinstance(func, ast.Name):
+            # Simple call: foo()
+            return func.id
+        elif isinstance(func, ast.Attribute):
+            # Method call: obj.foo() or module.foo()
+            # Try to resolve the full name
+            parts = []
+            current = func
+
+            while isinstance(current, ast.Attribute):
+                parts.append(current.attr)
+                current = current.value
+
+            if isinstance(current, ast.Name):
+                parts.append(current.id)
+
+            return ".".join(reversed(parts))
+
+        return None