impact-core 1.0.0__py3-none-any.whl

adapters/java/extractor.py

@@ -0,0 +1,332 @@
+import os
+import re
+import json
+from datetime import datetime, timezone
+
+try:
+    import javalang
+    HAS_JAVALANG = True
+except ImportError:
+    HAS_JAVALANG = False
+
+class JavaExtractor:
+    """Java source code AST-like parser to extract IMPACT dependency graphs using AST and regex fallbacks."""
+
+    def __init__(self, project_name: str, version: str):
+        self.project_name = project_name
+        self.version = version
+        self.nodes = {}
+        self.edges = []
+
+    def extract(self, src_dir: str, output_file: str):
+        if not os.path.exists(src_dir):
+            raise FileNotFoundError(f"Source directory does not exist: {src_dir}")
+
+        java_files = []
+        for root, _, files in os.walk(src_dir):
+            for file in files:
+                if file.endswith(".java"):
+                    java_files.append(os.path.join(root, file))
+
+        # First pass: find all classes/interfaces and their FQCNs
+        class_details = {}
+        project_classes = set() # Set of all FQCNs in the project
+        class_name_to_fqcn = {} # Map simple name -> set of FQCNs for resolving references
+
+        for filepath in java_files:
+            with open(filepath, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Calculate LOC and complexity metrics (consistent across both parsing modes)
+            lines = content.splitlines()
+            loc = len([line for line in lines if line.strip() and not line.strip().startswith("//")])
+            complexity = 1
+            for line in lines:
+                complexity += len(re.findall(r"\b(if|for|while|catch)\b|&&|\|\|", line))
+
+            parsed_ast = False
+            if HAS_JAVALANG:
+                try:
+                    tree = javalang.parse.parse(content)
+                    package_name = tree.package.name if tree.package else ""
+                    
+                    for t in tree.types:
+                        class_name = t.name
+                        fqcn = f"{package_name}.{class_name}" if package_name else class_name
+                        
+                        # Collect references from AST
+                        references = set()
+                        for path, node in tree:
+                            if isinstance(node, javalang.tree.ReferenceType):
+                                references.add(node.name)
+                                # Fix 1: also collect qualified nested references (Outer.Inner)
+                                if node.sub_type:
+                                    references.add(f"{node.name}.{node.sub_type.name}")
+                            elif isinstance(node, javalang.tree.MethodInvocation):
+                                if node.qualifier:
+                                    parts = node.qualifier.split('.')
+                                    if parts:
+                                        references.add(parts[0])
+                                    # Collect qualified name for Outer.method() style calls
+                                    if len(parts) == 2:
+                                        references.add(node.qualifier)
+                            elif isinstance(node, javalang.tree.MemberReference):
+                                if node.qualifier:
+                                    parts = node.qualifier.split('.')
+                                    if parts:
+                                        references.add(parts[0])
+                        
+                        imports = [imp.path for imp in tree.imports]
+                        
+                        class_details[fqcn] = {
+                            "name": class_name,
+                            "package": package_name,
+                            "filePath": os.path.relpath(filepath, src_dir),
+                            "loc": loc,
+                            "complexity": complexity,
+                            "content": content,
+                            "imports": imports,
+                            "ast_references": list(references),
+                            "use_ast": True
+                        }
+                        project_classes.add(fqcn)
+                        class_name_to_fqcn.setdefault(class_name, set()).add(fqcn)
+
+                        # Fix 2: register nested class declarations found inside class bodies
+                        if hasattr(t, 'body') and t.body:
+                            for member in t.body:
+                                if isinstance(member, (
+                                    javalang.tree.ClassDeclaration,
+                                    javalang.tree.InterfaceDeclaration,
+                                    javalang.tree.EnumDeclaration,
+                                )):
+                                    nested_name = member.name
+                                    nested_fqcn = f"{fqcn}.{nested_name}"
+                                    # Register as a graph node (inherits file/metrics from outer class)
+                                    class_details[nested_fqcn] = {
+                                        "name": nested_name,
+                                        "package": package_name,
+                                        "filePath": os.path.relpath(filepath, src_dir),
+                                        "loc": 0,          # nested LOC not separately measured
+                                        "complexity": 1,
+                                        "content": "",
+                                        "imports": imports,
+                                        "ast_references": [],
+                                        "use_ast": True
+                                    }
+                                    project_classes.add(nested_fqcn)
+                                    class_name_to_fqcn.setdefault(nested_name, set()).add(nested_fqcn)
+                                    # Register "OuterSimple.InnerSimple" for qualified lookup
+                                    class_name_to_fqcn.setdefault(
+                                        f"{class_name}.{nested_name}", set()
+                                    ).add(nested_fqcn)
+
+
+                    parsed_ast = True
+                except Exception as e:
+                    # AST parsing failed, log and fall back to regex
+                    # (Can happen on new Java syntax elements like records or dynamic vars)
+                    pass
+
+            if not parsed_ast:
+                # Regex Fallback
+                package_match = re.search(r"package\s+([\w\.]+);", content)
+                package_name = package_match.group(1) if package_match else ""
+
+                class_match = re.search(r"\b(?:class|interface|enum|record)\s+(\w+)", content)
+                if not class_match:
+                    continue
+                class_name = class_match.group(1)
+                fqcn = f"{package_name}.{class_name}" if package_name else class_name
+
+                class_details[fqcn] = {
+                    "name": class_name,
+                    "package": package_name,
+                    "filePath": os.path.relpath(filepath, src_dir),
+                    "loc": loc,
+                    "complexity": complexity,
+                    "content": content,
+                    "use_ast": False
+                }
+                project_classes.add(fqcn)
+                class_name_to_fqcn.setdefault(class_name, set()).add(fqcn)
+
+        # Second pass: resolve dependencies
+        for fqcn, details in class_details.items():
+            dependencies = set()
+            
+            if details.get("use_ast"):
+                # 1. Resolve AST-collected references semantically
+                for ref in details["ast_references"]:
+                    if ref == details["name"]:
+                        continue # Skip self-references
+                    
+                    resolved = False
+                    
+                    # A. Check explicit imports (e.g. import com.example.service.DbService;)
+                    for imp in details["imports"]:
+                        if imp.endswith(f".{ref}"):
+                            target_fqcn = imp
+                            if target_fqcn in project_classes:
+                                dependencies.add(target_fqcn)
+                                resolved = True
+                                break
+                    if resolved:
+                        continue
+                        
+                    # B. Check same package (e.g. current_package.DbService)
+                    target_fqcn = f"{details['package']}.{ref}" if details['package'] else ref
+                    if target_fqcn in project_classes:
+                        dependencies.add(target_fqcn)
+                        continue
+                        
+                    # C. Check wildcard imports (e.g. import com.example.service.*;)
+                    for imp in details["imports"]:
+                        if imp.endswith(".*"):
+                            wildcard_package = imp[:-2]
+                            target_fqcn = f"{wildcard_package}.{ref}"
+                            if target_fqcn in project_classes:
+                                dependencies.add(target_fqcn)
+                                resolved = True
+                                break
+                    if resolved:
+                        continue
+                        
+                    # D. Global fallback: Match simple name if unique in the project
+                    if ref in class_name_to_fqcn:
+                        candidates = class_name_to_fqcn[ref]
+                        if len(candidates) == 1:
+                            dependencies.add(list(candidates)[0])
+                        continue
+
+                    # Fix 3 / E. Resolve qualified nested references like "Outer.Inner"
+                    if '.' in ref:
+                        # E1. Direct lookup: "OuterSimple.InnerSimple" registered in first pass
+                        if ref in class_name_to_fqcn:
+                            candidates = class_name_to_fqcn[ref]
+                            if len(candidates) == 1:
+                                dependencies.add(list(candidates)[0])
+                                continue
+                        # E2. Resolve outer name -> FQCN, then append inner name
+                        outer_ref, inner_name = ref.split('.', 1)
+                        outer_fqcn = None
+                        # Try explicit imports for the outer class
+                        for imp in details["imports"]:
+                            if imp.endswith(f".{outer_ref}"):
+                                outer_fqcn = imp
+                                break
+                        # Try same-package outer class
+                        if not outer_fqcn:
+                            candidate = (
+                                f"{details['package']}.{outer_ref}"
+                                if details['package'] else outer_ref
+                            )
+                            if candidate in project_classes:
+                                outer_fqcn = candidate
+                        # Try wildcard imports for the outer class
+                        if not outer_fqcn:
+                            for imp in details["imports"]:
+                                if imp.endswith(".*"):
+                                    candidate = f"{imp[:-2]}.{outer_ref}"
+                                    if candidate in project_classes:
+                                        outer_fqcn = candidate
+                                        break
+                        if outer_fqcn:
+                            nested_fqcn = f"{outer_fqcn}.{inner_name}"
+                            if nested_fqcn in project_classes:
+                                dependencies.add(nested_fqcn)
+            else:
+                # 2. Regex fallback: search simple class name matches in the text content
+                content = details["content"]
+                for other_fqcn, other_details in class_details.items():
+                    if fqcn == other_fqcn:
+                        continue
+                    pattern = rf"\b{other_details['name']}\b"
+                    if re.search(pattern, content):
+                        dependencies.add(other_fqcn)
+
+            # Register resolved dependency edges
+            for target_fqcn in dependencies:
+                self.edges.append({
+                    "source": fqcn,
+                    "target": target_fqcn,
+                    "type": "calls"
+                })
+
+            self.nodes[fqcn] = {
+                "id": fqcn,
+                "name": details["name"],
+                "type": "class",
+                "filePath": details["filePath"],
+                "metrics": {
+                    "loc": details["loc"],
+                    "complexity": details["complexity"],
+                    "fanOut": len(dependencies)
+                }
+            }
+
+        # Update fanIn metrics
+        for edge in self.edges:
+            target = edge["target"]
+            if target in self.nodes:
+                self.nodes[target]["metrics"]["fanIn"] = self.nodes[target]["metrics"].get("fanIn", 0) + 1
+
+        # Fill default values for fanIn/fanOut
+        for node in self.nodes.values():
+            if "fanIn" not in node["metrics"]:
+                node["metrics"]["fanIn"] = 0
+            node["metrics"]["coupling"] = node["metrics"]["fanIn"] + node["metrics"]["fanOut"]
+
+        # Calculate system-wide metrics
+        total_loc = sum(n["metrics"]["loc"] for n in self.nodes.values())
+        total_classes = len(self.nodes)
+        avg_coupling = sum(n["metrics"]["coupling"] for n in self.nodes.values()) / max(1, total_classes)
+
+        output_data = {
+            "@context": {
+                "@vocab": "https://w3id.org/impact/ontology#",
+                "projectName": "projectName",
+                "version": "versionString",
+                "language": "language",
+                "extractedAt": "extractedAt",
+                "systemMetrics": "systemMetrics",
+                "nodes": "hasEntity",
+                "edges": "hasDependency",
+                "id": "@id",
+                "type": "@type",
+                "source": "source",
+                "target": "target"
+            },
+            "projectName": self.project_name,
+            "version": self.version,
+            "language": "Java",
+            "extractedAt": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+            "systemMetrics": {
+                "totalLinesOfCode": total_loc,
+                "totalClasses": total_classes,
+                "averageCoupling": avg_coupling
+            },
+            "nodes": list(self.nodes.values()),
+            "edges": self.edges
+        }
+
+        # Write to JSON
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(output_data, f, indent=2)
+
+        print(f"[JavaExtractor] Extracted graph via {'AST' if HAS_JAVALANG else 'Regex'} for {self.project_name} v{self.version} to {output_file}")
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 5:
+        print("Usage: python3 extractor.py <project_name> <version> <src_dir> <output_file>")
+        sys.exit(1)
+    
+    p_name = sys.argv[1]
+    ver = sys.argv[2]
+    s_dir = sys.argv[3]
+    out_f = sys.argv[4]
+    
+    extractor = JavaExtractor(p_name, ver)
+    extractor.extract(s_dir, out_f)

adapters/java/static_analyzer.py

@@ -0,0 +1,69 @@
+import json
+import os
+
+class PMDIntegration:
+    """Parses PMD static analysis reports and merges violations into the IMPACT graph."""
+
+    def merge_pmd_report(self, graph_json_path: str, pmd_json_path: str):
+        if not os.path.exists(graph_json_path):
+            raise FileNotFoundError(f"Graph file not found: {graph_json_path}")
+            
+        # If no PMD report exists, we simulate a mock clean run or print message
+        if not os.path.exists(pmd_json_path):
+            print(f"[PMDIntegration] PMD report {pmd_json_path} not found. Skipping static analysis merge.")
+            return
+
+        with open(graph_json_path, "r", encoding="utf-8") as f:
+            graph_data = json.load(f)
+
+        with open(pmd_json_path, "r", encoding="utf-8") as f:
+            pmd_data = json.load(f)
+
+        # Parse PMD violations
+        file_violations = {}
+        for pmd_file in pmd_data.get("files", []):
+            # Normalize path
+            rel_path = os.path.basename(pmd_file.get("filename", ""))
+            violations = []
+            for v in pmd_file.get("violations", []):
+                violations.append({
+                    "rule": v.get("rule"),
+                    "ruleset": v.get("ruleset"),
+                    "priority": v.get("priority"),
+                    "beginLine": v.get("beginLine"),
+                    "message": v.get("message")
+                })
+            file_violations[rel_path] = violations
+
+        # Merge violations into matching graph nodes
+        merged_count = 0
+        for node in graph_data.get("nodes", []):
+            file_name = os.path.basename(node.get("filePath", ""))
+            if file_name in file_violations:
+                node["staticAnalysisViolations"] = file_violations[file_name]
+                node["metrics"]["staticAnalysisViolationsCount"] = len(file_violations[file_name])
+                merged_count += len(file_violations[file_name])
+            else:
+                node["staticAnalysisViolations"] = []
+                node["metrics"]["staticAnalysisViolationsCount"] = 0
+
+        # Update system-wide metrics
+        if "systemMetrics" in graph_data:
+            graph_data["systemMetrics"]["totalStaticAnalysisViolations"] = merged_count
+
+        with open(graph_json_path, "w", encoding="utf-8") as f:
+            json.dump(graph_data, f, indent=2)
+
+        print(f"[PMDIntegration] Merged {merged_count} PMD static analysis violations into {graph_json_path}")
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 3:
+        print("Usage: python3 static_analyzer.py <graph_json_path> <pmd_json_path>")
+        sys.exit(1)
+        
+    g_path = sys.argv[1]
+    pmd_path = sys.argv[2]
+    
+    integration = PMDIntegration()
+    integration.merge_pmd_report(g_path, pmd_path)

core/agents/coordinator.py

@@ -0,0 +1,88 @@
+from core.agents.graph_agent import GraphAgent
+from core.agents.diff_agent import DiffAgent
+from core.agents.metrics_agent import MetricsAgent
+from core.agents.llm_agent import LLMAgent
+
+class CoordinatorAgent:
+    """Core coordinator that orchestrates the entire IMPACT evaluation loop."""
+    
+    def __init__(self, name: str = "CoordinatorAgent"):
+        self.name = name
+        self.graph_agent = GraphAgent()
+        self.diff_agent = DiffAgent()
+        self.metrics_agent = MetricsAgent()
+        self.llm_agent = LLMAgent()
+
+    def run_analysis(self, file_path_v1: str, file_path_v2: str, intents: list) -> str:
+        """Orchestrates the step-by-step evolution analysis of two versions."""
+        print("[Coordinator] Step 1: Loading graphs and checking statistics...")
+        stats_v1 = self.graph_agent.execute(file_path_v1)
+        stats_v2 = self.graph_agent.execute(file_path_v2)
+        
+        print("[Coordinator] Step 2: Running structural diff comparison...")
+        diff = self.diff_agent.execute(file_path_v1, file_path_v2)
+        
+        print("[Coordinator] Step 3: Computing graph metrics and identifying hubs...")
+        metrics = self.metrics_agent.execute(file_path_v2)
+        
+        print("[Coordinator] Step 4: Synthesizing results and checking intent conformance...")
+        report = self.llm_agent.execute(diff, metrics, intents)
+        
+        print("[Coordinator] Analysis complete.")
+        return report
+
+    def run_ecosystem_analysis(self, repo_coordinate: str, intents: list) -> str:
+        """Downloads, extracts, and runs the multi-agent evolution analysis on a GitHub repository coordinate."""
+        from core.ecosystem_crawler import GitHubEcosystemCrawler
+        import os
+        import sqlite3
+
+        print(f"[Coordinator] Orchestrating ecosystem analysis for {repo_coordinate}...")
+        owner, repo = repo_coordinate.split("/")
+        crawler = GitHubEcosystemCrawler()
+
+        # Check if the repository is already in the database queue, if not insert it
+        conn = sqlite3.connect("test_projects/github_benchmarks/crawler_queue.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT id, status, tag1, tag2 FROM queue WHERE owner = ? AND repo = ?", (owner, repo))
+        row = cursor.fetchone()
+        
+        if not row:
+            cursor.execute("INSERT INTO queue (owner, repo) VALUES (?, ?)", (owner, repo))
+            conn.commit()
+            cursor.execute("SELECT id, status, tag1, tag2 FROM queue WHERE owner = ? AND repo = ?", (owner, repo))
+            row = cursor.fetchone()
+        
+        repo_id, status, tag1, tag2 = row
+        conn.close()
+
+        # If it hasn't been crawled successfully yet, process it
+        if status != "crawled":
+            print(f"[Coordinator] Repository {repo_coordinate} is in '{status}' status. Initiating crawl/extraction...")
+            crawler.process_repo(repo_id, owner, repo)
+            
+            # Re-read status
+            conn = sqlite3.connect("test_projects/github_benchmarks/crawler_queue.db")
+            cursor = conn.cursor()
+            cursor.execute("SELECT status, tag1, tag2, error_msg FROM queue WHERE id = ?", (repo_id,))
+            status, tag1, tag2, error_msg = cursor.fetchone()
+            conn.close()
+            
+            if status == "failed":
+                raise Exception(f"Ecosystem crawl failed for {repo_coordinate}: {error_msg}")
+
+        # Path to the generated analysis report
+        repo_dir = f"test_projects/github_benchmarks/java/{owner}_{repo}"
+        report_path = os.path.join(repo_dir, f"{tag1}_to_{tag2}_analysis.txt")
+        
+        if not os.path.exists(report_path):
+            graph_v1 = os.path.join(repo_dir, f"{tag1}_graph.json")
+            graph_v2 = os.path.join(repo_dir, f"{tag2}_graph.json")
+            report = self.run_analysis(graph_v1, graph_v2, intents)
+            with open(report_path, "w", encoding="utf-8") as f:
+                f.write(report)
+            return report
+
+        with open(report_path, "r", encoding="utf-8") as f:
+            return f.read()
+

core/agents/diff_agent.py

@@ -0,0 +1,30 @@
+import os
+from core.graph_utils import load_impact_graph, compare_graphs
+
+class DiffAgent:
+    """Specialized agent for detecting structural differences and cycle shifts between versions."""
+    
+    def __init__(self, name: str = "DiffAgent"):
+        self.name = name
+
+    def execute(self, file_path_v1: str, file_path_v2: str) -> dict:
+        """Compares two versions of a dependency graph and returns the diff report."""
+        if not os.path.exists(file_path_v1) or not os.path.exists(file_path_v2):
+            raise FileNotFoundError("One or both graph files were not found.")
+            
+        g1 = load_impact_graph(file_path_v1)
+        g2 = load_impact_graph(file_path_v2)
+        
+        diff = compare_graphs(g1, g2)
+        
+        return {
+            "version_old": g1.graph["version"],
+            "version_new": g2.graph["version"],
+            "added_nodes_count": len(diff["added_nodes"]),
+            "removed_nodes_count": len(diff["removed_nodes"]),
+            "added_edges_count": len(diff["added_edges"]),
+            "removed_edges_count": len(diff["removed_edges"]),
+            "new_cycles_count": len(diff["new_cycles"]),
+            "broken_cycles_count": len(diff["broken_cycles"]),
+            "raw_diff": diff
+        }

core/agents/graph_agent.py

@@ -0,0 +1,24 @@
+import os
+import networkx as nx
+from core.graph_utils import load_impact_graph
+
+class GraphAgent:
+    """Specialized agent for loading and querying software dependency graphs."""
+    
+    def __init__(self, name: str = "GraphAgent"):
+        self.name = name
+
+    def execute(self, file_path: str) -> dict:
+        """Loads and returns summary statistics of the dependency graph."""
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Graph file not found: {file_path}")
+            
+        g = load_impact_graph(file_path)
+        
+        return {
+            "version": g.graph["version"],
+            "language": g.graph["language"],
+            "node_count": len(g.nodes),
+            "edge_count": len(g.edges),
+            "system_metrics": g.graph["systemMetrics"]
+        }