+
Issues
+ """
+
+ # Add issues by severity
+ for severity in ["critical", "error", "warning", "info"]:
+ severity_issues = [issue for issue in self.issues if issue.severity.value == severity]
+
+ if severity_issues:
+ html_content += f"""
+
{severity.upper()} Issues ({len(severity_issues)})
+
+ """
+
+ for issue in severity_issues:
+ location = f"{issue.file}:{issue.line}" if issue.line else issue.file
+ category = f"[{issue.category.value}]" if hasattr(issue, 'category') and issue.category else ""
+
+ html_content += f"""
+
+
{location} {category} {issue.message}
+
{issue.suggestion if hasattr(issue, 'suggestion') else ""}
+
+ """
+
+ html_content += """
+
+ """
+
+ # Add detailed analysis sections
+ html_content += """
+
+
Detailed Analysis
+ """
+
+ for analysis_type, results in self.results.get('results', {}).items():
+ html_content += f"""
+
{analysis_type}
+
{json.dumps(results, indent=2)}
+ """
+
+ html_content += """
+
+
+
+ """
+
+ with open(output_file, 'w') as f:
+ f.write(html_content)
+
+ def generate_report(self, report_type: str = "summary") -> str:
+ """
+ Generate a report from the analysis results.
+
+ Args:
+ report_type: Type of report to generate (summary, detailed, issues)
+
+ Returns:
+ Report as a string
+ """
+ if not self.results:
+ raise ValueError("No analysis results available")
+
+ if report_type == "summary":
+ return self._generate_summary_report()
+ elif report_type == "detailed":
+ return self._generate_detailed_report()
+ elif report_type == "issues":
+ return self._generate_issues_report()
+ else:
+ raise ValueError(f"Unknown report type: {report_type}")
+
+ def _generate_summary_report(self) -> str:
+ """Generate a summary report."""
+ report = "===== Codebase Analysis Summary Report =====\n\n"
+
+ # Add metadata
+ report += f"Repository: {self.results['metadata'].get('repo_name', 'Unknown')}\n"
+ report += f"Language: {self.results['metadata'].get('language', 'Unknown')}\n"
+ report += f"Analysis Time: {self.results['metadata'].get('analysis_time', 'Unknown')}\n"
+ report += f"Analysis Types: {', '.join(self.results['metadata'].get('analysis_types', []))}\n\n"
+
+ # Add issue statistics
+ report += f"Total Issues: {len(self.issues)}\n"
+ report += f"Critical: {self.results['issue_stats']['by_severity'].get('critical', 0)}\n"
+ report += f"Errors: {self.results['issue_stats']['by_severity'].get('error', 0)}\n"
+ report += f"Warnings: {self.results['issue_stats']['by_severity'].get('warning', 0)}\n"
+ report += f"Info: {self.results['issue_stats']['by_severity'].get('info', 0)}\n\n"
+
+ # Add analysis summaries
+ for analysis_type, results in self.results.get('results', {}).items():
+ report += f"===== {analysis_type.upper()} Analysis =====\n"
+
+ if analysis_type == "code_quality":
+ if "dead_code" in results:
+ dead_code = results["dead_code"]
+ report += f"Dead Code: {len(dead_code.get('unused_functions', []))} unused functions, "
+ report += f"{len(dead_code.get('unused_classes', []))} unused classes\n"
+
+ if "complexity" in results:
+ complexity = results["complexity"]
+ report += f"Complexity: {len(complexity.get('complex_functions', []))} complex functions\n"
+
+ elif analysis_type == "dependency":
+ if "circular_dependencies" in results:
+ circular = results["circular_dependencies"]
+ report += f"Circular Dependencies: {len(circular.get('circular_imports', []))}\n"
+
+ if "module_coupling" in results:
+ coupling = results["module_coupling"]
+ report += f"High Coupling Modules: {len(coupling.get('high_coupling_modules', []))}\n"
+
+ report += "\n"
+
+ return report
+
+ def _generate_detailed_report(self) -> str:
+ """Generate a detailed report."""
+ report = "===== Codebase Analysis Detailed Report =====\n\n"
+
+ # Add metadata
+ report += f"Repository: {self.results['metadata'].get('repo_name', 'Unknown')}\n"
+ report += f"Language: {self.results['metadata'].get('language', 'Unknown')}\n"
+ report += f"Analysis Time: {self.results['metadata'].get('analysis_time', 'Unknown')}\n"
+ report += f"Analysis Types: {', '.join(self.results['metadata'].get('analysis_types', []))}\n\n"
+
+ # Add detailed issue report
+ report += "===== Issues =====\n\n"
+
+ for severity in ["critical", "error", "warning", "info"]:
+ severity_issues = [issue for issue in self.issues if issue.severity.value == severity]
+
+ if severity_issues:
+ report += f"{severity.upper()} Issues ({len(severity_issues)}):\n"
+
+ for issue in severity_issues:
+ location = f"{issue.file}:{issue.line}" if issue.line else issue.file
+ category = f"[{issue.category.value}]" if hasattr(issue, 'category') and issue.category else ""
+
+ report += f"- {location} {category} {issue.message}\n"
+ if hasattr(issue, 'suggestion') and issue.suggestion:
+ report += f" Suggestion: {issue.suggestion}\n"
+
+ report += "\n"
+
+ # Add detailed analysis
+ for analysis_type, results in self.results.get('results', {}).items():
+ report += f"===== {analysis_type.upper()} Analysis =====\n\n"
+
+ # Format based on analysis type
+ if analysis_type == "code_quality":
+ # Dead code details
+ if "dead_code" in results:
+ dead_code = results["dead_code"]
+ report += "Dead Code:\n"
+
+ if dead_code.get('unused_functions'):
+ report += " Unused Functions:\n"
+ for func in dead_code.get('unused_functions', [])[:10]: # Limit to 10
+ report += f" - {func.get('name')} ({func.get('file')})\n"
+
+ if len(dead_code.get('unused_functions', [])) > 10:
+ report += f" ... and {len(dead_code.get('unused_functions', [])) - 10} more\n"
+
+ if dead_code.get('unused_classes'):
+ report += " Unused Classes:\n"
+ for cls in dead_code.get('unused_classes', [])[:10]: # Limit to 10
+ report += f" - {cls.get('name')} ({cls.get('file')})\n"
+
+ if len(dead_code.get('unused_classes', [])) > 10:
+ report += f" ... and {len(dead_code.get('unused_classes', [])) - 10} more\n"
+
+ report += "\n"
+
+ # Complexity details
+ if "complexity" in results:
+ complexity = results["complexity"]
+ report += "Code Complexity:\n"
+
+ if complexity.get('complex_functions'):
+ report += " Complex Functions:\n"
+ for func in complexity.get('complex_functions', [])[:10]: # Limit to 10
+ report += f" - {func.get('name')} (Complexity: {func.get('complexity')}, {func.get('file')})\n"
+
+ if len(complexity.get('complex_functions', [])) > 10:
+ report += f" ... and {len(complexity.get('complex_functions', [])) - 10} more\n"
+
+ report += "\n"
+
+ elif analysis_type == "dependency":
+ # Circular dependencies
+ if "circular_dependencies" in results:
+ circular = results["circular_dependencies"]
+ report += "Circular Dependencies:\n"
+
+ if circular.get('circular_imports'):
+ for i, cycle in enumerate(circular.get('circular_imports', [])[:5]): # Limit to 5
+ report += f" Cycle {i+1} (Length: {cycle.get('length')}):\n"
+ for j, file_path in enumerate(cycle.get('files', [])):
+ report += f" {j+1}. {file_path}\n"
+
+ if len(circular.get('circular_imports', [])) > 5:
+ report += f" ... and {len(circular.get('circular_imports', [])) - 5} more cycles\n"
+
+ report += "\n"
+
+ # Module coupling
+ if "module_coupling" in results:
+ coupling = results["module_coupling"]
+ report += "Module Coupling:\n"
+
+ if coupling.get('high_coupling_modules'):
+ report += " High Coupling Modules:\n"
+ for module in coupling.get('high_coupling_modules', [])[:10]: # Limit to 10
+ report += f" - {module.get('module')} (Ratio: {module.get('coupling_ratio'):.2f})\n"
+
+ if len(coupling.get('high_coupling_modules', [])) > 10:
+ report += f" ... and {len(coupling.get('high_coupling_modules', [])) - 10} more\n"
+
+ report += "\n"
+
+ return report
+
+ def _generate_issues_report(self) -> str:
+ """Generate an issues-focused report."""
+ report = "===== Codebase Analysis Issues Report =====\n\n"
+
+ # Add issue statistics
+ report += f"Total Issues: {len(self.issues)}\n"
+ report += f"Critical: {self.results['issue_stats']['by_severity'].get('critical', 0)}\n"
+ report += f"Errors: {self.results['issue_stats']['by_severity'].get('error', 0)}\n"
+ report += f"Warnings: {self.results['issue_stats']['by_severity'].get('warning', 0)}\n"
+ report += f"Info: {self.results['issue_stats']['by_severity'].get('info', 0)}\n\n"
+
+ # Add issues by severity
+ for severity in ["critical", "error", "warning", "info"]:
+ severity_issues = [issue for issue in self.issues if issue.severity.value == severity]
+
+ if severity_issues:
+ report += f"{severity.upper()} Issues ({len(severity_issues)}):\n"
+
+ for issue in severity_issues:
+ location = f"{issue.file}:{issue.line}" if issue.line else issue.file
+ category = f"[{issue.category.value}]" if hasattr(issue, 'category') and issue.category else ""
+
+ report += f"- {location} {category} {issue.message}\n"
+ if hasattr(issue, 'suggestion') and issue.suggestion:
+ report += f" Suggestion: {issue.suggestion}\n"
+
+ report += "\n"
+
+ return report
+
+def main():
+ """Command-line entry point."""
+ import argparse
+
+ parser = argparse.ArgumentParser(description="Unified Codebase Analyzer")
+
+ # Repository source options
+ source_group = parser.add_mutually_exclusive_group(required=True)
+ source_group.add_argument("--repo-url", help="URL of the repository to analyze")
+ source_group.add_argument("--repo-path", help="Local path to the repository to analyze")
+
+ # Analysis options
+ parser.add_argument("--analysis-types", nargs="+", choices=[at.value for at in AnalysisType],
+ default=["code_quality", "dependency"],
+ help="Types of analysis to perform")
+ parser.add_argument("--language", choices=["python", "typescript"],
+ help="Programming language (auto-detected if not provided)")
+ parser.add_argument("--base-branch", default="main",
+ help="Base branch for PR comparison (default: main)")
+ parser.add_argument("--pr-number", type=int,
+ help="PR number to analyze")
+
+ # Output options
+ parser.add_argument("--output-file",
+ help="Path to the output file")
+ parser.add_argument("--output-format", choices=["json", "html", "console"], default="json",
+ help="Output format")
+ parser.add_argument("--report-type", choices=["summary", "detailed", "issues"], default="summary",
+ help="Type of report to generate (default: summary)")
+
+ args = parser.parse_args()
+
+ try:
+ # Initialize the analyzer manager
+ manager = AnalyzerManager(
+ repo_url=args.repo_url,
+ repo_path=args.repo_path,
+ language=args.language,
+ base_branch=args.base_branch,
+ pr_number=args.pr_number
+ )
+
+ # Run the analysis
+ manager.analyze(
+ analysis_types=args.analysis_types,
+ output_file=args.output_file,
+ output_format=args.output_format
+ )
+
+ # Generate and print report if format is console
+ if args.output_format == "console":
+ report = manager.generate_report(args.report_type)
+ print(report)
+
+ except Exception as e:
+ logger.error(f"Error: {e}")
+ import traceback
+ traceback.print_exc()
+ sys.exit(1)
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/analyzer_manager.py b/codegen-on-oss/codegen_on_oss/analyzers/analyzer_manager.py
new file mode 100644
index 000000000..4458ee541
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/analyzer_manager.py
@@ -0,0 +1,452 @@
+#!/usr/bin/env python3
+"""
+Analyzer Manager Module
+
+This module provides a centralized interface for running various codebase analyzers.
+It coordinates the execution of different analyzer types and aggregates their results.
+"""
+
+import os
+import sys
+import json
+import logging
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, Type
+from datetime import datetime
+from pathlib import Path
+
+try:
+ from codegen_on_oss.analyzers.unified_analyzer import (
+ UnifiedCodeAnalyzer,
+ AnalyzerRegistry,
+ CodeQualityAnalyzerPlugin,
+ DependencyAnalyzerPlugin
+ )
+ from codegen_on_oss.analyzers.issue_types import Issue, IssueSeverity, AnalysisType, IssueCategory
+except ImportError:
+ print("Required analyzer modules not found.")
+ sys.exit(1)
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class AnalyzerManager:
+ """
+ Central manager for running different types of code analysis.
+
+ This class provides a unified interface for running various analyzers
+ and aggregating their results.
+ """
+
+ def __init__(self,
+ repo_url: Optional[str] = None,
+ repo_path: Optional[str] = None,
+ language: Optional[str] = None,
+ base_branch: str = "main",
+ pr_number: Optional[int] = None,
+ config: Optional[Dict[str, Any]] = None):
+ """
+ Initialize the analyzer manager.
+
+ Args:
+ repo_url: URL of the repository to analyze
+ repo_path: Local path to the repository to analyze
+ language: Programming language of the codebase
+ base_branch: Base branch for comparison
+ pr_number: PR number to analyze
+ config: Additional configuration options
+ """
+ self.repo_url = repo_url
+ self.repo_path = repo_path
+ self.language = language
+ self.base_branch = base_branch
+ self.pr_number = pr_number
+ self.config = config or {}
+
+ # Initialize the unified analyzer
+ self.analyzer = UnifiedCodeAnalyzer(
+ repo_url=repo_url,
+ repo_path=repo_path,
+ base_branch=base_branch,
+ pr_number=pr_number,
+ language=language,
+ config=config
+ )
+
+ # Register additional analyzers (if any)
+ self._register_custom_analyzers()
+
+ def _register_custom_analyzers(self):
+ """Register custom analyzers with the registry."""
+ # The default analyzers (CODE_QUALITY and DEPENDENCY) are registered automatically
+ # This method can be overridden by subclasses to register additional analyzers
+ pass
+
+ def run_analysis(self,
+ analysis_types: Optional[List[AnalysisType]] = None,
+ output_file: Optional[str] = None,
+ output_format: str = "json") -> Dict[str, Any]:
+ """
+ Run analysis on the codebase.
+
+ Args:
+ analysis_types: Types of analysis to run (defaults to CODE_QUALITY and DEPENDENCY)
+ output_file: Path to save results to (None for no save)
+ output_format: Format for output file (json, html, console)
+
+ Returns:
+ Dictionary containing analysis results
+ """
+ # Default to code quality and dependency analysis
+ if analysis_types is None:
+ analysis_types = [AnalysisType.CODE_QUALITY, AnalysisType.DEPENDENCY]
+
+ try:
+ # Run the analysis
+ logger.info(f"Running analysis: {', '.join([at.value for at in analysis_types])}")
+ results = self.analyzer.analyze(analysis_types)
+
+ # Save results if output file is specified
+ if output_file:
+ logger.info(f"Saving results to {output_file}")
+ self.analyzer.save_results(output_file, output_format)
+
+ return results
+
+ except Exception as e:
+ logger.error(f"Error running analysis: {e}")
+ import traceback
+ traceback.print_exc()
+ raise
+
+ def get_issues(self,
+ severity: Optional[IssueSeverity] = None,
+ category: Optional[IssueCategory] = None) -> List[Issue]:
+ """
+ Get issues from the analyzer.
+
+ Args:
+ severity: Filter issues by severity
+ category: Filter issues by category
+
+ Returns:
+ List of issues matching the filters
+ """
+ return self.analyzer.get_issues(severity, category)
+
+ def generate_report(self,
+ report_type: str = "summary",
+ output_file: Optional[str] = None) -> str:
+ """
+ Generate a report from the analysis results.
+
+ Args:
+ report_type: Type of report to generate (summary, detailed, issues)
+ output_file: Path to save report to (None for returning as string)
+
+ Returns:
+ Report as a string (if output_file is None)
+ """
+ if not hasattr(self.analyzer, 'results') or not self.analyzer.results:
+ raise ValueError("No analysis results available. Run analysis first.")
+
+ report = ""
+
+ if report_type == "summary":
+ report = self._generate_summary_report()
+ elif report_type == "detailed":
+ report = self._generate_detailed_report()
+ elif report_type == "issues":
+ report = self._generate_issues_report()
+ else:
+ raise ValueError(f"Unknown report type: {report_type}")
+
+ if output_file:
+ with open(output_file, 'w') as f:
+ f.write(report)
+ logger.info(f"Report saved to {output_file}")
+ return ""
+ else:
+ return report
+
+ def _generate_summary_report(self) -> str:
+ """Generate a summary report of the analysis results."""
+ results = self.analyzer.results
+
+ report = "===== Codebase Analysis Summary Report =====\n\n"
+
+ # Add metadata
+ report += "Metadata:\n"
+ report += f" Repository: {results['metadata'].get('repo_name', 'Unknown')}\n"
+ report += f" Language: {results['metadata'].get('language', 'Unknown')}\n"
+ report += f" Analysis Time: {results['metadata'].get('analysis_time', 'Unknown')}\n"
+ report += f" Analysis Types: {', '.join(results['metadata'].get('analysis_types', []))}\n"
+
+ # Add issue statistics
+ report += "\nIssue Statistics:\n"
+ report += f" Total Issues: {results['issue_stats']['total']}\n"
+ report += f" Critical: {results['issue_stats']['by_severity'].get('critical', 0)}\n"
+ report += f" Errors: {results['issue_stats']['by_severity'].get('error', 0)}\n"
+ report += f" Warnings: {results['issue_stats']['by_severity'].get('warning', 0)}\n"
+ report += f" Info: {results['issue_stats']['by_severity'].get('info', 0)}\n"
+
+ # Add codebase summary
+ if 'summary' in results:
+ report += "\nCodebase Summary:\n"
+ summary = results['summary']
+ report += f" Files: {summary.get('file_count', 0)}\n"
+ report += f" Lines of Code: {summary.get('total_loc', 0)}\n"
+ report += f" Functions: {summary.get('function_count', 0)}\n"
+ report += f" Classes: {summary.get('class_count', 0)}\n"
+
+ # Add analysis summaries
+ for analysis_type, analysis_results in results.get('results', {}).items():
+ report += f"\n{analysis_type.title()} Analysis Summary:\n"
+
+ if analysis_type == 'code_quality':
+ if 'dead_code' in analysis_results:
+ dead_code = analysis_results['dead_code']
+ report += f" Dead Code Items: {dead_code['summary']['total_dead_code_count']}\n"
+ report += f" Unused Functions: {dead_code['summary']['unused_functions_count']}\n"
+ report += f" Unused Classes: {dead_code['summary']['unused_classes_count']}\n"
+ report += f" Unused Variables: {dead_code['summary']['unused_variables_count']}\n"
+ report += f" Unused Imports: {dead_code['summary']['unused_imports_count']}\n"
+
+ if 'complexity' in analysis_results:
+ complexity = analysis_results['complexity']
+ report += f" Average Complexity: {complexity.get('average_complexity', 0):.2f}\n"
+ report += f" High Complexity Functions: {len(complexity.get('high_complexity_functions', []))}\n"
+
+ # Distribution
+ dist = complexity.get('complexity_distribution', {})
+ report += f" Complexity Distribution:\n"
+ report += f" Low: {dist.get('low', 0)}\n"
+ report += f" Medium: {dist.get('medium', 0)}\n"
+ report += f" High: {dist.get('high', 0)}\n"
+ report += f" Very High: {dist.get('very_high', 0)}\n"
+
+ elif analysis_type == 'dependency':
+ if 'circular_dependencies' in analysis_results:
+ circular = analysis_results['circular_dependencies']
+ report += f" Circular Dependencies: {circular.get('circular_dependencies_count', 0)}\n"
+ report += f" Affected Modules: {len(circular.get('affected_modules', []))}\n"
+
+ if 'module_coupling' in analysis_results:
+ coupling = analysis_results['module_coupling']
+ report += f" Average Coupling: {coupling.get('average_coupling', 0):.2f}\n"
+ report += f" High Coupling Modules: {len(coupling.get('high_coupling_modules', []))}\n"
+ report += f" Low Coupling Modules: {len(coupling.get('low_coupling_modules', []))}\n"
+
+ return report
+
+ def _generate_detailed_report(self) -> str:
+ """Generate a detailed report of the analysis results."""
+ results = self.analyzer.results
+
+ report = "===== Codebase Analysis Detailed Report =====\n\n"
+
+ # Add metadata
+ report += "Metadata:\n"
+ report += f" Repository: {results['metadata'].get('repo_name', 'Unknown')}\n"
+ report += f" Language: {results['metadata'].get('language', 'Unknown')}\n"
+ report += f" Analysis Time: {results['metadata'].get('analysis_time', 'Unknown')}\n"
+ report += f" Analysis Types: {', '.join(results['metadata'].get('analysis_types', []))}\n"
+
+ # Add detailed analysis sections
+ for analysis_type, analysis_results in results.get('results', {}).items():
+ report += f"\n{analysis_type.title()} Analysis:\n"
+
+ # Add relevant sections from each analysis type
+ if analysis_type == 'code_quality':
+ # Dead code
+ if 'dead_code' in analysis_results:
+ dead_code = analysis_results['dead_code']
+ report += f"\n Dead Code Analysis:\n"
+ report += f" Total Dead Code Items: {dead_code['summary']['total_dead_code_count']}\n"
+
+ # Unused functions
+ if dead_code['unused_functions']:
+ report += f"\n Unused Functions ({len(dead_code['unused_functions'])}):\n"
+ for func in dead_code['unused_functions'][:10]: # Limit to top 10
+ report += f" {func['name']} ({func['file']}:{func['line']})\n"
+ if len(dead_code['unused_functions']) > 10:
+ report += f" ... and {len(dead_code['unused_functions']) - 10} more\n"
+
+ # Unused classes
+ if dead_code['unused_classes']:
+ report += f"\n Unused Classes ({len(dead_code['unused_classes'])}):\n"
+ for cls in dead_code['unused_classes'][:10]: # Limit to top 10
+ report += f" {cls['name']} ({cls['file']}:{cls['line']})\n"
+ if len(dead_code['unused_classes']) > 10:
+ report += f" ... and {len(dead_code['unused_classes']) - 10} more\n"
+
+ # Complexity
+ if 'complexity' in analysis_results:
+ complexity = analysis_results['complexity']
+ report += f"\n Code Complexity Analysis:\n"
+ report += f" Average Complexity: {complexity.get('average_complexity', 0):.2f}\n"
+
+ # High complexity functions
+ high_complexity = complexity.get('high_complexity_functions', [])
+ if high_complexity:
+ report += f"\n High Complexity Functions ({len(high_complexity)}):\n"
+ for func in high_complexity[:10]: # Limit to top 10
+ report += f" {func['name']} (Complexity: {func['complexity']}, {func['file']}:{func['line']})\n"
+ if len(high_complexity) > 10:
+ report += f" ... and {len(high_complexity) - 10} more\n"
+
+ # Maintainability
+ if 'maintainability' in analysis_results:
+ maintain = analysis_results['maintainability']
+ report += f"\n Maintainability Analysis:\n"
+ report += f" Average Maintainability: {maintain.get('average_maintainability', 0):.2f}\n"
+
+ # Low maintainability functions
+ low_maintain = maintain.get('low_maintainability_functions', [])
+ if low_maintain:
+ report += f"\n Low Maintainability Functions ({len(low_maintain)}):\n"
+ for func in low_maintain[:10]: # Limit to top 10
+ report += f" {func['name']} (Index: {func['maintainability']:.1f}, {func['file']}:{func['line']})\n"
+ if len(low_maintain) > 10:
+ report += f" ... and {len(low_maintain) - 10} more\n"
+
+ elif analysis_type == 'dependency':
+ # Circular dependencies
+ if 'circular_dependencies' in analysis_results:
+ circular = analysis_results['circular_dependencies']
+ report += f"\n Circular Dependencies Analysis:\n"
+ report += f" Total Circular Dependencies: {circular.get('circular_dependencies_count', 0)}\n"
+
+ # List circular import chains
+ if circular.get('circular_imports', []):
+ report += f"\n Circular Import Chains ({len(circular['circular_imports'])}):\n"
+ for i, cycle in enumerate(circular['circular_imports'][:5]): # Limit to top 5
+ report += f" Chain {i+1} (Length: {cycle['length']}):\n"
+ for j, file_path in enumerate(cycle['files']):
+ report += f" {j+1}. {file_path}\n"
+ if len(circular['circular_imports']) > 5:
+ report += f" ... and {len(circular['circular_imports']) - 5} more chains\n"
+
+ # Module coupling
+ if 'module_coupling' in analysis_results:
+ coupling = analysis_results['module_coupling']
+ report += f"\n Module Coupling Analysis:\n"
+ report += f" Average Coupling: {coupling.get('average_coupling', 0):.2f}\n"
+
+ # High coupling modules
+ high_coupling = coupling.get('high_coupling_modules', [])
+ if high_coupling:
+ report += f"\n High Coupling Modules ({len(high_coupling)}):\n"
+ for module in high_coupling[:10]: # Limit to top 10
+ report += f" {module['module']} (Ratio: {module['coupling_ratio']:.2f}, Files: {module['file_count']}, Imports: {module['import_count']})\n"
+ if len(high_coupling) > 10:
+ report += f" ... and {len(high_coupling) - 10} more\n"
+
+ # External dependencies
+ if 'external_dependencies' in analysis_results:
+ ext_deps = analysis_results['external_dependencies']
+ most_used = ext_deps.get('most_used_external_modules', [])
+
+ if most_used:
+ report += f"\n Most Used External Modules:\n"
+ for module in most_used[:10]:
+ report += f" {module['module']} (Used {module['usage_count']} times)\n"
+
+ return report
+
+ def _generate_issues_report(self) -> str:
+ """Generate a report focused on issues found during analysis."""
+ issues = self.analyzer.issues
+
+ report = "===== Codebase Analysis Issues Report =====\n\n"
+
+ # Issue statistics
+ report += f"Total Issues: {len(issues)}\n"
+ report += f"Critical: {sum(1 for issue in issues if issue.severity == IssueSeverity.CRITICAL)}\n"
+ report += f"Errors: {sum(1 for issue in issues if issue.severity == IssueSeverity.ERROR)}\n"
+ report += f"Warnings: {sum(1 for issue in issues if issue.severity == IssueSeverity.WARNING)}\n"
+ report += f"Info: {sum(1 for issue in issues if issue.severity == IssueSeverity.INFO)}\n"
+
+ # Group issues by severity
+ issues_by_severity = {}
+ for severity in [IssueSeverity.CRITICAL, IssueSeverity.ERROR, IssueSeverity.WARNING, IssueSeverity.INFO]:
+ issues_by_severity[severity] = [issue for issue in issues if issue.severity == severity]
+
+ # Format issues by severity
+ for severity in [IssueSeverity.CRITICAL, IssueSeverity.ERROR, IssueSeverity.WARNING, IssueSeverity.INFO]:
+ severity_issues = issues_by_severity[severity]
+
+ if severity_issues:
+ report += f"\n{severity.value.upper()} Issues ({len(severity_issues)}):\n"
+
+ for issue in severity_issues:
+ location = f"{issue.file}:{issue.line}" if issue.line else issue.file
+ category = f"[{issue.category.value}]" if issue.category else ""
+ report += f"- {location} {category} {issue.message}\n"
+ report += f" Suggestion: {issue.suggestion}\n"
+
+ return report
+
+def main():
+ """Command-line entry point for running analyzers."""
+ import argparse
+
+ parser = argparse.ArgumentParser(description="Codebase Analyzer Manager")
+
+ # Repository source options
+ source_group = parser.add_mutually_exclusive_group(required=True)
+ source_group.add_argument("--repo-url", help="URL of the repository to analyze")
+ source_group.add_argument("--repo-path", help="Local path to the repository to analyze")
+
+ # Analysis options
+ parser.add_argument("--analysis-types", nargs="+", choices=[at.value for at in AnalysisType],
+ default=["code_quality", "dependency"],
+ help="Types of analysis to perform")
+ parser.add_argument("--language", choices=["python", "typescript"],
+ help="Programming language (auto-detected if not provided)")
+ parser.add_argument("--base-branch", default="main",
+ help="Base branch for PR comparison (default: main)")
+ parser.add_argument("--pr-number", type=int,
+ help="PR number to analyze")
+
+ # Output options
+ parser.add_argument("--output-file",
+ help="Path to the output file")
+ parser.add_argument("--output-format", choices=["json", "html", "console"], default="json",
+ help="Output format")
+ parser.add_argument("--report-type", choices=["summary", "detailed", "issues"], default="summary",
+ help="Type of report to generate (default: summary)")
+
+ args = parser.parse_args()
+
+ try:
+ # Initialize the analyzer manager
+ manager = AnalyzerManager(
+ repo_url=args.repo_url,
+ repo_path=args.repo_path,
+ language=args.language,
+ base_branch=args.base_branch,
+ pr_number=args.pr_number
+ )
+
+ # Run the analysis
+ analysis_types = [AnalysisType(at) for at in args.analysis_types]
+ manager.run_analysis(analysis_types, args.output_file, args.output_format)
+
+ # Generate and print report
+ if args.output_format == "console":
+ report = manager.generate_report(args.report_type)
+ print(report)
+
+ except Exception as e:
+ print(f"Error: {e}")
+ import traceback
+ traceback.print_exc()
+ sys.exit(1)
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/api.py b/codegen-on-oss/codegen_on_oss/analyzers/api.py
new file mode 100644
index 000000000..b774f37c0
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/api.py
@@ -0,0 +1,597 @@
+#!/usr/bin/env python3
+"""
+Analyzer API Module
+
+This module provides the API interface for the codegit-on-git frontend to interact
+with the codebase analysis backend. It handles requests for analysis, visualization,
+and data export.
+"""
+
+import os
+import sys
+import json
+import logging
+from typing import Dict, List, Set, Tuple, Any, Optional, Union
+
+# Import analyzer components
+from codegen_on_oss.analyzers.analyzer import AnalyzerManager
+from codegen_on_oss.analyzers.issues import Issue, IssueSeverity, AnalysisType, IssueCategory
+from codegen_on_oss.analyzers.visualization import Visualizer, VisualizationType, OutputFormat
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class CodegenAnalyzerAPI:
+ """
+ Backend API for codegit-on-git.
+
+ This class provides a unified interface for the frontend to interact with
+ the codebase analysis backend, including analysis, visualization, and data export.
+ """
+
+ def __init__(self, repo_path: Optional[str] = None, repo_url: Optional[str] = None):
+ """
+ Initialize the API with a repository.
+
+ Args:
+ repo_path: Local path to the repository
+ repo_url: URL of the repository
+ """
+ # Initialize analyzer
+ self.analyzer = AnalyzerManager(repo_path=repo_path, repo_url=repo_url)
+
+ # Initialize visualizer when needed
+ self._visualizer = None
+
+ # Cache for analysis results
+ self._analysis_cache = {}
+
+ @property
+ def visualizer(self) -> Visualizer:
+ """Get or initialize visualizer."""
+ if self._visualizer is None:
+ self._visualizer = Visualizer()
+ return self._visualizer
+
+ def analyze_codebase(
+ self,
+ analysis_types: Optional[List[Union[str, AnalysisType]]] = None,
+ force_refresh: bool = False
+ ) -> Dict[str, Any]:
+ """
+ Analyze the entire codebase.
+
+ Args:
+ analysis_types: Types of analysis to perform
+ force_refresh: Whether to force a refresh of the analysis
+
+ Returns:
+ Analysis results
+ """
+ cache_key = str(analysis_types) if analysis_types else "default"
+
+ # Check cache first
+ if not force_refresh and cache_key in self._analysis_cache:
+ return self._analysis_cache[cache_key]
+
+ # Run analysis
+ results = self.analyzer.analyze(analysis_types=analysis_types)
+
+ # Cache results
+ self._analysis_cache[cache_key] = results
+
+ return results
+
+ def analyze_pr(
+ self,
+ pr_number: int,
+ analysis_types: Optional[List[Union[str, AnalysisType]]] = None,
+ force_refresh: bool = False
+ ) -> Dict[str, Any]:
+ """
+ Analyze a specific PR.
+
+ Args:
+ pr_number: PR number to analyze
+ analysis_types: Types of analysis to perform
+ force_refresh: Whether to force a refresh of the analysis
+
+ Returns:
+ Analysis results
+ """
+ cache_key = f"pr_{pr_number}_{str(analysis_types)}"
+
+ # Check cache first
+ if not force_refresh and cache_key in self._analysis_cache:
+ return self._analysis_cache[cache_key]
+
+ # Set PR number
+ self.analyzer.pr_number = pr_number
+
+ # Use default analysis types if none provided
+ if analysis_types is None:
+ analysis_types = ["pr", "code_quality"]
+
+ # Run analysis
+ results = self.analyzer.analyze(analysis_types=analysis_types)
+
+ # Cache results
+ self._analysis_cache[cache_key] = results
+
+ return results
+
+ def get_issues(
+ self,
+ severity: Optional[Union[str, IssueSeverity]] = None,
+ category: Optional[Union[str, IssueCategory]] = None
+ ) -> List[Dict[str, Any]]:
+ """
+ Get issues matching criteria.
+
+ Args:
+ severity: Issue severity to filter by
+ category: Issue category to filter by
+
+ Returns:
+ List of matching issues
+ """
+ # Run analysis if not already done
+ if not self._analysis_cache:
+ self.analyze_codebase()
+
+ # Convert string severity to enum if needed
+ if isinstance(severity, str):
+ severity = IssueSeverity(severity)
+
+ # Convert string category to enum if needed
+ if isinstance(category, str):
+ category = IssueCategory(category)
+
+ # Get issues
+ issues = self.analyzer.get_issues(severity=severity, category=category)
+
+ # Convert to dictionaries
+ return [issue.to_dict() for issue in issues]
+
+ def find_symbol(self, symbol_name: str) -> Optional[Dict[str, Any]]:
+ """
+ Find a specific symbol in the codebase.
+
+ Args:
+ symbol_name: Name of the symbol to find
+
+ Returns:
+ Symbol information if found, None otherwise
+ """
+ # Run analysis if not already done
+ if not self._analysis_cache:
+ self.analyze_codebase()
+
+ # Get symbol
+ symbol = self.analyzer.base_codebase.get_symbol(symbol_name)
+
+ if symbol:
+ # Convert to dictionary
+ return self._symbol_to_dict(symbol)
+
+ return None
+
+ def get_module_dependencies(
+ self,
+ module_path: Optional[str] = None,
+ layout: str = "hierarchical",
+ format: str = "json"
+ ) -> Dict[str, Any]:
+ """
+ Get module dependencies.
+
+ Args:
+ module_path: Path to the module to analyze
+ layout: Layout algorithm to use
+ format: Output format
+
+ Returns:
+ Module dependency visualization
+ """
+ # Run analysis if not already done
+ if not self._analysis_cache:
+ self.analyze_codebase(analysis_types=["dependency"])
+
+ # Generate visualization
+ viz = self.visualizer.generate_module_dependency_graph(
+ codebase_context=self.analyzer.base_context,
+ module_path=module_path,
+ layout=layout
+ )
+
+ # Export if needed
+ if format != "json":
+ return self.visualizer.export(viz, format=format)
+
+ return viz
+
+ def get_function_call_graph(
+ self,
+ function_name: Union[str, List[str]],
+ depth: int = 2,
+ layout: str = "hierarchical",
+ format: str = "json"
+ ) -> Dict[str, Any]:
+ """
+ Get function call graph.
+
+ Args:
+ function_name: Name of the function(s) to analyze
+ depth: Maximum depth of the call graph
+ layout: Layout algorithm to use
+ format: Output format
+
+ Returns:
+ Function call graph visualization
+ """
+ # Run analysis if not already done
+ if not self._analysis_cache:
+ self.analyze_codebase(analysis_types=["code_quality"])
+
+ # Generate visualization
+ viz = self.visualizer.generate_function_call_graph(
+ functions=function_name,
+ codebase_context=self.analyzer.base_context,
+ depth=depth,
+ layout=layout
+ )
+
+ # Export if needed
+ if format != "json":
+ return self.visualizer.export(viz, format=format)
+
+ return viz
+
+ def get_pr_impact(
+ self,
+ pr_number: Optional[int] = None,
+ layout: str = "force",
+ format: str = "json"
+ ) -> Dict[str, Any]:
+ """
+ Get PR impact visualization.
+
+ Args:
+ pr_number: PR number to analyze
+ layout: Layout algorithm to use
+ format: Output format
+
+ Returns:
+ PR impact visualization
+ """
+ # Analyze PR if needed
+ if pr_number is not None:
+ self.analyze_pr(pr_number, analysis_types=["pr"])
+ elif self.analyzer.pr_number is None:
+ raise ValueError("No PR number specified")
+
+ # Generate visualization
+ viz = self.visualizer.generate_pr_diff_visualization(
+ pr_analysis=self.analyzer.results["results"]["pr"],
+ layout=layout
+ )
+
+ # Export if needed
+ if format != "json":
+ return self.visualizer.export(viz, format=format)
+
+ return viz
+
+ def export_visualization(
+ self,
+ visualization: Dict[str, Any],
+ format: str = "json",
+ filename: Optional[str] = None
+ ) -> Union[str, Dict[str, Any]]:
+ """
+ Export visualization in specified format.
+
+ Args:
+ visualization: Visualization to export
+ format: Output format
+ filename: Output filename
+
+ Returns:
+ Exported visualization or path to saved file
+ """
+ return self.visualizer.export(
+ visualization,
+ format=format,
+ filename=filename
+ )
+
+ def get_static_errors(self) -> List[Dict[str, Any]]:
+ """
+ Get static errors in the codebase.
+
+ Returns:
+ List of static errors
+ """
+ # Run analysis if not already done
+ if not self._analysis_cache:
+ self.analyze_codebase(analysis_types=["code_quality"])
+
+ # Get errors
+ errors = self.analyzer.get_issues(severity=IssueSeverity.ERROR)
+
+ # Convert to dictionaries
+ return [error.to_dict() for error in errors]
+
+ def get_parameter_issues(self) -> List[Dict[str, Any]]:
+ """
+ Get parameter-related issues.
+
+ Returns:
+ List of parameter issues
+ """
+ # Run analysis if not already done
+ if not self._analysis_cache:
+ self.analyze_codebase(analysis_types=["code_quality"])
+
+ # Get parameter issues
+ issues = self.analyzer.get_issues(category=IssueCategory.PARAMETER_MISMATCH)
+
+ # Convert to dictionaries
+ return [issue.to_dict() for issue in issues]
+
+ def get_unimplemented_functions(self) -> List[Dict[str, Any]]:
+ """
+ Get unimplemented functions.
+
+ Returns:
+ List of unimplemented functions
+ """
+ # Run analysis if not already done
+ if not self._analysis_cache:
+ self.analyze_codebase(analysis_types=["code_quality"])
+
+ # Get implementation issues
+ issues = self.analyzer.get_issues(category=IssueCategory.IMPLEMENTATION_ERROR)
+
+ # Convert to dictionaries
+ return [issue.to_dict() for issue in issues]
+
+ def get_circular_dependencies(self) -> List[Dict[str, Any]]:
+ """
+ Get circular dependencies.
+
+ Returns:
+ List of circular dependencies
+ """
+ # Run analysis if not already done
+ if not self._analysis_cache:
+ self.analyze_codebase(analysis_types=["dependency"])
+
+ # Get circular dependencies
+ if "dependency" in self.analyzer.results.get("results", {}):
+ return self.analyzer.results["results"]["dependency"].get("circular_dependencies", {}).get("circular_imports", [])
+
+ return []
+
+ def get_module_coupling(self) -> List[Dict[str, Any]]:
+ """
+ Get module coupling metrics.
+
+ Returns:
+ Module coupling metrics
+ """
+ # Run analysis if not already done
+ if not self._analysis_cache:
+ self.analyze_codebase(analysis_types=["dependency"])
+
+ # Get module coupling
+ if "dependency" in self.analyzer.results.get("results", {}):
+ return self.analyzer.results["results"]["dependency"].get("module_coupling", {}).get("high_coupling_modules", [])
+
+ return []
+
+ def get_diff_analysis(self, pr_number: int) -> Dict[str, Any]:
+ """
+ Get diff analysis for a PR.
+
+ Args:
+ pr_number: PR number to analyze
+
+ Returns:
+ Diff analysis results
+ """
+ # Analyze PR
+ self.analyze_pr(pr_number, analysis_types=["pr"])
+
+ # Get diff analysis
+ if "pr" in self.analyzer.results.get("results", {}):
+ return self.analyzer.results["results"]["pr"]
+
+ return {}
+
+ def clear_cache(self):
+ """Clear the analysis cache."""
+ self._analysis_cache = {}
+
+ def _symbol_to_dict(self, symbol) -> Dict[str, Any]:
+ """Convert symbol to dictionary."""
+ symbol_dict = {
+ "name": symbol.name if hasattr(symbol, 'name') else str(symbol),
+ "type": str(symbol.symbol_type) if hasattr(symbol, 'symbol_type') else "unknown",
+ "file": symbol.file.file_path if hasattr(symbol, 'file') and hasattr(symbol.file, 'file_path') else "unknown",
+ "line": symbol.line if hasattr(symbol, 'line') else None,
+ }
+
+ # Add function-specific info
+ if hasattr(symbol, 'parameters'):
+ symbol_dict["parameters"] = [
+ {
+ "name": p.name if hasattr(p, 'name') else str(p),
+ "type": str(p.type) if hasattr(p, 'type') and p.type else None,
+ "has_default": p.has_default if hasattr(p, 'has_default') else False
+ }
+ for p in symbol.parameters
+ ]
+
+ symbol_dict["return_type"] = str(symbol.return_type) if hasattr(symbol, 'return_type') and symbol.return_type else None
+ symbol_dict["is_async"] = symbol.is_async if hasattr(symbol, 'is_async') else False
+
+ # Add class-specific info
+ if hasattr(symbol, 'superclasses'):
+ symbol_dict["superclasses"] = [
+ sc.name if hasattr(sc, 'name') else str(sc)
+ for sc in symbol.superclasses
+ ]
+
+ return symbol_dict
+
+
+def create_api(repo_path: Optional[str] = None, repo_url: Optional[str] = None) -> CodegenAnalyzerAPI:
+ """
+ Create an API instance.
+
+ Args:
+ repo_path: Local path to the repository
+ repo_url: URL of the repository
+
+ Returns:
+ API instance
+ """
+ return CodegenAnalyzerAPI(repo_path=repo_path, repo_url=repo_url)
+
+
+# API endpoints for Flask or FastAPI integration
+def api_analyze_codebase(repo_path: str, analysis_types: Optional[List[str]] = None) -> Dict[str, Any]:
+ """
+ API endpoint for codebase analysis.
+
+ Args:
+ repo_path: Path to the repository
+ analysis_types: Types of analysis to perform
+
+ Returns:
+ Analysis results
+ """
+ api = create_api(repo_path=repo_path)
+ return api.analyze_codebase(analysis_types=analysis_types)
+
+
+def api_analyze_pr(repo_path: str, pr_number: int) -> Dict[str, Any]:
+ """
+ API endpoint for PR analysis.
+
+ Args:
+ repo_path: Path to the repository
+ pr_number: PR number to analyze
+
+ Returns:
+ Analysis results
+ """
+ api = create_api(repo_path=repo_path)
+ return api.analyze_pr(pr_number=pr_number)
+
+
+def api_get_visualization(
+ repo_path: str,
+ viz_type: str,
+ params: Dict[str, Any]
+) -> Dict[str, Any]:
+ """
+ API endpoint for visualizations.
+
+ Args:
+ repo_path: Path to the repository
+ viz_type: Type of visualization
+ params: Visualization parameters
+
+ Returns:
+ Visualization data
+ """
+ api = create_api(repo_path=repo_path)
+
+ # Run appropriate analysis based on visualization type
+ if viz_type == "module_dependencies":
+ api.analyze_codebase(analysis_types=["dependency"])
+ elif viz_type in ["function_calls", "code_quality"]:
+ api.analyze_codebase(analysis_types=["code_quality"])
+ elif viz_type == "pr_impact":
+ api.analyze_pr(pr_number=params["pr_number"])
+
+ # Generate visualization
+ if viz_type == "module_dependencies":
+ return api.get_module_dependencies(
+ module_path=params.get("module_path"),
+ layout=params.get("layout", "hierarchical"),
+ format=params.get("format", "json")
+ )
+ elif viz_type == "function_calls":
+ return api.get_function_call_graph(
+ function_name=params["function_name"],
+ depth=params.get("depth", 2),
+ layout=params.get("layout", "hierarchical"),
+ format=params.get("format", "json")
+ )
+ elif viz_type == "pr_impact":
+ return api.get_pr_impact(
+ pr_number=params.get("pr_number"),
+ layout=params.get("layout", "force"),
+ format=params.get("format", "json")
+ )
+ else:
+ raise ValueError(f"Unknown visualization type: {viz_type}")
+
+
+def api_get_static_errors(repo_path: str) -> List[Dict[str, Any]]:
+ """
+ API endpoint for static errors.
+
+ Args:
+ repo_path: Path to the repository
+
+ Returns:
+ List of static errors
+ """
+ api = create_api(repo_path=repo_path)
+ return api.get_static_errors()
+
+
+def api_get_function_issues(repo_path: str, function_name: str) -> List[Dict[str, Any]]:
+ """
+ API endpoint for function issues.
+
+ Args:
+ repo_path: Path to the repository
+ function_name: Name of the function
+
+ Returns:
+ List of function issues
+ """
+ api = create_api(repo_path=repo_path)
+ api.analyze_codebase(analysis_types=["code_quality"])
+
+ # Get symbol
+ symbol = api.analyzer.base_codebase.get_symbol(function_name)
+
+ if not symbol:
+ return []
+
+ # Get file path
+ file_path = symbol.file.file_path if hasattr(symbol, 'file') and hasattr(symbol.file, 'file_path') else None
+
+ if not file_path:
+ return []
+
+ # Get issues for this file and symbol
+ issues = api.analyzer.get_issues()
+ return [
+ issue.to_dict() for issue in issues
+ if issue.file == file_path and (
+ issue.symbol == function_name or
+ (hasattr(issue, 'related_symbols') and function_name in issue.related_symbols)
+ )
+ ]
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/base_analyzer.py b/codegen-on-oss/codegen_on_oss/analyzers/base_analyzer.py
new file mode 100644
index 000000000..aec1c571f
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/base_analyzer.py
@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+"""
+Base Analyzer Module
+
+This module provides the foundation for all code analyzers in the system.
+It defines a common interface and shared functionality for codebase analysis.
+"""
+
+import os
+import sys
+import json
+import logging
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, TypeVar, cast
+from abc import ABC, abstractmethod
+
+try:
+ from codegen.sdk.core.codebase import Codebase
+ from codegen.configs.models.codebase import CodebaseConfig
+ from codegen.configs.models.secrets import SecretsConfig
+ from codegen.sdk.codebase.config import ProjectConfig
+ from codegen.git.schemas.repo_config import RepoConfig
+ from codegen.git.repo_operator.repo_operator import RepoOperator
+ from codegen.shared.enums.programming_language import ProgrammingLanguage
+
+ # Import from our own modules
+ from codegen_on_oss.context_codebase import CodebaseContext, get_node_classes, GLOBAL_FILE_IGNORE_LIST
+ from codegen_on_oss.current_code_codebase import get_selected_codebase
+ from codegen_on_oss.analyzers.issue_types import Issue, IssueSeverity, AnalysisType, IssueCategory
+except ImportError:
+ print("Codegen SDK or required modules not found.")
+ sys.exit(1)
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class BaseCodeAnalyzer(ABC):
+ """
+ Base class for all code analyzers.
+
+ This abstract class defines the common interface and shared functionality
+ for all code analyzers in the system. Specific analyzers should inherit
+ from this class and implement the abstract methods.
+ """
+
+ def __init__(
+ self,
+ repo_url: Optional[str] = None,
+ repo_path: Optional[str] = None,
+ base_branch: str = "main",
+ pr_number: Optional[int] = None,
+ language: Optional[str] = None,
+ file_ignore_list: Optional[List[str]] = None,
+ config: Optional[Dict[str, Any]] = None
+ ):
+ """
+ Initialize the base analyzer.
+
+ Args:
+ repo_url: URL of the repository to analyze
+ repo_path: Local path to the repository to analyze
+ base_branch: Base branch for comparison
+ pr_number: PR number to analyze
+ language: Programming language of the codebase
+ file_ignore_list: List of file patterns to ignore
+ config: Additional configuration options
+ """
+ self.repo_url = repo_url
+ self.repo_path = repo_path
+ self.base_branch = base_branch
+ self.pr_number = pr_number
+ self.language = language
+
+ # Use custom ignore list or default global list
+ self.file_ignore_list = file_ignore_list or GLOBAL_FILE_IGNORE_LIST
+
+ # Configuration options
+ self.config = config or {}
+
+ # Codebase and context objects
+ self.base_codebase = None
+ self.pr_codebase = None
+ self.base_context = None
+ self.pr_context = None
+
+ # Analysis results
+ self.issues: List[Issue] = []
+ self.results: Dict[str, Any] = {}
+
+ # PR comparison data
+ self.pr_diff = None
+ self.commit_shas = None
+ self.modified_symbols = None
+ self.pr_branch = None
+
+ # Initialize codebase(s) based on provided parameters
+ if repo_url:
+ self._init_from_url(repo_url, language)
+ elif repo_path:
+ self._init_from_path(repo_path, language)
+
+ # If PR number is provided, initialize PR-specific data
+ if self.pr_number is not None and self.base_codebase is not None:
+ self._init_pr_data(self.pr_number)
+
+ # Initialize contexts
+ self._init_contexts()
+
+ def _init_from_url(self, repo_url: str, language: Optional[str] = None):
+ """
+ Initialize codebase from a repository URL.
+
+ Args:
+ repo_url: URL of the repository
+ language: Programming language of the codebase
+ """
+ try:
+ # Extract repository information
+ if repo_url.endswith('.git'):
+ repo_url = repo_url[:-4]
+
+ parts = repo_url.rstrip('/').split('/')
+ repo_name = parts[-1]
+ owner = parts[-2]
+ repo_full_name = f"{owner}/{repo_name}"
+
+ # Create temporary directory for cloning
+ tmp_dir = tempfile.mkdtemp(prefix="analyzer_")
+
+ # Set up configuration
+ config = CodebaseConfig(
+ debug=False,
+ allow_external=True,
+ py_resolve_syspath=True,
+ )
+
+ secrets = SecretsConfig()
+
+ # Determine programming language
+ prog_lang = None
+ if language:
+ prog_lang = ProgrammingLanguage(language.upper())
+
+ # Initialize the codebase
+ logger.info(f"Initializing codebase from {repo_url}")
+
+ self.base_codebase = Codebase.from_github(
+ repo_full_name=repo_full_name,
+ tmp_dir=tmp_dir,
+ language=prog_lang,
+ config=config,
+ secrets=secrets
+ )
+
+ logger.info(f"Successfully initialized codebase from {repo_url}")
+
+ except Exception as e:
+ logger.error(f"Error initializing codebase from URL: {e}")
+ raise
+
+ def _init_from_path(self, repo_path: str, language: Optional[str] = None):
+ """
+ Initialize codebase from a local repository path.
+
+ Args:
+ repo_path: Path to the repository
+ language: Programming language of the codebase
+ """
+ try:
+ # Set up configuration
+ config = CodebaseConfig(
+ debug=False,
+ allow_external=True,
+ py_resolve_syspath=True,
+ )
+
+ secrets = SecretsConfig()
+
+ # Initialize the codebase
+ logger.info(f"Initializing codebase from {repo_path}")
+
+ # Determine programming language
+ prog_lang = None
+ if language:
+ prog_lang = ProgrammingLanguage(language.upper())
+
+ # Set up repository configuration
+ repo_config = RepoConfig.from_repo_path(repo_path)
+ repo_config.respect_gitignore = False
+ repo_operator = RepoOperator(repo_config=repo_config, bot_commit=False)
+
+ # Create project configuration
+ project_config = ProjectConfig(
+ repo_operator=repo_operator,
+ programming_language=prog_lang if prog_lang else None
+ )
+
+ # Initialize codebase
+ self.base_codebase = Codebase(
+ projects=[project_config],
+ config=config,
+ secrets=secrets
+ )
+
+ logger.info(f"Successfully initialized codebase from {repo_path}")
+
+ except Exception as e:
+ logger.error(f"Error initializing codebase from path: {e}")
+ raise
+
+ def _init_pr_data(self, pr_number: int):
+ """
+ Initialize PR-specific data.
+
+ Args:
+ pr_number: PR number to analyze
+ """
+ try:
+ logger.info(f"Fetching PR #{pr_number} data")
+ result = self.base_codebase.get_modified_symbols_in_pr(pr_number)
+
+ # Unpack the result tuple
+ if len(result) >= 3:
+ self.pr_diff, self.commit_shas, self.modified_symbols = result[:3]
+ if len(result) >= 4:
+ self.pr_branch = result[3]
+
+ logger.info(f"Found {len(self.modified_symbols)} modified symbols in PR")
+
+ # Initialize PR codebase
+ self._init_pr_codebase()
+
+ except Exception as e:
+ logger.error(f"Error initializing PR data: {e}")
+ raise
+
+ def _init_pr_codebase(self):
+ """Initialize PR codebase by checking out the PR branch."""
+ if not self.base_codebase or not self.pr_number:
+ logger.error("Base codebase or PR number not initialized")
+ return
+
+ try:
+ # Get PR data if not already fetched
+ if not self.pr_branch:
+ self._init_pr_data(self.pr_number)
+
+ if not self.pr_branch:
+ logger.error("Failed to get PR branch")
+ return
+
+ # Clone the base codebase
+ self.pr_codebase = self.base_codebase
+
+ # Checkout PR branch
+ logger.info(f"Checking out PR branch: {self.pr_branch}")
+ self.pr_codebase.checkout(self.pr_branch)
+
+ logger.info("Successfully initialized PR codebase")
+
+ except Exception as e:
+ logger.error(f"Error initializing PR codebase: {e}")
+ raise
+
+ def _init_contexts(self):
+ """Initialize CodebaseContext objects for both base and PR codebases."""
+ if self.base_codebase:
+ try:
+ self.base_context = CodebaseContext(
+ codebase=self.base_codebase,
+ base_path=self.repo_path,
+ pr_branch=None,
+ base_branch=self.base_branch
+ )
+ logger.info("Successfully initialized base context")
+ except Exception as e:
+ logger.error(f"Error initializing base context: {e}")
+
+ if self.pr_codebase:
+ try:
+ self.pr_context = CodebaseContext(
+ codebase=self.pr_codebase,
+ base_path=self.repo_path,
+ pr_branch=self.pr_branch,
+ base_branch=self.base_branch
+ )
+ logger.info("Successfully initialized PR context")
+ except Exception as e:
+ logger.error(f"Error initializing PR context: {e}")
+
+ def add_issue(self, issue: Issue):
+ """
+ Add an issue to the list of detected issues.
+
+ Args:
+ issue: Issue to add
+ """
+ self.issues.append(issue)
+
+ def get_issues(self, severity: Optional[IssueSeverity] = None, category: Optional[IssueCategory] = None) -> List[Issue]:
+ """
+ Get all issues matching the specified criteria.
+
+ Args:
+ severity: Optional severity level to filter by
+ category: Optional category to filter by
+
+ Returns:
+ List of matching issues
+ """
+ filtered_issues = self.issues
+
+ if severity:
+ filtered_issues = [i for i in filtered_issues if i.severity == severity]
+
+ if category:
+ filtered_issues = [i for i in filtered_issues if i.category == category]
+
+ return filtered_issues
+
+ def save_results(self, output_file: str):
+ """
+ Save analysis results to a file.
+
+ Args:
+ output_file: Path to the output file
+ """
+ with open(output_file, 'w') as f:
+ json.dump(self.results, f, indent=2)
+
+ logger.info(f"Results saved to {output_file}")
+
+ @abstractmethod
+ def analyze(self, analysis_type: AnalysisType) -> Dict[str, Any]:
+ """
+ Perform analysis on the codebase.
+
+ Args:
+ analysis_type: Type of analysis to perform
+
+ Returns:
+ Dictionary containing analysis results
+ """
+ pass
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/code_quality.py b/codegen-on-oss/codegen_on_oss/analyzers/code_quality.py
new file mode 100644
index 000000000..f40c79eaf
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/code_quality.py
@@ -0,0 +1,1102 @@
+#!/usr/bin/env python3
+"""
+Code Quality Analyzer Module
+
+This module provides analysis of code quality issues such as dead code,
+complexity, style, and maintainability. It identifies issues like unused variables,
+functions with excessive complexity, parameter errors, and implementation problems.
+"""
+
+import os
+import re
+import sys
+import math
+import logging
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, cast
+
+# Import from our own modules
+from codegen_on_oss.analyzers.issues import (
+ Issue, IssueSeverity, IssueCategory, IssueCollection,
+ CodeLocation, create_issue, AnalysisType
+)
+from codegen_on_oss.analyzers.codebase_context import CodebaseContext
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class CodeQualityAnalyzer:
+ """
+ Analyzer for code quality issues.
+
+ This class analyzes code quality issues in a codebase, including dead code,
+ complexity, style, and maintainability issues.
+ """
+
+ def __init__(
+ self,
+ codebase_context: CodebaseContext,
+ issue_collection: Optional[IssueCollection] = None
+ ):
+ """
+ Initialize the analyzer.
+
+ Args:
+ codebase_context: Context for the codebase to analyze
+ issue_collection: Collection for storing issues
+ """
+ self.context = codebase_context
+ self.issues = issue_collection or IssueCollection()
+
+ # Register default issue filters
+ self._register_default_filters()
+
+ def _register_default_filters(self):
+ """Register default issue filters."""
+ # Filter out issues in test files
+ self.issues.add_filter(
+ lambda issue: "test" not in issue.location.file.lower(),
+ "Skip issues in test files"
+ )
+
+ # Filter out issues in generated files
+ self.issues.add_filter(
+ lambda issue: "generated" not in issue.location.file.lower(),
+ "Skip issues in generated files"
+ )
+
+ def analyze(self) -> Dict[str, Any]:
+ """
+ Perform code quality analysis.
+
+ Returns:
+ Dictionary containing analysis results
+ """
+ logger.info("Starting code quality analysis")
+
+ # Clear existing issues
+ self.issues = IssueCollection()
+ self._register_default_filters()
+
+ # Analyze dead code
+ dead_code = self._find_dead_code()
+
+ # Analyze complexity
+ complexity = self._analyze_complexity()
+
+ # Analyze parameters
+ parameter_issues = self._check_function_parameters()
+
+ # Analyze style issues
+ style_issues = self._check_style_issues()
+
+ # Analyze implementations
+ implementation_issues = self._check_implementations()
+
+ # Analyze maintainability
+ maintainability = self._calculate_maintainability()
+
+ # Combine results
+ results = {
+ "summary": {
+ "issue_count": len(self.issues.issues),
+ "analyzed_functions": len(self.context.get_functions()),
+ "analyzed_classes": len(self.context.get_classes()),
+ "analyzed_files": len(self.context.get_files())
+ },
+ "dead_code": dead_code,
+ "complexity": complexity,
+ "parameter_issues": parameter_issues,
+ "style_issues": style_issues,
+ "implementation_issues": implementation_issues,
+ "maintainability": maintainability,
+ "issues": self.issues.to_dict()
+ }
+
+ logger.info(f"Code quality analysis complete. Found {len(self.issues.issues)} issues.")
+
+ return results
+
+ def _find_dead_code(self) -> Dict[str, Any]:
+ """
+ Find unused code (dead code) in the codebase.
+
+ Returns:
+ Dictionary containing dead code analysis results
+ """
+ logger.info("Analyzing dead code")
+
+ dead_code = {
+ "unused_functions": [],
+ "unused_classes": [],
+ "unused_variables": [],
+ "unused_imports": []
+ }
+
+ # Find unused functions
+ for function in self.context.get_functions():
+ # Skip if function should be excluded
+ if self._should_skip_symbol(function):
+ continue
+
+ # Skip decorated functions (as they might be used indirectly)
+ if hasattr(function, 'decorators') and function.decorators:
+ continue
+
+ # Check if function has no call sites or usages
+ has_call_sites = hasattr(function, 'call_sites') and len(function.call_sites) > 0
+ has_usages = hasattr(function, 'usages') and len(function.usages) > 0
+
+ if not has_call_sites and not has_usages:
+ # Skip magic methods and main functions
+ if (hasattr(function, 'is_magic') and function.is_magic) or (
+ hasattr(function, 'name') and function.name in ['main', '__main__']):
+ continue
+
+ # Get file path and name safely
+ file_path = function.file.file_path if hasattr(function, 'file') and hasattr(function.file, 'file_path') else "unknown"
+ func_name = function.name if hasattr(function, 'name') else str(function)
+
+ # Add to dead code list
+ dead_code["unused_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": function.line if hasattr(function, 'line') else None
+ })
+
+ # Add issue
+ self.issues.add_issue(create_issue(
+ message=f"Unused function: {func_name}",
+ severity=IssueSeverity.WARNING,
+ file=file_path,
+ line=function.line if hasattr(function, 'line') else None,
+ category=IssueCategory.DEAD_CODE,
+ symbol=func_name,
+ suggestion="Consider removing this unused function or documenting why it's needed"
+ ))
+
+ # Find unused classes
+ for cls in self.context.get_classes():
+ # Skip if class should be excluded
+ if self._should_skip_symbol(cls):
+ continue
+
+ # Check if class has no usages
+ has_usages = hasattr(cls, 'usages') and len(cls.usages) > 0
+
+ if not has_usages:
+ # Get file path and name safely
+ file_path = cls.file.file_path if hasattr(cls, 'file') and hasattr(cls.file, 'file_path') else "unknown"
+ cls_name = cls.name if hasattr(cls, 'name') else str(cls)
+
+ # Add to dead code list
+ dead_code["unused_classes"].append({
+ "name": cls_name,
+ "file": file_path,
+ "line": cls.line if hasattr(cls, 'line') else None
+ })
+
+ # Add issue
+ self.issues.add_issue(create_issue(
+ message=f"Unused class: {cls_name}",
+ severity=IssueSeverity.WARNING,
+ file=file_path,
+ line=cls.line if hasattr(cls, 'line') else None,
+ category=IssueCategory.DEAD_CODE,
+ symbol=cls_name,
+ suggestion="Consider removing this unused class or documenting why it's needed"
+ ))
+
+ # Find unused variables
+ for function in self.context.get_functions():
+ if not hasattr(function, 'code_block') or not hasattr(function.code_block, 'local_var_assignments'):
+ continue
+
+ for var_assignment in function.code_block.local_var_assignments:
+ # Check if variable has no usages
+ has_usages = hasattr(var_assignment, 'local_usages') and len(var_assignment.local_usages) > 0
+
+ if not has_usages:
+ # Skip if variable name indicates it's intentionally unused (e.g., _)
+ var_name = var_assignment.name if hasattr(var_assignment, 'name') else str(var_assignment)
+ if var_name == "_" or var_name.startswith("_unused"):
+ continue
+
+ # Get file path
+ file_path = function.file.file_path if hasattr(function, 'file') and hasattr(function.file, 'file_path') else "unknown"
+
+ # Add to dead code list
+ dead_code["unused_variables"].append({
+ "name": var_name,
+ "file": file_path,
+ "line": var_assignment.line if hasattr(var_assignment, 'line') else None,
+ "function": function.name if hasattr(function, 'name') else str(function)
+ })
+
+ # Add issue
+ self.issues.add_issue(create_issue(
+ message=f"Unused variable '{var_name}' in function '{function.name if hasattr(function, 'name') else 'unknown'}'",
+ severity=IssueSeverity.INFO,
+ file=file_path,
+ line=var_assignment.line if hasattr(var_assignment, 'line') else None,
+ category=IssueCategory.DEAD_CODE,
+ symbol=var_name,
+ suggestion="Consider removing this unused variable"
+ ))
+
+ # Find unused imports
+ for file in self.context.get_files():
+ if hasattr(file, 'is_binary') and file.is_binary:
+ continue
+
+ if not hasattr(file, 'imports'):
+ continue
+
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file)
+
+ for imp in file.imports:
+ if not hasattr(imp, 'usages'):
+ continue
+
+ if len(imp.usages) == 0:
+ # Get import source safely
+ import_source = imp.source if hasattr(imp, 'source') else str(imp)
+
+ # Add to dead code list
+ dead_code["unused_imports"].append({
+ "import": import_source,
+ "file": file_path,
+ "line": imp.line if hasattr(imp, 'line') else None
+ })
+
+ # Add issue
+ self.issues.add_issue(create_issue(
+ message=f"Unused import: {import_source}",
+ severity=IssueSeverity.INFO,
+ file=file_path,
+ line=imp.line if hasattr(imp, 'line') else None,
+ category=IssueCategory.DEAD_CODE,
+ code=import_source,
+ suggestion="Remove this unused import"
+ ))
+
+ # Add summary statistics
+ dead_code["summary"] = {
+ "unused_functions_count": len(dead_code["unused_functions"]),
+ "unused_classes_count": len(dead_code["unused_classes"]),
+ "unused_variables_count": len(dead_code["unused_variables"]),
+ "unused_imports_count": len(dead_code["unused_imports"]),
+ "total_dead_code_count": (
+ len(dead_code["unused_functions"]) +
+ len(dead_code["unused_classes"]) +
+ len(dead_code["unused_variables"]) +
+ len(dead_code["unused_imports"])
+ )
+ }
+
+ return dead_code
+
+ def _analyze_complexity(self) -> Dict[str, Any]:
+ """
+ Analyze code complexity.
+
+ Returns:
+ Dictionary containing complexity analysis results
+ """
+ logger.info("Analyzing code complexity")
+
+ complexity_result = {
+ "function_complexity": [],
+ "high_complexity_functions": [],
+ "average_complexity": 0.0,
+ "complexity_distribution": {
+ "low": 0,
+ "medium": 0,
+ "high": 0,
+ "very_high": 0
+ }
+ }
+
+ # Process all functions to calculate complexity
+ total_complexity = 0
+ function_count = 0
+
+ for function in self.context.get_functions():
+ # Skip if function should be excluded
+ if self._should_skip_symbol(function):
+ continue
+
+ # Skip if no code block
+ if not hasattr(function, 'code_block'):
+ continue
+
+ # Calculate cyclomatic complexity
+ complexity = self._calculate_cyclomatic_complexity(function)
+
+ # Get file path and name safely
+ file_path = function.file.file_path if hasattr(function, 'file') and hasattr(function.file, 'file_path') else "unknown"
+ func_name = function.name if hasattr(function, 'name') else str(function)
+
+ # Add to complexity list
+ complexity_result["function_complexity"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": function.line if hasattr(function, 'line') else None,
+ "complexity": complexity
+ })
+
+ # Track total complexity
+ total_complexity += complexity
+ function_count += 1
+
+ # Categorize complexity
+ if complexity <= 5:
+ complexity_result["complexity_distribution"]["low"] += 1
+ elif complexity <= 10:
+ complexity_result["complexity_distribution"]["medium"] += 1
+ elif complexity <= 15:
+ complexity_result["complexity_distribution"]["high"] += 1
+ else:
+ complexity_result["complexity_distribution"]["very_high"] += 1
+
+ # Flag high complexity functions
+ if complexity > 10:
+ complexity_result["high_complexity_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": function.line if hasattr(function, 'line') else None,
+ "complexity": complexity
+ })
+
+ # Add issue
+ severity = IssueSeverity.WARNING if complexity <= 15 else IssueSeverity.ERROR
+ self.issues.add_issue(create_issue(
+ message=f"Function '{func_name}' has high cyclomatic complexity ({complexity})",
+ severity=severity,
+ file=file_path,
+ line=function.line if hasattr(function, 'line') else None,
+ category=IssueCategory.COMPLEXITY,
+ symbol=func_name,
+ suggestion="Consider refactoring this function to reduce complexity"
+ ))
+
+ # Calculate average complexity
+ complexity_result["average_complexity"] = total_complexity / function_count if function_count > 0 else 0.0
+
+ # Sort high complexity functions by complexity
+ complexity_result["high_complexity_functions"].sort(key=lambda x: x["complexity"], reverse=True)
+
+ return complexity_result
+
+ def _calculate_cyclomatic_complexity(self, function) -> int:
+ """
+ Calculate cyclomatic complexity for a function.
+
+ Args:
+ function: Function to analyze
+
+ Returns:
+ Cyclomatic complexity score
+ """
+ complexity = 1 # Base complexity
+
+ def analyze_statement(statement):
+ nonlocal complexity
+
+ # Check for if statements (including elif branches)
+ if hasattr(statement, 'if_clause'):
+ complexity += 1
+
+ # Count elif branches
+ if hasattr(statement, 'elif_statements'):
+ complexity += len(statement.elif_statements)
+
+ # Count else branches
+ if hasattr(statement, 'else_clause') and statement.else_clause:
+ complexity += 1
+
+ # Count for loops
+ if hasattr(statement, 'is_for_loop') and statement.is_for_loop:
+ complexity += 1
+
+ # Count while loops
+ if hasattr(statement, 'is_while_loop') and statement.is_while_loop:
+ complexity += 1
+
+ # Count try/except blocks (each except adds a path)
+ if hasattr(statement, 'is_try_block') and statement.is_try_block:
+ if hasattr(statement, 'except_clauses'):
+ complexity += len(statement.except_clauses)
+
+ # Recursively process nested statements
+ if hasattr(statement, 'statements'):
+ for nested_stmt in statement.statements:
+ analyze_statement(nested_stmt)
+
+ # Process all statements in the function's code block
+ if hasattr(function, 'code_block') and hasattr(function.code_block, 'statements'):
+ for statement in function.code_block.statements:
+ analyze_statement(statement)
+
+ # If we can't analyze the AST, fall back to simple pattern matching
+ elif hasattr(function, 'source'):
+ source = function.source
+ # Count branch points
+ complexity += source.count('if ')
+ complexity += source.count('elif ')
+ complexity += source.count('for ')
+ complexity += source.count('while ')
+ complexity += source.count('except:')
+ complexity += source.count('except ')
+ complexity += source.count('case ')
+
+ return complexity
+
+ def _check_function_parameters(self) -> Dict[str, Any]:
+ """
+ Check for function parameter issues.
+
+ Returns:
+ Dictionary containing parameter analysis results
+ """
+ logger.info("Analyzing function parameters")
+
+ parameter_issues = {
+ "missing_types": [],
+ "inconsistent_types": [],
+ "unused_parameters": [],
+ "incorrect_usage": []
+ }
+
+ for function in self.context.get_functions():
+ # Skip if function should be excluded
+ if self._should_skip_symbol(function):
+ continue
+
+ # Skip if no parameters
+ if not hasattr(function, 'parameters'):
+ continue
+
+ file_path = function.file.file_path if hasattr(function, 'file') and hasattr(function.file, 'file_path') else "unknown"
+ func_name = function.name if hasattr(function, 'name') else str(function)
+
+ # Check for missing type annotations
+ missing_types = []
+ for param in function.parameters:
+ if not hasattr(param, 'name'):
+ continue
+
+ if not hasattr(param, 'type') or not param.type:
+ missing_types.append(param.name)
+
+ if missing_types:
+ parameter_issues["missing_types"].append({
+ "function": func_name,
+ "file": file_path,
+ "line": function.line if hasattr(function, 'line') else None,
+ "parameters": missing_types
+ })
+
+ self.issues.add_issue(create_issue(
+ message=f"Function '{func_name}' has parameters without type annotations: {', '.join(missing_types)}",
+ severity=IssueSeverity.WARNING,
+ file=file_path,
+ line=function.line if hasattr(function, 'line') else None,
+ category=IssueCategory.TYPE_ERROR,
+ symbol=func_name,
+ suggestion="Add type annotations to all parameters"
+ ))
+
+ # Check for unused parameters
+ if hasattr(function, 'source'):
+ # This is a simple check that looks for parameter names in the function body
+ # A more sophisticated check would analyze the AST
+ unused_params = []
+ for param in function.parameters:
+ if not hasattr(param, 'name'):
+ continue
+
+ # Skip self/cls parameter in methods
+ if param.name in ['self', 'cls'] and hasattr(function, 'parent') and function.parent:
+ continue
+
+ # Check if parameter name appears in function body
+ # This is a simple heuristic and may produce false positives
+ param_regex = r'\b' + re.escape(param.name) + r'\b'
+ body_lines = function.source.split('\n')[1:] if function.source.count('\n') > 0 else []
+ body_text = '\n'.join(body_lines)
+
+ if not re.search(param_regex, body_text):
+ unused_params.append(param.name)
+
+ if unused_params:
+ parameter_issues["unused_parameters"].append({
+ "function": func_name,
+ "file": file_path,
+ "line": function.line if hasattr(function, 'line') else None,
+ "parameters": unused_params
+ })
+
+ self.issues.add_issue(create_issue(
+ message=f"Function '{func_name}' has unused parameters: {', '.join(unused_params)}",
+ severity=IssueSeverity.INFO,
+ file=file_path,
+ line=function.line if hasattr(function, 'line') else None,
+ category=IssueCategory.DEAD_CODE,
+ symbol=func_name,
+ suggestion="Remove unused parameters or use them in the function body"
+ ))
+
+ # Check for incorrect parameter usage at call sites
+ if hasattr(function, 'call_sites'):
+ for call_site in function.call_sites:
+ # Skip if call site has no arguments
+ if not hasattr(call_site, 'args'):
+ continue
+
+ # Get required parameter count (excluding those with defaults)
+ required_count = 0
+ if hasattr(function, 'parameters'):
+ required_count = sum(1 for p in function.parameters
+ if not hasattr(p, 'has_default') or not p.has_default)
+
+ # Get call site file info
+ call_file = call_site.file.file_path if hasattr(call_site, 'file') and hasattr(call_site.file, 'file_path') else "unknown"
+ call_line = call_site.line if hasattr(call_site, 'line') else None
+
+ # Check parameter count
+ arg_count = len(call_site.args)
+ if arg_count < required_count:
+ parameter_issues["incorrect_usage"].append({
+ "function": func_name,
+ "caller_file": call_file,
+ "caller_line": call_line,
+ "required_count": required_count,
+ "provided_count": arg_count
+ })
+
+ self.issues.add_issue(create_issue(
+ message=f"Call to '{func_name}' has too few arguments ({arg_count} provided, {required_count} required)",
+ severity=IssueSeverity.ERROR,
+ file=call_file,
+ line=call_line,
+ category=IssueCategory.PARAMETER_MISMATCH,
+ symbol=func_name,
+ suggestion=f"Provide all required arguments to '{func_name}'"
+ ))
+
+ # Check for inconsistent parameter types across overloaded functions
+ functions_by_name = {}
+ for function in self.context.get_functions():
+ if hasattr(function, 'name'):
+ if function.name not in functions_by_name:
+ functions_by_name[function.name] = []
+ functions_by_name[function.name].append(function)
+
+ for func_name, overloads in functions_by_name.items():
+ if len(overloads) > 1:
+ # Check for inconsistent parameter types
+ for i, func1 in enumerate(overloads):
+ for func2 in overloads[i+1:]:
+ inconsistent_types = []
+
+ # Skip if either function has no parameters
+ if not hasattr(func1, 'parameters') or not hasattr(func2, 'parameters'):
+ continue
+
+ # Get common parameter names
+ func1_param_names = {p.name for p in func1.parameters if hasattr(p, 'name')}
+ func2_param_names = {p.name for p in func2.parameters if hasattr(p, 'name')}
+ common_params = func1_param_names.intersection(func2_param_names)
+
+ # Check parameter types
+ for param_name in common_params:
+ # Get parameter objects
+ param1 = next((p for p in func1.parameters if hasattr(p, 'name') and p.name == param_name), None)
+ param2 = next((p for p in func2.parameters if hasattr(p, 'name') and p.name == param_name), None)
+
+ if param1 and param2 and hasattr(param1, 'type') and hasattr(param2, 'type'):
+ if param1.type and param2.type and str(param1.type) != str(param2.type):
+ inconsistent_types.append({
+ "parameter": param_name,
+ "type1": str(param1.type),
+ "type2": str(param2.type),
+ "function1": f"{func1.file.file_path}:{func1.line}" if hasattr(func1, 'file') and hasattr(func1.file, 'file_path') and hasattr(func1, 'line') else str(func1),
+ "function2": f"{func2.file.file_path}:{func2.line}" if hasattr(func2, 'file') and hasattr(func2.file, 'file_path') and hasattr(func2, 'line') else str(func2)
+ })
+
+ if inconsistent_types:
+ parameter_issues["inconsistent_types"].extend(inconsistent_types)
+
+ for issue in inconsistent_types:
+ func1_file = func1.file.file_path if hasattr(func1, 'file') and hasattr(func1.file, 'file_path') else "unknown"
+ func1_line = func1.line if hasattr(func1, 'line') else None
+
+ self.issues.add_issue(create_issue(
+ message=f"Inconsistent types for parameter '{issue['parameter']}': {issue['type1']} vs {issue['type2']}",
+ severity=IssueSeverity.ERROR,
+ file=func1_file,
+ line=func1_line,
+ category=IssueCategory.TYPE_ERROR,
+ symbol=func_name,
+ suggestion="Use consistent parameter types across function overloads"
+ ))
+
+ # Add summary statistics
+ parameter_issues["summary"] = {
+ "missing_types_count": len(parameter_issues["missing_types"]),
+ "inconsistent_types_count": len(parameter_issues["inconsistent_types"]),
+ "unused_parameters_count": len(parameter_issues["unused_parameters"]),
+ "incorrect_usage_count": len(parameter_issues["incorrect_usage"]),
+ "total_issues": (
+ len(parameter_issues["missing_types"]) +
+ len(parameter_issues["inconsistent_types"]) +
+ len(parameter_issues["unused_parameters"]) +
+ len(parameter_issues["incorrect_usage"])
+ )
+ }
+
+ return parameter_issues
+
+ def _check_style_issues(self) -> Dict[str, Any]:
+ """
+ Check for code style issues.
+
+ Returns:
+ Dictionary containing style analysis results
+ """
+ logger.info("Analyzing code style")
+
+ style_result = {
+ "long_functions": [],
+ "long_lines": [],
+ "inconsistent_naming": [],
+ "summary": {
+ "long_functions_count": 0,
+ "long_lines_count": 0,
+ "inconsistent_naming_count": 0
+ }
+ }
+
+ # Check for long functions (too many lines)
+ for function in self.context.get_functions():
+ # Skip if function should be excluded
+ if self._should_skip_symbol(function):
+ continue
+
+ # Get function code
+ if hasattr(function, 'source'):
+ code = function.source
+ lines = code.split('\n')
+
+ # Check function length
+ if len(lines) > 50: # Threshold for "too long"
+ # Get file path and name safely
+ file_path = function.file.file_path if hasattr(function, 'file') and hasattr(function.file, 'file_path') else "unknown"
+ func_name = function.name if hasattr(function, 'name') else str(function)
+
+ # Add to long functions list
+ style_result["long_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": function.line if hasattr(function, 'line') else None,
+ "line_count": len(lines)
+ })
+
+ # Add issue
+ self.issues.add_issue(create_issue(
+ message=f"Function '{func_name}' is too long ({len(lines)} lines)",
+ severity=IssueSeverity.INFO,
+ file=file_path,
+ line=function.line if hasattr(function, 'line') else None,
+ category=IssueCategory.STYLE_ISSUE,
+ symbol=func_name,
+ suggestion="Consider breaking this function into smaller, more focused functions"
+ ))
+
+ # Check for long lines
+ for file in self.context.get_files():
+ # Skip binary files
+ if hasattr(file, 'is_binary') and file.is_binary:
+ continue
+
+ # Get file content
+ if hasattr(file, 'content'):
+ lines = file.content.split('\n')
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file)
+
+ # Find long lines
+ for i, line in enumerate(lines):
+ if len(line) > 100: # Threshold for "too long"
+ # Skip comment lines
+ if line.lstrip().startswith('#') or line.lstrip().startswith('//'):
+ continue
+
+ # Skip lines with strings that can't be easily broken
+ if '"' in line or "'" in line:
+ # If the line is mostly a string, skip it
+ if line.count('"') >= 2 or line.count("'") >= 2:
+ continue
+
+ # Add to long lines list
+ style_result["long_lines"].append({
+ "file": file_path,
+ "line_number": i + 1,
+ "line_length": len(line),
+ "line_content": line[:50] + "..." if len(line) > 50 else line
+ })
+
+ # Add issue (only for very long lines)
+ if len(line) > 120:
+ self.issues.add_issue(create_issue(
+ message=f"Line is too long ({len(line)} characters)",
+ severity=IssueSeverity.INFO,
+ file=file_path,
+ line=i + 1,
+ category=IssueCategory.STYLE_ISSUE,
+ suggestion="Consider breaking this line into multiple lines"
+ ))
+
+ # Update summary
+ style_result["summary"]["long_functions_count"] = len(style_result["long_functions"])
+ style_result["summary"]["long_lines_count"] = len(style_result["long_lines"])
+ style_result["summary"]["inconsistent_naming_count"] = len(style_result["inconsistent_naming"])
+
+ return style_result
+
+ def _check_implementations(self) -> Dict[str, Any]:
+ """
+ Check for implementation issues.
+
+ Returns:
+ Dictionary containing implementation analysis results
+ """
+ logger.info("Analyzing implementations")
+
+ implementation_issues = {
+ "unimplemented_functions": [],
+ "empty_functions": [],
+ "abstract_methods_without_implementation": [],
+ "interface_methods_not_implemented": [],
+ "summary": {
+ "unimplemented_functions_count": 0,
+ "empty_functions_count": 0,
+ "abstract_methods_without_implementation_count": 0,
+ "interface_methods_not_implemented_count": 0
+ }
+ }
+
+ # Check for empty functions
+ for function in self.context.get_functions():
+ # Skip if function should be excluded
+ if self._should_skip_symbol(function):
+ continue
+
+ # Get function source
+ if hasattr(function, 'source'):
+ source = function.source
+
+ # Check if function is empty or just has 'pass'
+ is_empty = False
+
+ if not source or source.strip() == "":
+ is_empty = True
+ else:
+ # Extract function body (skip the first line with the def)
+ body_lines = source.split('\n')[1:] if '\n' in source else []
+
+ # Check if body is empty or just has whitespace, docstring, or pass
+ non_empty_lines = [
+ line for line in body_lines
+ if line.strip() and
+ not line.strip().startswith('#') and
+ not (line.strip().startswith('"""') or line.strip().startswith("'''")) and
+ not line.strip() == 'pass'
+ ]
+
+ if not non_empty_lines:
+ is_empty = True
+
+ if is_empty:
+ # Get file path and name safely
+ file_path = function.file.file_path if hasattr(function, 'file') and hasattr(function.file, 'file_path') else "unknown"
+ func_name = function.name if hasattr(function, 'name') else str(function)
+
+ # Skip interface/abstract methods that are supposed to be empty
+ is_abstract = (
+ hasattr(function, 'is_abstract') and function.is_abstract or
+ hasattr(function, 'parent') and hasattr(function.parent, 'is_interface') and function.parent.is_interface
+ )
+
+ if not is_abstract:
+ # Add to empty functions list
+ implementation_issues["empty_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": function.line if hasattr(function, 'line') else None
+ })
+
+ # Add issue
+ self.issues.add_issue(create_issue(
+ message=f"Function '{func_name}' is empty",
+ severity=IssueSeverity.WARNING,
+ file=file_path,
+ line=function.line if hasattr(function, 'line') else None,
+ category=IssueCategory.MISSING_IMPLEMENTATION,
+ symbol=func_name,
+ suggestion="Implement this function or remove it if not needed"
+ ))
+
+ # Check for abstract methods without implementations
+ abstract_methods = []
+ for function in self.context.get_functions():
+ # Skip if function should be excluded
+ if self._should_skip_symbol(function):
+ continue
+
+ # Check if function is abstract
+ is_abstract = (
+ hasattr(function, 'is_abstract') and function.is_abstract or
+ hasattr(function, 'decorators') and any(
+ hasattr(d, 'name') and d.name in ['abstractmethod', 'abc.abstractmethod']
+ for d in function.decorators
+ )
+ )
+
+ if is_abstract and hasattr(function, 'parent') and hasattr(function, 'name'):
+ abstract_methods.append((function.parent, function.name))
+
+ # For each abstract method, check if it has implementations in subclasses
+ for parent, method_name in abstract_methods:
+ if not hasattr(parent, 'name'):
+ continue
+
+ parent_name = parent.name
+
+ # Find all subclasses
+ subclasses = []
+ for cls in self.context.get_classes():
+ if hasattr(cls, 'superclasses'):
+ for superclass in cls.superclasses:
+ if hasattr(superclass, 'name') and superclass.name == parent_name:
+ subclasses.append(cls)
+
+ # Check if method is implemented in all subclasses
+ for subclass in subclasses:
+ if not hasattr(subclass, 'methods'):
+ continue
+
+ # Check if method is implemented
+ implemented = any(
+ hasattr(m, 'name') and m.name == method_name
+ for m in subclass.methods
+ )
+
+ if not implemented:
+ # Get file path and name safely
+ file_path = subclass.file.file_path if hasattr(subclass, 'file') and hasattr(subclass.file, 'file_path') else "unknown"
+ cls_name = subclass.name if hasattr(subclass, 'name') else str(subclass)
+
+ # Add to unimplemented list
+ implementation_issues["abstract_methods_without_implementation"].append({
+ "method": method_name,
+ "parent_class": parent_name,
+ "subclass": cls_name,
+ "file": file_path,
+ "line": subclass.line if hasattr(subclass, 'line') else None
+ })
+
+ # Add issue
+ self.issues.add_issue(create_issue(
+ message=f"Class '{cls_name}' does not implement abstract method '{method_name}' from '{parent_name}'",
+ severity=IssueSeverity.ERROR,
+ file=file_path,
+ line=subclass.line if hasattr(subclass, 'line') else None,
+ category=IssueCategory.MISSING_IMPLEMENTATION,
+ symbol=cls_name,
+ suggestion=f"Implement the '{method_name}' method in '{cls_name}'"
+ ))
+
+ # Update summary
+ implementation_issues["summary"]["unimplemented_functions_count"] = len(implementation_issues["unimplemented_functions"])
+ implementation_issues["summary"]["empty_functions_count"] = len(implementation_issues["empty_functions"])
+ implementation_issues["summary"]["abstract_methods_without_implementation_count"] = len(implementation_issues["abstract_methods_without_implementation"])
+ implementation_issues["summary"]["interface_methods_not_implemented_count"] = len(implementation_issues["interface_methods_not_implemented"])
+
+ return implementation_issues
+
+ def _calculate_maintainability(self) -> Dict[str, Any]:
+ """
+ Calculate maintainability metrics.
+
+ Returns:
+ Dictionary containing maintainability analysis results
+ """
+ logger.info("Analyzing maintainability")
+
+ maintainability_result = {
+ "function_maintainability": [],
+ "low_maintainability_functions": [],
+ "average_maintainability": 0.0,
+ "maintainability_distribution": {
+ "high": 0,
+ "medium": 0,
+ "low": 0
+ }
+ }
+
+ # Process all functions to calculate maintainability
+ total_maintainability = 0
+ function_count = 0
+
+ for function in self.context.get_functions():
+ # Skip if function should be excluded
+ if self._should_skip_symbol(function):
+ continue
+
+ # Skip if no code block
+ if not hasattr(function, 'code_block'):
+ continue
+
+ # Calculate metrics
+ complexity = self._calculate_cyclomatic_complexity(function)
+
+ # Calculate Halstead volume (approximation)
+ operators = 0
+ operands = 0
+
+ if hasattr(function, 'source'):
+ code = function.source
+ # Simple approximation of operators and operands
+ operators = len([c for c in code if c in '+-*/=<>!&|^~%'])
+ # Counting words as potential operands
+ operands = len(re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', code))
+
+ halstead_volume = operators * operands * math.log2(operators + operands) if operators + operands > 0 else 0
+
+ # Count lines of code
+ loc = len(function.source.split('\n')) if hasattr(function, 'source') else 0
+
+ # Calculate maintainability index
+ # Formula: 171 - 5.2 * ln(Halstead Volume) - 0.23 * (Cyclomatic Complexity) - 16.2 * ln(LOC)
+ halstead_term = 5.2 * math.log(max(1, halstead_volume)) if halstead_volume > 0 else 0
+ complexity_term = 0.23 * complexity
+ loc_term = 16.2 * math.log(max(1, loc)) if loc > 0 else 0
+
+ maintainability = 171 - halstead_term - complexity_term - loc_term
+
+ # Normalize to 0-100 scale
+ maintainability = max(0, min(100, maintainability * 100 / 171))
+
+ # Get file path and name safely
+ file_path = function.file.file_path if hasattr(function, 'file') and hasattr(function.file, 'file_path') else "unknown"
+ func_name = function.name if hasattr(function, 'name') else str(function)
+
+ # Add to maintainability list
+ maintainability_result["function_maintainability"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": function.line if hasattr(function, 'line') else None,
+ "maintainability": maintainability,
+ "complexity": complexity,
+ "halstead_volume": halstead_volume,
+ "loc": loc
+ })
+
+ # Track total maintainability
+ total_maintainability += maintainability
+ function_count += 1
+
+ # Categorize maintainability
+ if maintainability >= 70:
+ maintainability_result["maintainability_distribution"]["high"] += 1
+ elif maintainability >= 50:
+ maintainability_result["maintainability_distribution"]["medium"] += 1
+ else:
+ maintainability_result["maintainability_distribution"]["low"] += 1
+
+ # Flag low maintainability functions
+ maintainability_result["low_maintainability_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": function.line if hasattr(function, 'line') else None,
+ "maintainability": maintainability,
+ "complexity": complexity,
+ "halstead_volume": halstead_volume,
+ "loc": loc
+ })
+
+ # Add issue
+ self.issues.add_issue(create_issue(
+ message=f"Function '{func_name}' has low maintainability index ({maintainability:.1f})",
+ severity=IssueSeverity.WARNING,
+ file=file_path,
+ line=function.line if hasattr(function, 'line') else None,
+ category=IssueCategory.COMPLEXITY,
+ symbol=func_name,
+ suggestion="Consider refactoring this function to improve maintainability"
+ ))
+
+ # Calculate average maintainability
+ maintainability_result["average_maintainability"] = total_maintainability / function_count if function_count > 0 else 0.0
+
+ # Sort low maintainability functions
+ maintainability_result["low_maintainability_functions"].sort(key=lambda x: x["maintainability"])
+
+ return maintainability_result
+
+ def _should_skip_symbol(self, symbol) -> bool:
+ """
+ Check if a symbol should be skipped during analysis.
+
+ Args:
+ symbol: Symbol to check
+
+ Returns:
+ True if the symbol should be skipped, False otherwise
+ """
+ # Skip if no file
+ if not hasattr(symbol, 'file'):
+ return True
+
+ # Skip if file should be skipped
+ if self._should_skip_file(symbol.file):
+ return True
+
+ return False
+
+ def _should_skip_file(self, file) -> bool:
+ """
+ Check if a file should be skipped during analysis.
+
+ Args:
+ file: File to check
+
+ Returns:
+ True if the file should be skipped, False otherwise
+ """
+ # Skip binary files
+ if hasattr(file, 'is_binary') and file.is_binary:
+ return True
+
+ # Get file path
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file)
+
+ # Skip test files
+ if "test" in file_path.lower():
+ return True
+
+ # Skip generated files
+ if "generated" in file_path.lower():
+ return True
+
+ # Skip files in ignore list
+ for pattern in self.context.file_ignore_list:
+ if pattern in file_path:
+ return True
+
+ return False
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/code_quality_analyzer.py b/codegen-on-oss/codegen_on_oss/analyzers/code_quality_analyzer.py
new file mode 100644
index 000000000..8e8983e4d
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/code_quality_analyzer.py
@@ -0,0 +1,530 @@
+#!/usr/bin/env python3
+"""
+Code Quality Analyzer Module
+
+This module provides analysis of code quality issues such as
+dead code, complexity, style, and maintainability.
+"""
+
+import os
+import sys
+import math
+import logging
+from typing import Dict, List, Set, Tuple, Any, Optional, Union
+
+from codegen_on_oss.analyzers.base_analyzer import BaseCodeAnalyzer
+from codegen_on_oss.analyzers.issue_types import Issue, IssueSeverity, AnalysisType, IssueCategory
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class CodeQualityAnalyzer(BaseCodeAnalyzer):
+ """
+ Analyzer for code quality issues.
+
+ This analyzer detects issues related to code quality, including
+ dead code, complexity, style, and maintainability.
+ """
+
+ def analyze(self, analysis_type: AnalysisType = AnalysisType.CODE_QUALITY) -> Dict[str, Any]:
+ """
+ Perform code quality analysis on the codebase.
+
+ Args:
+ analysis_type: Type of analysis to perform
+
+ Returns:
+ Dictionary containing analysis results
+ """
+ if not self.base_codebase:
+ raise ValueError("Codebase not initialized")
+
+ result = {
+ "metadata": {
+ "analysis_time": str(datetime.now()),
+ "analysis_type": analysis_type,
+ "repo_name": getattr(self.base_codebase.ctx, 'repo_name', None),
+ "language": str(getattr(self.base_codebase.ctx, 'programming_language', None)),
+ },
+ "summary": {},
+ }
+
+ # Reset issues list
+ self.issues = []
+
+ # Perform appropriate analysis based on type
+ if analysis_type == AnalysisType.CODE_QUALITY:
+ # Run all code quality checks
+ result["dead_code"] = self._find_dead_code()
+ result["complexity"] = self._analyze_code_complexity()
+ result["style_issues"] = self._check_style_issues()
+ result["maintainability"] = self._calculate_maintainability()
+
+ # Add issues to the result
+ result["issues"] = [issue.to_dict() for issue in self.issues]
+ result["issue_counts"] = {
+ "total": len(self.issues),
+ "by_severity": {
+ "critical": sum(1 for issue in self.issues if issue.severity == IssueSeverity.CRITICAL),
+ "error": sum(1 for issue in self.issues if issue.severity == IssueSeverity.ERROR),
+ "warning": sum(1 for issue in self.issues if issue.severity == IssueSeverity.WARNING),
+ "info": sum(1 for issue in self.issues if issue.severity == IssueSeverity.INFO),
+ },
+ "by_category": {
+ category.value: sum(1 for issue in self.issues if issue.category == category)
+ for category in IssueCategory
+ if any(issue.category == category for issue in self.issues)
+ }
+ }
+
+ # Store results
+ self.results = result
+
+ return result
+
+ def _find_dead_code(self) -> Dict[str, Any]:
+ """
+ Find unused code (dead code) in the codebase.
+
+ Returns:
+ Dictionary containing dead code analysis results
+ """
+ dead_code = {
+ "unused_functions": [],
+ "unused_classes": [],
+ "unused_variables": [],
+ "unused_imports": []
+ }
+
+ # Find unused functions
+ if hasattr(self.base_codebase, 'functions'):
+ for func in self.base_codebase.functions:
+ # Skip test files
+ if hasattr(func, 'file') and hasattr(func.file, 'filepath') and "test" in func.file.filepath:
+ continue
+
+ # Skip decorated functions (as they might be used indirectly)
+ if hasattr(func, 'decorators') and func.decorators:
+ continue
+
+ # Check if function has no call sites or usages
+ has_call_sites = hasattr(func, 'call_sites') and len(func.call_sites) > 0
+ has_usages = hasattr(func, 'usages') and len(func.usages) > 0
+
+ if not has_call_sites and not has_usages:
+ # Get file path and name safely
+ file_path = func.file.filepath if hasattr(func, 'file') and hasattr(func.file, 'filepath') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Add to dead code list
+ dead_code["unused_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None
+ })
+
+ # Add issue
+ self.add_issue(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Unused function: {func_name}",
+ severity=IssueSeverity.WARNING,
+ category=IssueCategory.DEAD_CODE,
+ symbol=func_name,
+ suggestion="Consider removing this unused function or documenting why it's needed"
+ ))
+
+ # Find unused classes
+ if hasattr(self.base_codebase, 'classes'):
+ for cls in self.base_codebase.classes:
+ # Skip test files
+ if hasattr(cls, 'file') and hasattr(cls.file, 'filepath') and "test" in cls.file.filepath:
+ continue
+
+ # Check if class has no usages
+ has_usages = hasattr(cls, 'usages') and len(cls.usages) > 0
+
+ if not has_usages:
+ # Get file path and name safely
+ file_path = cls.file.filepath if hasattr(cls, 'file') and hasattr(cls.file, 'filepath') else "unknown"
+ cls_name = cls.name if hasattr(cls, 'name') else str(cls)
+
+ # Add to dead code list
+ dead_code["unused_classes"].append({
+ "name": cls_name,
+ "file": file_path,
+ "line": cls.line if hasattr(cls, 'line') else None
+ })
+
+ # Add issue
+ self.add_issue(Issue(
+ file=file_path,
+ line=cls.line if hasattr(cls, 'line') else None,
+ message=f"Unused class: {cls_name}",
+ severity=IssueSeverity.WARNING,
+ category=IssueCategory.DEAD_CODE,
+ symbol=cls_name,
+ suggestion="Consider removing this unused class or documenting why it's needed"
+ ))
+
+ # Find unused variables
+ if hasattr(self.base_codebase, 'functions'):
+ for func in self.base_codebase.functions:
+ if not hasattr(func, 'code_block') or not hasattr(func.code_block, 'local_var_assignments'):
+ continue
+
+ for var_assignment in func.code_block.local_var_assignments:
+ # Check if variable has no usages
+ has_usages = hasattr(var_assignment, 'local_usages') and len(var_assignment.local_usages) > 0
+
+ if not has_usages:
+ # Get file path and name safely
+ file_path = func.file.filepath if hasattr(func, 'file') and hasattr(func.file, 'filepath') else "unknown"
+ var_name = var_assignment.name if hasattr(var_assignment, 'name') else str(var_assignment)
+
+ # Add to dead code list
+ dead_code["unused_variables"].append({
+ "name": var_name,
+ "file": file_path,
+ "line": var_assignment.line if hasattr(var_assignment, 'line') else None
+ })
+
+ # Add issue
+ self.add_issue(Issue(
+ file=file_path,
+ line=var_assignment.line if hasattr(var_assignment, 'line') else None,
+ message=f"Unused variable: {var_name}",
+ severity=IssueSeverity.INFO,
+ category=IssueCategory.DEAD_CODE,
+ symbol=var_name,
+ suggestion="Consider removing this unused variable"
+ ))
+
+ # Summarize findings
+ dead_code["summary"] = {
+ "unused_functions_count": len(dead_code["unused_functions"]),
+ "unused_classes_count": len(dead_code["unused_classes"]),
+ "unused_variables_count": len(dead_code["unused_variables"]),
+ "unused_imports_count": len(dead_code["unused_imports"]),
+ "total_dead_code_count": (
+ len(dead_code["unused_functions"]) +
+ len(dead_code["unused_classes"]) +
+ len(dead_code["unused_variables"]) +
+ len(dead_code["unused_imports"])
+ )
+ }
+
+ return dead_code
+
+ def _analyze_code_complexity(self) -> Dict[str, Any]:
+ """
+ Analyze code complexity.
+
+ Returns:
+ Dictionary containing complexity analysis results
+ """
+ complexity_result = {
+ "function_complexity": [],
+ "high_complexity_functions": [],
+ "average_complexity": 0.0,
+ "complexity_distribution": {
+ "low": 0,
+ "medium": 0,
+ "high": 0,
+ "very_high": 0
+ }
+ }
+
+ # Process all functions to calculate complexity
+ total_complexity = 0
+ function_count = 0
+
+ if hasattr(self.base_codebase, 'functions'):
+ for func in self.base_codebase.functions:
+ # Skip if no code block
+ if not hasattr(func, 'code_block'):
+ continue
+
+ # Calculate cyclomatic complexity
+ complexity = self._calculate_cyclomatic_complexity(func)
+
+ # Get file path and name safely
+ file_path = func.file.filepath if hasattr(func, 'file') and hasattr(func.file, 'filepath') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Add to complexity list
+ complexity_result["function_complexity"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "complexity": complexity
+ })
+
+ # Track total complexity
+ total_complexity += complexity
+ function_count += 1
+
+ # Categorize complexity
+ if complexity <= 5:
+ complexity_result["complexity_distribution"]["low"] += 1
+ elif complexity <= 10:
+ complexity_result["complexity_distribution"]["medium"] += 1
+ elif complexity <= 15:
+ complexity_result["complexity_distribution"]["high"] += 1
+ else:
+ complexity_result["complexity_distribution"]["very_high"] += 1
+
+ # Flag high complexity functions
+ if complexity > 10:
+ complexity_result["high_complexity_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "complexity": complexity
+ })
+
+ # Add issue
+ severity = IssueSeverity.WARNING if complexity <= 15 else IssueSeverity.ERROR
+ self.add_issue(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"High cyclomatic complexity: {complexity}",
+ severity=severity,
+ category=IssueCategory.COMPLEXITY,
+ symbol=func_name,
+ suggestion="Consider refactoring this function to reduce complexity"
+ ))
+
+ # Calculate average complexity
+ complexity_result["average_complexity"] = total_complexity / function_count if function_count > 0 else 0.0
+
+ # Sort high complexity functions by complexity
+ complexity_result["high_complexity_functions"].sort(key=lambda x: x["complexity"], reverse=True)
+
+ return complexity_result
+
+ def _calculate_cyclomatic_complexity(self, function) -> int:
+ """
+ Calculate cyclomatic complexity for a function.
+
+ Args:
+ function: Function to analyze
+
+ Returns:
+ Cyclomatic complexity score
+ """
+ complexity = 1 # Base complexity
+
+ def analyze_statement(statement):
+ nonlocal complexity
+
+ # Check for if statements (including elif branches)
+ if hasattr(statement, 'if_clause'):
+ complexity += 1
+
+ # Count elif branches
+ if hasattr(statement, 'elif_statements'):
+ complexity += len(statement.elif_statements)
+
+ # Count else branches
+ if hasattr(statement, 'else_clause') and statement.else_clause:
+ complexity += 1
+
+ # Count for loops
+ if hasattr(statement, 'is_for_loop') and statement.is_for_loop:
+ complexity += 1
+
+ # Count while loops
+ if hasattr(statement, 'is_while_loop') and statement.is_while_loop:
+ complexity += 1
+
+ # Count try/except blocks (each except adds a path)
+ if hasattr(statement, 'is_try_block') and statement.is_try_block:
+ if hasattr(statement, 'except_clauses'):
+ complexity += len(statement.except_clauses)
+
+ # Recursively process nested statements
+ if hasattr(statement, 'statements'):
+ for nested_stmt in statement.statements:
+ analyze_statement(nested_stmt)
+
+ # Process all statements in the function's code block
+ if hasattr(function, 'code_block') and hasattr(function.code_block, 'statements'):
+ for statement in function.code_block.statements:
+ analyze_statement(statement)
+
+ return complexity
+
+ def _check_style_issues(self) -> Dict[str, Any]:
+ """
+ Check for code style issues.
+
+ Returns:
+ Dictionary containing style issues analysis results
+ """
+ style_result = {
+ "long_functions": [],
+ "long_lines": [],
+ "inconsistent_naming": [],
+ "summary": {
+ "long_functions_count": 0,
+ "long_lines_count": 0,
+ "inconsistent_naming_count": 0
+ }
+ }
+
+ # Check for long functions (too many lines)
+ if hasattr(self.base_codebase, 'functions'):
+ for func in self.base_codebase.functions:
+ # Get function code
+ if hasattr(func, 'code_block') and hasattr(func.code_block, 'source'):
+ code = func.code_block.source
+ lines = code.split('\n')
+
+ # Check function length
+ if len(lines) > 50: # Threshold for "too long"
+ # Get file path and name safely
+ file_path = func.file.filepath if hasattr(func, 'file') and hasattr(func.file, 'filepath') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Add to long functions list
+ style_result["long_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "line_count": len(lines)
+ })
+
+ # Add issue
+ self.add_issue(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Long function: {len(lines)} lines",
+ severity=IssueSeverity.INFO,
+ category=IssueCategory.STYLE_ISSUE,
+ symbol=func_name,
+ suggestion="Consider breaking this function into smaller, more focused functions"
+ ))
+
+ # Update summary
+ style_result["summary"]["long_functions_count"] = len(style_result["long_functions"])
+ style_result["summary"]["long_lines_count"] = len(style_result["long_lines"])
+ style_result["summary"]["inconsistent_naming_count"] = len(style_result["inconsistent_naming"])
+
+ return style_result
+
+ def _calculate_maintainability(self) -> Dict[str, Any]:
+ """
+ Calculate maintainability metrics.
+
+ Returns:
+ Dictionary containing maintainability analysis results
+ """
+ maintainability_result = {
+ "function_maintainability": [],
+ "low_maintainability_functions": [],
+ "average_maintainability": 0.0,
+ "maintainability_distribution": {
+ "high": 0,
+ "medium": 0,
+ "low": 0
+ }
+ }
+
+ # Process all functions to calculate maintainability
+ total_maintainability = 0
+ function_count = 0
+
+ if hasattr(self.base_codebase, 'functions'):
+ for func in self.base_codebase.functions:
+ # Skip if no code block
+ if not hasattr(func, 'code_block'):
+ continue
+
+ # Calculate metrics
+ complexity = self._calculate_cyclomatic_complexity(func)
+
+ # Calculate Halstead volume (approximation)
+ operators = 0
+ operands = 0
+
+ if hasattr(func, 'code_block') and hasattr(func.code_block, 'source'):
+ code = func.code_block.source
+ # Simple approximation of operators and operands
+ operators = len([c for c in code if c in '+-*/=<>!&|^~%'])
+ # Counting words as potential operands
+ import re
+ operands = len(re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', code))
+
+ halstead_volume = operators * operands * math.log2(operators + operands) if operators + operands > 0 else 0
+
+ # Count lines of code
+ loc = len(func.code_block.source.split('\n')) if hasattr(func, 'code_block') and hasattr(func.code_block, 'source') else 0
+
+ # Calculate maintainability index
+ # Formula: 171 - 5.2 * ln(Halstead Volume) - 0.23 * (Cyclomatic Complexity) - 16.2 * ln(LOC)
+ halstead_term = 5.2 * math.log(max(1, halstead_volume)) if halstead_volume > 0 else 0
+ complexity_term = 0.23 * complexity
+ loc_term = 16.2 * math.log(max(1, loc)) if loc > 0 else 0
+
+ maintainability = 171 - halstead_term - complexity_term - loc_term
+
+ # Normalize to 0-100 scale
+ maintainability = max(0, min(100, maintainability * 100 / 171))
+
+ # Get file path and name safely
+ file_path = func.file.filepath if hasattr(func, 'file') and hasattr(func.file, 'filepath') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Add to maintainability list
+ maintainability_result["function_maintainability"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "maintainability": maintainability,
+ "complexity": complexity,
+ "halstead_volume": halstead_volume,
+ "loc": loc
+ })
+
+ # Track total maintainability
+ total_maintainability += maintainability
+ function_count += 1
+
+ # Categorize maintainability
+ if maintainability >= 70:
+ maintainability_result["maintainability_distribution"]["high"] += 1
+ elif maintainability >= 50:
+ maintainability_result["maintainability_distribution"]["medium"] += 1
+ else:
+ maintainability_result["maintainability_distribution"]["low"] += 1
+
+ # Flag low maintainability functions
+ maintainability_result["low_maintainability_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "maintainability": maintainability,
+ "complexity": complexity,
+ "halstead_volume": halstead_volume,
+ "loc": loc
+ })
+
+ # Add issue
+ self.add_issue(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Low maintainability index: {maintainability:.1f}",
+ severity=IssueSeverity.WARNING,
+ category=IssueCategory.COMPLEXITY,
+ symbol=func_name,
+ suggestion="Consider refactoring this function to improve maintainability"
+ ))
+
+ # Calculate average maintainability
+ maintainability_result["average_maintainability"] = total_maintainability / function_count if function_count > 0 else 0.0
+
+ # Sort low maintainability functions
+ maintainability_result["low_maintainability_functions"].sort(key=lambda x: x["maintainability"])
+
+ return maintainability_result
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/codebase_analyzer.py b/codegen-on-oss/codegen_on_oss/analyzers/codebase_analyzer.py
new file mode 100644
index 000000000..c555e44fd
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/codebase_analyzer.py
@@ -0,0 +1,1901 @@
+#!/usr/bin/env python3
+"""
+Comprehensive Codebase and PR Analyzer
+
+This module leverages the Codegen SDK to provide detailed analysis of codebases
+and pull requests, including comparison between base and PR versions to identify
+issues, errors, and quality problems.
+"""
+
+import os
+import sys
+import json
+import time
+import logging
+import argparse
+import tempfile
+import networkx as nx
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, TypeVar, cast
+from dataclasses import dataclass
+from enum import Enum
+
+try:
+ from codegen.sdk.core.codebase import Codebase
+ from codegen.configs.models.codebase import CodebaseConfig
+ from codegen.configs.models.secrets import SecretsConfig
+ from codegen.sdk.codebase.config import ProjectConfig
+ from codegen.git.schemas.repo_config import RepoConfig
+ from codegen.git.repo_operator.repo_operator import RepoOperator
+ from codegen.shared.enums.programming_language import ProgrammingLanguage
+ from codegen.sdk.codebase.codebase_analysis import get_codebase_summary, get_file_summary
+ from codegen.sdk.core.file import SourceFile
+ from codegen.sdk.enums import EdgeType, SymbolType
+ from codegen.sdk.core.symbol import Symbol
+ from codegen.sdk.core.function import Function
+ from codegen.sdk.core.class_definition import Class
+ from codegen.git.utils.pr_review import CodegenPR
+
+ # Import our custom CodebaseContext
+ from codegen_on_oss.context_codebase import CodebaseContext, get_node_classes, GLOBAL_FILE_IGNORE_LIST
+except ImportError:
+ print("Codegen SDK not found. Please install it first.")
+ sys.exit(1)
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class AnalysisType(str, Enum):
+ """Types of analysis that can be performed."""
+ CODEBASE = "codebase"
+ PR = "pr"
+ COMPARISON = "comparison"
+
+class IssueSeverity(str, Enum):
+ """Severity levels for issues."""
+ ERROR = "error"
+ WARNING = "warning"
+ INFO = "info"
+
+@dataclass
+class Issue:
+ """Represents an issue found during analysis."""
+ file: str
+ line: Optional[int]
+ message: str
+ severity: IssueSeverity
+ symbol: Optional[str] = None
+ code: Optional[str] = None
+ suggestion: Optional[str] = None
+
+ def to_dict(self) -> Dict[str, Any]:
+ return {
+ "file": self.file,
+ "line": self.line,
+ "message": self.message,
+ "severity": self.severity,
+ "symbol": self.symbol,
+ "code": self.code,
+ "suggestion": self.suggestion
+ }
+
+class CodebaseAnalyzer:
+ """
+ Advanced analyzer for codebases and PRs using the Codegen SDK.
+
+ This analyzer provides detailed analysis of:
+ 1. Single codebase analysis to find issues
+ 2. PR analysis to check changes and identify problems
+ 3. Comparison between base branch and PR to verify correctness
+
+ The analyzer uses the CodebaseContext to build a graph representation of the codebase
+ and perform advanced analysis on the codebase structure.
+ """
+
+ def __init__(
+ self,
+ repo_url: Optional[str] = None,
+ repo_path: Optional[str] = None,
+ base_branch: str = "main",
+ pr_number: Optional[int] = None,
+ language: Optional[str] = None,
+ file_ignore_list: Optional[List[str]] = None
+ ):
+ """Initialize the CodebaseAnalyzer.
+
+ Args:
+ repo_url: URL of the repository to analyze
+ repo_path: Local path to the repository to analyze
+ base_branch: Base branch for comparison
+ pr_number: PR number to analyze
+ language: Programming language of the codebase (auto-detected if not provided)
+ file_ignore_list: List of file patterns to ignore during analysis
+ """
+ self.repo_url = repo_url
+ self.repo_path = repo_path
+ self.base_branch = base_branch
+ self.pr_number = pr_number
+ self.language = language
+
+ # Use custom ignore list or default global list
+ self.file_ignore_list = file_ignore_list or GLOBAL_FILE_IGNORE_LIST
+
+ self.base_codebase = None
+ self.pr_codebase = None
+
+ # Context objects for advanced graph analysis
+ self.base_context = None
+ self.pr_context = None
+
+ self.issues = []
+ self.pr_diff = None
+ self.commit_shas = None
+ self.modified_symbols = None
+ self.pr_branch = None
+
+ # Initialize codebase(s) based on provided parameters
+ if repo_url:
+ self._init_from_url(repo_url, language)
+ elif repo_path:
+ self._init_from_path(repo_path, language)
+
+ # If PR number is provided, initialize PR-specific data
+ if self.pr_number is not None and self.base_codebase is not None:
+ self._init_pr_data(self.pr_number)
+
+ # Initialize CodebaseContext objects
+ if self.base_codebase:
+ self.base_context = CodebaseContext(
+ codebase=self.base_codebase,
+ base_path=self.repo_path,
+ pr_branch=None,
+ base_branch=self.base_branch
+ )
+
+ if self.pr_codebase:
+ self.pr_context = CodebaseContext(
+ codebase=self.pr_codebase,
+ base_path=self.repo_path,
+ pr_branch=self.pr_branch,
+ base_branch=self.base_branch
+ )
+
+ def _init_from_url(self, repo_url: str, language: Optional[str] = None):
+ """Initialize base codebase from a repository URL."""
+ try:
+ # Extract owner and repo name from URL
+ if repo_url.endswith('.git'):
+ repo_url = repo_url[:-4]
+
+ parts = repo_url.rstrip('/').split('/')
+ repo_name = parts[-1]
+ owner = parts[-2]
+ repo_full_name = f"{owner}/{repo_name}"
+
+ # Create a temporary directory for cloning
+ tmp_dir = tempfile.mkdtemp(prefix="codebase_analyzer_")
+
+ # Configure the codebase
+ config = CodebaseConfig(
+ debug=False,
+ allow_external=True,
+ py_resolve_syspath=True,
+ )
+
+ secrets = SecretsConfig()
+
+ # Initialize the codebase
+ logger.info(f"Initializing codebase from {repo_url}...")
+
+ prog_lang = None
+ if language:
+ prog_lang = ProgrammingLanguage(language.upper())
+
+ # Initialize base codebase
+ self.base_codebase = Codebase.from_github(
+ repo_full_name=repo_full_name,
+ tmp_dir=tmp_dir,
+ language=prog_lang,
+ config=config,
+ secrets=secrets
+ )
+
+ logger.info(f"Successfully initialized codebase from {repo_url}")
+
+ # If PR number is specified, also initialize PR codebase
+ if self.pr_number:
+ self._init_pr_codebase()
+
+ except Exception as e:
+ logger.error(f"Error initializing codebase from URL: {e}")
+ raise
+
+ def _init_from_path(self, repo_path: str, language: Optional[str] = None):
+ """Initialize codebase from a local repository path."""
+ try:
+ # Configure the codebase
+ config = CodebaseConfig(
+ debug=False,
+ allow_external=True,
+ py_resolve_syspath=True,
+ )
+
+ secrets = SecretsConfig()
+
+ # Initialize the codebase
+ logger.info(f"Initializing codebase from {repo_path}...")
+
+ # Set up programming language
+ prog_lang = None
+ if language:
+ prog_lang = ProgrammingLanguage(language.upper())
+
+ # Create repo config and repo operator
+ repo_config = RepoConfig.from_repo_path(repo_path)
+ repo_config.respect_gitignore = False
+ repo_operator = RepoOperator(repo_config=repo_config, bot_commit=False)
+
+ # Configure project with repo operator and language
+ project_config = ProjectConfig(
+ repo_operator=repo_operator,
+ programming_language=prog_lang if prog_lang else None
+ )
+
+ # Initialize codebase with proper project configuration
+ self.base_codebase = Codebase(
+ projects=[project_config],
+ config=config,
+ secrets=secrets
+ )
+
+ logger.info(f"Successfully initialized codebase from {repo_path}")
+
+ # If PR number is specified, also initialize PR codebase
+ if self.pr_number:
+ self._init_pr_codebase()
+
+ except Exception as e:
+ logger.error(f"Error initializing codebase from path: {e}")
+ raise
+
+ def _init_pr_data(self, pr_number: int):
+ """Initialize PR-specific data."""
+ try:
+ logger.info(f"Fetching PR #{pr_number} data...")
+ result = self.base_codebase.get_modified_symbols_in_pr(pr_number)
+
+ # Unpack the result tuple
+ if len(result) >= 3:
+ self.pr_diff, self.commit_shas, self.modified_symbols = result[:3]
+ if len(result) >= 4:
+ self.pr_branch = result[3]
+
+ logger.info(f"Found {len(self.modified_symbols)} modified symbols in PR")
+
+ except Exception as e:
+ logger.error(f"Error initializing PR data: {e}")
+ raise
+
+ def _init_pr_codebase(self):
+ """Initialize PR codebase by checking out the PR branch."""
+ if not self.base_codebase or not self.pr_number:
+ logger.error("Base codebase or PR number not initialized")
+ return
+
+ try:
+ # Get PR data if not already fetched
+ if not self.pr_branch:
+ self._init_pr_data(self.pr_number)
+
+ if not self.pr_branch:
+ logger.error("Failed to get PR branch")
+ return
+
+ # Clone the base codebase
+ self.pr_codebase = self.base_codebase
+
+ # Checkout PR branch
+ logger.info(f"Checking out PR branch: {self.pr_branch}")
+ self.pr_codebase.checkout(self.pr_branch)
+
+ logger.info("Successfully initialized PR codebase")
+
+ except Exception as e:
+ logger.error(f"Error initializing PR codebase: {e}")
+ raise
+
+ def analyze(self, analysis_type: AnalysisType = AnalysisType.CODEBASE) -> Dict[str, Any]:
+ """
+ Perform a comprehensive analysis of the codebase or PR.
+
+ Args:
+ analysis_type: Type of analysis to perform (codebase, pr, or comparison)
+
+ Returns:
+ Dict containing the analysis results
+ """
+ if not self.base_codebase:
+ raise ValueError("Codebase not initialized")
+
+ result = {
+ "metadata": {
+ "analysis_time": datetime.now().isoformat(),
+ "analysis_type": analysis_type,
+ "repo_name": self.base_codebase.ctx.repo_name,
+ "language": str(self.base_codebase.ctx.programming_language),
+ },
+ "summary": get_codebase_summary(self.base_codebase),
+ }
+
+ # Reset issues list
+ self.issues = []
+
+ if analysis_type == AnalysisType.CODEBASE:
+ # Perform static analysis on base codebase
+ logger.info("Performing static analysis on codebase...")
+ result["static_analysis"] = self._perform_static_analysis(self.base_codebase)
+
+ elif analysis_type == AnalysisType.PR:
+ # Analyze PR changes
+ if not self.pr_number:
+ raise ValueError("PR number not provided")
+
+ logger.info(f"Analyzing PR #{self.pr_number}...")
+ result["pr_analysis"] = self._analyze_pr()
+
+ elif analysis_type == AnalysisType.COMPARISON:
+ # Compare base codebase with PR
+ if not self.pr_codebase:
+ raise ValueError("PR codebase not initialized")
+
+ logger.info("Comparing base codebase with PR...")
+ result["comparison"] = self._compare_codebases()
+
+ # Add issues to the result
+ result["issues"] = [issue.to_dict() for issue in self.issues]
+ result["issue_counts"] = {
+ "total": len(self.issues),
+ "by_severity": {
+ "error": sum(1 for issue in self.issues if issue.severity == IssueSeverity.ERROR),
+ "warning": sum(1 for issue in self.issues if issue.severity == IssueSeverity.WARNING),
+ "info": sum(1 for issue in self.issues if issue.severity == IssueSeverity.INFO),
+ }
+ }
+
+ return result
+
+ def _perform_static_analysis(self, codebase: Codebase) -> Dict[str, Any]:
+ """
+ Perform static analysis on a codebase using the CodebaseContext
+ for deep graph-based analysis.
+
+ This method analyzes various aspects of the codebase including:
+ - Dead code detection
+ - Parameter and function signature issues
+ - Error handling patterns
+ - Call site compatibility
+ - Import dependencies
+ - Inheritance hierarchies
+ - Code complexity metrics
+ - Graph-based dependency analysis
+ """
+ analysis_result = {}
+
+ # Use the context for more advanced analysis if available
+ context = self.base_context if codebase == self.base_codebase else None
+
+ # Check for unused symbols (dead code)
+ analysis_result["dead_code"] = self._find_dead_code(codebase)
+
+ # Check for parameter issues
+ analysis_result["parameter_issues"] = self._check_function_parameters(codebase)
+
+ # Check for error handling issues
+ analysis_result["error_handling"] = self._check_error_handling(codebase)
+
+ # Check for call site issues
+ analysis_result["call_site_issues"] = self._check_call_sites(codebase)
+
+ # Check for import issues
+ analysis_result["import_issues"] = self._check_imports(codebase)
+
+ # Check for inheritance issues
+ analysis_result["inheritance_issues"] = self._check_inheritance(codebase)
+
+ # Analyze code complexity
+ analysis_result["code_complexity"] = self._analyze_code_complexity(codebase)
+
+ # Add graph-based analysis if context is available
+ if context:
+ # Analyze dependency chains
+ analysis_result["dependency_chains"] = self._analyze_dependency_chains(context)
+
+ # Analyze circular dependencies
+ analysis_result["circular_dependencies"] = self._find_circular_dependencies(context)
+
+ # Analyze module coupling
+ analysis_result["module_coupling"] = self._analyze_module_coupling(context)
+
+ # Analyze call hierarchy
+ analysis_result["call_hierarchy"] = self._analyze_call_hierarchy(context)
+
+ return analysis_result
+
+ def _analyze_dependency_chains(self, context: CodebaseContext) -> Dict[str, Any]:
+ """Analyze dependency chains in the codebase."""
+ result = {
+ "long_chains": [],
+ "critical_paths": []
+ }
+
+ # Find long dependency chains
+ for node in context.nodes:
+ if not hasattr(node, 'name'):
+ continue
+
+ # Skip non-symbol nodes
+ if not isinstance(node, Symbol):
+ continue
+
+ # Use NetworkX to find longest paths from this node
+ try:
+ # Create a subgraph containing only symbol nodes
+ symbol_nodes = [n for n in context.nodes if isinstance(n, Symbol)]
+ subgraph = context.build_subgraph(symbol_nodes)
+
+ # Find paths
+ paths = []
+ for target in symbol_nodes:
+ if node != target and hasattr(target, 'name'):
+ try:
+ path = nx.shortest_path(subgraph, node, target)
+ if len(path) > 3: # Only track paths with at least 3 edges
+ paths.append(path)
+ except (nx.NetworkXNoPath, nx.NodeNotFound):
+ pass
+
+ # Sort by path length and take longest
+ paths.sort(key=len, reverse=True)
+ if paths and len(paths[0]) > 3:
+ path_info = {
+ "source": node.name,
+ "targets": [paths[0][-1].name if hasattr(paths[0][-1], 'name') else str(paths[0][-1])],
+ "length": len(paths[0]),
+ "path": [n.name if hasattr(n, 'name') else str(n) for n in paths[0]]
+ }
+ result["long_chains"].append(path_info)
+ except Exception as e:
+ # Skip errors in graph analysis
+ pass
+
+ # Sort by chain length and limit to top 10
+ result["long_chains"].sort(key=lambda x: x["length"], reverse=True)
+ result["long_chains"] = result["long_chains"][:10]
+
+ return result
+
+ def _find_circular_dependencies(self, context: CodebaseContext) -> Dict[str, Any]:
+ """Find circular dependencies in the codebase."""
+ result = {
+ "circular_imports": [],
+ "circular_function_calls": []
+ }
+
+ # Find circular dependencies in the context graph
+ try:
+ cycles = list(nx.simple_cycles(context._graph))
+
+ # Filter and categorize cycles
+ for cycle in cycles:
+ # Check if it's an import cycle
+ if all(hasattr(node, 'symbol_type') and hasattr(node, 'name') for node in cycle):
+ cycle_type = "unknown"
+
+ # Check if all nodes in the cycle are files
+ if all(isinstance(node, SourceFile) for node in cycle):
+ cycle_type = "import"
+ result["circular_imports"].append({
+ "files": [node.path if hasattr(node, 'path') else str(node) for node in cycle],
+ "length": len(cycle)
+ })
+
+ # Check if all nodes in the cycle are functions
+ elif all(isinstance(node, Function) for node in cycle):
+ cycle_type = "function_call"
+ result["circular_function_calls"].append({
+ "functions": [node.name if hasattr(node, 'name') else str(node) for node in cycle],
+ "length": len(cycle)
+ })
+
+ # Add as an issue
+ if len(cycle) > 0 and hasattr(cycle[0], 'file') and hasattr(cycle[0].file, 'file_path'):
+ self.issues.append(Issue(
+ file=cycle[0].file.file_path,
+ line=cycle[0].line if hasattr(cycle[0], 'line') else None,
+ message=f"Circular function call dependency detected",
+ severity=IssueSeverity.ERROR,
+ symbol=cycle[0].name if hasattr(cycle[0], 'name') else str(cycle[0]),
+ suggestion="Refactor the code to eliminate circular dependencies"
+ ))
+ except Exception as e:
+ # Skip errors in cycle detection
+ pass
+
+ return result
+
+ def _analyze_module_coupling(self, context: CodebaseContext) -> Dict[str, Any]:
+ """Analyze module coupling in the codebase."""
+ result = {
+ "high_coupling": [],
+ "low_cohesion": []
+ }
+
+ # Create a mapping of files to their dependencies
+ file_dependencies = {}
+
+ # Iterate over all files
+ for file_node in [node for node in context.nodes if isinstance(node, SourceFile)]:
+ if not hasattr(file_node, 'path'):
+ continue
+
+ file_path = str(file_node.path)
+
+ # Get all outgoing dependencies
+ dependencies = []
+ for succ in context.successors(file_node):
+ if isinstance(succ, SourceFile) and hasattr(succ, 'path'):
+ dependencies.append(str(succ.path))
+
+ # Get all symbols in the file
+ file_symbols = [node for node in context.nodes if isinstance(node, Symbol) and
+ hasattr(node, 'file') and hasattr(node.file, 'path') and
+ str(node.file.path) == file_path]
+
+ # Calculate coupling metrics
+ file_dependencies[file_path] = {
+ "dependencies": dependencies,
+ "dependency_count": len(dependencies),
+ "symbol_count": len(file_symbols),
+ "coupling_ratio": len(dependencies) / max(1, len(file_symbols))
+ }
+
+ # Identify files with high coupling (many dependencies)
+ high_coupling_files = sorted(
+ file_dependencies.items(),
+ key=lambda x: x[1]["dependency_count"],
+ reverse=True
+ )[:10]
+
+ result["high_coupling"] = [
+ {
+ "file": file_path,
+ "dependency_count": data["dependency_count"],
+ "dependencies": data["dependencies"][:5] # Limit to first 5 for brevity
+ }
+ for file_path, data in high_coupling_files
+ if data["dependency_count"] > 5 # Only include if it has more than 5 dependencies
+ ]
+
+ return result
+
+ def _analyze_call_hierarchy(self, context: CodebaseContext) -> Dict[str, Any]:
+ """Analyze function call hierarchy in the codebase."""
+ result = {
+ "entry_points": [],
+ "leaf_functions": [],
+ "deep_call_chains": []
+ }
+
+ # Find potential entry points (functions not called by others)
+ entry_points = []
+ for node in context.nodes:
+ if isinstance(node, Function) and hasattr(node, 'name'):
+ # Check if this function has no incoming CALLS edges
+ has_callers = False
+ for pred, _, data in context.in_edges(node, data=True):
+ if 'type' in data and data['type'] == EdgeType.CALLS:
+ has_callers = True
+ break
+
+ if not has_callers:
+ entry_points.append(node)
+
+ # Find leaf functions (those that don't call other functions)
+ leaf_functions = []
+ for node in context.nodes:
+ if isinstance(node, Function) and hasattr(node, 'name'):
+ # Check if this function has no outgoing CALLS edges
+ has_callees = False
+ for _, succ, data in context.out_edges(node, data=True):
+ if 'type' in data and data['type'] == EdgeType.CALLS:
+ has_callees = True
+ break
+
+ if not has_callees:
+ leaf_functions.append(node)
+
+ # Record entry points
+ result["entry_points"] = [
+ {
+ "name": func.name,
+ "file": func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ }
+ for func in entry_points[:20] # Limit to 20 for brevity
+ ]
+
+ # Record leaf functions
+ result["leaf_functions"] = [
+ {
+ "name": func.name,
+ "file": func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ }
+ for func in leaf_functions[:20] # Limit to 20 for brevity
+ ]
+
+ # Find deep call chains
+ for entry_point in entry_points:
+ try:
+ # Create a subgraph containing only Function nodes
+ func_nodes = [n for n in context.nodes if isinstance(n, Function)]
+ subgraph = context.build_subgraph(func_nodes)
+
+ # Find longest paths from this entry point
+ longest_path = []
+ for leaf in leaf_functions:
+ try:
+ path = nx.shortest_path(subgraph, entry_point, leaf)
+ if len(path) > len(longest_path):
+ longest_path = path
+ except (nx.NetworkXNoPath, nx.NodeNotFound):
+ pass
+
+ if len(longest_path) > 3: # Only record if path length > 3
+ call_chain = {
+ "entry_point": entry_point.name,
+ "length": len(longest_path),
+ "calls": [func.name for func in longest_path if hasattr(func, 'name')]
+ }
+ result["deep_call_chains"].append(call_chain)
+ except Exception as e:
+ # Skip errors in path finding
+ pass
+
+ # Sort by chain length and limit to top 10
+ result["deep_call_chains"].sort(key=lambda x: x["length"], reverse=True)
+ result["deep_call_chains"] = result["deep_call_chains"][:10]
+
+ return result
+
+ def _analyze_pr(self) -> Dict[str, Any]:
+ """Analyze a PR and find issues."""
+ if not self.pr_codebase or not self.pr_diff or not self.commit_shas:
+ raise ValueError("PR data not initialized")
+
+ pr_analysis = {}
+
+ # Get modified symbols and files
+ modified_files = set(self.commit_shas.keys())
+ pr_analysis["modified_files_count"] = len(modified_files)
+ pr_analysis["modified_symbols_count"] = len(self.modified_symbols)
+
+ # Analyze modified files
+ file_issues = []
+ for file_path in modified_files:
+ file = self.pr_codebase.get_file(file_path)
+ if file:
+ # Check file issues
+ self._check_file_issues(file)
+
+ # Add file summary
+ file_issues.append({
+ "file": file_path,
+ "issues": [issue.to_dict() for issue in self.issues if issue.file == file_path]
+ })
+
+ pr_analysis["file_issues"] = file_issues
+
+ # Perform targeted static analysis on modified symbols
+ new_func_count = 0
+ modified_func_count = 0
+
+ for symbol_name in self.modified_symbols:
+ symbol = self.pr_codebase.get_symbol(symbol_name)
+ if not symbol:
+ continue
+
+ # Check if function is new or modified
+ if symbol.symbol_type == SymbolType.Function:
+ # Try to find in base codebase
+ try:
+ base_symbol = self.base_codebase.get_symbol(symbol_name)
+ if not base_symbol:
+ new_func_count += 1
+ else:
+ modified_func_count += 1
+ except:
+ new_func_count += 1
+
+ # Check function for issues
+ func = cast(Function, symbol)
+ self._check_function_for_issues(func)
+
+ pr_analysis["new_functions"] = new_func_count
+ pr_analysis["modified_functions"] = modified_func_count
+
+ return pr_analysis
+
+ def _compare_codebases(self) -> Dict[str, Any]:
+ """
+ Compare base codebase with PR codebase using advanced CodebaseContext.
+
+ This method uses the graph representation of both codebases to perform
+ a detailed comparison of the structure and relationships between them.
+ """
+ if not self.base_codebase or not self.pr_codebase:
+ raise ValueError("Both base and PR codebases must be initialized")
+
+ if not self.base_context or not self.pr_context:
+ raise ValueError("Both base and PR CodebaseContext objects must be initialized")
+
+ comparison = {
+ "graph_analysis": {},
+ "structure_changes": {},
+ "dependency_changes": {},
+ "api_changes": {}
+ }
+
+ # Compare graph structures using CodebaseContext
+ base_nodes = self.base_context.nodes
+ pr_nodes = self.pr_context.nodes
+
+ # Analyze nodes that exist in both, only in base, or only in PR
+ common_nodes = []
+ base_only_nodes = []
+ pr_only_nodes = []
+
+ for base_node in base_nodes:
+ if hasattr(base_node, 'name'):
+ node_name = base_node.name
+ # Look for matching node in PR
+ pr_node = next((n for n in pr_nodes if hasattr(n, 'name') and n.name == node_name), None)
+
+ if pr_node:
+ common_nodes.append((base_node, pr_node))
+ else:
+ base_only_nodes.append(base_node)
+
+ # Find PR-only nodes
+ for pr_node in pr_nodes:
+ if hasattr(pr_node, 'name'):
+ node_name = pr_node.name
+ # Check if it already exists in base
+ if not any(hasattr(n, 'name') and n.name == node_name for n in base_nodes):
+ pr_only_nodes.append(pr_node)
+
+ # Add graph analysis results
+ comparison["graph_analysis"] = {
+ "common_node_count": len(common_nodes),
+ "base_only_node_count": len(base_only_nodes),
+ "pr_only_node_count": len(pr_only_nodes)
+ }
+
+ # Compare dependencies using graph edges
+ base_edges = list(self.base_context.edges(data=True))
+ pr_edges = list(self.pr_context.edges(data=True))
+
+ # Analyze dependency changes
+ removed_dependencies = []
+ added_dependencies = []
+
+ # Process existing modified symbols
+ if self.modified_symbols:
+ detailed_comparison = []
+
+ for symbol_name in self.modified_symbols:
+ # Check if symbol exists in both codebases using context
+ base_symbol = self.base_context.get_node(symbol_name)
+ pr_symbol = self.pr_context.get_node(symbol_name)
+
+ if not base_symbol and not pr_symbol:
+ continue
+
+ # Compare symbols
+ symbol_comparison = {
+ "name": symbol_name,
+ "in_base": base_symbol is not None,
+ "in_pr": pr_symbol is not None,
+ }
+
+ # For functions, compare parameters
+ if (base_symbol and hasattr(base_symbol, 'symbol_type') and base_symbol.symbol_type == SymbolType.Function and
+ pr_symbol and hasattr(pr_symbol, 'symbol_type') and pr_symbol.symbol_type == SymbolType.Function):
+
+ base_func = cast(Function, base_symbol)
+ pr_func = cast(Function, pr_symbol)
+
+ # Get function dependencies from context
+ base_dependencies = self.base_context.successors(base_func)
+ pr_dependencies = self.pr_context.successors(pr_func)
+
+ # Analyze dependency changes for this function
+ for dep in base_dependencies:
+ if hasattr(dep, 'name') and not any(hasattr(d, 'name') and d.name == dep.name for d in pr_dependencies):
+ removed_dependencies.append((base_func.name, dep.name))
+
+ for dep in pr_dependencies:
+ if hasattr(dep, 'name') and not any(hasattr(d, 'name') and d.name == dep.name for d in base_dependencies):
+ added_dependencies.append((pr_func.name, dep.name))
+
+ # Compare parameter counts
+ base_params = list(base_func.parameters)
+ pr_params = list(pr_func.parameters)
+
+ param_changes = []
+ removed_params = []
+ added_params = []
+
+ # Find removed parameters
+ for base_param in base_params:
+ if not any(pr_param.name == base_param.name for pr_param in pr_params if hasattr(pr_param, 'name')):
+ removed_params.append(base_param.name if hasattr(base_param, 'name') else str(base_param))
+
+ # Find added parameters
+ for pr_param in pr_params:
+ if not any(base_param.name == pr_param.name for base_param in base_params if hasattr(base_param, 'name')):
+ added_params.append(pr_param.name if hasattr(pr_param, 'name') else str(pr_param))
+
+ symbol_comparison["parameter_changes"] = {
+ "removed": removed_params,
+ "added": added_params
+ }
+
+ # Check for parameter type changes
+ for base_param in base_params:
+ for pr_param in pr_params:
+ if (hasattr(base_param, 'name') and hasattr(pr_param, 'name') and
+ base_param.name == pr_param.name):
+
+ base_type = str(base_param.type) if hasattr(base_param, 'type') and base_param.type else None
+ pr_type = str(pr_param.type) if hasattr(pr_param, 'type') and pr_param.type else None
+
+ if base_type != pr_type:
+ param_changes.append({
+ "param": base_param.name,
+ "old_type": base_type,
+ "new_type": pr_type
+ })
+
+ if param_changes:
+ symbol_comparison["type_changes"] = param_changes
+
+ # Check if return type changed
+ base_return_type = str(base_func.return_type) if hasattr(base_func, 'return_type') and base_func.return_type else None
+ pr_return_type = str(pr_func.return_type) if hasattr(pr_func, 'return_type') and pr_func.return_type else None
+
+ if base_return_type != pr_return_type:
+ symbol_comparison["return_type_change"] = {
+ "old": base_return_type,
+ "new": pr_return_type
+ }
+
+ # Check call site compatibility
+ if hasattr(base_func, 'call_sites') and hasattr(pr_func, 'call_sites'):
+ base_call_sites = list(base_func.call_sites)
+ call_site_issues = []
+
+ # For each call site in base, check if it's still compatible with PR function
+ for call_site in base_call_sites:
+ if len(removed_params) > 0 and not all(param.has_default for param in base_params if hasattr(param, 'name') and param.name in removed_params):
+ # Required parameter was removed
+ file_path = call_site.file.file_path if hasattr(call_site, 'file') and hasattr(call_site.file, 'file_path') else "unknown"
+ line = call_site.line if hasattr(call_site, 'line') else None
+
+ call_site_issues.append({
+ "file": file_path,
+ "line": line,
+ "issue": "Required parameter was removed, call site may be broken"
+ })
+
+ # Add issue
+ self.issues.append(Issue(
+ file=file_path,
+ line=line,
+ message=f"Call to {symbol_name} may be broken due to signature change",
+ severity=IssueSeverity.ERROR,
+ symbol=symbol_name,
+ suggestion="Update call site to match new function signature"
+ ))
+
+ if call_site_issues:
+ symbol_comparison["call_site_issues"] = call_site_issues
+
+ detailed_comparison.append(symbol_comparison)
+
+ comparison["symbol_comparison"] = detailed_comparison
+
+ # Compare overall codebase stats
+ base_stats = {
+ "files": len(list(self.base_codebase.files)),
+ "functions": len(list(self.base_codebase.functions)) if hasattr(self.base_codebase, 'functions') else 0,
+ "classes": len(list(self.base_codebase.classes)) if hasattr(self.base_codebase, 'classes') else 0,
+ "imports": len(list(self.base_codebase.imports)) if hasattr(self.base_codebase, 'imports') else 0,
+ }
+
+ pr_stats = {
+ "files": len(list(self.pr_codebase.files)),
+ "functions": len(list(self.pr_codebase.functions)) if hasattr(self.pr_codebase, 'functions') else 0,
+ "classes": len(list(self.pr_codebase.classes)) if hasattr(self.pr_codebase, 'classes') else 0,
+ "imports": len(list(self.pr_codebase.imports)) if hasattr(self.pr_codebase, 'imports') else 0,
+ }
+
+ comparison["stats_comparison"] = {
+ "base": base_stats,
+ "pr": pr_stats,
+ "diff": {
+ "files": pr_stats["files"] - base_stats["files"],
+ "functions": pr_stats["functions"] - base_stats["functions"],
+ "classes": pr_stats["classes"] - base_stats["classes"],
+ "imports": pr_stats["imports"] - base_stats["imports"],
+ }
+ }
+
+ return comparison
+
+ def _find_dead_code(self, codebase: Codebase) -> Dict[str, Any]:
+ """Find unused code (dead code) in the codebase."""
+ dead_code = {
+ "unused_functions": [],
+ "unused_classes": [],
+ "unused_variables": [],
+ "unused_imports": []
+ }
+
+ # Find unused functions (no call sites)
+ if hasattr(codebase, 'functions'):
+ for func in codebase.functions:
+ if not hasattr(func, 'call_sites'):
+ continue
+
+ if len(func.call_sites) == 0:
+ # Skip magic methods and main functions
+ if (hasattr(func, 'is_magic') and func.is_magic) or (hasattr(func, 'name') and func.name in ['main', '__main__']):
+ continue
+
+ # Get file and name safely
+ file_path = func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Add to dead code list and issues
+ dead_code["unused_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Unused function: {func_name}",
+ severity=IssueSeverity.WARNING,
+ symbol=func_name,
+ suggestion="Consider removing or using this function"
+ ))
+
+ # Find unused classes (no symbol usages)
+ if hasattr(codebase, 'classes'):
+ for cls in codebase.classes:
+ if not hasattr(cls, 'symbol_usages'):
+ continue
+
+ if len(cls.symbol_usages) == 0:
+ # Get file and name safely
+ file_path = cls.file.file_path if hasattr(cls, 'file') and hasattr(cls.file, 'file_path') else "unknown"
+ cls_name = cls.name if hasattr(cls, 'name') else str(cls)
+
+ # Add to dead code list and issues
+ dead_code["unused_classes"].append({
+ "name": cls_name,
+ "file": file_path,
+ "line": cls.line if hasattr(cls, 'line') else None
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=cls.line if hasattr(cls, 'line') else None,
+ message=f"Unused class: {cls_name}",
+ severity=IssueSeverity.WARNING,
+ symbol=cls_name,
+ suggestion="Consider removing or using this class"
+ ))
+
+ # Find unused variables
+ if hasattr(codebase, 'global_vars'):
+ for var in codebase.global_vars:
+ if not hasattr(var, 'symbol_usages'):
+ continue
+
+ if len(var.symbol_usages) == 0:
+ # Get file and name safely
+ file_path = var.file.file_path if hasattr(var, 'file') and hasattr(var.file, 'file_path') else "unknown"
+ var_name = var.name if hasattr(var, 'name') else str(var)
+
+ # Add to dead code list and issues
+ dead_code["unused_variables"].append({
+ "name": var_name,
+ "file": file_path,
+ "line": var.line if hasattr(var, 'line') else None
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=var.line if hasattr(var, 'line') else None,
+ message=f"Unused variable: {var_name}",
+ severity=IssueSeverity.INFO,
+ symbol=var_name,
+ suggestion="Consider removing this unused variable"
+ ))
+
+ # Find unused imports
+ for file in codebase.files:
+ if hasattr(file, 'is_binary') and file.is_binary:
+ continue
+
+ if not hasattr(file, 'imports'):
+ continue
+
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file)
+
+ for imp in file.imports:
+ if not hasattr(imp, 'usages'):
+ continue
+
+ if len(imp.usages) == 0:
+ # Get import source safely
+ import_source = imp.source if hasattr(imp, 'source') else str(imp)
+
+ # Add to dead code list and issues
+ dead_code["unused_imports"].append({
+ "import": import_source,
+ "file": file_path,
+ "line": imp.line if hasattr(imp, 'line') else None
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=imp.line if hasattr(imp, 'line') else None,
+ message=f"Unused import: {import_source}",
+ severity=IssueSeverity.INFO,
+ code=import_source,
+ suggestion="Remove this unused import"
+ ))
+
+ # Add total counts
+ dead_code["counts"] = {
+ "unused_functions": len(dead_code["unused_functions"]),
+ "unused_classes": len(dead_code["unused_classes"]),
+ "unused_variables": len(dead_code["unused_variables"]),
+ "unused_imports": len(dead_code["unused_imports"]),
+ "total": len(dead_code["unused_functions"]) + len(dead_code["unused_classes"]) +
+ len(dead_code["unused_variables"]) + len(dead_code["unused_imports"]),
+ }
+
+ return dead_code
+
+ def _check_function_parameters(self, codebase: Codebase) -> Dict[str, Any]:
+ """Check function parameters for issues."""
+ parameter_issues = {
+ "missing_types": [],
+ "inconsistent_types": [],
+ "unused_parameters": []
+ }
+
+ if not hasattr(codebase, 'functions'):
+ return parameter_issues
+
+ for func in codebase.functions:
+ if not hasattr(func, 'parameters'):
+ continue
+
+ file_path = func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Check for missing type annotations
+ missing_types = []
+ for param in func.parameters:
+ if not hasattr(param, 'name'):
+ continue
+
+ if not hasattr(param, 'type') or not param.type:
+ missing_types.append(param.name)
+
+ if missing_types:
+ parameter_issues["missing_types"].append({
+ "function": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "parameters": missing_types
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Function {func_name} has parameters without type annotations: {', '.join(missing_types)}",
+ severity=IssueSeverity.WARNING,
+ symbol=func_name,
+ suggestion="Add type annotations to all parameters"
+ ))
+
+ # Check for unused parameters
+ if hasattr(func, 'source'):
+ # This is a simple check that looks for parameter names in the function body
+ # A more sophisticated check would analyze the AST
+ unused_params = []
+ for param in func.parameters:
+ if not hasattr(param, 'name'):
+ continue
+
+ # Skip self/cls parameter in methods
+ if param.name in ['self', 'cls'] and hasattr(func, 'parent') and func.parent:
+ continue
+
+ # Check if parameter name appears in function body
+ # This is a simple heuristic and may produce false positives
+ param_regex = r'\b' + re.escape(param.name) + r'\b'
+ body_lines = func.source.split('\n')[1:] if func.source.count('\n') > 0 else []
+ body_text = '\n'.join(body_lines)
+
+ if not re.search(param_regex, body_text):
+ unused_params.append(param.name)
+
+ if unused_params:
+ parameter_issues["unused_parameters"].append({
+ "function": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "parameters": unused_params
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Function {func_name} has potentially unused parameters: {', '.join(unused_params)}",
+ severity=IssueSeverity.INFO,
+ symbol=func_name,
+ suggestion="Check if these parameters are actually used"
+ ))
+
+ # Check for consistent parameter types across overloaded functions
+ if hasattr(codebase, 'functions'):
+ # Find functions with the same name
+ overloads = [f for f in codebase.functions if hasattr(f, 'name') and f.name == func_name and f != func]
+
+ if overloads:
+ for overload in overloads:
+ # Check if the same parameter name has different types
+ if not hasattr(overload, 'parameters'):
+ continue
+
+ inconsistent_types = []
+ for param in func.parameters:
+ if not hasattr(param, 'name') or not hasattr(param, 'type'):
+ continue
+
+ # Find matching parameter in overload
+ matching_params = [p for p in overload.parameters if hasattr(p, 'name') and p.name == param.name]
+
+ for matching_param in matching_params:
+ if (hasattr(matching_param, 'type') and matching_param.type and
+ str(matching_param.type) != str(param.type)):
+
+ inconsistent_types.append({
+ "parameter": param.name,
+ "type1": str(param.type),
+ "type2": str(matching_param.type),
+ "function1": f"{func_name} at {file_path}:{func.line if hasattr(func, 'line') else '?'}",
+ "function2": f"{overload.name} at {overload.file.file_path if hasattr(overload, 'file') and hasattr(overload.file, 'file_path') else 'unknown'}:{overload.line if hasattr(overload, 'line') else '?'}"
+ })
+
+ if inconsistent_types:
+ parameter_issues["inconsistent_types"].extend(inconsistent_types)
+
+ for issue in inconsistent_types:
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Inconsistent parameter types for {issue['parameter']}: {issue['type1']} vs {issue['type2']}",
+ severity=IssueSeverity.ERROR,
+ symbol=func_name,
+ suggestion="Use consistent parameter types across function overloads"
+ ))
+
+ # Add total counts
+ parameter_issues["counts"] = {
+ "missing_types": len(parameter_issues["missing_types"]),
+ "inconsistent_types": len(parameter_issues["inconsistent_types"]),
+ "unused_parameters": len(parameter_issues["unused_parameters"]),
+ "total": len(parameter_issues["missing_types"]) + len(parameter_issues["inconsistent_types"]) +
+ len(parameter_issues["unused_parameters"]),
+ }
+
+ return parameter_issues
+
+ def _check_error_handling(self, codebase: Codebase) -> Dict[str, Any]:
+ """Check for error handling issues."""
+ error_handling = {
+ "bare_excepts": [],
+ "pass_in_except": [],
+ "errors_not_raised": []
+ }
+
+ if not hasattr(codebase, 'functions'):
+ return error_handling
+
+ for func in codebase.functions:
+ if not hasattr(func, 'source'):
+ continue
+
+ file_path = func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Check for bare except clauses
+ if re.search(r'except\s*:', func.source):
+ error_handling["bare_excepts"].append({
+ "function": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Function {func_name} uses bare 'except:' clause",
+ severity=IssueSeverity.WARNING,
+ symbol=func_name,
+ suggestion="Specify exception types to catch"
+ ))
+
+ # Check for 'pass' in except blocks
+ if re.search(r'except[^:]*:.*\bpass\b', func.source, re.DOTALL):
+ error_handling["pass_in_except"].append({
+ "function": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Function {func_name} silently ignores exceptions with 'pass'",
+ severity=IssueSeverity.WARNING,
+ symbol=func_name,
+ suggestion="Add proper error handling or logging"
+ ))
+
+ # Check for error classes that aren't raised
+ if hasattr(func, 'symbol_type') and func.symbol_type == SymbolType.Class:
+ # Check if class name contains 'Error' or 'Exception'
+ if hasattr(func, 'name') and ('Error' in func.name or 'Exception' in func.name):
+ cls = cast(Class, func)
+
+ # Check if class extends Exception
+ is_exception = False
+ if hasattr(cls, 'superclasses'):
+ superclass_names = [sc.name for sc in cls.superclasses if hasattr(sc, 'name')]
+ if any(name in ['Exception', 'BaseException'] for name in superclass_names):
+ is_exception = True
+
+ if is_exception and hasattr(cls, 'symbol_usages') and not any('raise' in str(usage) for usage in cls.symbol_usages):
+ error_handling["errors_not_raised"].append({
+ "class": cls.name,
+ "file": file_path,
+ "line": cls.line if hasattr(cls, 'line') else None,
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=cls.line if hasattr(cls, 'line') else None,
+ message=f"Exception class {cls.name} is defined but never raised",
+ severity=IssueSeverity.INFO,
+ symbol=cls.name,
+ suggestion="Either use this exception or remove it"
+ ))
+
+ # Add total counts
+ error_handling["counts"] = {
+ "bare_excepts": len(error_handling["bare_excepts"]),
+ "pass_in_except": len(error_handling["pass_in_except"]),
+ "errors_not_raised": len(error_handling["errors_not_raised"]),
+ "total": len(error_handling["bare_excepts"]) + len(error_handling["pass_in_except"]) +
+ len(error_handling["errors_not_raised"]),
+ }
+
+ return error_handling
+
+ def _check_call_sites(self, codebase: Codebase) -> Dict[str, Any]:
+ """Check for issues with function call sites."""
+ call_site_issues = {
+ "wrong_parameter_count": [],
+ "wrong_return_type_usage": []
+ }
+
+ if not hasattr(codebase, 'functions'):
+ return call_site_issues
+
+ for func in codebase.functions:
+ if not hasattr(func, 'call_sites'):
+ continue
+
+ file_path = func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Get required parameter count (excluding those with defaults)
+ required_count = 0
+ if hasattr(func, 'parameters'):
+ required_count = sum(1 for p in func.parameters if not hasattr(p, 'has_default') or not p.has_default)
+
+ # Check each call site
+ for call_site in func.call_sites:
+ if not hasattr(call_site, 'args'):
+ continue
+
+ # Get call site file info
+ call_file = call_site.file.file_path if hasattr(call_site, 'file') and hasattr(call_site.file, 'file_path') else "unknown"
+ call_line = call_site.line if hasattr(call_site, 'line') else None
+
+ # Check parameter count
+ arg_count = len(call_site.args)
+ if arg_count < required_count:
+ call_site_issues["wrong_parameter_count"].append({
+ "function": func_name,
+ "caller_file": call_file,
+ "caller_line": call_line,
+ "required_count": required_count,
+ "provided_count": arg_count
+ })
+
+ self.issues.append(Issue(
+ file=call_file,
+ line=call_line,
+ message=f"Call to {func_name} has too few arguments ({arg_count} provided, {required_count} required)",
+ severity=IssueSeverity.ERROR,
+ symbol=func_name,
+ suggestion=f"Provide all required arguments to {func_name}"
+ ))
+
+ # Add total counts
+ call_site_issues["counts"] = {
+ "wrong_parameter_count": len(call_site_issues["wrong_parameter_count"]),
+ "wrong_return_type_usage": len(call_site_issues["wrong_return_type_usage"]),
+ "total": len(call_site_issues["wrong_parameter_count"]) + len(call_site_issues["wrong_return_type_usage"]),
+ }
+
+ return call_site_issues
+
+ def _check_imports(self, codebase: Codebase) -> Dict[str, Any]:
+ """Check for import issues."""
+ import_issues = {
+ "circular_imports": [],
+ "wildcard_imports": []
+ }
+
+ # Check for circular imports
+ try:
+ # Build dependency graph
+ dependency_map = {}
+
+ for file in codebase.files:
+ if hasattr(file, 'is_binary') and file.is_binary:
+ continue
+
+ if not hasattr(file, 'imports'):
+ continue
+
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file)
+ imports = []
+
+ for imp in file.imports:
+ if hasattr(imp, "imported_symbol") and imp.imported_symbol:
+ imported_symbol = imp.imported_symbol
+ if hasattr(imported_symbol, "file") and imported_symbol.file:
+ imported_file_path = imported_symbol.file.file_path if hasattr(imported_symbol.file, 'file_path') else str(imported_symbol.file)
+ imports.append(imported_file_path)
+
+ dependency_map[file_path] = imports
+
+ # Create a directed graph
+ import networkx as nx
+ G = nx.DiGraph()
+
+ # Add nodes and edges
+ for file_path, imports in dependency_map.items():
+ G.add_node(file_path)
+ for imp in imports:
+ if imp in dependency_map: # Only add edges for files that exist in our dependency map
+ G.add_edge(file_path, imp)
+
+ # Find cycles
+ try:
+ cycles = list(nx.simple_cycles(G))
+
+ for cycle in cycles:
+ import_issues["circular_imports"].append({
+ "cycle": cycle,
+ "length": len(cycle)
+ })
+
+ # Create an issue for each file in the cycle
+ for file_path in cycle:
+ self.issues.append(Issue(
+ file=file_path,
+ line=None,
+ message=f"Circular import detected: {' -> '.join(cycle)}",
+ severity=IssueSeverity.ERROR,
+ suggestion="Refactor imports to break circular dependency"
+ ))
+ except nx.NetworkXNoCycle:
+ pass # No cycles found
+
+ except Exception as e:
+ logger.error(f"Error detecting circular imports: {e}")
+
+ # Check for wildcard imports
+ for file in codebase.files:
+ if hasattr(file, 'is_binary') and file.is_binary:
+ continue
+
+ if not hasattr(file, 'imports'):
+ continue
+
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file)
+
+ for imp in file.imports:
+ if not hasattr(imp, 'source'):
+ continue
+
+ # Check for wildcard imports (from module import *)
+ if re.search(r'from\s+[\w.]+\s+import\s+\*', imp.source):
+ import_issues["wildcard_imports"].append({
+ "file": file_path,
+ "line": imp.line if hasattr(imp, 'line') else None,
+ "import": imp.source
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=imp.line if hasattr(imp, 'line') else None,
+ message=f"Wildcard import: {imp.source}",
+ severity=IssueSeverity.WARNING,
+ code=imp.source,
+ suggestion="Import specific symbols instead of using wildcard imports"
+ ))
+
+ # Add total counts
+ import_issues["counts"] = {
+ "circular_imports": len(import_issues["circular_imports"]),
+ "wildcard_imports": len(import_issues["wildcard_imports"]),
+ "total": len(import_issues["circular_imports"]) + len(import_issues["wildcard_imports"]),
+ }
+
+ return import_issues
+
+ def _check_inheritance(self, codebase: Codebase) -> Dict[str, Any]:
+ """Check for inheritance issues."""
+ inheritance_issues = {
+ "deep_inheritance": [],
+ "multiple_inheritance": [],
+ "inconsistent_interfaces": []
+ }
+
+ if not hasattr(codebase, 'classes'):
+ return inheritance_issues
+
+ for cls in codebase.classes:
+ if not hasattr(cls, 'superclasses'):
+ continue
+
+ file_path = cls.file.file_path if hasattr(cls, 'file') and hasattr(cls.file, 'file_path') else "unknown"
+ cls_name = cls.name if hasattr(cls, 'name') else str(cls)
+
+ # Check inheritance depth
+ inheritance_depth = len(cls.superclasses)
+ if inheritance_depth > 3: # Arbitrary threshold for deep inheritance
+ inheritance_issues["deep_inheritance"].append({
+ "class": cls_name,
+ "file": file_path,
+ "line": cls.line if hasattr(cls, 'line') else None,
+ "depth": inheritance_depth,
+ "hierarchy": [sc.name if hasattr(sc, 'name') else str(sc) for sc in cls.superclasses]
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=cls.line if hasattr(cls, 'line') else None,
+ message=f"Deep inheritance detected for class {cls_name} (depth: {inheritance_depth})",
+ severity=IssueSeverity.WARNING,
+ symbol=cls_name,
+ suggestion="Consider composition over inheritance or flattening the hierarchy"
+ ))
+
+ # Check multiple inheritance
+ if inheritance_depth > 1:
+ inheritance_issues["multiple_inheritance"].append({
+ "class": cls_name,
+ "file": file_path,
+ "line": cls.line if hasattr(cls, 'line') else None,
+ "superclasses": [sc.name if hasattr(sc, 'name') else str(sc) for sc in cls.superclasses]
+ })
+
+ # We don't create an issue for this by default, as multiple inheritance is not always bad
+
+ # Add total counts
+ inheritance_issues["counts"] = {
+ "deep_inheritance": len(inheritance_issues["deep_inheritance"]),
+ "multiple_inheritance": len(inheritance_issues["multiple_inheritance"]),
+ "inconsistent_interfaces": len(inheritance_issues["inconsistent_interfaces"]),
+ "total": len(inheritance_issues["deep_inheritance"]) + len(inheritance_issues["multiple_inheritance"]) +
+ len(inheritance_issues["inconsistent_interfaces"]),
+ }
+
+ return inheritance_issues
+
+ def _analyze_code_complexity(self, codebase: Codebase) -> Dict[str, Any]:
+ """Analyze code complexity."""
+ complexity = {
+ "complex_functions": [],
+ "long_functions": [],
+ "deeply_nested_code": []
+ }
+
+ if not hasattr(codebase, 'functions'):
+ return complexity
+
+ for func in codebase.functions:
+ if not hasattr(func, 'source'):
+ continue
+
+ file_path = func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Check function length
+ func_lines = func.source.count('\n') + 1
+ if func_lines > 50: # Arbitrary threshold for long functions
+ complexity["long_functions"].append({
+ "function": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "length": func_lines
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Function {func_name} is too long ({func_lines} lines)",
+ severity=IssueSeverity.WARNING,
+ symbol=func_name,
+ suggestion="Consider breaking this function into smaller functions"
+ ))
+
+ # Check cyclomatic complexity (approximate)
+ # Count branch points (if, for, while, case, etc.)
+ branch_points = (
+ func.source.count('if ') +
+ func.source.count('elif ') +
+ func.source.count('for ') +
+ func.source.count('while ') +
+ func.source.count('case ') +
+ func.source.count('except ') +
+ func.source.count(' and ') +
+ func.source.count(' or ')
+ )
+
+ if branch_points > 10: # Arbitrary threshold for complex functions
+ complexity["complex_functions"].append({
+ "function": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "branch_points": branch_points
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Function {func_name} is complex (branch points: {branch_points})",
+ severity=IssueSeverity.WARNING,
+ symbol=func_name,
+ suggestion="Refactor to reduce complexity"
+ ))
+
+ # Check nesting depth
+ lines = func.source.split('\n')
+ max_indent = 0
+ for line in lines:
+ indent = len(line) - len(line.lstrip())
+ max_indent = max(max_indent, indent)
+
+ # Estimate nesting depth (rough approximation)
+ est_nesting_depth = max_indent // 4 # Assuming 4 spaces per indent level
+
+ if est_nesting_depth > 4: # Arbitrary threshold for deeply nested code
+ complexity["deeply_nested_code"].append({
+ "function": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "estimated_nesting_depth": est_nesting_depth
+ })
+
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Function {func_name} has deeply nested code (est. depth: {est_nesting_depth})",
+ severity=IssueSeverity.WARNING,
+ symbol=func_name,
+ suggestion="Refactor to reduce nesting by extracting methods or using early returns"
+ ))
+
+ # Add total counts
+ complexity["counts"] = {
+ "complex_functions": len(complexity["complex_functions"]),
+ "long_functions": len(complexity["long_functions"]),
+ "deeply_nested_code": len(complexity["deeply_nested_code"]),
+ "total": len(complexity["complex_functions"]) + len(complexity["long_functions"]) +
+ len(complexity["deeply_nested_code"]),
+ }
+
+ return complexity
+
+ def _check_file_issues(self, file: SourceFile) -> None:
+ """Check a file for issues."""
+ # Skip binary files
+ if hasattr(file, 'is_binary') and file.is_binary:
+ return
+
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file)
+
+ # Check file size
+ if hasattr(file, 'content'):
+ file_size = len(file.content)
+ if file_size > 500 * 1024: # 500 KB
+ self.issues.append(Issue(
+ file=file_path,
+ line=None,
+ message=f"File is very large ({file_size / 1024:.1f} KB)",
+ severity=IssueSeverity.WARNING,
+ suggestion="Consider breaking this file into smaller modules"
+ ))
+
+ # Check for too many imports
+ if hasattr(file, 'imports') and len(file.imports) > 30: # Arbitrary threshold
+ self.issues.append(Issue(
+ file=file_path,
+ line=None,
+ message=f"File has too many imports ({len(file.imports)})",
+ severity=IssueSeverity.WARNING,
+ suggestion="Consider refactoring to reduce the number of imports"
+ ))
+
+ # Check for file-level issues in symbol definitions
+ if hasattr(file, 'symbols'):
+ # Check for mixing class and function definitions at the top level
+ toplevel_classes = [s for s in file.symbols if hasattr(s, 'symbol_type') and s.symbol_type == SymbolType.Class]
+ toplevel_functions = [s for s in file.symbols if hasattr(s, 'symbol_type') and s.symbol_type == SymbolType.Function]
+
+ if len(toplevel_classes) > 0 and len(toplevel_functions) > 5:
+ self.issues.append(Issue(
+ file=file_path,
+ line=None,
+ message=f"File mixes classes and many functions at the top level",
+ severity=IssueSeverity.INFO,
+ suggestion="Consider separating classes and functions into different modules"
+ ))
+
+ def _check_function_for_issues(self, func: Function) -> None:
+ """Check a function for issues."""
+ file_path = func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Check for return type
+ if not hasattr(func, 'return_type') or not func.return_type:
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Function {func_name} lacks a return type annotation",
+ severity=IssueSeverity.WARNING,
+ symbol=func_name,
+ suggestion="Add a return type annotation"
+ ))
+
+ # Check parameters for types
+ if hasattr(func, 'parameters'):
+ missing_types = [p.name for p in func.parameters if hasattr(p, 'name') and (not hasattr(p, 'type') or not p.type)]
+ if missing_types:
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Function {func_name} has parameters without type annotations: {', '.join(missing_types)}",
+ severity=IssueSeverity.WARNING,
+ symbol=func_name,
+ suggestion="Add type annotations to all parameters"
+ ))
+
+ # Check for docstring
+ if hasattr(func, 'source'):
+ lines = func.source.split('\n')
+ if len(lines) > 1:
+ # Check if second line starts a docstring
+ if not any(line.strip().startswith('"""') or line.strip().startswith("'''") for line in lines[:3]):
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Function {func_name} lacks a docstring",
+ severity=IssueSeverity.INFO,
+ symbol=func_name,
+ suggestion="Add a docstring describing the function's purpose, parameters, and return value"
+ ))
+
+ # Check for error handling in async functions
+ if hasattr(func, 'is_async') and func.is_async and hasattr(func, 'source'):
+ if 'await' in func.source and 'try' not in func.source:
+ self.issues.append(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Async function {func_name} has awaits without try/except",
+ severity=IssueSeverity.WARNING,
+ symbol=func_name,
+ suggestion="Add error handling for await expressions"
+ ))
+
+def main():
+ """Main entry point for the codebase analyzer."""
+ parser = argparse.ArgumentParser(description="Comprehensive Codebase and PR Analyzer")
+
+ # Repository source options
+ source_group = parser.add_mutually_exclusive_group(required=True)
+ source_group.add_argument("--repo-url", help="URL of the repository to analyze")
+ source_group.add_argument("--repo-path", help="Local path to the repository to analyze")
+
+ # Analysis options
+ parser.add_argument("--analysis-type", choices=["codebase", "pr", "comparison"], default="codebase",
+ help="Type of analysis to perform (default: codebase)")
+ parser.add_argument("--language", choices=["python", "typescript"], help="Programming language (auto-detected if not provided)")
+ parser.add_argument("--base-branch", default="main", help="Base branch for PR comparison (default: main)")
+ parser.add_argument("--pr-number", type=int, help="PR number to analyze")
+
+ # Output options
+ parser.add_argument("--output-format", choices=["json", "html", "console"], default="json", help="Output format")
+ parser.add_argument("--output-file", help="Path to the output file")
+
+ args = parser.parse_args()
+
+ try:
+ # Initialize the analyzer
+ analyzer = CodebaseAnalyzer(
+ repo_url=args.repo_url,
+ repo_path=args.repo_path,
+ base_branch=args.base_branch,
+ pr_number=args.pr_number,
+ language=args.language
+ )
+
+ # Perform the analysis
+ analysis_type = AnalysisType(args.analysis_type)
+ results = analyzer.analyze(analysis_type)
+
+ # Output the results
+ if args.output_format == "json":
+ if args.output_file:
+ with open(args.output_file, 'w') as f:
+ json.dump(results, f, indent=2)
+ print(f"Analysis results saved to {args.output_file}")
+ else:
+ print(json.dumps(results, indent=2))
+ elif args.output_format == "html":
+ # Create a simple HTML report
+ if not args.output_file:
+ args.output_file = "codebase_analysis_report.html"
+
+ with open(args.output_file, 'w') as f:
+ f.write(f"""
+
+
+
Codebase Analysis Report
+
+
+
+
Codebase Analysis Report
+
+
Summary
+
Repository: {results["metadata"]["repo_name"]}
+
Language: {results["metadata"]["language"]}
+
Analysis Type: {results["metadata"]["analysis_type"]}
+
Analysis Time: {results["metadata"]["analysis_time"]}
+
Total Issues: {results["issue_counts"]["total"]}
+
+ - Errors: {results["issue_counts"]["by_severity"]["error"]}
+ - Warnings: {results["issue_counts"]["by_severity"]["warning"]}
+ - Info: {results["issue_counts"]["by_severity"]["info"]}
+
+
+
+
+
Issues
+
+""")
+
+ # Add issues
+ for issue in results["issues"]:
+ severity_class = issue["severity"]
+ location = f"{issue['file']}:{issue['line']}" if issue['line'] else issue['file']
+
+ f.write(f"""
+ -
+ {location}: {issue['message']}
+ {f"
Symbol: {issue['symbol']}" if issue['symbol'] else ""}
+ {f"
Suggestion: {issue['suggestion']}" if issue['suggestion'] else ""}
+
+""")
+
+ f.write("""
+
+
+
+
+
Detailed Analysis
+
""")
+
+ # Add detailed analysis as formatted JSON
+ f.write(json.dumps(results, indent=2))
+
+ f.write("""
+
+
+
+
+""")
+
+ print(f"HTML report saved to {args.output_file}")
+
+ elif args.output_format == "console":
+ print(f"===== Codebase Analysis Report =====")
+ print(f"Repository: {results['metadata']['repo_name']}")
+ print(f"Language: {results['metadata']['language']}")
+ print(f"Analysis Type: {results['metadata']['analysis_type']}")
+ print(f"Analysis Time: {results['metadata']['analysis_time']}")
+ print(f"Total Issues: {results['issue_counts']['total']}")
+ print(f" Errors: {results['issue_counts']['by_severity']['error']}")
+ print(f" Warnings: {results['issue_counts']['by_severity']['warning']}")
+ print(f" Info: {results['issue_counts']['by_severity']['info']}")
+
+ print("\n===== Issues =====")
+ for issue in results["issues"]:
+ severity = issue["severity"].upper()
+ location = f"{issue['file']}:{issue['line']}" if issue['line'] else issue['file']
+ print(f"[{severity}] {location}: {issue['message']}")
+ if issue['symbol']:
+ print(f" Symbol: {issue['symbol']}")
+ if issue['suggestion']:
+ print(f" Suggestion: {issue['suggestion']}")
+ print()
+
+ except Exception as e:
+ print(f"Error: {e}")
+ import traceback
+ traceback.print_exc()
+ sys.exit(1)
+
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/codebase_context.py b/codegen-on-oss/codegen_on_oss/analyzers/codebase_context.py
new file mode 100644
index 000000000..bb1cd1bb4
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/codebase_context.py
@@ -0,0 +1,694 @@
+#!/usr/bin/env python3
+"""
+Codebase Context Module
+
+This module provides a comprehensive graph-based context representation of a codebase
+for advanced analysis capabilities, including dependency analysis, code structure
+visualization, and PR comparison. It serves as the central data model for analysis.
+"""
+
+import os
+import sys
+import logging
+import networkx as nx
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, Callable, TypeVar, cast
+from enum import Enum
+from pathlib import Path
+
+try:
+ from codegen.sdk.core.codebase import Codebase
+ from codegen.sdk.codebase.codebase_context import CodebaseContext as SDKCodebaseContext
+ from codegen.sdk.core.file import SourceFile
+ from codegen.sdk.core.directory import Directory
+ from codegen.sdk.core.symbol import Symbol
+ from codegen.sdk.core.function import Function
+ from codegen.sdk.core.class_definition import Class
+ from codegen.sdk.enums import EdgeType, SymbolType
+except ImportError:
+ print("Codegen SDK not found. Please install it first.")
+ sys.exit(1)
+
+# Import context components
+from codegen_on_oss.analyzers.context.file import FileContext
+from codegen_on_oss.analyzers.context.function import FunctionContext
+from codegen_on_oss.analyzers.context.graph import (
+ build_dependency_graph,
+ find_circular_dependencies,
+ calculate_centrality
+)
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+# Global file ignore patterns
+GLOBAL_FILE_IGNORE_LIST = [
+ "__pycache__",
+ ".git",
+ "node_modules",
+ "dist",
+ "build",
+ ".DS_Store",
+ ".pytest_cache",
+ ".venv",
+ "venv",
+ "env",
+ ".env",
+ ".idea",
+ ".vscode",
+]
+
+class NodeType(str, Enum):
+ """Types of nodes in the graph."""
+ FILE = "file"
+ DIRECTORY = "directory"
+ FUNCTION = "function"
+ CLASS = "class"
+ MODULE = "module"
+ VARIABLE = "variable"
+ UNKNOWN = "unknown"
+
+def get_node_type(node: Any) -> NodeType:
+ """Determine the type of a node."""
+ if isinstance(node, SourceFile):
+ return NodeType.FILE
+ elif isinstance(node, Directory):
+ return NodeType.DIRECTORY
+ elif isinstance(node, Function):
+ return NodeType.FUNCTION
+ elif isinstance(node, Class):
+ return NodeType.CLASS
+ else:
+ return NodeType.UNKNOWN
+
+class CodebaseContext:
+ """
+ Graph-based representation of a codebase for advanced analysis.
+
+ This class provides a unified graph representation of a codebase, including
+ files, directories, functions, classes, and their relationships. It serves
+ as the central data model for all analysis operations.
+ """
+
+ def __init__(
+ self,
+ codebase: Codebase,
+ base_path: Optional[str] = None,
+ pr_branch: Optional[str] = None,
+ base_branch: str = "main",
+ file_ignore_list: Optional[List[str]] = None
+ ):
+ """
+ Initialize the CodebaseContext.
+
+ Args:
+ codebase: The codebase to analyze
+ base_path: Base path of the codebase
+ pr_branch: PR branch name (for PR analysis)
+ base_branch: Base branch name (for PR analysis)
+ file_ignore_list: List of file patterns to ignore
+ """
+ self.codebase = codebase
+ self.base_path = base_path
+ self.pr_branch = pr_branch
+ self.base_branch = base_branch
+ self.file_ignore_list = file_ignore_list or GLOBAL_FILE_IGNORE_LIST
+
+ # Initialize graph
+ self._graph = nx.DiGraph()
+
+ # File and symbol context caches
+ self._file_contexts = {}
+ self._function_contexts = {}
+
+ # Build the graph
+ self._build_graph()
+
+ def _build_graph(self):
+ """Build the codebase graph."""
+ logger.info("Building codebase graph...")
+
+ # Add nodes for files
+ for file in self.codebase.files:
+ # Skip ignored files
+ if self._should_ignore_file(file):
+ continue
+
+ # Add file node
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file)
+ self._graph.add_node(file,
+ type=NodeType.FILE,
+ path=file_path)
+
+ # Add nodes for functions in the file
+ if hasattr(file, 'functions'):
+ for func in file.functions:
+ # Create function node
+ func_name = func.name if hasattr(func, 'name') else str(func)
+ self._graph.add_node(func,
+ type=NodeType.FUNCTION,
+ name=func_name,
+ file=file)
+
+ # Add edge from file to function
+ self._graph.add_edge(file, func, type=EdgeType.CONTAINS)
+
+ # Add nodes for classes in the file
+ if hasattr(file, 'classes'):
+ for cls in file.classes:
+ # Create class node
+ cls_name = cls.name if hasattr(cls, 'name') else str(cls)
+ self._graph.add_node(cls,
+ type=NodeType.CLASS,
+ name=cls_name,
+ file=file)
+
+ # Add edge from file to class
+ self._graph.add_edge(file, cls, type=EdgeType.CONTAINS)
+
+ # Add nodes for methods in the class
+ if hasattr(cls, 'methods'):
+ for method in cls.methods:
+ # Create method node
+ method_name = method.name if hasattr(method, 'name') else str(method)
+ self._graph.add_node(method,
+ type=NodeType.FUNCTION,
+ name=method_name,
+ file=file,
+ class_name=cls_name)
+
+ # Add edge from class to method
+ self._graph.add_edge(cls, method, type=EdgeType.CONTAINS)
+
+ # Add edges for imports
+ for file in self.codebase.files:
+ # Skip ignored files
+ if self._should_ignore_file(file):
+ continue
+
+ # Add import edges
+ if hasattr(file, 'imports'):
+ for imp in file.imports:
+ # Get imported file
+ imported_file = None
+
+ if hasattr(imp, 'resolved_file'):
+ imported_file = imp.resolved_file
+ elif hasattr(imp, 'resolved_symbol') and hasattr(imp.resolved_symbol, 'file'):
+ imported_file = imp.resolved_symbol.file
+
+ if imported_file and imported_file in self._graph:
+ # Add edge from file to imported file
+ self._graph.add_edge(file, imported_file, type=EdgeType.IMPORTS)
+
+ # Add edges for function calls
+ for func in [n for n in self._graph.nodes if get_node_type(n) == NodeType.FUNCTION]:
+ if hasattr(func, 'call_sites'):
+ for call_site in func.call_sites:
+ if hasattr(call_site, 'called_function') and call_site.called_function in self._graph:
+ # Add edge from function to called function
+ self._graph.add_edge(func, call_site.called_function, type=EdgeType.CALLS)
+
+ # Add edges for class inheritance
+ for cls in [n for n in self._graph.nodes if get_node_type(n) == NodeType.CLASS]:
+ if hasattr(cls, 'superclasses'):
+ for superclass in cls.superclasses:
+ if superclass in self._graph:
+ # Add edge from class to superclass
+ self._graph.add_edge(cls, superclass, type=EdgeType.INHERITS_FROM)
+
+ logger.info(f"Graph built with {len(self._graph.nodes)} nodes and {len(self._graph.edges)} edges")
+
+ def _should_ignore_file(self, file) -> bool:
+ """Check if a file should be ignored."""
+ if hasattr(file, 'is_binary') and file.is_binary:
+ return True
+
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file)
+
+ # Check against ignore list
+ for pattern in self.file_ignore_list:
+ if pattern in file_path:
+ return True
+
+ return False
+
+ def get_file_context(self, file: Union[SourceFile, str]) -> FileContext:
+ """
+ Get context for a specific file.
+
+ Args:
+ file: File object or file path
+
+ Returns:
+ FileContext for the specified file
+ """
+ # If file is a string, find the corresponding file object
+ if isinstance(file, str):
+ for f in self.codebase.files:
+ file_path = f.file_path if hasattr(f, 'file_path') else str(f)
+ if file_path == file:
+ file = f
+ break
+ else:
+ raise ValueError(f"File not found: {file}")
+
+ # Get file path
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file)
+
+ # Return cached context if available
+ if file_path in self._file_contexts:
+ return self._file_contexts[file_path]
+
+ # Create and cache new context
+ context = FileContext(file)
+ self._file_contexts[file_path] = context
+
+ return context
+
+ def get_function_context(self, function: Union[Function, str]) -> FunctionContext:
+ """
+ Get context for a specific function.
+
+ Args:
+ function: Function object or function name
+
+ Returns:
+ FunctionContext for the specified function
+ """
+ # If function is a string, find the corresponding function object
+ if isinstance(function, str):
+ for f in self.get_functions():
+ if hasattr(f, 'name') and f.name == function:
+ function = f
+ break
+ else:
+ raise ValueError(f"Function not found: {function}")
+
+ # Get function name
+ func_name = function.name if hasattr(function, 'name') else str(function)
+
+ # Return cached context if available
+ if func_name in self._function_contexts:
+ return self._function_contexts[func_name]
+
+ # Create and cache new context
+ context = FunctionContext(function)
+ self._function_contexts[func_name] = context
+
+ return context
+
+ @property
+ def graph(self) -> nx.DiGraph:
+ """Get the codebase graph."""
+ return self._graph
+
+ @property
+ def nodes(self) -> List[Any]:
+ """Get all nodes in the graph."""
+ return list(self._graph.nodes)
+
+ def get_node(self, name: str) -> Optional[Any]:
+ """
+ Get a node by name.
+
+ Args:
+ name: Name of the node to get
+
+ Returns:
+ The node, or None if not found
+ """
+ for node in self._graph.nodes:
+ if (hasattr(node, 'name') and node.name == name) or str(node) == name:
+ return node
+ return None
+
+ def predecessors(self, node: Any) -> List[Any]:
+ """
+ Get predecessors of a node.
+
+ Args:
+ node: Node to get predecessors for
+
+ Returns:
+ List of predecessor nodes
+ """
+ return list(self._graph.predecessors(node))
+
+ def successors(self, node: Any) -> List[Any]:
+ """
+ Get successors of a node.
+
+ Args:
+ node: Node to get successors for
+
+ Returns:
+ List of successor nodes
+ """
+ return list(self._graph.successors(node))
+
+ def get_nodes_by_type(self, node_type: NodeType) -> List[Any]:
+ """
+ Get nodes by type.
+
+ Args:
+ node_type: Type of nodes to get
+
+ Returns:
+ List of nodes of the specified type
+ """
+ return [n for n in self._graph.nodes if get_node_type(n) == node_type]
+
+ def get_files(self) -> List[SourceFile]:
+ """
+ Get all files in the codebase.
+
+ Returns:
+ List of files
+ """
+ return self.get_nodes_by_type(NodeType.FILE)
+
+ def get_functions(self) -> List[Function]:
+ """
+ Get all functions in the codebase.
+
+ Returns:
+ List of functions
+ """
+ return self.get_nodes_by_type(NodeType.FUNCTION)
+
+ def get_classes(self) -> List[Class]:
+ """
+ Get all classes in the codebase.
+
+ Returns:
+ List of classes
+ """
+ return self.get_nodes_by_type(NodeType.CLASS)
+
+ def find_paths(self, source: Any, target: Any, cutoff: Optional[int] = None) -> List[List[Any]]:
+ """
+ Find all paths between two nodes.
+
+ Args:
+ source: Source node
+ target: Target node
+ cutoff: Maximum path length
+
+ Returns:
+ List of paths from source to target
+ """
+ if source not in self._graph or target not in self._graph:
+ return []
+
+ try:
+ return list(nx.all_simple_paths(self._graph, source, target, cutoff=cutoff))
+ except nx.NetworkXError:
+ return []
+
+ def find_cycles(self) -> List[List[Any]]:
+ """
+ Find cycles in the graph.
+
+ Returns:
+ List of cycles in the graph
+ """
+ try:
+ return list(nx.simple_cycles(self._graph))
+ except nx.NetworkXNoCycle:
+ return []
+
+ def get_import_graph(self) -> nx.DiGraph:
+ """
+ Get the import dependency graph.
+
+ Returns:
+ NetworkX DiGraph representing import dependencies
+ """
+ # Create a subgraph with only file nodes
+ files = self.get_files()
+ subgraph = self._graph.subgraph(files)
+
+ # Create a new graph with only import edges
+ import_graph = nx.DiGraph()
+
+ for source, target, data in subgraph.edges(data=True):
+ if 'type' in data and data['type'] == EdgeType.IMPORTS:
+ # Get file paths
+ source_path = source.file_path if hasattr(source, 'file_path') else str(source)
+ target_path = target.file_path if hasattr(target, 'file_path') else str(target)
+
+ # Add edge to import graph
+ import_graph.add_edge(source_path, target_path)
+
+ return import_graph
+
+ def get_call_graph(self) -> nx.DiGraph:
+ """
+ Get the function call graph.
+
+ Returns:
+ NetworkX DiGraph representing function calls
+ """
+ # Create a subgraph with only function nodes
+ functions = self.get_functions()
+ subgraph = self._graph.subgraph(functions)
+
+ # Create a new graph with only call edges
+ call_graph = nx.DiGraph()
+
+ for source, target, data in subgraph.edges(data=True):
+ if 'type' in data and data['type'] == EdgeType.CALLS:
+ # Get function names
+ source_name = source.name if hasattr(source, 'name') else str(source)
+ target_name = target.name if hasattr(target, 'name') else str(target)
+
+ # Add edge to call graph
+ call_graph.add_edge(source_name, target_name)
+
+ return call_graph
+
+ def get_inheritance_graph(self) -> nx.DiGraph:
+ """
+ Get the class inheritance graph.
+
+ Returns:
+ NetworkX DiGraph representing class inheritance
+ """
+ # Create a subgraph with only class nodes
+ classes = self.get_classes()
+ subgraph = self._graph.subgraph(classes)
+
+ # Create a new graph with only inheritance edges
+ inheritance_graph = nx.DiGraph()
+
+ for source, target, data in subgraph.edges(data=True):
+ if 'type' in data and data['type'] == EdgeType.INHERITS_FROM:
+ # Get class names
+ source_name = source.name if hasattr(source, 'name') else str(source)
+ target_name = target.name if hasattr(target, 'name') else str(target)
+
+ # Add edge to inheritance graph
+ inheritance_graph.add_edge(source_name, target_name)
+
+ return inheritance_graph
+
+ def analyze_dependencies(self) -> Dict[str, Any]:
+ """
+ Analyze dependencies in the codebase.
+
+ Returns:
+ Dictionary containing dependency analysis results
+ """
+ # Get import graph
+ import_graph = self.get_import_graph()
+
+ # Find circular dependencies
+ circular_deps = find_circular_dependencies(import_graph)
+
+ # Calculate centrality
+ centrality = calculate_centrality(import_graph)
+
+ # Find hub modules (most central)
+ hub_modules = sorted(centrality.items(), key=lambda x: x[1], reverse=True)[:10]
+
+ return {
+ "circular_dependencies": [
+ {"cycle": cycle, "length": len(cycle)}
+ for cycle in circular_deps
+ ],
+ "hub_modules": [
+ {"module": module, "centrality": centrality}
+ for module, centrality in hub_modules
+ ],
+ "dependency_count": len(import_graph.edges),
+ "module_count": len(import_graph.nodes)
+ }
+
+ def analyze_code_structure(self) -> Dict[str, Any]:
+ """
+ Analyze code structure.
+
+ Returns:
+ Dictionary containing code structure analysis results
+ """
+ return {
+ "file_count": len(self.get_files()),
+ "function_count": len(self.get_functions()),
+ "class_count": len(self.get_classes()),
+ "average_file_size": self._calculate_average_file_size(),
+ "average_function_size": self._calculate_average_function_size(),
+ "most_complex_files": self._find_most_complex_files(10),
+ "most_complex_functions": self._find_most_complex_functions(10)
+ }
+
+ def _calculate_average_file_size(self) -> float:
+ """
+ Calculate average file size in lines.
+
+ Returns:
+ Average file size in lines
+ """
+ files = self.get_files()
+
+ if not files:
+ return 0
+
+ total_lines = 0
+ file_count = 0
+
+ for file in files:
+ if hasattr(file, 'content'):
+ lines = len(file.content.split('\n'))
+ total_lines += lines
+ file_count += 1
+
+ return total_lines / file_count if file_count > 0 else 0
+
+ def _calculate_average_function_size(self) -> float:
+ """
+ Calculate average function size in lines.
+
+ Returns:
+ Average function size in lines
+ """
+ functions = self.get_functions()
+
+ if not functions:
+ return 0
+
+ total_lines = 0
+ function_count = 0
+
+ for func in functions:
+ if hasattr(func, 'source'):
+ lines = len(func.source.split('\n'))
+ total_lines += lines
+ function_count += 1
+
+ return total_lines / function_count if function_count > 0 else 0
+
+ def _find_most_complex_files(self, limit: int = 10) -> List[Dict[str, Any]]:
+ """
+ Find the most complex files.
+
+ Args:
+ limit: Maximum number of files to return
+
+ Returns:
+ List of complex files with complexity metrics
+ """
+ files = self.get_files()
+ file_complexity = []
+
+ for file in files:
+ file_context = self.get_file_context(file)
+ complexity = file_context.analyze_complexity()
+
+ file_complexity.append({
+ "file": file_context.path,
+ "complexity": complexity
+ })
+
+ # Sort by complexity
+ file_complexity.sort(key=lambda x: x["complexity"].get("total_complexity", 0), reverse=True)
+
+ return file_complexity[:limit]
+
+ def _find_most_complex_functions(self, limit: int = 10) -> List[Dict[str, Any]]:
+ """
+ Find the most complex functions.
+
+ Args:
+ limit: Maximum number of functions to return
+
+ Returns:
+ List of complex functions with complexity metrics
+ """
+ functions = self.get_functions()
+ function_complexity = []
+
+ for func in functions:
+ function_context = self.get_function_context(func)
+ complexity = function_context.analyze_complexity()
+
+ function_complexity.append({
+ "function": function_context.name,
+ "file": function_context.file_path,
+ "line": function_context.line,
+ "complexity": complexity["cyclomatic_complexity"]
+ })
+
+ # Sort by complexity
+ function_complexity.sort(key=lambda x: x["complexity"], reverse=True)
+
+ return function_complexity[:limit]
+
+ def export_to_dict(self) -> Dict[str, Any]:
+ """
+ Export the codebase context to a dictionary.
+
+ Returns:
+ Dictionary representation of the codebase context
+ """
+ nodes = []
+ for node in self._graph.nodes:
+ node_data = {
+ "id": str(id(node)),
+ "type": get_node_type(node).value,
+ }
+
+ if hasattr(node, 'name'):
+ node_data["name"] = node.name
+
+ if hasattr(node, 'file') and hasattr(node.file, 'file_path'):
+ node_data["file"] = node.file.file_path
+
+ nodes.append(node_data)
+
+ edges = []
+ for source, target, data in self._graph.edges(data=True):
+ edge_data = {
+ "source": str(id(source)),
+ "target": str(id(target)),
+ }
+
+ if "type" in data:
+ edge_data["type"] = data["type"].value if isinstance(data["type"], Enum) else str(data["type"])
+
+ edges.append(edge_data)
+
+ return {
+ "nodes": nodes,
+ "edges": edges,
+ "summary": {
+ "file_count": len(self.get_files()),
+ "function_count": len(self.get_functions()),
+ "class_count": len(self.get_classes()),
+ "edge_count": len(self._graph.edges)
+ }
+ }
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/codebase_visualizer.py b/codegen-on-oss/codegen_on_oss/analyzers/codebase_visualizer.py
new file mode 100644
index 000000000..0e7a47b7a
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/codebase_visualizer.py
@@ -0,0 +1,1561 @@
+#!/usr/bin/env python3
+"""
+Codebase Visualizer Module
+
+This module provides comprehensive visualization capabilities for codebases and PR analyses.
+It integrates with codebase_analyzer.py and context_codebase.py to provide visual representations
+of code structure, dependencies, and issues. It supports multiple visualization types to help
+developers understand codebase architecture and identify potential problems.
+"""
+
+import os
+import sys
+import json
+import logging
+import tempfile
+import math
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, TypeVar, cast, Callable
+from datetime import datetime
+from dataclasses import dataclass, field
+
+try:
+ import networkx as nx
+ import matplotlib.pyplot as plt
+ from matplotlib.colors import LinearSegmentedColormap
+except ImportError:
+ print("Visualization dependencies not found. Please install them with: pip install networkx matplotlib")
+ sys.exit(1)
+
+try:
+ from codegen.sdk.core.codebase import Codebase
+ from codegen.sdk.core.symbol import Symbol
+ from codegen.sdk.core.function import Function
+ from codegen.sdk.core.class_definition import Class
+ from codegen.sdk.core.file import SourceFile
+ from codegen.sdk.core.import_resolution import Import
+ from codegen.sdk.enums import EdgeType, SymbolType
+ from codegen.sdk.core.detached_symbols.function_call import FunctionCall
+
+ # Import custom modules
+ from codegen_on_oss.context_codebase import CodebaseContext, get_node_classes, GLOBAL_FILE_IGNORE_LIST
+ from codegen_on_oss.codebase_analyzer import CodebaseAnalyzer, Issue, IssueSeverity, AnalysisType
+ from codegen_on_oss.current_code_codebase import get_selected_codebase
+except ImportError:
+ print("Codegen SDK or custom modules not found. Please ensure all dependencies are installed.")
+ sys.exit(1)
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class VisualizationType(str, Enum):
+ """Types of visualizations supported by this module."""
+ CALL_GRAPH = "call_graph"
+ DEPENDENCY_GRAPH = "dependency_graph"
+ BLAST_RADIUS = "blast_radius"
+ CLASS_METHODS = "class_methods"
+ MODULE_DEPENDENCIES = "module_dependencies"
+ DEAD_CODE = "dead_code"
+ CYCLOMATIC_COMPLEXITY = "cyclomatic_complexity"
+ ISSUES_HEATMAP = "issues_heatmap"
+ PR_COMPARISON = "pr_comparison"
+
+class OutputFormat(str, Enum):
+ """Output formats for visualizations."""
+ JSON = "json"
+ PNG = "png"
+ SVG = "svg"
+ HTML = "html"
+ DOT = "dot"
+
+@dataclass
+class VisualizationConfig:
+ """Configuration for visualization generation."""
+ max_depth: int = 5
+ ignore_external: bool = True
+ ignore_tests: bool = True
+ node_size_base: int = 300
+ edge_width_base: float = 1.0
+ filename_filter: Optional[List[str]] = None
+ symbol_filter: Optional[List[str]] = None
+ output_format: OutputFormat = OutputFormat.JSON
+ output_directory: Optional[str] = None
+ layout_algorithm: str = "spring"
+ highlight_nodes: List[str] = field(default_factory=list)
+ highlight_color: str = "#ff5555"
+ color_palette: Dict[str, str] = field(default_factory=lambda: {
+ "Function": "#a277ff", # Purple
+ "Class": "#ffca85", # Orange
+ "File": "#80CBC4", # Teal
+ "Module": "#81D4FA", # Light Blue
+ "Variable": "#B39DDB", # Light Purple
+ "Root": "#ef5350", # Red
+ "Warning": "#FFCA28", # Amber
+ "Error": "#EF5350", # Red
+ "Dead": "#78909C", # Gray
+ "External": "#B0BEC5", # Light Gray
+ })
+
+class CodebaseVisualizer:
+ """
+ Visualizer for codebase structures and analytics.
+
+ This class provides methods to generate various visualizations of a codebase,
+ including call graphs, dependency graphs, complexity heatmaps, and more.
+ It integrates with CodebaseAnalyzer to visualize analysis results.
+ """
+
+ def __init__(
+ self,
+ analyzer: Optional[CodebaseAnalyzer] = None,
+ codebase: Optional[Codebase] = None,
+ context: Optional[CodebaseContext] = None,
+ config: Optional[VisualizationConfig] = None
+ ):
+ """
+ Initialize the CodebaseVisualizer.
+
+ Args:
+ analyzer: Optional CodebaseAnalyzer instance with analysis results
+ codebase: Optional Codebase instance to visualize
+ context: Optional CodebaseContext providing graph representation
+ config: Visualization configuration options
+ """
+ self.analyzer = analyzer
+ self.codebase = codebase or (analyzer.base_codebase if analyzer else None)
+ self.context = context or (analyzer.base_context if analyzer else None)
+ self.config = config or VisualizationConfig()
+
+ # Create visualization directory if specified
+ if self.config.output_directory:
+ os.makedirs(self.config.output_directory, exist_ok=True)
+
+ # Initialize graph for visualization
+ self.graph = nx.DiGraph()
+
+ # Initialize codebase if needed
+ if not self.codebase and not self.context:
+ logger.info("No codebase or context provided, initializing from current directory")
+ self.codebase = get_selected_codebase()
+ self.context = CodebaseContext(
+ codebase=self.codebase,
+ base_path=os.getcwd()
+ )
+ elif self.codebase and not self.context:
+ logger.info("Creating context from provided codebase")
+ self.context = CodebaseContext(
+ codebase=self.codebase,
+ base_path=os.getcwd() if not hasattr(self.codebase, 'base_path') else self.codebase.base_path
+ )
+
+ def _initialize_graph(self):
+ """Initialize a fresh graph for visualization."""
+ self.graph = nx.DiGraph()
+
+ def _add_node(self, node: Any, **attrs):
+ """
+ Add a node to the visualization graph with attributes.
+
+ Args:
+ node: Node object to add
+ **attrs: Node attributes
+ """
+ # Skip if node already exists
+ if self.graph.has_node(node):
+ return
+
+ # Generate node ID (memory address for unique identification)
+ node_id = id(node)
+
+ # Get node name
+ if "name" in attrs:
+ node_name = attrs["name"]
+ elif hasattr(node, "name"):
+ node_name = node.name
+ elif hasattr(node, "path"):
+ node_name = str(node.path).split("/")[-1]
+ else:
+ node_name = str(node)
+
+ # Determine node type and color
+ node_type = node.__class__.__name__
+ color = attrs.get("color", self.config.color_palette.get(node_type, "#BBBBBB"))
+
+ # Add node with attributes
+ self.graph.add_node(
+ node_id,
+ original_node=node,
+ name=node_name,
+ type=node_type,
+ color=color,
+ **attrs
+ )
+
+ return node_id
+
+ def _add_edge(self, source: Any, target: Any, **attrs):
+ """
+ Add an edge to the visualization graph with attributes.
+
+ Args:
+ source: Source node
+ target: Target node
+ **attrs: Edge attributes
+ """
+ # Get node IDs
+ source_id = id(source)
+ target_id = id(target)
+
+ # Add edge with attributes
+ self.graph.add_edge(
+ source_id,
+ target_id,
+ **attrs
+ )
+
+ def _generate_filename(self, visualization_type: VisualizationType, entity_name: str):
+ """
+ Generate a filename for the visualization.
+
+ Args:
+ visualization_type: Type of visualization
+ entity_name: Name of the entity being visualized
+
+ Returns:
+ Generated filename
+ """
+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+ sanitized_name = entity_name.replace("/", "_").replace("\\", "_").replace(".", "_")
+ return f"{visualization_type.value}_{sanitized_name}_{timestamp}.{self.config.output_format.value}"
+
+ def _save_visualization(self, visualization_type: VisualizationType, entity_name: str, data: Any):
+ """
+ Save a visualization to file or return it.
+
+ Args:
+ visualization_type: Type of visualization
+ entity_name: Name of the entity being visualized
+ data: Visualization data to save
+
+ Returns:
+ Path to saved file or visualization data
+ """
+ filename = self._generate_filename(visualization_type, entity_name)
+
+ if self.config.output_directory:
+ filepath = os.path.join(self.config.output_directory, filename)
+ else:
+ filepath = filename
+
+ if self.config.output_format == OutputFormat.JSON:
+ with open(filepath, 'w') as f:
+ json.dump(data, f, indent=2)
+ elif self.config.output_format in [OutputFormat.PNG, OutputFormat.SVG]:
+ # Save matplotlib figure
+ plt.savefig(filepath, format=self.config.output_format.value, bbox_inches='tight')
+ plt.close()
+ elif self.config.output_format == OutputFormat.DOT:
+ # Save as DOT file for Graphviz
+ try:
+ from networkx.drawing.nx_agraph import write_dot
+ write_dot(self.graph, filepath)
+ except ImportError:
+ logger.error("networkx.drawing.nx_agraph not available. Install pygraphviz for DOT format.")
+ return None
+
+ logger.info(f"Visualization saved to {filepath}")
+ return filepath
+
+ def _convert_graph_to_json(self):
+ """
+ Convert the networkx graph to a JSON-serializable dictionary.
+
+ Returns:
+ Dictionary representation of the graph
+ """
+ nodes = []
+ for node, attrs in self.graph.nodes(data=True):
+ # Create a serializable node
+ node_data = {
+ "id": node,
+ "name": attrs.get("name", ""),
+ "type": attrs.get("type", ""),
+ "color": attrs.get("color", "#BBBBBB"),
+ }
+
+ # Add file path if available
+ if "file_path" in attrs:
+ node_data["file_path"] = attrs["file_path"]
+
+ # Add other attributes
+ for key, value in attrs.items():
+ if key not in ["name", "type", "color", "file_path", "original_node"]:
+ if isinstance(value, (str, int, float, bool, list, dict)) or value is None:
+ node_data[key] = value
+
+ nodes.append(node_data)
+
+ edges = []
+ for source, target, attrs in self.graph.edges(data=True):
+ # Create a serializable edge
+ edge_data = {
+ "source": source,
+ "target": target,
+ }
+
+ # Add other attributes
+ for key, value in attrs.items():
+ if isinstance(value, (str, int, float, bool, list, dict)) or value is None:
+ edge_data[key] = value
+
+ edges.append(edge_data)
+
+ return {
+ "nodes": nodes,
+ "edges": edges,
+ "metadata": {
+ "visualization_type": self.current_visualization_type,
+ "entity_name": self.current_entity_name,
+ "timestamp": datetime.now().isoformat(),
+ "node_count": len(nodes),
+ "edge_count": len(edges),
+ }
+ }
+
+ def _plot_graph(self):
+ """
+ Plot the graph using matplotlib.
+
+ Returns:
+ Matplotlib figure
+ """
+ plt.figure(figsize=(12, 10))
+
+ # Extract node positions using specified layout algorithm
+ if self.config.layout_algorithm == "spring":
+ pos = nx.spring_layout(self.graph, seed=42)
+ elif self.config.layout_algorithm == "kamada_kawai":
+ pos = nx.kamada_kawai_layout(self.graph)
+ elif self.config.layout_algorithm == "spectral":
+ pos = nx.spectral_layout(self.graph)
+ else:
+ # Default to spring layout
+ pos = nx.spring_layout(self.graph, seed=42)
+
+ # Extract node colors
+ node_colors = [attrs.get("color", "#BBBBBB") for _, attrs in self.graph.nodes(data=True)]
+
+ # Extract node sizes (can be based on some metric)
+ node_sizes = [self.config.node_size_base for _ in self.graph.nodes()]
+
+ # Draw nodes
+ nx.draw_networkx_nodes(
+ self.graph, pos,
+ node_color=node_colors,
+ node_size=node_sizes,
+ alpha=0.8
+ )
+
+ # Draw edges
+ nx.draw_networkx_edges(
+ self.graph, pos,
+ width=self.config.edge_width_base,
+ alpha=0.6,
+ arrows=True,
+ arrowsize=10
+ )
+
+ # Draw labels
+ nx.draw_networkx_labels(
+ self.graph, pos,
+ labels={node: attrs.get("name", "") for node, attrs in self.graph.nodes(data=True)},
+ font_size=8,
+ font_weight="bold"
+ )
+
+ plt.title(f"{self.current_visualization_type} - {self.current_entity_name}")
+ plt.axis("off")
+
+ return plt.gcf()
+
+ def visualize_call_graph(self, function_name: str, max_depth: Optional[int] = None):
+ """
+ Generate a call graph visualization for a function.
+
+ Args:
+ function_name: Name of the function to visualize
+ max_depth: Maximum depth of the call graph (overrides config)
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ self.current_visualization_type = VisualizationType.CALL_GRAPH
+ self.current_entity_name = function_name
+
+ # Set max depth
+ current_max_depth = max_depth if max_depth is not None else self.config.max_depth
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Find the function in the codebase
+ function = None
+ for func in self.codebase.functions:
+ if func.name == function_name:
+ function = func
+ break
+
+ if not function:
+ logger.error(f"Function {function_name} not found in codebase")
+ return None
+
+ # Add root node
+ root_id = self._add_node(
+ function,
+ name=function_name,
+ color=self.config.color_palette.get("Root"),
+ is_root=True
+ )
+
+ # Recursively add call relationships
+ visited = set([function])
+
+ def add_calls(func, depth=0):
+ if depth >= current_max_depth:
+ return
+
+ # Skip if no function calls attribute
+ if not hasattr(func, "function_calls"):
+ return
+
+ for call in func.function_calls:
+ # Skip recursive calls
+ if call.name == func.name:
+ continue
+
+ # Get the called function
+ called_func = call.function_definition
+ if not called_func:
+ continue
+
+ # Skip external modules if configured
+ if self.config.ignore_external and hasattr(called_func, "is_external") and called_func.is_external:
+ continue
+
+ # Generate name for display
+ if hasattr(called_func, "is_method") and called_func.is_method and hasattr(called_func, "parent_class"):
+ called_name = f"{called_func.parent_class.name}.{called_func.name}"
+ else:
+ called_name = called_func.name
+
+ # Add node for called function
+ called_id = self._add_node(
+ called_func,
+ name=called_name,
+ color=self.config.color_palette.get("Function"),
+ file_path=called_func.file.path if hasattr(called_func, "file") and hasattr(called_func.file, "path") else None
+ )
+
+ # Add edge for call relationship
+ self._add_edge(
+ function,
+ called_func,
+ type="call",
+ file_path=call.filepath if hasattr(call, "filepath") else None,
+ line=call.line if hasattr(call, "line") else None
+ )
+
+ # Recursively process called function
+ if isinstance(called_func, Function) and called_func not in visited:
+ visited.add(called_func)
+ add_calls(called_func, depth + 1)
+
+ # Start from the root function
+ add_calls(function)
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.CALL_GRAPH, function_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.CALL_GRAPH, function_name, fig)
+
+ def visualize_dependency_graph(self, symbol_name: str, max_depth: Optional[int] = None):
+ """
+ Generate a dependency graph visualization for a symbol.
+
+ Args:
+ symbol_name: Name of the symbol to visualize
+ max_depth: Maximum depth of the dependency graph (overrides config)
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ self.current_visualization_type = VisualizationType.DEPENDENCY_GRAPH
+ self.current_entity_name = symbol_name
+
+ # Set max depth
+ current_max_depth = max_depth if max_depth is not None else self.config.max_depth
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Find the symbol in the codebase
+ symbol = None
+ for sym in self.codebase.symbols:
+ if hasattr(sym, "name") and sym.name == symbol_name:
+ symbol = sym
+ break
+
+ if not symbol:
+ logger.error(f"Symbol {symbol_name} not found in codebase")
+ return None
+
+ # Add root node
+ root_id = self._add_node(
+ symbol,
+ name=symbol_name,
+ color=self.config.color_palette.get("Root"),
+ is_root=True
+ )
+
+ # Recursively add dependencies
+ visited = set([symbol])
+
+ def add_dependencies(sym, depth=0):
+ if depth >= current_max_depth:
+ return
+
+ # Skip if no dependencies attribute
+ if not hasattr(sym, "dependencies"):
+ return
+
+ for dep in sym.dependencies:
+ dep_symbol = None
+
+ if isinstance(dep, Symbol):
+ dep_symbol = dep
+ elif isinstance(dep, Import) and hasattr(dep, "resolved_symbol"):
+ dep_symbol = dep.resolved_symbol
+
+ if not dep_symbol:
+ continue
+
+ # Skip external modules if configured
+ if self.config.ignore_external and hasattr(dep_symbol, "is_external") and dep_symbol.is_external:
+ continue
+
+ # Add node for dependency
+ dep_id = self._add_node(
+ dep_symbol,
+ name=dep_symbol.name if hasattr(dep_symbol, "name") else str(dep_symbol),
+ color=self.config.color_palette.get(dep_symbol.__class__.__name__, "#BBBBBB"),
+ file_path=dep_symbol.file.path if hasattr(dep_symbol, "file") and hasattr(dep_symbol.file, "path") else None
+ )
+
+ # Add edge for dependency relationship
+ self._add_edge(
+ sym,
+ dep_symbol,
+ type="depends_on"
+ )
+
+ # Recursively process dependency
+ if dep_symbol not in visited:
+ visited.add(dep_symbol)
+ add_dependencies(dep_symbol, depth + 1)
+
+ # Start from the root symbol
+ add_dependencies(symbol)
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.DEPENDENCY_GRAPH, symbol_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.DEPENDENCY_GRAPH, symbol_name, fig)
+
+ def visualize_blast_radius(self, symbol_name: str, max_depth: Optional[int] = None):
+ """
+ Generate a blast radius visualization for a symbol.
+
+ Args:
+ symbol_name: Name of the symbol to visualize
+ max_depth: Maximum depth of the blast radius (overrides config)
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ self.current_visualization_type = VisualizationType.BLAST_RADIUS
+ self.current_entity_name = symbol_name
+
+ # Set max depth
+ current_max_depth = max_depth if max_depth is not None else self.config.max_depth
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Find the symbol in the codebase
+ symbol = None
+ for sym in self.codebase.symbols:
+ if hasattr(sym, "name") and sym.name == symbol_name:
+ symbol = sym
+ break
+
+ if not symbol:
+ logger.error(f"Symbol {symbol_name} not found in codebase")
+ return None
+
+ # Add root node
+ root_id = self._add_node(
+ symbol,
+ name=symbol_name,
+ color=self.config.color_palette.get("Root"),
+ is_root=True
+ )
+
+ # Recursively add usages (reverse dependencies)
+ visited = set([symbol])
+
+ def add_usages(sym, depth=0):
+ if depth >= current_max_depth:
+ return
+
+ # Skip if no usages attribute
+ if not hasattr(sym, "usages"):
+ return
+
+ for usage in sym.usages:
+ # Skip if no usage symbol
+ if not hasattr(usage, "usage_symbol"):
+ continue
+
+ usage_symbol = usage.usage_symbol
+
+ # Skip external modules if configured
+ if self.config.ignore_external and hasattr(usage_symbol, "is_external") and usage_symbol.is_external:
+ continue
+
+ # Add node for usage
+ usage_id = self._add_node(
+ usage_symbol,
+ name=usage_symbol.name if hasattr(usage_symbol, "name") else str(usage_symbol),
+ color=self.config.color_palette.get(usage_symbol.__class__.__name__, "#BBBBBB"),
+ file_path=usage_symbol.file.path if hasattr(usage_symbol, "file") and hasattr(usage_symbol.file, "path") else None
+ )
+
+ # Add edge for usage relationship
+ self._add_edge(
+ sym,
+ usage_symbol,
+ type="used_by"
+ )
+
+ # Recursively process usage
+ if usage_symbol not in visited:
+ visited.add(usage_symbol)
+ add_usages(usage_symbol, depth + 1)
+
+ # Start from the root symbol
+ add_usages(symbol)
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.BLAST_RADIUS, symbol_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.BLAST_RADIUS, symbol_name, fig)
+
+ def visualize_class_methods(self, class_name: str):
+ """
+ Generate a class methods visualization.
+
+ Args:
+ class_name: Name of the class to visualize
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ self.current_visualization_type = VisualizationType.CLASS_METHODS
+ self.current_entity_name = class_name
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Find the class in the codebase
+ class_obj = None
+ for cls in self.codebase.classes:
+ if cls.name == class_name:
+ class_obj = cls
+ break
+
+ if not class_obj:
+ logger.error(f"Class {class_name} not found in codebase")
+ return None
+
+ # Add class node
+ class_id = self._add_node(
+ class_obj,
+ name=class_name,
+ color=self.config.color_palette.get("Class"),
+ is_root=True
+ )
+
+ # Skip if no methods attribute
+ if not hasattr(class_obj, "methods"):
+ logger.error(f"Class {class_name} has no methods attribute")
+ return None
+
+ # Add method nodes and connections
+ method_ids = {}
+ for method in class_obj.methods:
+ method_name = f"{class_name}.{method.name}"
+
+ # Add method node
+ method_id = self._add_node(
+ method,
+ name=method_name,
+ color=self.config.color_palette.get("Function"),
+ file_path=method.file.path if hasattr(method, "file") and hasattr(method.file, "path") else None
+ )
+
+ method_ids[method.name] = method_id
+
+ # Add edge from class to method
+ self._add_edge(
+ class_obj,
+ method,
+ type="contains"
+ )
+
+ # Add call relationships between methods
+ for method in class_obj.methods:
+ # Skip if no function calls attribute
+ if not hasattr(method, "function_calls"):
+ continue
+
+ for call in method.function_calls:
+ # Get the called function
+ called_func = call.function_definition
+ if not called_func:
+ continue
+
+ # Only add edges between methods of this class
+ if hasattr(called_func, "is_method") and called_func.is_method and \
+ hasattr(called_func, "parent_class") and called_func.parent_class == class_obj:
+ self._add_edge(
+ method,
+ called_func,
+ type="calls",
+ line=call.line if hasattr(call, "line") else None
+ )
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.CLASS_METHODS, class_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.CLASS_METHODS, class_name, fig)
+
+ def visualize_module_dependencies(self, module_path: str):
+ """
+ Generate a module dependencies visualization.
+
+ Args:
+ module_path: Path to the module to visualize
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ self.current_visualization_type = VisualizationType.MODULE_DEPENDENCIES
+ self.current_entity_name = module_path
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Get all files in the module
+ module_files = []
+ for file in self.codebase.files:
+ if hasattr(file, "path") and str(file.path).startswith(module_path):
+ module_files.append(file)
+
+ if not module_files:
+ logger.error(f"No files found in module {module_path}")
+ return None
+
+ # Add file nodes
+ module_node_ids = {}
+ for file in module_files:
+ file_name = str(file.path).split("/")[-1]
+ file_module = "/".join(str(file.path).split("/")[:-1])
+
+ # Add file node
+ file_id = self._add_node(
+ file,
+ name=file_name,
+ module=file_module,
+ color=self.config.color_palette.get("File"),
+ file_path=str(file.path)
+ )
+
+ module_node_ids[str(file.path)] = file_id
+
+ # Add import relationships
+ for file in module_files:
+ # Skip if no imports attribute
+ if not hasattr(file, "imports"):
+ continue
+
+ for imp in file.imports:
+ imported_file = None
+
+ # Try to get imported file
+ if hasattr(imp, "resolved_file"):
+ imported_file = imp.resolved_file
+ elif hasattr(imp, "resolved_symbol") and hasattr(imp.resolved_symbol, "file"):
+ imported_file = imp.resolved_symbol.file
+
+ if not imported_file:
+ continue
+
+ # Skip external modules if configured
+ if self.config.ignore_external and hasattr(imported_file, "is_external") and imported_file.is_external:
+ continue
+
+ # Add node for imported file if not already added
+ imported_path = str(imported_file.path) if hasattr(imported_file, "path") else ""
+
+ if imported_path not in module_node_ids:
+ imported_name = imported_path.split("/")[-1]
+ imported_module = "/".join(imported_path.split("/")[:-1])
+
+ imported_id = self._add_node(
+ imported_file,
+ name=imported_name,
+ module=imported_module,
+ color=self.config.color_palette.get("External" if imported_path.startswith(module_path) else "File"),
+ file_path=imported_path
+ )
+
+ module_node_ids[imported_path] = imported_id
+
+ # Add edge for import relationship
+ self._add_edge(
+ file,
+ imported_file,
+ type="imports",
+ import_name=imp.name if hasattr(imp, "name") else ""
+ )
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.MODULE_DEPENDENCIES, module_path, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.MODULE_DEPENDENCIES, module_path, fig)
+
+ def visualize_dead_code(self, path_filter: Optional[str] = None):
+ """
+ Generate a visualization of dead (unused) code in the codebase.
+
+ Args:
+ path_filter: Optional path to filter files
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ self.current_visualization_type = VisualizationType.DEAD_CODE
+ self.current_entity_name = path_filter or "codebase"
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Initialize analyzer if needed
+ if not self.analyzer:
+ logger.info("Initializing analyzer for dead code detection")
+ self.analyzer = CodebaseAnalyzer(
+ codebase=self.codebase,
+ repo_path=self.context.base_path if hasattr(self.context, "base_path") else None
+ )
+
+ # Perform analysis if not already done
+ if not hasattr(self.analyzer, "results") or not self.analyzer.results:
+ logger.info("Running code analysis")
+ self.analyzer.analyze(AnalysisType.CODEBASE)
+
+ # Extract dead code information from analysis results
+ if not hasattr(self.analyzer, "results"):
+ logger.error("Analysis results not available")
+ return None
+
+ dead_code = {}
+ if "static_analysis" in self.analyzer.results and "dead_code" in self.analyzer.results["static_analysis"]:
+ dead_code = self.analyzer.results["static_analysis"]["dead_code"]
+
+ if not dead_code:
+ logger.warning("No dead code detected in analysis results")
+ return None
+
+ # Create file nodes for containing dead code
+ file_nodes = {}
+
+ # Process unused functions
+ if "unused_functions" in dead_code:
+ for unused_func in dead_code["unused_functions"]:
+ file_path = unused_func.get("file", "")
+
+ # Skip if path filter is specified and doesn't match
+ if path_filter and not file_path.startswith(path_filter):
+ continue
+
+ # Add file node if not already added
+ if file_path not in file_nodes:
+ # Find file in codebase
+ file_obj = None
+ for file in self.codebase.files:
+ if hasattr(file, "path") and str(file.path) == file_path:
+ file_obj = file
+ break
+
+ if file_obj:
+ file_name = file_path.split("/")[-1]
+ file_id = self._add_node(
+ file_obj,
+ name=file_name,
+ color=self.config.color_palette.get("File"),
+ file_path=file_path
+ )
+
+ file_nodes[file_path] = file_obj
+
+ # Add unused function node
+ func_name = unused_func.get("name", "")
+ func_line = unused_func.get("line", None)
+
+ # Create a placeholder for the function (we don't have the actual object)
+ func_obj = {"name": func_name, "file_path": file_path, "line": func_line, "type": "Function"}
+
+ func_id = self._add_node(
+ func_obj,
+ name=func_name,
+ color=self.config.color_palette.get("Dead"),
+ file_path=file_path,
+ line=func_line,
+ is_dead=True
+ )
+
+ # Add edge from file to function
+ if file_path in file_nodes:
+ self._add_edge(
+ file_nodes[file_path],
+ func_obj,
+ type="contains_dead"
+ )
+
+ # Process unused variables
+ if "unused_variables" in dead_code:
+ for unused_var in dead_code["unused_variables"]:
+ file_path = unused_var.get("file", "")
+
+ # Skip if path filter is specified and doesn't match
+ if path_filter and not file_path.startswith(path_filter):
+ continue
+
+ # Add file node if not already added
+ if file_path not in file_nodes:
+ # Find file in codebase
+ file_obj = None
+ for file in self.codebase.files:
+ if hasattr(file, "path") and str(file.path) == file_path:
+ file_obj = file
+ break
+
+ if file_obj:
+ file_name = file_path.split("/")[-1]
+ file_id = self._add_node(
+ file_obj,
+ name=file_name,
+ color=self.config.color_palette.get("File"),
+ file_path=file_path
+ )
+
+ file_nodes[file_path] = file_obj
+
+ # Add unused variable node
+ var_name = unused_var.get("name", "")
+ var_line = unused_var.get("line", None)
+
+ # Create a placeholder for the variable
+ var_obj = {"name": var_name, "file_path": file_path, "line": var_line, "type": "Variable"}
+
+ var_id = self._add_node(
+ var_obj,
+ name=var_name,
+ color=self.config.color_palette.get("Dead"),
+ file_path=file_path,
+ line=var_line,
+ is_dead=True
+ )
+
+ # Add edge from file to variable
+ if file_path in file_nodes:
+ self._add_edge(
+ file_nodes[file_path],
+ var_obj,
+ type="contains_dead"
+ )
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.DEAD_CODE, self.current_entity_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.DEAD_CODE, self.current_entity_name, fig)
+
+ def visualize_cyclomatic_complexity(self, path_filter: Optional[str] = None):
+ """
+ Generate a heatmap visualization of cyclomatic complexity.
+
+ Args:
+ path_filter: Optional path to filter files
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ self.current_visualization_type = VisualizationType.CYCLOMATIC_COMPLEXITY
+ self.current_entity_name = path_filter or "codebase"
+
+ # Initialize analyzer if needed
+ if not self.analyzer:
+ logger.info("Initializing analyzer for complexity analysis")
+ self.analyzer = CodebaseAnalyzer(
+ codebase=self.codebase,
+ repo_path=self.context.base_path if hasattr(self.context, "base_path") else None
+ )
+
+ # Perform analysis if not already done
+ if not hasattr(self.analyzer, "results") or not self.analyzer.results:
+ logger.info("Running code analysis")
+ self.analyzer.analyze(AnalysisType.CODEBASE)
+
+ # Extract complexity information from analysis results
+ if not hasattr(self.analyzer, "results"):
+ logger.error("Analysis results not available")
+ return None
+
+ complexity_data = {}
+ if "static_analysis" in self.analyzer.results and "code_complexity" in self.analyzer.results["static_analysis"]:
+ complexity_data = self.analyzer.results["static_analysis"]["code_complexity"]
+
+ if not complexity_data:
+ logger.warning("No complexity data found in analysis results")
+ return None
+
+ # Extract function complexities
+ functions = []
+ if "function_complexity" in complexity_data:
+ for func_data in complexity_data["function_complexity"]:
+ # Skip if path filter is specified and doesn't match
+ if path_filter and not func_data.get("file", "").startswith(path_filter):
+ continue
+
+ functions.append({
+ "name": func_data.get("name", ""),
+ "file": func_data.get("file", ""),
+ "complexity": func_data.get("complexity", 1),
+ "line": func_data.get("line", None)
+ })
+
+ # Sort functions by complexity (descending)
+ functions.sort(key=lambda x: x.get("complexity", 0), reverse=True)
+
+ # Generate heatmap visualization
+ plt.figure(figsize=(12, 10))
+
+ # Extract data for heatmap
+ func_names = [f"{func['name']} ({func['file'].split('/')[-1]})" for func in functions[:30]]
+ complexities = [func.get("complexity", 0) for func in functions[:30]]
+
+ # Create horizontal bar chart
+ bars = plt.barh(func_names, complexities)
+
+ # Color bars by complexity
+ norm = plt.Normalize(1, max(10, max(complexities)))
+ cmap = plt.cm.get_cmap('YlOrRd')
+
+ for i, bar in enumerate(bars):
+ complexity = complexities[i]
+ bar.set_color(cmap(norm(complexity)))
+
+ # Add labels and title
+ plt.xlabel('Cyclomatic Complexity')
+ plt.title('Top Functions by Cyclomatic Complexity')
+ plt.grid(axis='x', linestyle='--', alpha=0.6)
+
+ # Add colorbar
+ plt.colorbar(plt.cm.ScalarMappable(norm=norm, cmap=cmap), label='Complexity')
+
+ # Save and return visualization
+ return self._save_visualization(VisualizationType.CYCLOMATIC_COMPLEXITY, self.current_entity_name, plt.gcf())
+
+ def visualize_issues_heatmap(self, severity: Optional[IssueSeverity] = None, path_filter: Optional[str] = None):
+ """
+ Generate a heatmap visualization of issues in the codebase.
+
+ Args:
+ severity: Optional severity level to filter issues
+ path_filter: Optional path to filter files
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ self.current_visualization_type = VisualizationType.ISSUES_HEATMAP
+ self.current_entity_name = f"{severity.value if severity else 'all'}_issues"
+
+ # Initialize analyzer if needed
+ if not self.analyzer:
+ logger.info("Initializing analyzer for issues analysis")
+ self.analyzer = CodebaseAnalyzer(
+ codebase=self.codebase,
+ repo_path=self.context.base_path if hasattr(self.context, "base_path") else None
+ )
+
+ # Perform analysis if not already done
+ if not hasattr(self.analyzer, "results") or not self.analyzer.results:
+ logger.info("Running code analysis")
+ self.analyzer.analyze(AnalysisType.CODEBASE)
+
+ # Extract issues from analysis results
+ if not hasattr(self.analyzer, "results") or "issues" not in self.analyzer.results:
+ logger.error("Issues not available in analysis results")
+ return None
+
+ issues = self.analyzer.results["issues"]
+
+ # Filter issues by severity if specified
+ if severity:
+ issues = [issue for issue in issues if issue.get("severity") == severity]
+
+ # Filter issues by path if specified
+ if path_filter:
+ issues = [issue for issue in issues if issue.get("file", "").startswith(path_filter)]
+
+ if not issues:
+ logger.warning("No issues found matching the criteria")
+ return None
+
+ # Group issues by file
+ file_issues = {}
+ for issue in issues:
+ file_path = issue.get("file", "")
+ if file_path not in file_issues:
+ file_issues[file_path] = []
+
+ file_issues[file_path].append(issue)
+
+ # Generate heatmap visualization
+ plt.figure(figsize=(12, 10))
+
+ # Extract data for heatmap
+ files = list(file_issues.keys())
+ file_names = [file_path.split("/")[-1] for file_path in files]
+ issue_counts = [len(file_issues[file_path]) for file_path in files]
+
+ # Sort by issue count
+ sorted_data = sorted(zip(file_names, issue_counts, files), key=lambda x: x[1], reverse=True)
+ file_names, issue_counts, files = zip(*sorted_data)
+
+ # Create horizontal bar chart
+ bars = plt.barh(file_names[:20], issue_counts[:20])
+
+ # Color bars by issue count
+ norm = plt.Normalize(1, max(5, max(issue_counts[:20])))
+ cmap = plt.cm.get_cmap('OrRd')
+
+ for i, bar in enumerate(bars):
+ count = issue_counts[i]
+ bar.set_color(cmap(norm(count)))
+
+ # Add labels and title
+ plt.xlabel('Number of Issues')
+ severity_text = f" ({severity.value})" if severity else ""
+ plt.title(f'Files with the Most Issues{severity_text}')
+ plt.grid(axis='x', linestyle='--', alpha=0.6)
+
+ # Add colorbar
+ plt.colorbar(plt.cm.ScalarMappable(norm=norm, cmap=cmap), label='Issue Count')
+
+ # Save and return visualization
+ return self._save_visualization(VisualizationType.ISSUES_HEATMAP, self.current_entity_name, plt.gcf())
+
+ def visualize_pr_comparison(self):
+ """
+ Generate a visualization comparing base branch with PR.
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ self.current_visualization_type = VisualizationType.PR_COMPARISON
+
+ # Check if analyzer has PR data
+ if not self.analyzer or not self.analyzer.pr_codebase or not self.analyzer.base_codebase:
+ logger.error("PR comparison requires analyzer with PR data")
+ return None
+
+ self.current_entity_name = f"pr_{self.analyzer.pr_number}" if self.analyzer.pr_number else "pr_comparison"
+
+ # Perform comparison analysis if not already done
+ if not hasattr(self.analyzer, "results") or not self.analyzer.results:
+ logger.info("Running PR comparison analysis")
+ self.analyzer.analyze(AnalysisType.COMPARISON)
+
+ # Extract comparison data from analysis results
+ if not hasattr(self.analyzer, "results") or "comparison" not in self.analyzer.results:
+ logger.error("Comparison data not available in analysis results")
+ return None
+
+ comparison = self.analyzer.results["comparison"]
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Process symbol comparison data
+ if "symbol_comparison" in comparison:
+ for symbol_data in comparison["symbol_comparison"]:
+ symbol_name = symbol_data.get("name", "")
+ in_base = symbol_data.get("in_base", False)
+ in_pr = symbol_data.get("in_pr", False)
+
+ # Create a placeholder for the symbol
+ symbol_obj = {
+ "name": symbol_name,
+ "in_base": in_base,
+ "in_pr": in_pr,
+ "type": "Symbol"
+ }
+
+ # Determine node color based on presence in base and PR
+ if in_base and in_pr:
+ color = "#A5D6A7" # Light green (modified)
+ elif in_base:
+ color = "#EF9A9A" # Light red (removed)
+ else:
+ color = "#90CAF9" # Light blue (added)
+
+ # Add node for symbol
+ symbol_id = self._add_node(
+ symbol_obj,
+ name=symbol_name,
+ color=color,
+ in_base=in_base,
+ in_pr=in_pr
+ )
+
+ # Process parameter changes if available
+ if "parameter_changes" in symbol_data:
+ param_changes = symbol_data["parameter_changes"]
+
+ # Process removed parameters
+ for param in param_changes.get("removed", []):
+ param_obj = {
+ "name": param,
+ "change_type": "removed",
+ "type": "Parameter"
+ }
+
+ param_id = self._add_node(
+ param_obj,
+ name=param,
+ color="#EF9A9A", # Light red (removed)
+ change_type="removed"
+ )
+
+ self._add_edge(
+ symbol_obj,
+ param_obj,
+ type="removed_parameter"
+ )
+
+ # Process added parameters
+ for param in param_changes.get("added", []):
+ param_obj = {
+ "name": param,
+ "change_type": "added",
+ "type": "Parameter"
+ }
+
+ param_id = self._add_node(
+ param_obj,
+ name=param,
+ color="#90CAF9", # Light blue (added)
+ change_type="added"
+ )
+
+ self._add_edge(
+ symbol_obj,
+ param_obj,
+ type="added_parameter"
+ )
+
+ # Process return type changes if available
+ if "return_type_change" in symbol_data:
+ return_type_change = symbol_data["return_type_change"]
+ old_type = return_type_change.get("old", "None")
+ new_type = return_type_change.get("new", "None")
+
+ return_obj = {
+ "name": f"{old_type} -> {new_type}",
+ "old_type": old_type,
+ "new_type": new_type,
+ "type": "ReturnType"
+ }
+
+ return_id = self._add_node(
+ return_obj,
+ name=f"{old_type} -> {new_type}",
+ color="#FFD54F", # Amber (changed)
+ old_type=old_type,
+ new_type=new_type
+ )
+
+ self._add_edge(
+ symbol_obj,
+ return_obj,
+ type="return_type_change"
+ )
+
+ # Process call site issues if available
+ if "call_site_issues" in symbol_data:
+ for issue in symbol_data["call_site_issues"]:
+ issue_file = issue.get("file", "")
+ issue_line = issue.get("line", None)
+ issue_text = issue.get("issue", "")
+
+ # Create a placeholder for the issue
+ issue_obj = {
+ "name": issue_text,
+ "file": issue_file,
+ "line": issue_line,
+ "type": "Issue"
+ }
+
+ issue_id = self._add_node(
+ issue_obj,
+ name=f"{issue_file.split('/')[-1]}:{issue_line}",
+ color="#EF5350", # Red (error)
+ file_path=issue_file,
+ line=issue_line,
+ issue_text=issue_text
+ )
+
+ self._add_edge(
+ symbol_obj,
+ issue_obj,
+ type="call_site_issue"
+ )
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.PR_COMPARISON, self.current_entity_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.PR_COMPARISON, self.current_entity_name, fig)
+
+# Command-line interface
+def main():
+ """
+ Command-line interface for the codebase visualizer.
+
+ This function parses command-line arguments and generates visualizations
+ based on the specified parameters.
+ """
+ parser = argparse.ArgumentParser(
+ description="Generate visualizations of codebase structure and analysis."
+ )
+
+ # Repository options
+ repo_group = parser.add_argument_group("Repository Options")
+ repo_group.add_argument(
+ "--repo-url",
+ help="URL of the repository to analyze"
+ )
+ repo_group.add_argument(
+ "--repo-path",
+ help="Local path to the repository to analyze"
+ )
+ repo_group.add_argument(
+ "--language",
+ help="Programming language of the codebase"
+ )
+
+ # Visualization options
+ viz_group = parser.add_argument_group("Visualization Options")
+ viz_group.add_argument(
+ "--type",
+ choices=[t.value for t in VisualizationType],
+ required=True,
+ help="Type of visualization to generate"
+ )
+ viz_group.add_argument(
+ "--entity",
+ help="Name of the entity to visualize (function, class, file, etc.)"
+ )
+ viz_group.add_argument(
+ "--max-depth",
+ type=int,
+ default=5,
+ help="Maximum depth for recursive visualizations"
+ )
+ viz_group.add_argument(
+ "--ignore-external",
+ action="store_true",
+ help="Ignore external dependencies"
+ )
+ viz_group.add_argument(
+ "--severity",
+ choices=[s.value for s in IssueSeverity],
+ help="Filter issues by severity"
+ )
+ viz_group.add_argument(
+ "--path-filter",
+ help="Filter by file path"
+ )
+
+ # PR options
+ pr_group = parser.add_argument_group("PR Options")
+ pr_group.add_argument(
+ "--pr-number",
+ type=int,
+ help="PR number to analyze"
+ )
+ pr_group.add_argument(
+ "--base-branch",
+ default="main",
+ help="Base branch for comparison"
+ )
+
+ # Output options
+ output_group = parser.add_argument_group("Output Options")
+ output_group.add_argument(
+ "--output-format",
+ choices=[f.value for f in OutputFormat],
+ default="json",
+ help="Output format for the visualization"
+ )
+ output_group.add_argument(
+ "--output-directory",
+ help="Directory to save visualizations"
+ )
+ output_group.add_argument(
+ "--layout",
+ choices=["spring", "kamada_kawai", "spectral"],
+ default="spring",
+ help="Layout algorithm for graph visualization"
+ )
+
+ args = parser.parse_args()
+
+ # Create visualizer configuration
+ config = VisualizationConfig(
+ max_depth=args.max_depth,
+ ignore_external=args.ignore_external,
+ output_format=OutputFormat(args.output_format),
+ output_directory=args.output_directory,
+ layout_algorithm=args.layout
+ )
+
+ # Create codebase analyzer if needed for PR comparison
+ analyzer = None
+ if args.type == VisualizationType.PR_COMPARISON.value or args.pr_number:
+ analyzer = CodebaseAnalyzer(
+ repo_url=args.repo_url,
+ repo_path=args.repo_path,
+ base_branch=args.base_branch,
+ pr_number=args.pr_number,
+ language=args.language
+ )
+
+ # Create visualizer
+ visualizer = CodebaseVisualizer(
+ analyzer=analyzer,
+ config=config
+ )
+
+ # Generate visualization based on type
+ viz_type = VisualizationType(args.type)
+ result = None
+
+ if viz_type == VisualizationType.CALL_GRAPH:
+ if not args.entity:
+ logger.error("Entity name required for call graph visualization")
+ sys.exit(1)
+
+ result = visualizer.visualize_call_graph(args.entity)
+
+ elif viz_type == VisualizationType.DEPENDENCY_GRAPH:
+ if not args.entity:
+ logger.error("Entity name required for dependency graph visualization")
+ sys.exit(1)
+
+ result = visualizer.visualize_dependency_graph(args.entity)
+
+ elif viz_type == VisualizationType.BLAST_RADIUS:
+ if not args.entity:
+ logger.error("Entity name required for blast radius visualization")
+ sys.exit(1)
+
+ result = visualizer.visualize_blast_radius(args.entity)
+
+ elif viz_type == VisualizationType.CLASS_METHODS:
+ if not args.entity:
+ logger.error("Class name required for class methods visualization")
+ sys.exit(1)
+
+ result = visualizer.visualize_class_methods(args.entity)
+
+ elif viz_type == VisualizationType.MODULE_DEPENDENCIES:
+ if not args.entity:
+ logger.error("Module path required for module dependencies visualization")
+ sys.exit(1)
+
+ result = visualizer.visualize_module_dependencies(args.entity)
+
+ elif viz_type == VisualizationType.DEAD_CODE:
+ result = visualizer.visualize_dead_code(args.path_filter)
+
+ elif viz_type == VisualizationType.CYCLOMATIC_COMPLEXITY:
+ result = visualizer.visualize_cyclomatic_complexity(args.path_filter)
+
+ elif viz_type == VisualizationType.ISSUES_HEATMAP:
+ severity = IssueSeverity(args.severity) if args.severity else None
+ result = visualizer.visualize_issues_heatmap(severity, args.path_filter)
+
+ elif viz_type == VisualizationType.PR_COMPARISON:
+ if not args.pr_number:
+ logger.error("PR number required for PR comparison visualization")
+ sys.exit(1)
+
+ result = visualizer.visualize_pr_comparison()
+
+ # Output result
+ if result:
+ logger.info(f"Visualization completed: {result}")
+ else:
+ logger.error("Failed to generate visualization")
+ sys.exit(1)
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/context/__init__.py b/codegen-on-oss/codegen_on_oss/analyzers/context/__init__.py
new file mode 100644
index 000000000..497fad744
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/context/__init__.py
@@ -0,0 +1,16 @@
+"""
+Codebase Context Module
+
+This module provides graph-based context representations of codebases,
+files, classes, and functions to support advanced analysis capabilities.
+"""
+
+from codegen_on_oss.analyzers.context.codebase import CodebaseContext
+from codegen_on_oss.analyzers.context.file import FileContext
+from codegen_on_oss.analyzers.context.function import FunctionContext
+
+__all__ = [
+ 'CodebaseContext',
+ 'FileContext',
+ 'FunctionContext',
+]
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/context/codebase.py b/codegen-on-oss/codegen_on_oss/analyzers/context/codebase.py
new file mode 100644
index 000000000..51e98c64e
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/context/codebase.py
@@ -0,0 +1,465 @@
+#!/usr/bin/env python3
+"""
+Codebase Context Module
+
+This module provides a graph-based context representation of a codebase
+for advanced analysis capabilities, including dependency analysis,
+code structure visualization, and PR comparison.
+"""
+
+import os
+import sys
+import logging
+import networkx as nx
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, Callable, TypeVar, cast
+from enum import Enum
+from pathlib import Path
+
+try:
+ from codegen.sdk.core.codebase import Codebase
+ from codegen.sdk.codebase.codebase_context import CodebaseContext as SDKCodebaseContext
+ from codegen.sdk.core.file import SourceFile
+ from codegen.sdk.core.directory import Directory
+ from codegen.sdk.core.symbol import Symbol
+ from codegen.sdk.core.function import Function
+ from codegen.sdk.core.class_definition import Class
+ from codegen.sdk.enums import EdgeType, SymbolType
+except ImportError:
+ print("Codegen SDK not found. Please install it first.")
+ sys.exit(1)
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+# Global file ignore patterns
+GLOBAL_FILE_IGNORE_LIST = [
+ "__pycache__",
+ ".git",
+ "node_modules",
+ "dist",
+ "build",
+ ".DS_Store",
+ ".pytest_cache",
+ ".venv",
+ "venv",
+ "env",
+ ".env",
+ ".idea",
+ ".vscode",
+]
+
+class NodeType(str, Enum):
+ """Types of nodes in the graph."""
+ FILE = "file"
+ DIRECTORY = "directory"
+ FUNCTION = "function"
+ CLASS = "class"
+ MODULE = "module"
+ VARIABLE = "variable"
+ UNKNOWN = "unknown"
+
+def get_node_type(node: Any) -> NodeType:
+ """Determine the type of a node."""
+ if isinstance(node, SourceFile):
+ return NodeType.FILE
+ elif isinstance(node, Directory):
+ return NodeType.DIRECTORY
+ elif isinstance(node, Function):
+ return NodeType.FUNCTION
+ elif isinstance(node, Class):
+ return NodeType.CLASS
+ else:
+ return NodeType.UNKNOWN
+
+def get_node_classes():
+ """Get a dictionary mapping node types to their classes."""
+ return {
+ NodeType.FILE: SourceFile,
+ NodeType.DIRECTORY: Directory,
+ NodeType.FUNCTION: Function,
+ NodeType.CLASS: Class,
+ }
+
+class CodebaseContext:
+ """
+ Graph-based representation of a codebase for advanced analysis.
+
+ This class provides a graph representation of a codebase, including
+ files, directories, functions, classes, and their relationships.
+ It supports advanced analysis capabilities such as dependency analysis,
+ code structure visualization, and PR comparison.
+ """
+
+ def __init__(
+ self,
+ codebase: Codebase,
+ base_path: Optional[str] = None,
+ pr_branch: Optional[str] = None,
+ base_branch: str = "main",
+ file_ignore_list: Optional[List[str]] = None
+ ):
+ """
+ Initialize the CodebaseContext.
+
+ Args:
+ codebase: The codebase to analyze
+ base_path: Base path of the codebase
+ pr_branch: PR branch name (for PR analysis)
+ base_branch: Base branch name (for PR analysis)
+ file_ignore_list: List of file patterns to ignore
+ """
+ self.codebase = codebase
+ self.base_path = base_path
+ self.pr_branch = pr_branch
+ self.base_branch = base_branch
+ self.file_ignore_list = file_ignore_list or GLOBAL_FILE_IGNORE_LIST
+
+ # Initialize graph
+ self._graph = nx.DiGraph()
+
+ # Build the graph
+ self._build_graph()
+
+ def _build_graph(self):
+ """Build the codebase graph."""
+ logger.info("Building codebase graph...")
+
+ # Add nodes for files
+ for file in self.codebase.files:
+ # Skip ignored files
+ if self._should_ignore_file(file):
+ continue
+
+ # Add file node
+ self._graph.add_node(file,
+ type=NodeType.FILE,
+ path=file.file_path if hasattr(file, 'file_path') else str(file))
+
+ # Add nodes for functions in the file
+ if hasattr(file, 'functions'):
+ for func in file.functions:
+ self._graph.add_node(func,
+ type=NodeType.FUNCTION,
+ name=func.name if hasattr(func, 'name') else str(func),
+ file=file)
+
+ # Add edge from file to function
+ self._graph.add_edge(file, func, type=EdgeType.CONTAINS)
+
+ # Add nodes for classes in the file
+ if hasattr(file, 'classes'):
+ for cls in file.classes:
+ self._graph.add_node(cls,
+ type=NodeType.CLASS,
+ name=cls.name if hasattr(cls, 'name') else str(cls),
+ file=file)
+
+ # Add edge from file to class
+ self._graph.add_edge(file, cls, type=EdgeType.CONTAINS)
+
+ # Add nodes for methods in the class
+ if hasattr(cls, 'methods'):
+ for method in cls.methods:
+ self._graph.add_node(method,
+ type=NodeType.FUNCTION,
+ name=method.name if hasattr(method, 'name') else str(method),
+ file=file,
+ class_name=cls.name if hasattr(cls, 'name') else str(cls))
+
+ # Add edge from class to method
+ self._graph.add_edge(cls, method, type=EdgeType.CONTAINS)
+
+ # Add edges for imports
+ for file in self.codebase.files:
+ # Skip ignored files
+ if self._should_ignore_file(file):
+ continue
+
+ # Add import edges
+ if hasattr(file, 'imports'):
+ for imp in file.imports:
+ # Get imported file
+ imported_file = None
+
+ if hasattr(imp, 'resolved_file'):
+ imported_file = imp.resolved_file
+ elif hasattr(imp, 'resolved_symbol') and hasattr(imp.resolved_symbol, 'file'):
+ imported_file = imp.resolved_symbol.file
+
+ if imported_file and imported_file in self._graph:
+ # Add edge from file to imported file
+ self._graph.add_edge(file, imported_file, type=EdgeType.IMPORTS)
+
+ # Add edges for function calls
+ for func in [n for n in self._graph.nodes if get_node_type(n) == NodeType.FUNCTION]:
+ if hasattr(func, 'call_sites'):
+ for call_site in func.call_sites:
+ if hasattr(call_site, 'called_function') and call_site.called_function in self._graph:
+ # Add edge from function to called function
+ self._graph.add_edge(func, call_site.called_function, type=EdgeType.CALLS)
+
+ # Add edges for class inheritance
+ for cls in [n for n in self._graph.nodes if get_node_type(n) == NodeType.CLASS]:
+ if hasattr(cls, 'superclasses'):
+ for superclass in cls.superclasses:
+ if superclass in self._graph:
+ # Add edge from class to superclass
+ self._graph.add_edge(cls, superclass, type=EdgeType.INHERITS_FROM)
+
+ logger.info(f"Graph built with {len(self._graph.nodes)} nodes and {len(self._graph.edges)} edges")
+
+ def _should_ignore_file(self, file) -> bool:
+ """Check if a file should be ignored."""
+ if hasattr(file, 'is_binary') and file.is_binary:
+ return True
+
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file)
+
+ # Check against ignore list
+ for pattern in self.file_ignore_list:
+ if pattern in file_path:
+ return True
+
+ return False
+
+ @property
+ def graph(self) -> nx.DiGraph:
+ """Get the codebase graph."""
+ return self._graph
+
+ @property
+ def nodes(self) -> List[Any]:
+ """Get all nodes in the graph."""
+ return list(self._graph.nodes)
+
+ def get_node(self, name: str) -> Optional[Any]:
+ """
+ Get a node by name.
+
+ Args:
+ name: Name of the node to get
+
+ Returns:
+ The node, or None if not found
+ """
+ for node in self._graph.nodes:
+ if (hasattr(node, 'name') and node.name == name) or str(node) == name:
+ return node
+ return None
+
+ def predecessors(self, node: Any) -> List[Any]:
+ """
+ Get predecessors of a node.
+
+ Args:
+ node: Node to get predecessors for
+
+ Returns:
+ List of predecessor nodes
+ """
+ return list(self._graph.predecessors(node))
+
+ def successors(self, node: Any) -> List[Any]:
+ """
+ Get successors of a node.
+
+ Args:
+ node: Node to get successors for
+
+ Returns:
+ List of successor nodes
+ """
+ return list(self._graph.successors(node))
+
+ def in_edges(self, node: Any, data: bool = False) -> List[Any]:
+ """
+ Get incoming edges of a node.
+
+ Args:
+ node: Node to get edges for
+ data: Whether to include edge data
+
+ Returns:
+ List of incoming edges
+ """
+ return list(self._graph.in_edges(node, data=data))
+
+ def out_edges(self, node: Any, data: bool = False) -> List[Any]:
+ """
+ Get outgoing edges of a node.
+
+ Args:
+ node: Node to get edges for
+ data: Whether to include edge data
+
+ Returns:
+ List of outgoing edges
+ """
+ return list(self._graph.out_edges(node, data=data))
+
+ def edges(self, data: bool = False) -> List[Any]:
+ """
+ Get all edges in the graph.
+
+ Args:
+ data: Whether to include edge data
+
+ Returns:
+ List of edges
+ """
+ return list(self._graph.edges(data=data))
+
+ def get_nodes_by_type(self, node_type: NodeType) -> List[Any]:
+ """
+ Get nodes by type.
+
+ Args:
+ node_type: Type of nodes to get
+
+ Returns:
+ List of nodes of the specified type
+ """
+ return [n for n in self._graph.nodes if get_node_type(n) == node_type]
+
+ def build_subgraph(self, nodes: List[Any]) -> nx.DiGraph:
+ """
+ Build a subgraph from a list of nodes.
+
+ Args:
+ nodes: List of nodes to include in the subgraph
+
+ Returns:
+ Subgraph containing the specified nodes
+ """
+ return self._graph.subgraph(nodes)
+
+ def find_paths(self, source: Any, target: Any, cutoff: Optional[int] = None) -> List[List[Any]]:
+ """
+ Find all paths between two nodes.
+
+ Args:
+ source: Source node
+ target: Target node
+ cutoff: Maximum path length
+
+ Returns:
+ List of paths from source to target
+ """
+ if source not in self._graph or target not in self._graph:
+ return []
+
+ try:
+ return list(nx.all_simple_paths(self._graph, source, target, cutoff=cutoff))
+ except nx.NetworkXError:
+ return []
+
+ def find_shortest_path(self, source: Any, target: Any) -> Optional[List[Any]]:
+ """
+ Find the shortest path between two nodes.
+
+ Args:
+ source: Source node
+ target: Target node
+
+ Returns:
+ Shortest path from source to target, or None if no path exists
+ """
+ if source not in self._graph or target not in self._graph:
+ return None
+
+ try:
+ return nx.shortest_path(self._graph, source, target)
+ except nx.NetworkXNoPath:
+ return None
+
+ def find_cycles(self) -> List[List[Any]]:
+ """
+ Find cycles in the graph.
+
+ Returns:
+ List of cycles in the graph
+ """
+ try:
+ return list(nx.simple_cycles(self._graph))
+ except nx.NetworkXNoCycle:
+ return []
+
+ def get_files(self) -> List[SourceFile]:
+ """
+ Get all files in the codebase.
+
+ Returns:
+ List of files
+ """
+ return self.get_nodes_by_type(NodeType.FILE)
+
+ def get_functions(self) -> List[Function]:
+ """
+ Get all functions in the codebase.
+
+ Returns:
+ List of functions
+ """
+ return self.get_nodes_by_type(NodeType.FUNCTION)
+
+ def get_classes(self) -> List[Class]:
+ """
+ Get all classes in the codebase.
+
+ Returns:
+ List of classes
+ """
+ return self.get_nodes_by_type(NodeType.CLASS)
+
+ def export_to_networkx(self) -> nx.DiGraph:
+ """
+ Export the graph to a NetworkX graph.
+
+ Returns:
+ NetworkX graph representation of the codebase
+ """
+ return self._graph.copy()
+
+ def export_to_dict(self) -> Dict[str, Any]:
+ """
+ Export the graph to a dictionary.
+
+ Returns:
+ Dictionary representation of the codebase graph
+ """
+ nodes = []
+ for node in self._graph.nodes:
+ node_data = {
+ "id": str(id(node)),
+ "type": get_node_type(node).value,
+ }
+
+ if hasattr(node, 'name'):
+ node_data["name"] = node.name
+
+ if hasattr(node, 'file') and hasattr(node.file, 'file_path'):
+ node_data["file"] = node.file.file_path
+
+ nodes.append(node_data)
+
+ edges = []
+ for source, target, data in self._graph.edges(data=True):
+ edge_data = {
+ "source": str(id(source)),
+ "target": str(id(target)),
+ }
+
+ if "type" in data:
+ edge_data["type"] = data["type"].value if isinstance(data["type"], Enum) else str(data["type"])
+
+ edges.append(edge_data)
+
+ return {
+ "nodes": nodes,
+ "edges": edges
+ }
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/context/file.py b/codegen-on-oss/codegen_on_oss/analyzers/context/file.py
new file mode 100644
index 000000000..191573b95
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/context/file.py
@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+"""
+File Context Module
+
+This module provides a specialized context for file-level analysis,
+including structure, imports, exports, and symbols within a file.
+"""
+
+import os
+import sys
+import logging
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, cast
+from pathlib import Path
+
+try:
+ from codegen.sdk.core.file import SourceFile
+ from codegen.sdk.core.symbol import Symbol
+ from codegen.sdk.core.function import Function
+ from codegen.sdk.core.class_definition import Class
+ from codegen.sdk.enums import EdgeType, SymbolType
+except ImportError:
+ print("Codegen SDK not found. Please install it first.")
+ sys.exit(1)
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class FileContext:
+ """
+ Context for file-level analysis.
+
+ This class provides specialized analysis capabilities for a single file,
+ including structure analysis, import/export analysis, and symbol analysis.
+ """
+
+ def __init__(self, file: SourceFile):
+ """
+ Initialize the FileContext.
+
+ Args:
+ file: The file to analyze
+ """
+ self.file = file
+ self.path = file.file_path if hasattr(file, 'file_path') else str(file)
+ self.functions = list(file.functions) if hasattr(file, 'functions') else []
+ self.classes = list(file.classes) if hasattr(file, 'classes') else []
+ self.imports = list(file.imports) if hasattr(file, 'imports') else []
+ self.exports = list(file.exports) if hasattr(file, 'exports') else []
+
+ # Collect symbols
+ self.symbols: List[Symbol] = []
+ self.symbols.extend(self.functions)
+ self.symbols.extend(self.classes)
+
+ # Add symbols from file.symbols if available
+ if hasattr(file, 'symbols'):
+ for symbol in file.symbols:
+ if symbol not in self.symbols:
+ self.symbols.append(symbol)
+
+ def get_symbol(self, name: str) -> Optional[Symbol]:
+ """
+ Get a symbol by name.
+
+ Args:
+ name: Name of the symbol to get
+
+ Returns:
+ The symbol, or None if not found
+ """
+ for symbol in self.symbols:
+ if hasattr(symbol, 'name') and symbol.name == name:
+ return symbol
+ return None
+
+ def get_function(self, name: str) -> Optional[Function]:
+ """
+ Get a function by name.
+
+ Args:
+ name: Name of the function to get
+
+ Returns:
+ The function, or None if not found
+ """
+ for func in self.functions:
+ if hasattr(func, 'name') and func.name == name:
+ return func
+ return None
+
+ def get_class(self, name: str) -> Optional[Class]:
+ """
+ Get a class by name.
+
+ Args:
+ name: Name of the class to get
+
+ Returns:
+ The class, or None if not found
+ """
+ for cls in self.classes:
+ if hasattr(cls, 'name') and cls.name == name:
+ return cls
+ return None
+
+ def get_import(self, name: str) -> Optional[Any]:
+ """
+ Get an import by name.
+
+ Args:
+ name: Name of the import to get
+
+ Returns:
+ The import, or None if not found
+ """
+ for imp in self.imports:
+ if hasattr(imp, 'name') and imp.name == name:
+ return imp
+ return None
+
+ def get_export(self, name: str) -> Optional[Any]:
+ """
+ Get an export by name.
+
+ Args:
+ name: Name of the export to get
+
+ Returns:
+ The export, or None if not found
+ """
+ for exp in self.exports:
+ if hasattr(exp, 'name') and exp.name == name:
+ return exp
+ return None
+
+ def get_symbols_by_type(self, symbol_type: SymbolType) -> List[Symbol]:
+ """
+ Get symbols by type.
+
+ Args:
+ symbol_type: Type of symbols to get
+
+ Returns:
+ List of symbols of the specified type
+ """
+ return [s for s in self.symbols if hasattr(s, 'symbol_type') and s.symbol_type == symbol_type]
+
+ def get_imported_modules(self) -> List[str]:
+ """
+ Get imported module names.
+
+ Returns:
+ List of imported module names
+ """
+ modules = []
+ for imp in self.imports:
+ if hasattr(imp, 'module_name'):
+ modules.append(imp.module_name)
+ return modules
+
+ def get_exported_symbols(self) -> List[str]:
+ """
+ Get exported symbol names.
+
+ Returns:
+ List of exported symbol names
+ """
+ symbols = []
+ for exp in self.exports:
+ if hasattr(exp, 'name'):
+ symbols.append(exp.name)
+ return symbols
+
+ def analyze_complexity(self) -> Dict[str, Any]:
+ """
+ Analyze code complexity in the file.
+
+ Returns:
+ Dictionary containing complexity metrics
+ """
+ result = {
+ "functions": {},
+ "average_complexity": 0,
+ "max_complexity": 0,
+ "total_complexity": 0
+ }
+
+ total_complexity = 0
+ max_complexity = 0
+ function_count = 0
+
+ for func in self.functions:
+ # Calculate cyclomatic complexity
+ complexity = self._calculate_cyclomatic_complexity(func)
+
+ # Update metrics
+ total_complexity += complexity
+ max_complexity = max(max_complexity, complexity)
+ function_count += 1
+
+ # Add function metrics
+ func_name = func.name if hasattr(func, 'name') else str(func)
+ result["functions"][func_name] = {
+ "complexity": complexity,
+ "line_count": len(func.source.split('\n')) if hasattr(func, 'source') else 0
+ }
+
+ # Update summary metrics
+ result["average_complexity"] = total_complexity / function_count if function_count > 0 else 0
+ result["max_complexity"] = max_complexity
+ result["total_complexity"] = total_complexity
+
+ return result
+
+ def _calculate_cyclomatic_complexity(self, function) -> int:
+ """
+ Calculate cyclomatic complexity for a function.
+
+ Args:
+ function: Function to analyze
+
+ Returns:
+ Cyclomatic complexity score
+ """
+ complexity = 1 # Base complexity
+
+ if not hasattr(function, 'source'):
+ return complexity
+
+ source = function.source
+
+ # Count branching statements
+ complexity += source.count('if ')
+ complexity += source.count('elif ')
+ complexity += source.count('for ')
+ complexity += source.count('while ')
+ complexity += source.count('except:')
+ complexity += source.count('except ')
+ complexity += source.count(' and ')
+ complexity += source.count(' or ')
+ complexity += source.count('case ')
+
+ return complexity
+
+ def analyze_imports(self) -> Dict[str, Any]:
+ """
+ Analyze imports in the file.
+
+ Returns:
+ Dictionary containing import analysis
+ """
+ result = {
+ "total_imports": len(self.imports),
+ "resolved_imports": 0,
+ "unresolved_imports": 0,
+ "external_imports": 0,
+ "internal_imports": 0,
+ "import_details": []
+ }
+
+ for imp in self.imports:
+ import_info = {
+ "name": imp.name if hasattr(imp, 'name') else str(imp),
+ "module": imp.module_name if hasattr(imp, 'module_name') else "unknown",
+ "is_resolved": False,
+ "is_external": False
+ }
+
+ # Check if import is resolved
+ if hasattr(imp, 'resolved_file') and imp.resolved_file:
+ import_info["is_resolved"] = True
+ result["resolved_imports"] += 1
+ elif hasattr(imp, 'resolved_symbol') and imp.resolved_symbol:
+ import_info["is_resolved"] = True
+ result["resolved_imports"] += 1
+ else:
+ result["unresolved_imports"] += 1
+
+ # Check if import is external
+ if hasattr(imp, 'is_external'):
+ import_info["is_external"] = imp.is_external
+ if imp.is_external:
+ result["external_imports"] += 1
+ else:
+ result["internal_imports"] += 1
+
+ result["import_details"].append(import_info)
+
+ return result
+
+ def analyze_structure(self) -> Dict[str, Any]:
+ """
+ Analyze file structure.
+
+ Returns:
+ Dictionary containing structure analysis
+ """
+ result = {
+ "path": self.path,
+ "line_count": 0,
+ "function_count": len(self.functions),
+ "class_count": len(self.classes),
+ "import_count": len(self.imports),
+ "export_count": len(self.exports)
+ }
+
+ # Count lines of code
+ if hasattr(self.file, 'content'):
+ result["line_count"] = len(self.file.content.split('\n'))
+
+ return result
+
+ def to_dict(self) -> Dict[str, Any]:
+ """
+ Convert the file context to a dictionary.
+
+ Returns:
+ Dictionary representation of the file context
+ """
+ return {
+ "path": self.path,
+ "functions": [func.name if hasattr(func, 'name') else str(func) for func in self.functions],
+ "classes": [cls.name if hasattr(cls, 'name') else str(cls) for cls in self.classes],
+ "imports": [imp.name if hasattr(imp, 'name') else str(imp) for imp in self.imports],
+ "exports": [exp.name if hasattr(exp, 'name') else str(exp) for exp in self.exports],
+ "symbols": [sym.name if hasattr(sym, 'name') else str(sym) for sym in self.symbols]
+ }
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/context/function.py b/codegen-on-oss/codegen_on_oss/analyzers/context/function.py
new file mode 100644
index 000000000..26b453f62
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/context/function.py
@@ -0,0 +1,336 @@
+#!/usr/bin/env python3
+"""
+Function Context Module
+
+This module provides a specialized context for function-level analysis,
+including parameters, return types, complexity, and call relationships.
+"""
+
+import os
+import sys
+import logging
+import re
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, cast
+from pathlib import Path
+
+try:
+ from codegen.sdk.core.function import Function
+ from codegen.sdk.core.symbol import Symbol
+ from codegen.sdk.enums import EdgeType
+except ImportError:
+ print("Codegen SDK not found. Please install it first.")
+ sys.exit(1)
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class FunctionContext:
+ """
+ Context for function-level analysis.
+
+ This class provides specialized analysis capabilities for a single function,
+ including parameter analysis, return type analysis, complexity analysis,
+ and call relationship analysis.
+ """
+
+ def __init__(self, function: Function):
+ """
+ Initialize the FunctionContext.
+
+ Args:
+ function: The function to analyze
+ """
+ self.function = function
+ self.name = function.name if hasattr(function, 'name') else str(function)
+ self.file = function.file if hasattr(function, 'file') else None
+ self.file_path = function.file.file_path if hasattr(function, 'file') and hasattr(function.file, 'file_path') else "unknown"
+ self.line = function.line if hasattr(function, 'line') else None
+ self.parameters = list(function.parameters) if hasattr(function, 'parameters') else []
+ self.return_type = function.return_type if hasattr(function, 'return_type') else None
+ self.is_async = function.is_async if hasattr(function, 'is_async') else False
+ self.source = function.source if hasattr(function, 'source') else ""
+ self.call_sites = list(function.call_sites) if hasattr(function, 'call_sites') else []
+ self.locals = []
+
+ # Extract local variables if available
+ if hasattr(function, 'code_block') and hasattr(function.code_block, 'local_var_assignments'):
+ self.locals = list(function.code_block.local_var_assignments)
+
+ def get_parameter(self, name: str) -> Optional[Any]:
+ """
+ Get a parameter by name.
+
+ Args:
+ name: Name of the parameter to get
+
+ Returns:
+ The parameter, or None if not found
+ """
+ for param in self.parameters:
+ if hasattr(param, 'name') and param.name == name:
+ return param
+ return None
+
+ def get_parameter_types(self) -> Dict[str, Any]:
+ """
+ Get parameter types.
+
+ Returns:
+ Dictionary mapping parameter names to types
+ """
+ result = {}
+ for param in self.parameters:
+ if hasattr(param, 'name'):
+ param_type = param.type if hasattr(param, 'type') else None
+ result[param.name] = str(param_type) if param_type else None
+ return result
+
+ def get_called_functions(self) -> List[Any]:
+ """
+ Get functions called by this function.
+
+ Returns:
+ List of called functions
+ """
+ result = []
+ for call_site in self.call_sites:
+ if hasattr(call_site, 'called_function'):
+ result.append(call_site.called_function)
+ return result
+
+ def analyze_complexity(self) -> Dict[str, Any]:
+ """
+ Analyze function complexity.
+
+ Returns:
+ Dictionary containing complexity metrics
+ """
+ result = {
+ "name": self.name,
+ "file": self.file_path,
+ "line": self.line,
+ "cyclomatic_complexity": self._calculate_cyclomatic_complexity(),
+ "line_count": len(self.source.split('\n')) if self.source else 0,
+ "parameter_count": len(self.parameters),
+ "nesting_depth": self._calculate_nesting_depth()
+ }
+
+ return result
+
+ def _calculate_cyclomatic_complexity(self) -> int:
+ """
+ Calculate cyclomatic complexity of the function.
+
+ Returns:
+ Cyclomatic complexity score
+ """
+ if not self.source:
+ return 1
+
+ complexity = 1 # Base complexity
+
+ # Count branching statements
+ complexity += self.source.count('if ')
+ complexity += self.source.count('elif ')
+ complexity += self.source.count('for ')
+ complexity += self.source.count('while ')
+ complexity += self.source.count('except:')
+ complexity += self.source.count('except ')
+ complexity += self.source.count(' and ')
+ complexity += self.source.count(' or ')
+ complexity += self.source.count('case ')
+
+ return complexity
+
+ def _calculate_nesting_depth(self) -> int:
+ """
+ Calculate the maximum nesting depth of the function.
+
+ Returns:
+ Maximum nesting depth
+ """
+ if not self.source:
+ return 0
+
+ lines = self.source.split('\n')
+ max_indent = 0
+
+ for line in lines:
+ if line.strip(): # Skip empty lines
+ indent = len(line) - len(line.lstrip())
+ max_indent = max(max_indent, indent)
+
+ # Estimate nesting depth (rough approximation)
+ est_nesting_depth = max_indent // 4 # Assuming 4 spaces per indent level
+
+ return est_nesting_depth
+
+ def analyze_parameters(self) -> Dict[str, Any]:
+ """
+ Analyze function parameters.
+
+ Returns:
+ Dictionary containing parameter analysis
+ """
+ result = {
+ "total_parameters": len(self.parameters),
+ "typed_parameters": 0,
+ "untyped_parameters": 0,
+ "default_parameters": 0,
+ "parameter_details": []
+ }
+
+ for param in self.parameters:
+ param_info = {
+ "name": param.name if hasattr(param, 'name') else str(param),
+ "type": str(param.type) if hasattr(param, 'type') and param.type else None,
+ "has_default": param.has_default if hasattr(param, 'has_default') else False,
+ "position": param.position if hasattr(param, 'position') else None
+ }
+
+ # Update counts
+ if param_info["type"]:
+ result["typed_parameters"] += 1
+ else:
+ result["untyped_parameters"] += 1
+
+ if param_info["has_default"]:
+ result["default_parameters"] += 1
+
+ result["parameter_details"].append(param_info)
+
+ return result
+
+ def analyze_return_type(self) -> Dict[str, Any]:
+ """
+ Analyze function return type.
+
+ Returns:
+ Dictionary containing return type analysis
+ """
+ return {
+ "has_return_type": self.return_type is not None,
+ "return_type": str(self.return_type) if self.return_type else None,
+ "return_type_category": self._categorize_return_type()
+ }
+
+ def _categorize_return_type(self) -> str:
+ """
+ Categorize the return type.
+
+ Returns:
+ Category of the return type
+ """
+ if not self.return_type:
+ return "untyped"
+
+ type_str = str(self.return_type).lower()
+
+ if "none" in type_str:
+ return "none"
+ elif "bool" in type_str:
+ return "boolean"
+ elif "int" in type_str or "float" in type_str or "number" in type_str:
+ return "numeric"
+ elif "str" in type_str or "string" in type_str:
+ return "string"
+ elif "list" in type_str or "array" in type_str:
+ return "list"
+ elif "dict" in type_str or "map" in type_str:
+ return "dictionary"
+ elif "tuple" in type_str:
+ return "tuple"
+ elif "union" in type_str or "|" in type_str:
+ return "union"
+ elif "callable" in type_str or "function" in type_str:
+ return "callable"
+ else:
+ return "complex"
+
+ def analyze_call_sites(self) -> Dict[str, Any]:
+ """
+ Analyze function call sites.
+
+ Returns:
+ Dictionary containing call site analysis
+ """
+ result = {
+ "total_call_sites": len(self.call_sites),
+ "calls_by_function": {},
+ "calls_by_file": {}
+ }
+
+ for call_site in self.call_sites:
+ # Get called function
+ called_function = None
+ if hasattr(call_site, 'called_function'):
+ called_function = call_site.called_function
+
+ # Skip if no called function
+ if not called_function:
+ continue
+
+ # Get function name
+ func_name = called_function.name if hasattr(called_function, 'name') else str(called_function)
+
+ # Update calls by function
+ if func_name not in result["calls_by_function"]:
+ result["calls_by_function"][func_name] = 0
+ result["calls_by_function"][func_name] += 1
+
+ # Get file
+ file_path = "unknown"
+ if hasattr(call_site, 'file') and hasattr(call_site.file, 'file_path'):
+ file_path = call_site.file.file_path
+
+ # Update calls by file
+ if file_path not in result["calls_by_file"]:
+ result["calls_by_file"][file_path] = 0
+ result["calls_by_file"][file_path] += 1
+
+ return result
+
+ def analyze_usage_patterns(self) -> Dict[str, Any]:
+ """
+ Analyze function usage patterns.
+
+ Returns:
+ Dictionary containing usage pattern analysis
+ """
+ result = {
+ "uses_async_await": self.is_async or "await " in self.source,
+ "uses_exceptions": "try:" in self.source or "except:" in self.source or "except " in self.source,
+ "uses_loops": "for " in self.source or "while " in self.source,
+ "uses_conditionals": "if " in self.source or "elif " in self.source or "else:" in self.source,
+ "uses_comprehensions": "[" in self.source and "for" in self.source and "]" in self.source,
+ "uses_generators": "yield " in self.source,
+ "uses_decorators": hasattr(self.function, 'decorators') and bool(self.function.decorators)
+ }
+
+ return result
+
+ def to_dict(self) -> Dict[str, Any]:
+ """
+ Convert the function context to a dictionary.
+
+ Returns:
+ Dictionary representation of the function context
+ """
+ return {
+ "name": self.name,
+ "file_path": self.file_path,
+ "line": self.line,
+ "is_async": self.is_async,
+ "parameters": [param.name if hasattr(param, 'name') else str(param) for param in self.parameters],
+ "return_type": str(self.return_type) if self.return_type else None,
+ "complexity": self._calculate_cyclomatic_complexity(),
+ "line_count": len(self.source.split('\n')) if self.source else 0,
+ "nesting_depth": self._calculate_nesting_depth(),
+ "local_variables": [local.name if hasattr(local, 'name') else str(local) for local in self.locals],
+ "call_sites_count": len(self.call_sites)
+ }
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/context/graph/__init__.py b/codegen-on-oss/codegen_on_oss/analyzers/context/graph/__init__.py
new file mode 100644
index 000000000..99d6cc83f
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/context/graph/__init__.py
@@ -0,0 +1,179 @@
+"""
+Graph Context Module
+
+This module provides utilities for working with graph representations
+of code, including building, traversing, exporting, and visualizing graphs.
+"""
+
+from typing import Dict, List, Any, Optional
+
+import networkx as nx
+
+def build_dependency_graph(edges: List[Dict[str, Any]]) -> nx.DiGraph:
+ """
+ Build a dependency graph from a list of edges.
+
+ Args:
+ edges: List of edges, where each edge is a dictionary with
+ 'source', 'target', and optional 'type' keys
+
+ Returns:
+ NetworkX DiGraph representing the dependencies
+ """
+ graph = nx.DiGraph()
+
+ for edge in edges:
+ source = edge.get('source')
+ target = edge.get('target')
+ edge_type = edge.get('type', 'unknown')
+
+ if source and target:
+ graph.add_edge(source, target, type=edge_type)
+
+ return graph
+
+def find_circular_dependencies(graph: nx.DiGraph) -> List[List[str]]:
+ """
+ Find circular dependencies in a graph.
+
+ Args:
+ graph: NetworkX DiGraph to analyze
+
+ Returns:
+ List of cycles, where each cycle is a list of node names
+ """
+ try:
+ return list(nx.simple_cycles(graph))
+ except nx.NetworkXNoCycle:
+ return []
+
+def find_hub_nodes(graph: nx.DiGraph, threshold: int = 5) -> List[str]:
+ """
+ Find hub nodes in a graph (nodes with many connections).
+
+ Args:
+ graph: NetworkX DiGraph to analyze
+ threshold: Minimum number of connections to be considered a hub
+
+ Returns:
+ List of hub node names
+ """
+ hubs = []
+
+ for node in graph.nodes():
+ # Count both incoming and outgoing connections
+ connection_count = graph.in_degree(node) + graph.out_degree(node)
+
+ if connection_count >= threshold:
+ hubs.append(node)
+
+ # Sort by connection count in descending order
+ hubs.sort(key=lambda node: graph.in_degree(node) + graph.out_degree(node), reverse=True)
+
+ return hubs
+
+def calculate_centrality(graph: nx.DiGraph) -> Dict[str, float]:
+ """
+ Calculate centrality for each node in the graph.
+
+ Args:
+ graph: NetworkX DiGraph to analyze
+
+ Returns:
+ Dictionary mapping node names to centrality scores
+ """
+ try:
+ return nx.betweenness_centrality(graph)
+ except:
+ # Fall back to degree centrality if betweenness fails
+ return nx.degree_centrality(graph)
+
+def export_to_dot(graph: nx.DiGraph, filename: Optional[str] = None) -> str:
+ """
+ Export a graph to DOT format.
+
+ Args:
+ graph: NetworkX DiGraph to export
+ filename: File to write DOT to, or None to return as string
+
+ Returns:
+ DOT representation of the graph if filename is None,
+ otherwise returns empty string
+ """
+ try:
+ import pydot
+ from networkx.drawing.nx_pydot import write_dot
+
+ if filename:
+ write_dot(graph, filename)
+ return ""
+ else:
+ # Convert to pydot
+ pydot_graph = nx.nx_pydot.to_pydot(graph)
+ return pydot_graph.to_string()
+
+ except ImportError:
+ # Fallback to basic DOT export if pydot is not available
+ dot = ["digraph G {"]
+
+ # Add nodes
+ for node in graph.nodes():
+ dot.append(f' "{node}";')
+
+ # Add edges
+ for u, v, data in graph.edges(data=True):
+ edge_type = data.get('type', '')
+ edge_str = f' "{u}" -> "{v}"'
+
+ if edge_type:
+ edge_str += f' [label="{edge_type}"]'
+
+ edge_str += ';'
+ dot.append(edge_str)
+
+ dot.append("}")
+ dot_str = "\n".join(dot)
+
+ if filename:
+ with open(filename, 'w') as f:
+ f.write(dot_str)
+ return ""
+ else:
+ return dot_str
+
+def calculate_cohesion(graph: nx.DiGraph, module_nodes: Dict[str, List[str]]) -> Dict[str, float]:
+ """
+ Calculate cohesion for modules in the graph.
+
+ Args:
+ graph: NetworkX DiGraph to analyze
+ module_nodes: Dictionary mapping module names to lists of node names
+
+ Returns:
+ Dictionary mapping module names to cohesion scores
+ """
+ cohesion = {}
+
+ for module, nodes in module_nodes.items():
+ if not nodes:
+ cohesion[module] = 0.0
+ continue
+
+ # Create subgraph for this module
+ module_subgraph = graph.subgraph(nodes)
+
+ # Count internal edges
+ internal_edges = module_subgraph.number_of_edges()
+
+ # Count external edges
+ external_edges = 0
+ for node in nodes:
+ for _, target in graph.out_edges(node):
+ if target not in nodes:
+ external_edges += 1
+
+ # Calculate cohesion as ratio of internal to total edges
+ total_edges = internal_edges + external_edges
+ cohesion[module] = internal_edges / total_edges if total_edges > 0 else 0.0
+
+ return cohesion
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/context_codebase.py b/codegen-on-oss/codegen_on_oss/analyzers/context_codebase.py
new file mode 100644
index 000000000..935752aa0
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/context_codebase.py
@@ -0,0 +1,912 @@
+#!/usr/bin/env python3
+"""
+CodebaseContext Module
+
+This module provides context for codebase analysis, including graph manipulation
+and codebase comparison capabilities. It's particularly useful for PR analysis
+and codebase vs. PR comparisons.
+"""
+
+import os
+import sys
+import tempfile
+import shutil
+import re
+import logging
+from pathlib import Path
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, TypeVar, cast, Callable
+from enum import Enum
+import networkx as nx
+
+try:
+ from codegen.sdk.core.codebase import Codebase
+ from codegen.sdk.codebase.codebase_context import CodebaseContext as SDKCodebaseContext
+ from codegen.configs.models.codebase import CodebaseConfig
+ from codegen.configs.models.secrets import SecretsConfig
+ from codegen.sdk.codebase.config import ProjectConfig
+ from codegen.git.schemas.repo_config import RepoConfig
+ from codegen.git.repo_operator.repo_operator import RepoOperator
+ from codegen.shared.enums.programming_language import ProgrammingLanguage
+ from codegen.sdk.core.file import SourceFile
+ from codegen.sdk.core.directory import Directory
+ from codegen.sdk.core.symbol import Symbol
+ from codegen.sdk.core.function import Function
+ from codegen.sdk.core.class_definition import Class
+ from codegen.sdk.enums import EdgeType, SymbolType
+ from codegen.sdk.codebase.transactions import Transaction
+ from codegen.sdk.codebase.transaction_manager import TransactionManager
+except ImportError:
+ print("Codegen SDK not found. Please install it first.")
+ sys.exit(1)
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+# Global ignore list for files that should be excluded from analysis
+GLOBAL_FILE_IGNORE_LIST = [
+ "__pycache__",
+ ".git",
+ ".github",
+ ".vscode",
+ ".idea",
+ "node_modules",
+ "dist",
+ "build",
+ "venv",
+ ".env",
+ "env",
+ ".DS_Store",
+ "*.pyc",
+ "*.pyo",
+ "*.pyd",
+ "*.so",
+ "*.dll",
+ "*.zip",
+ "*.gz",
+ "*.tar",
+ "*.log",
+]
+
+def get_node_classes():
+ """Return a tuple of classes that represent nodes in the codebase graph."""
+ return (Symbol, Function, Class, Directory, SourceFile)
+
+class CodebaseContext:
+ """
+ Enhanced context for codebase analysis, providing graph manipulation
+ and codebase comparison capabilities.
+
+ This class extends the functionality of the SDK's CodebaseContext
+ with additional methods for PR analysis and codebase comparison.
+ """
+
+ def __init__(
+ self,
+ codebase: Codebase,
+ base_path: Optional[str] = None,
+ pr_branch: Optional[str] = None,
+ base_branch: str = "main",
+ ):
+ """
+ Initialize the CodebaseContext.
+
+ Args:
+ codebase: Codebase instance to analyze
+ base_path: Base path of the codebase
+ pr_branch: PR branch name (if applicable)
+ base_branch: Base branch name
+ """
+ self.codebase = codebase
+ self.base_path = base_path or ""
+ self.pr_branch = pr_branch
+ self.base_branch = base_branch
+
+ # Graph for storing codebase structure
+ self._graph = nx.DiGraph()
+
+ # Transaction management
+ self.transaction_manager = TransactionManager()
+
+ # Cache for nodes and files
+ self._node_cache = {}
+ self._file_cache = {}
+ self._directory_cache = {}
+
+ # Initialize the graph
+ self.build_graph()
+
+ def __repr__(self) -> str:
+ """String representation of the CodebaseContext."""
+ return f"CodebaseContext(nodes={len(self.nodes)}, edges={len(self.edges)}, files={len(self._file_cache)})"
+
+ @property
+ def _graph(self) -> nx.DiGraph:
+ """Get the graph."""
+ return self.__graph
+
+ @_graph.setter
+ def _graph(self, graph: nx.DiGraph) -> None:
+ """Set the graph."""
+ self.__graph = graph
+
+ def build_graph(self) -> None:
+ """Build the codebase graph."""
+ # Clear existing graph and caches
+ self._graph = nx.DiGraph()
+ self._node_cache = {}
+ self._file_cache = {}
+ self._directory_cache = {}
+
+ # Add files to the graph
+ for file in self.codebase.files:
+ if any(re.match(pattern, file.path) for pattern in GLOBAL_FILE_IGNORE_LIST):
+ continue
+
+ self.add_node(file)
+
+ # Cache file for faster access
+ self._file_cache[str(file.path)] = file
+
+ # Add symbols to the graph
+ for symbol in self.codebase.symbols:
+ self.add_node(symbol)
+
+ # Connect symbol to its file
+ if hasattr(symbol, 'file') and symbol.file:
+ self.add_edge(symbol.file, symbol, EdgeType.CONTAINS)
+
+ # Connect class members to their class
+ if hasattr(symbol, 'parent') and symbol.parent:
+ self.add_edge(symbol.parent, symbol, EdgeType.CONTAINS)
+
+ # Build directory tree
+ self.build_directory_tree()
+
+ # Compute dependencies
+ self._compute_dependencies()
+
+ def apply_diffs(self, diffs: Dict[str, Any]) -> None:
+ """
+ Apply diffs to the codebase.
+
+ Args:
+ diffs: Dictionary of file paths to diff content
+ """
+ for file_path, diff in diffs.items():
+ # Process each file's diff
+ self._process_diff_files({file_path: diff})
+
+ # Rebuild the graph with the applied diffs
+ self.build_graph()
+
+ def _reset_files(self) -> None:
+ """Reset any modified files to their original state."""
+ # Clear file cache
+ self._file_cache = {}
+
+ # Re-populate cache from codebase
+ for file in self.codebase.files:
+ self._file_cache[str(file.path)] = file
+
+ def reset_codebase(self) -> None:
+ """Reset the codebase to its original state."""
+ # Reset files
+ self._reset_files()
+
+ # Rebuild the graph
+ self.build_graph()
+
+ def undo_applied_diffs(self) -> None:
+ """Undo all applied diffs."""
+ self._revert_diffs()
+ self.build_graph()
+
+ def _revert_diffs(self) -> None:
+ """Revert any applied diffs."""
+ # Use transaction manager to revert all transactions
+ self.transaction_manager.revert_all()
+
+ # Reset files
+ self._reset_files()
+
+ def save_commit(self, message: str) -> str:
+ """
+ Save changes as a commit.
+
+ Args:
+ message: Commit message
+
+ Returns:
+ Commit hash
+ """
+ # Use repo operator to commit changes
+ if hasattr(self.codebase, 'repo_operator'):
+ return self.codebase.repo_operator.commit(message)
+ return ""
+
+ def prune_graph(self) -> None:
+ """Remove any nodes that no longer exist in the codebase."""
+ nodes_to_remove = []
+
+ for node in self.nodes:
+ if hasattr(node, 'path'):
+ path = str(node.path)
+
+ # Check if file still exists
+ if isinstance(node, SourceFile) and path not in self._file_cache:
+ nodes_to_remove.append(node)
+
+ # Check if directory still exists
+ elif isinstance(node, Directory) and path not in self._directory_cache:
+ nodes_to_remove.append(node)
+
+ # Check if symbol's file still exists
+ elif hasattr(node, 'file') and node.file:
+ file_path = str(node.file.path)
+ if file_path not in self._file_cache:
+ nodes_to_remove.append(node)
+
+ # Remove nodes
+ for node in nodes_to_remove:
+ self.remove_node(node)
+
+ def build_directory_tree(self) -> None:
+ """Build the directory tree from the files."""
+ directories = {}
+
+ for file in self._file_cache.values():
+ path = file.path
+ parent_dir = path.parent
+
+ # Create directory nodes
+ current_dir = parent_dir
+ while str(current_dir) != ".":
+ dir_path = str(current_dir)
+
+ if dir_path not in directories:
+ dir_node = Directory(current_dir)
+ directories[dir_path] = dir_node
+ self.add_node(dir_node)
+ self._directory_cache[dir_path] = dir_node
+
+ # Connect to parent directory
+ parent_path = str(current_dir.parent)
+ if parent_path != "." and parent_path in directories:
+ parent_node = directories[parent_path]
+ self.add_edge(parent_node, dir_node, EdgeType.CONTAINS)
+
+ # Connect file to directory
+ if str(current_dir) == str(parent_dir):
+ self.add_edge(directories[dir_path], file, EdgeType.CONTAINS)
+
+ current_dir = current_dir.parent
+ if str(current_dir) == ".":
+ break
+
+ def get_directory(self, path: Union[str, Path]) -> Optional[Directory]:
+ """
+ Get a directory node from the graph.
+
+ Args:
+ path: Directory path
+
+ Returns:
+ Directory node or None if not found
+ """
+ path_str = str(path)
+
+ # Check cache first
+ if path_str in self._directory_cache:
+ return self._directory_cache[path_str]
+
+ # Search for the directory in the graph
+ for node in self.nodes:
+ if isinstance(node, Directory) and str(node.path) == path_str:
+ self._directory_cache[path_str] = node
+ return node
+
+ return None
+
+ def _process_diff_files(self, diff_files: Dict[str, Any]) -> None:
+ """
+ Process diff files and apply changes to the codebase.
+
+ Args:
+ diff_files: Dictionary mapping file paths to diff content
+ """
+ for file_path, diff_content in diff_files.items():
+ file = self.get_file(file_path)
+
+ if file:
+ # Create a transaction for this change
+ transaction = Transaction(file, diff_content)
+
+ # Apply the transaction
+ self.transaction_manager.apply(transaction)
+ else:
+ # Handle new file creation
+ if isinstance(diff_content, str):
+ # Create new file
+ new_file = self.add_single_file(file_path, diff_content)
+
+ if new_file:
+ # Add to cache
+ self._file_cache[file_path] = new_file
+
+ def _compute_dependencies(self) -> None:
+ """Compute dependencies between symbols."""
+ # Process imports to create dependency edges
+ for file in self._file_cache.values():
+ if hasattr(file, 'imports'):
+ for import_item in file.imports:
+ imported_symbol = None
+
+ # Try to resolve the import
+ if hasattr(import_item, 'resolved_symbol') and import_item.resolved_symbol:
+ imported_symbol = import_item.resolved_symbol
+ elif hasattr(import_item, 'name'):
+ # Try to find the symbol by name
+ for symbol in self.codebase.symbols:
+ if hasattr(symbol, 'name') and symbol.name == import_item.name:
+ imported_symbol = symbol
+ break
+
+ if imported_symbol:
+ # Create dependency edge
+ self.add_edge(file, imported_symbol, EdgeType.IMPORTS)
+
+ # Process function calls to create call edges
+ for func in self.codebase.functions:
+ if hasattr(func, 'calls'):
+ for call in func.calls:
+ called_func = None
+
+ # Try to resolve the call
+ if hasattr(call, 'resolved_symbol') and call.resolved_symbol:
+ called_func = call.resolved_symbol
+ elif hasattr(call, 'name'):
+ # Try to find the function by name
+ for other_func in self.codebase.functions:
+ if hasattr(other_func, 'name') and other_func.name == call.name:
+ called_func = other_func
+ break
+
+ if called_func:
+ # Create call edge
+ self.add_edge(func, called_func, EdgeType.CALLS)
+
+ def build_subgraph(self, nodes: List[Any]) -> nx.DiGraph:
+ """
+ Build a subgraph containing only the specified nodes.
+
+ Args:
+ nodes: List of nodes to include in the subgraph
+
+ Returns:
+ Subgraph as a new DiGraph
+ """
+ subgraph = nx.DiGraph()
+
+ # Add nodes
+ for node in nodes:
+ if self.has_node(node):
+ subgraph.add_node(node)
+
+ # Add edges
+ for u, v, data in self.edges(data=True):
+ if subgraph.has_node(u) and subgraph.has_node(v):
+ subgraph.add_edge(u, v, **data)
+
+ return subgraph
+
+ def get_node(self, id_or_obj: Any) -> Optional[Any]:
+ """
+ Get a node from the graph by ID or object.
+
+ Args:
+ id_or_obj: Node ID or object
+
+ Returns:
+ Node or None if not found
+ """
+ if self.has_node(id_or_obj):
+ return id_or_obj
+
+ # Check if it's a string path
+ if isinstance(id_or_obj, str):
+ # Try to find file or directory
+ if id_or_obj in self._file_cache:
+ return self._file_cache[id_or_obj]
+
+ if id_or_obj in self._directory_cache:
+ return self._directory_cache[id_or_obj]
+
+ # Try to find by name
+ for node in self.nodes:
+ if hasattr(node, 'name') and node.name == id_or_obj:
+ return node
+
+ if hasattr(node, 'path') and str(node.path) == id_or_obj:
+ return node
+
+ return None
+
+ def get_nodes(self, node_type: Optional[Any] = None) -> List[Any]:
+ """
+ Get all nodes of a specific type.
+
+ Args:
+ node_type: Type of nodes to return
+
+ Returns:
+ List of nodes
+ """
+ if node_type is None:
+ return list(self.nodes)
+
+ return [node for node in self.nodes if isinstance(node, node_type)]
+
+ def get_edges(self, edge_type: Optional[Any] = None) -> List[Tuple[Any, Any, Dict[str, Any]]]:
+ """
+ Get all edges of a specific type.
+
+ Args:
+ edge_type: Type of edges to return
+
+ Returns:
+ List of edges as (u, v, data) tuples
+ """
+ edges = list(self.edges(data=True))
+
+ if edge_type is None:
+ return edges
+
+ return [
+ (u, v, data) for u, v, data in edges
+ if 'type' in data and data['type'] == edge_type
+ ]
+
+ def get_file(self, path: Union[str, Path]) -> Optional[SourceFile]:
+ """
+ Get a file from the codebase.
+
+ Args:
+ path: File path
+
+ Returns:
+ SourceFile or None if not found
+ """
+ path_str = str(path)
+
+ # Check cache first
+ if path_str in self._file_cache:
+ return self._file_cache[path_str]
+
+ # Try to get raw file
+ file = self._get_raw_file_from_path(path_str)
+
+ if file:
+ self._file_cache[path_str] = file
+
+ return file
+
+ def _get_raw_file_from_path(self, path: str) -> Optional[SourceFile]:
+ """
+ Get a file from the codebase by its path.
+
+ Args:
+ path: File path
+
+ Returns:
+ SourceFile or None if not found
+ """
+ # Try to get file from codebase
+ if hasattr(self.codebase, 'get_file'):
+ return self.codebase.get_file(path)
+
+ # Fallback to searching in files
+ for file in self.codebase.files:
+ if str(file.path) == path:
+ return file
+
+ return None
+
+ def get_external_module(self, name: str) -> Optional[Any]:
+ """
+ Get an external module from the codebase.
+
+ Args:
+ name: Module name
+
+ Returns:
+ External module or None if not found
+ """
+ if hasattr(self.codebase, 'get_external_module'):
+ return self.codebase.get_external_module(name)
+
+ # Fallback: search through external modules
+ if hasattr(self.codebase, 'external_modules'):
+ for module in self.codebase.external_modules:
+ if hasattr(module, 'name') and module.name == name:
+ return module
+
+ return None
+
+ def add_node(self, node: Any) -> None:
+ """
+ Add a node to the graph.
+
+ Args:
+ node: Node to add
+ """
+ if not self.has_node(node):
+ self._graph.add_node(node)
+
+ # Add to cache if applicable
+ if hasattr(node, 'path'):
+ path_str = str(node.path)
+
+ if isinstance(node, SourceFile):
+ self._file_cache[path_str] = node
+ elif isinstance(node, Directory):
+ self._directory_cache[path_str] = node
+
+ def add_child(self, parent: Any, child: Any, edge_type: Optional[Any] = None) -> None:
+ """
+ Add a child node to a parent node.
+
+ Args:
+ parent: Parent node
+ child: Child node
+ edge_type: Type of edge
+ """
+ self.add_node(parent)
+ self.add_node(child)
+
+ edge_data = {}
+ if edge_type is not None:
+ edge_data['type'] = edge_type
+
+ self.add_edge(parent, child, edge_type)
+
+ def has_node(self, node: Any) -> bool:
+ """
+ Check if a node exists in the graph.
+
+ Args:
+ node: Node to check
+
+ Returns:
+ True if the node exists, False otherwise
+ """
+ return self._graph.has_node(node)
+
+ def has_edge(self, u: Any, v: Any) -> bool:
+ """
+ Check if an edge exists in the graph.
+
+ Args:
+ u: Source node
+ v: Target node
+
+ Returns:
+ True if the edge exists, False otherwise
+ """
+ return self._graph.has_edge(u, v)
+
+ def add_edge(self, u: Any, v: Any, edge_type: Optional[Any] = None) -> None:
+ """
+ Add an edge to the graph.
+
+ Args:
+ u: Source node
+ v: Target node
+ edge_type: Type of edge
+ """
+ if not self.has_node(u):
+ self.add_node(u)
+
+ if not self.has_node(v):
+ self.add_node(v)
+
+ edge_data = {}
+ if edge_type is not None:
+ edge_data['type'] = edge_type
+
+ self._graph.add_edge(u, v, **edge_data)
+
+ def add_edges(self, edge_list: List[Tuple[Any, Any, Dict[str, Any]]]) -> None:
+ """
+ Add multiple edges to the graph.
+
+ Args:
+ edge_list: List of (u, v, data) tuples
+ """
+ for u, v, data in edge_list:
+ if not self.has_node(u):
+ self.add_node(u)
+
+ if not self.has_node(v):
+ self.add_node(v)
+
+ self._graph.add_edge(u, v, **data)
+
+ @property
+ def nodes(self) -> List[Any]:
+ """Get all nodes in the graph."""
+ return list(self._graph.nodes())
+
+ @property
+ def edges(self) -> Callable:
+ """Get all edges in the graph."""
+ return self._graph.edges
+
+ def predecessor(self, node: Any) -> Optional[Any]:
+ """
+ Get the predecessor of a node.
+
+ Args:
+ node: Node to get predecessor for
+
+ Returns:
+ Predecessor node or None if not found
+ """
+ preds = list(self.predecessors(node))
+ return preds[0] if preds else None
+
+ def predecessors(self, node: Any) -> List[Any]:
+ """
+ Get all predecessors of a node.
+
+ Args:
+ node: Node to get predecessors for
+
+ Returns:
+ List of predecessor nodes
+ """
+ if not self.has_node(node):
+ return []
+
+ return list(self._graph.predecessors(node))
+
+ def successors(self, node: Any) -> List[Any]:
+ """
+ Get all successors of a node.
+
+ Args:
+ node: Node to get successors for
+
+ Returns:
+ List of successor nodes
+ """
+ if not self.has_node(node):
+ return []
+
+ return list(self._graph.successors(node))
+
+ def get_edge_data(self, u: Any, v: Any) -> Dict[str, Any]:
+ """
+ Get the data for an edge.
+
+ Args:
+ u: Source node
+ v: Target node
+
+ Returns:
+ Edge data dictionary
+ """
+ if not self.has_edge(u, v):
+ return {}
+
+ return self._graph.get_edge_data(u, v)
+
+ def in_edges(self, node: Any, data: bool = False) -> List[Any]:
+ """
+ Get all incoming edges for a node.
+
+ Args:
+ node: Node to get incoming edges for
+ data: Whether to include edge data
+
+ Returns:
+ List of incoming edges
+ """
+ if not self.has_node(node):
+ return []
+
+ return list(self._graph.in_edges(node, data=data))
+
+ def out_edges(self, node: Any, data: bool = False) -> List[Any]:
+ """
+ Get all outgoing edges for a node.
+
+ Args:
+ node: Node to get outgoing edges for
+ data: Whether to include edge data
+
+ Returns:
+ List of outgoing edges
+ """
+ if not self.has_node(node):
+ return []
+
+ return list(self._graph.out_edges(node, data=data))
+
+ def remove_node(self, node: Any) -> None:
+ """
+ Remove a node from the graph.
+
+ Args:
+ node: Node to remove
+ """
+ if self.has_node(node):
+ self._graph.remove_node(node)
+
+ # Remove from cache if applicable
+ if hasattr(node, 'path'):
+ path_str = str(node.path)
+
+ if isinstance(node, SourceFile) and path_str in self._file_cache:
+ del self._file_cache[path_str]
+ elif isinstance(node, Directory) and path_str in self._directory_cache:
+ del self._directory_cache[path_str]
+
+ def remove_edge(self, u: Any, v: Any) -> None:
+ """
+ Remove an edge from the graph.
+
+ Args:
+ u: Source node
+ v: Target node
+ """
+ if self.has_edge(u, v):
+ self._graph.remove_edge(u, v)
+
+ def to_absolute(self, path: Union[str, Path]) -> str:
+ """
+ Convert a relative path to an absolute path.
+
+ Args:
+ path: Relative path
+
+ Returns:
+ Absolute path
+ """
+ path_str = str(path)
+
+ if os.path.isabs(path_str):
+ return path_str
+
+ return os.path.join(self.base_path, path_str)
+
+ def to_relative(self, path: Union[str, Path]) -> str:
+ """
+ Convert an absolute path to a relative path.
+
+ Args:
+ path: Absolute path
+
+ Returns:
+ Relative path
+ """
+ path_str = str(path)
+
+ if not os.path.isabs(path_str):
+ return path_str
+
+ return os.path.relpath(path_str, self.base_path)
+
+ def is_subdir(self, parent: Union[str, Path], child: Union[str, Path]) -> bool:
+ """
+ Check if a directory is a subdirectory of another.
+
+ Args:
+ parent: Parent directory
+ child: Child directory
+
+ Returns:
+ True if child is a subdirectory of parent, False otherwise
+ """
+ parent_str = str(parent)
+ child_str = str(child)
+
+ parent_abs = os.path.abspath(parent_str)
+ child_abs = os.path.abspath(child_str)
+
+ return child_abs.startswith(parent_abs)
+
+ def commit_transactions(self, message: str) -> str:
+ """
+ Commit all pending transactions.
+
+ Args:
+ message: Commit message
+
+ Returns:
+ Commit hash
+ """
+ # Apply all transactions and commit
+ self.transaction_manager.apply_all()
+
+ return self.save_commit(message)
+
+ def add_single_file(self, path: str, content: str) -> Optional[SourceFile]:
+ """
+ Add a single file to the codebase.
+
+ Args:
+ path: File path
+ content: File content
+
+ Returns:
+ SourceFile or None if creation failed
+ """
+ # Add file to the transaction manager
+ transaction = Transaction.create_new_file(path, content)
+ self.transaction_manager.add(transaction)
+
+ # Initialize file in codebase
+ if hasattr(self.codebase, 'add_file'):
+ return self.codebase.add_file(path, content)
+
+ return None
+
+ @property
+ def session(self) -> Any:
+ """Get the transaction session."""
+ return self.transaction_manager.session
+
+ def remove_directory(self, path: Union[str, Path]) -> None:
+ """
+ Remove a directory and all its contents from the codebase.
+
+ Args:
+ path: Directory path
+ """
+ path_str = str(path)
+ dir_node = self.get_directory(path_str)
+
+ if not dir_node:
+ return
+
+ # Get all files in the directory
+ files_to_remove = []
+ for file in self._file_cache.values():
+ if self.is_subdir(path_str, file.path):
+ files_to_remove.append(file)
+
+ # Remove files
+ for file in files_to_remove:
+ file_path = str(file.path)
+
+ # Create transaction for removal
+ transaction = Transaction.delete_file(file_path)
+ self.transaction_manager.add(transaction)
+
+ # Remove from cache
+ if file_path in self._file_cache:
+ del self._file_cache[file_path]
+
+ # Remove from graph
+ if self.has_node(file):
+ self.remove_node(file)
+
+ # Remove directory from cache
+ if path_str in self._directory_cache:
+ del self._directory_cache[path_str]
+
+ # Remove directory node from graph
+ if self.has_node(dir_node):
+ self.remove_node(dir_node)
+
+ @property
+ def ts_declassify(self) -> Optional[Callable]:
+ """Get TypeScript declassify function if available."""
+ if hasattr(self.codebase, 'ts_declassify'):
+ return self.codebase.ts_declassify
+ return None
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/current_code_codebase.py b/codegen-on-oss/codegen_on_oss/analyzers/current_code_codebase.py
new file mode 100644
index 000000000..137081efe
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/current_code_codebase.py
@@ -0,0 +1,230 @@
+import importlib
+import os
+from pathlib import Path
+from typing import Optional, TypedDict, Union, List
+
+from codegen.shared.decorators.docs import DocumentedObject, apidoc_objects, no_apidoc_objects, py_apidoc_objects, ts_apidoc_objects
+from codegen.sdk.core.codebase import Codebase, CodebaseType
+from codegen.sdk.codebase.config import ProjectConfig
+from codegen.configs.models.codebase import CodebaseConfig
+from codegen.configs.models.secrets import SecretsConfig
+from codegen.git.repo_operator.repo_operator import RepoOperator
+from codegen.git.schemas.repo_config import RepoConfig
+from codegen.shared.enums.programming_language import ProgrammingLanguage
+from codegen.shared.logging.get_logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_repo_path() -> str:
+ """Returns the base directory path of the repository being analyzed.
+ If not explicitly provided, defaults to the current directory.
+ """
+ # Default to current directory if not specified
+ return os.getcwd()
+
+
+def get_base_path(repo_path: str) -> str:
+ """Determines the base path within the repository.
+ For monorepos this might be a subdirectory, for simple repos it's the root.
+ """
+ # Check if there's a src directory, which is a common pattern
+ if os.path.isdir(os.path.join(repo_path, "src")):
+ return "src"
+ return ""
+
+
+def get_selected_codebase(
+ repo_path: Optional[str] = None,
+ base_path: Optional[str] = None,
+ config: Optional[CodebaseConfig] = None,
+ secrets: Optional[SecretsConfig] = None,
+ subdirectories: Optional[List[str]] = None,
+ programming_language: Optional[ProgrammingLanguage] = None
+) -> CodebaseType:
+ """Returns a Codebase instance for the selected repository.
+
+ Parameters:
+ repo_path: Path to the repository
+ base_path: Base directory within the repository where code is located
+ config: CodebaseConfig instance for customizing codebase behavior
+ secrets: SecretsConfig for any credentials needed
+ subdirectories: List of subdirectories to include in the analysis
+ programming_language: Primary programming language of the codebase
+
+ Returns:
+ A Codebase instance initialized with the provided parameters
+ """
+ if not repo_path:
+ repo_path = get_repo_path()
+
+ if not base_path:
+ base_path = get_base_path(repo_path)
+
+ logger.info(f"Creating codebase from repo at: {repo_path} with base_path {base_path}")
+
+ # Set up repository config
+ repo_config = RepoConfig.from_repo_path(repo_path)
+ repo_config.respect_gitignore = True # Respect gitignore by default
+ op = RepoOperator(repo_config=repo_config, bot_commit=False)
+
+ # Use provided config or create a new one
+ config = (config or CodebaseConfig()).model_copy(update={"base_path": base_path})
+
+ # Determine the programming language if not provided
+ if not programming_language:
+ # Default to Python, but try to detect from files
+ programming_language = ProgrammingLanguage.PYTHON
+ # TODO: Add language detection logic if needed
+
+ # Create project config
+ projects = [
+ ProjectConfig(
+ repo_operator=op,
+ programming_language=programming_language,
+ subdirectories=subdirectories,
+ base_path=base_path
+ )
+ ]
+
+ # Create and return codebase
+ codebase = Codebase(projects=projects, config=config, secrets=secrets)
+ return codebase
+
+
+def import_modules_from_path(directory_path: str, package_prefix: str = ""):
+ """Imports all Python modules from the given directory path.
+
+ This is used to collect all documented objects from the modules.
+
+ Parameters:
+ directory_path: Path to the directory containing Python modules
+ package_prefix: Prefix to use for module imports (e.g., 'mypackage.')
+ """
+ directory = Path(directory_path)
+ if not directory.exists() or not directory.is_dir():
+ logger.warning(f"Directory does not exist: {directory_path}")
+ return
+
+ for file in directory.rglob("*.py"):
+ if "__init__" in file.name or "braintrust_evaluator" in file.name:
+ continue
+
+ try:
+ # Convert path to module name
+ relative_path = file.relative_to(directory)
+ module_name = package_prefix + str(relative_path).replace("/", ".").removesuffix(".py")
+
+ # Import the module
+ importlib.import_module(module_name)
+ logger.debug(f"Successfully imported module: {module_name}")
+ except Exception as e:
+ logger.error(f"Error importing {module_name}: {e}")
+
+
+class DocumentedObjects(TypedDict):
+ """Type definition for the documented objects collection."""
+ apidoc: list[DocumentedObject]
+ ts_apidoc: list[DocumentedObject]
+ py_apidoc: list[DocumentedObject]
+ no_apidoc: list[DocumentedObject]
+
+
+def get_documented_objects(
+ repo_path: Optional[str] = None,
+ package_prefix: str = "",
+ import_paths: Optional[List[str]] = None
+) -> DocumentedObjects:
+ """Get all objects decorated with API documentation decorators.
+
+ This function imports modules from the specified paths and collects
+ objects decorated with apidoc, py_apidoc, ts_apidoc, and no_apidoc.
+
+ Parameters:
+ repo_path: Path to the repository root
+ package_prefix: Prefix to use for importing modules
+ import_paths: List of paths to import from
+
+ Returns:
+ A dictionary containing the collected documented objects
+ """
+ if not repo_path:
+ repo_path = get_repo_path()
+
+ if not import_paths:
+ # Default to importing from common directories
+ base_path = get_base_path(repo_path)
+ import_paths = [
+ os.path.join(repo_path, base_path),
+ os.path.join(repo_path, base_path, "codegen") if base_path else os.path.join(repo_path, "codegen"),
+ os.path.join(repo_path, base_path, "sdk") if base_path else os.path.join(repo_path, "sdk"),
+ ]
+
+ # Import all modules to populate the documented objects lists
+ for path in import_paths:
+ if os.path.exists(path) and os.path.isdir(path):
+ import_modules_from_path(path, package_prefix)
+
+ # Add core types if they aren't already added
+ from codegen.sdk.core.codebase import CodebaseType, PyCodebaseType, TSCodebaseType
+
+ if CodebaseType not in apidoc_objects:
+ apidoc_objects.append(DocumentedObject(name="CodebaseType", module="codegen.sdk.core.codebase", object=CodebaseType))
+ if PyCodebaseType not in apidoc_objects:
+ apidoc_objects.append(DocumentedObject(name="PyCodebaseType", module="codegen.sdk.core.codebase", object=PyCodebaseType))
+ if TSCodebaseType not in apidoc_objects:
+ apidoc_objects.append(DocumentedObject(name="TSCodebaseType", module="codegen.sdk.core.codebase", object=TSCodebaseType))
+
+ # Return the collected objects
+ return {
+ "apidoc": apidoc_objects,
+ "py_apidoc": py_apidoc_objects,
+ "ts_apidoc": ts_apidoc_objects,
+ "no_apidoc": no_apidoc_objects
+ }
+
+
+def get_codebase_with_docs(
+ repo_path: Optional[str] = None,
+ base_path: Optional[str] = None,
+ config: Optional[CodebaseConfig] = None,
+ secrets: Optional[SecretsConfig] = None,
+ subdirectories: Optional[List[str]] = None,
+ programming_language: Optional[ProgrammingLanguage] = None,
+ package_prefix: str = "",
+ import_paths: Optional[List[str]] = None
+) -> tuple[CodebaseType, DocumentedObjects]:
+ """Convenience function to get both a codebase and its documented objects.
+
+ Parameters:
+ repo_path: Path to the repository
+ base_path: Base directory within the repository
+ config: CodebaseConfig instance
+ secrets: SecretsConfig instance
+ subdirectories: List of subdirectories to include
+ programming_language: Primary programming language of the codebase
+ package_prefix: Prefix for importing modules
+ import_paths: List of paths to import from
+
+ Returns:
+ A tuple containing the Codebase instance and the documented objects
+ """
+ if not repo_path:
+ repo_path = get_repo_path()
+
+ codebase = get_selected_codebase(
+ repo_path=repo_path,
+ base_path=base_path,
+ config=config,
+ secrets=secrets,
+ subdirectories=subdirectories,
+ programming_language=programming_language
+ )
+
+ documented_objects = get_documented_objects(
+ repo_path=repo_path,
+ package_prefix=package_prefix,
+ import_paths=import_paths
+ )
+
+ return codebase, documented_objects
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/dependencies.py b/codegen-on-oss/codegen_on_oss/analyzers/dependencies.py
new file mode 100644
index 000000000..f16e43718
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/dependencies.py
@@ -0,0 +1,860 @@
+#!/usr/bin/env python3
+"""
+Dependency Analysis Module
+
+This module provides comprehensive analysis of codebase dependencies, including
+import relationships, circular dependencies, module coupling, and external
+dependencies analysis.
+"""
+
+import os
+import sys
+import logging
+import networkx as nx
+from datetime import datetime
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, TypeVar, cast
+from pathlib import Path
+from dataclasses import dataclass, field
+
+try:
+ from codegen.sdk.core.codebase import Codebase
+ from codegen.sdk.core.file import SourceFile
+ from codegen.sdk.core.symbol import Symbol
+ from codegen.sdk.core.function import Function
+ from codegen.sdk.enums import EdgeType, SymbolType
+
+ # Import from our own modules
+ from codegen_on_oss.analyzers.issues import Issue, IssueCollection, IssueSeverity, IssueCategory, CodeLocation
+ from codegen_on_oss.analyzers.models.analysis_result import AnalysisResult, DependencyResult
+ from codegen_on_oss.analyzers.codebase_context import CodebaseContext
+except ImportError:
+ print("Codegen SDK or required modules not found.")
+ sys.exit(1)
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+@dataclass
+class ImportDependency:
+ """Represents an import dependency between files or modules."""
+ source: str
+ target: str
+ import_name: Optional[str] = None
+ is_external: bool = False
+ is_relative: bool = False
+ line_number: Optional[int] = None
+
+@dataclass
+class ModuleDependency:
+ """Represents a dependency between modules."""
+ source_module: str
+ target_module: str
+ imports_count: int = 1
+ is_circular: bool = False
+
+@dataclass
+class CircularDependency:
+ """Represents a circular dependency in the codebase."""
+ files: List[str]
+ modules: List[str]
+ length: int
+ cycle_type: str = "import" # Either "import" or "function_call"
+
+@dataclass
+class ModuleCoupling:
+ """Represents coupling metrics for a module."""
+ module: str
+ file_count: int
+ imported_modules: List[str]
+ import_count: int
+ coupling_ratio: float
+ exported_symbols: List[str] = field(default_factory=list)
+
+@dataclass
+class ExternalDependency:
+ """Represents an external dependency."""
+ module_name: str
+ usage_count: int
+ importing_files: List[str] = field(default_factory=list)
+ imported_symbols: List[str] = field(default_factory=list)
+
+class DependencyAnalyzer:
+ """
+ Analyzer for codebase dependencies.
+
+ This analyzer provides comprehensive dependency analysis, including:
+ 1. Import dependencies analysis
+ 2. Circular dependencies detection
+ 3. Module coupling analysis
+ 4. External dependencies analysis
+ 5. Call graph analysis
+ """
+
+ def __init__(
+ self,
+ codebase: Optional[Codebase] = None,
+ context: Optional[CodebaseContext] = None,
+ issue_collection: Optional[IssueCollection] = None
+ ):
+ """
+ Initialize the DependencyAnalyzer.
+
+ Args:
+ codebase: Codebase instance to analyze
+ context: CodebaseContext for advanced graph analysis
+ issue_collection: Collection to store detected issues
+ """
+ self.codebase = codebase
+ self.context = context
+ self.issues = issue_collection or IssueCollection()
+
+ # Analysis results
+ self.import_dependencies: List[ImportDependency] = []
+ self.module_dependencies: List[ModuleDependency] = []
+ self.circular_dependencies: List[CircularDependency] = []
+ self.module_coupling: Dict[str, ModuleCoupling] = {}
+ self.external_dependencies: Dict[str, ExternalDependency] = {}
+
+ # Analysis graphs
+ self.import_graph = nx.DiGraph()
+ self.module_graph = nx.DiGraph()
+ self.call_graph = nx.DiGraph()
+ self.class_hierarchy_graph = nx.DiGraph()
+
+ # Initialize context if needed
+ if self.codebase and not self.context:
+ try:
+ self.context = CodebaseContext(codebase=self.codebase)
+ except Exception as e:
+ logger.error(f"Error initializing context: {e}")
+
+ def analyze(self) -> DependencyResult:
+ """
+ Perform comprehensive dependency analysis on the codebase.
+
+ Returns:
+ DependencyResult containing all dependency analysis results
+ """
+ # Reset results
+ self.import_dependencies = []
+ self.module_dependencies = []
+ self.circular_dependencies = []
+ self.module_coupling = {}
+ self.external_dependencies = {}
+
+ # Initialize graphs
+ self.import_graph = nx.DiGraph()
+ self.module_graph = nx.DiGraph()
+ self.call_graph = nx.DiGraph()
+ self.class_hierarchy_graph = nx.DiGraph()
+
+ # Perform analysis
+ self._analyze_import_dependencies()
+ self._find_circular_dependencies()
+ self._analyze_module_coupling()
+ self._analyze_external_dependencies()
+ self._analyze_call_graph()
+ self._analyze_class_hierarchy()
+
+ # Return structured results
+ return self._create_result()
+
+ def _create_result(self) -> DependencyResult:
+ """Create a structured result object from the analysis results."""
+ # Organize import dependencies
+ import_deps = {
+ "file_dependencies": [
+ {
+ "source_file": dep.source,
+ "target_file": dep.target,
+ "import_name": dep.import_name,
+ "is_external": dep.is_external,
+ "is_relative": dep.is_relative,
+ "line_number": dep.line_number
+ }
+ for dep in self.import_dependencies
+ ],
+ "module_dependencies": [
+ {
+ "source_module": dep.source_module,
+ "target_module": dep.target_module,
+ "imports_count": dep.imports_count,
+ "is_circular": dep.is_circular
+ }
+ for dep in self.module_dependencies
+ ],
+ "stats": {
+ "total_imports": len(self.import_dependencies),
+ "internal_imports": sum(1 for dep in self.import_dependencies if not dep.is_external),
+ "external_imports": sum(1 for dep in self.import_dependencies if dep.is_external),
+ "relative_imports": sum(1 for dep in self.import_dependencies if dep.is_relative)
+ }
+ }
+
+ # Organize circular dependencies
+ circular_deps = {
+ "circular_imports": [
+ {
+ "files": dep.files,
+ "modules": dep.modules,
+ "length": dep.length,
+ "cycle_type": dep.cycle_type
+ }
+ for dep in self.circular_dependencies
+ ],
+ "circular_dependencies_count": len(self.circular_dependencies),
+ "affected_modules": list(set(
+ module
+ for dep in self.circular_dependencies
+ for module in dep.modules
+ ))
+ }
+
+ # Organize module coupling
+ coupling = {
+ "high_coupling_modules": [
+ {
+ "module": module,
+ "coupling_ratio": data.coupling_ratio,
+ "import_count": data.import_count,
+ "file_count": data.file_count,
+ "imported_modules": data.imported_modules
+ }
+ for module, data in self.module_coupling.items()
+ if data.coupling_ratio > 3 # Threshold for high coupling
+ ],
+ "low_coupling_modules": [
+ {
+ "module": module,
+ "coupling_ratio": data.coupling_ratio,
+ "import_count": data.import_count,
+ "file_count": data.file_count,
+ "imported_modules": data.imported_modules
+ }
+ for module, data in self.module_coupling.items()
+ if data.coupling_ratio < 0.5 and data.file_count > 1 # Threshold for low coupling
+ ],
+ "average_coupling": (
+ sum(data.coupling_ratio for data in self.module_coupling.values()) /
+ len(self.module_coupling) if self.module_coupling else 0
+ )
+ }
+
+ # Organize external dependencies
+ external_deps = {
+ "external_modules": list(self.external_dependencies.keys()),
+ "most_used_external_modules": [
+ {
+ "module": module,
+ "usage_count": data.usage_count,
+ "importing_files": data.importing_files[:10] # Limit to 10 files
+ }
+ for module, data in sorted(
+ self.external_dependencies.items(),
+ key=lambda x: x[1].usage_count,
+ reverse=True
+ )[:10] # Top 10 most used
+ ],
+ "total_external_modules": len(self.external_dependencies)
+ }
+
+ # Create result object
+ return DependencyResult(
+ import_dependencies=import_deps,
+ circular_dependencies=circular_deps,
+ module_coupling=coupling,
+ external_dependencies=external_deps,
+ call_graph=self._export_call_graph(),
+ class_hierarchy=self._export_class_hierarchy()
+ )
+
+ def _analyze_import_dependencies(self) -> None:
+ """Analyze import dependencies in the codebase."""
+ if not self.codebase:
+ logger.error("Codebase not initialized")
+ return
+
+ # Process all files to extract import information
+ for file in self.codebase.files:
+ # Skip if no imports
+ if not hasattr(file, 'imports') or not file.imports:
+ continue
+
+ # Get file path
+ file_path = str(file.file_path if hasattr(file, 'file_path') else
+ file.path if hasattr(file, 'path') else file)
+
+ # Extract module name from file path
+ file_parts = file_path.split('/')
+ module_name = '/'.join(file_parts[:-1]) if len(file_parts) > 1 else file_parts[0]
+
+ # Initialize module info in module graph
+ if not self.module_graph.has_node(module_name):
+ self.module_graph.add_node(module_name, files=set([file_path]))
+ else:
+ self.module_graph.nodes[module_name]['files'].add(file_path)
+
+ # Process imports
+ for imp in file.imports:
+ # Get import information
+ import_name = imp.name if hasattr(imp, 'name') else "unknown"
+ line_number = imp.line if hasattr(imp, 'line') else None
+ is_relative = hasattr(imp, 'is_relative') and imp.is_relative
+
+ # Try to get imported file
+ imported_file = None
+ if hasattr(imp, 'resolved_file'):
+ imported_file = imp.resolved_file
+ elif hasattr(imp, 'resolved_symbol') and hasattr(imp.resolved_symbol, 'file'):
+ imported_file = imp.resolved_symbol.file
+
+ # Get imported file path and module
+ if imported_file:
+ # Get imported file path
+ imported_path = str(imported_file.file_path if hasattr(imported_file, 'file_path') else
+ imported_file.path if hasattr(imported_file, 'path') else imported_file)
+
+ # Extract imported module name
+ imported_parts = imported_path.split('/')
+ imported_module = '/'.join(imported_parts[:-1]) if len(imported_parts) > 1 else imported_parts[0]
+
+ # Check if external
+ is_external = hasattr(imported_file, 'is_external') and imported_file.is_external
+
+ # Add to import dependencies
+ self.import_dependencies.append(ImportDependency(
+ source=file_path,
+ target=imported_path,
+ import_name=import_name,
+ is_external=is_external,
+ is_relative=is_relative,
+ line_number=line_number
+ ))
+
+ # Add to import graph
+ self.import_graph.add_edge(file_path, imported_path,
+ name=import_name,
+ external=is_external,
+ relative=is_relative)
+
+ # Add to module graph
+ if not is_external:
+ # Initialize imported module if needed
+ if not self.module_graph.has_node(imported_module):
+ self.module_graph.add_node(imported_module, files=set([imported_path]))
+ else:
+ self.module_graph.nodes[imported_module]['files'].add(imported_path)
+
+ # Add module dependency
+ if module_name != imported_module: # Skip self-imports
+ if self.module_graph.has_edge(module_name, imported_module):
+ # Increment count for existing edge
+ self.module_graph[module_name][imported_module]['count'] += 1
+ else:
+ # Add new edge
+ self.module_graph.add_edge(module_name, imported_module, count=1)
+ else:
+ # Handle external import that couldn't be resolved
+ # Extract module name from import
+ if hasattr(imp, 'module_name') and imp.module_name:
+ external_module = imp.module_name
+ is_external = True
+
+ # Add to import dependencies
+ self.import_dependencies.append(ImportDependency(
+ source=file_path,
+ target=external_module,
+ import_name=import_name,
+ is_external=True,
+ is_relative=is_relative,
+ line_number=line_number
+ ))
+
+ # Track external dependency
+ self._track_external_dependency(external_module, file_path, import_name)
+
+ # Extract module dependencies from module graph
+ for source, target, data in self.module_graph.edges(data=True):
+ self.module_dependencies.append(ModuleDependency(
+ source_module=source,
+ target_module=target,
+ imports_count=data.get('count', 1)
+ ))
+
+ def _find_circular_dependencies(self) -> None:
+ """Find circular dependencies in the codebase."""
+ # Find circular dependencies at the file level
+ try:
+ file_cycles = list(nx.simple_cycles(self.import_graph))
+
+ for cycle in file_cycles:
+ if len(cycle) < 2:
+ continue
+
+ # Get the modules involved in the cycle
+ modules = []
+ for file_path in cycle:
+ parts = file_path.split('/')
+ module = '/'.join(parts[:-1]) if len(parts) > 1 else parts[0]
+ modules.append(module)
+
+ # Create circular dependency
+ circular_dep = CircularDependency(
+ files=cycle,
+ modules=modules,
+ length=len(cycle),
+ cycle_type="import"
+ )
+
+ self.circular_dependencies.append(circular_dep)
+
+ # Create issue for this circular dependency
+ self.issues.add(Issue(
+ message=f"Circular import dependency detected between {len(cycle)} files",
+ severity=IssueSeverity.ERROR,
+ category=IssueCategory.DEPENDENCY_CYCLE,
+ location=CodeLocation(
+ file=cycle[0],
+ line=None
+ ),
+ suggestion="Refactor the code to break the circular dependency, potentially by extracting shared code into a separate module"
+ ))
+
+ # Mark modules as circular in module dependencies
+ for i in range(len(modules)):
+ source = modules[i]
+ target = modules[(i+1) % len(modules)]
+
+ for dep in self.module_dependencies:
+ if dep.source_module == source and dep.target_module == target:
+ dep.is_circular = True
+
+ except Exception as e:
+ logger.error(f"Error finding circular dependencies: {e}")
+
+ # Find circular dependencies at the module level
+ try:
+ module_cycles = list(nx.simple_cycles(self.module_graph))
+
+ for cycle in module_cycles:
+ if len(cycle) < 2:
+ continue
+
+ # Find files for these modules
+ files = []
+ for module in cycle:
+ if self.module_graph.has_node(module) and 'files' in self.module_graph.nodes[module]:
+ module_files = self.module_graph.nodes[module]['files']
+ if module_files:
+ files.append(next(iter(module_files))) # Take first file
+
+ # Only add if we haven't already found this cycle at the file level
+ if not any(set(cycle) == set(dep.modules) for dep in self.circular_dependencies):
+ circular_dep = CircularDependency(
+ files=files,
+ modules=cycle,
+ length=len(cycle),
+ cycle_type="import"
+ )
+
+ self.circular_dependencies.append(circular_dep)
+
+ # Create issue for this circular dependency
+ self.issues.add(Issue(
+ message=f"Circular dependency detected between modules: {', '.join(cycle)}",
+ severity=IssueSeverity.ERROR,
+ category=IssueCategory.DEPENDENCY_CYCLE,
+ location=CodeLocation(
+ file=files[0] if files else cycle[0],
+ line=None
+ ),
+ suggestion="Refactor the code to break the circular dependency"
+ ))
+
+ except Exception as e:
+ logger.error(f"Error finding circular module dependencies: {e}")
+
+ # If we have context, also find circular function call dependencies
+ if self.context and hasattr(self.context, '_graph'):
+ try:
+ # Try to find function call cycles
+ function_nodes = [node for node in self.context.nodes if isinstance(node, Function)]
+
+ # Build function call graph
+ call_graph = nx.DiGraph()
+
+ for func in function_nodes:
+ call_graph.add_node(func)
+
+ # Add call edges
+ for _, target, data in self.context.out_edges(func, data=True):
+ if isinstance(target, Function) and data.get('type') == EdgeType.CALLS:
+ call_graph.add_edge(func, target)
+
+ # Find cycles
+ func_cycles = list(nx.simple_cycles(call_graph))
+
+ for cycle in func_cycles:
+ if len(cycle) < 2:
+ continue
+
+ # Get files and function names
+ files = []
+ function_names = []
+
+ for func in cycle:
+ function_names.append(func.name if hasattr(func, 'name') else str(func))
+ if hasattr(func, 'file') and hasattr(func.file, 'file_path'):
+ files.append(str(func.file.file_path))
+
+ # Get modules
+ modules = []
+ for file_path in files:
+ parts = file_path.split('/')
+ module = '/'.join(parts[:-1]) if len(parts) > 1 else parts[0]
+ modules.append(module)
+
+ # Create circular dependency
+ circular_dep = CircularDependency(
+ files=files,
+ modules=modules,
+ length=len(cycle),
+ cycle_type="function_call"
+ )
+
+ self.circular_dependencies.append(circular_dep)
+
+ # Create issue for this circular dependency
+ self.issues.add(Issue(
+ message=f"Circular function call dependency detected: {' -> '.join(function_names)}",
+ severity=IssueSeverity.ERROR if len(cycle) > 2 else IssueSeverity.WARNING,
+ category=IssueCategory.DEPENDENCY_CYCLE,
+ location=CodeLocation(
+ file=files[0] if files else "unknown",
+ line=None
+ ),
+ suggestion="Refactor the code to eliminate the circular function calls"
+ ))
+
+ except Exception as e:
+ logger.error(f"Error finding circular function call dependencies: {e}")
+
+ def _analyze_module_coupling(self) -> None:
+ """Analyze module coupling in the codebase."""
+ # Use module graph to calculate coupling metrics
+ for module in self.module_graph.nodes():
+ # Get files in this module
+ files = self.module_graph.nodes[module].get('files', set())
+ file_count = len(files)
+
+ # Get imported modules
+ imported_modules = []
+ for _, target in self.module_graph.out_edges(module):
+ imported_modules.append(target)
+
+ # Calculate metrics
+ import_count = len(imported_modules)
+ coupling_ratio = import_count / file_count if file_count > 0 else 0
+
+ # Find exported symbols if we have the context
+ exported_symbols = []
+ if self.context:
+ for file_path in files:
+ file = self.context.get_file(file_path)
+ if file and hasattr(file, 'exports'):
+ for export in file.exports:
+ if hasattr(export, 'name'):
+ exported_symbols.append(export.name)
+
+ # Create module coupling data
+ self.module_coupling[module] = ModuleCoupling(
+ module=module,
+ file_count=file_count,
+ imported_modules=imported_modules,
+ import_count=import_count,
+ coupling_ratio=coupling_ratio,
+ exported_symbols=exported_symbols
+ )
+
+ # Check for high coupling
+ if coupling_ratio > 3 and file_count > 1: # Threshold for high coupling
+ self.issues.add(Issue(
+ message=f"High module coupling: {module} has a coupling ratio of {coupling_ratio:.2f}",
+ severity=IssueSeverity.WARNING,
+ category=IssueCategory.DEPENDENCY_CYCLE,
+ location=CodeLocation(
+ file=next(iter(files)) if files else module,
+ line=None
+ ),
+ suggestion="Consider refactoring to reduce the number of dependencies"
+ ))
+
+ def _analyze_external_dependencies(self) -> None:
+ """Analyze external dependencies in the codebase."""
+ # Collect external dependencies from import dependencies
+ for dep in self.import_dependencies:
+ if dep.is_external:
+ external_name = dep.target
+ import_name = dep.import_name
+ file_path = dep.source
+
+ self._track_external_dependency(external_name, file_path, import_name)
+
+ def _track_external_dependency(self, module_name: str, file_path: str, import_name: Optional[str] = None) -> None:
+ """Track an external dependency."""
+ if module_name not in self.external_dependencies:
+ self.external_dependencies[module_name] = ExternalDependency(
+ module_name=module_name,
+ usage_count=1,
+ importing_files=[file_path],
+ imported_symbols=[import_name] if import_name else []
+ )
+ else:
+ # Update existing dependency
+ self.external_dependencies[module_name].usage_count += 1
+
+ if file_path not in self.external_dependencies[module_name].importing_files:
+ self.external_dependencies[module_name].importing_files.append(file_path)
+
+ if import_name and import_name not in self.external_dependencies[module_name].imported_symbols:
+ self.external_dependencies[module_name].imported_symbols.append(import_name)
+
+ def _analyze_call_graph(self) -> None:
+ """Analyze function call relationships."""
+ # Skip if we don't have context
+ if not self.context:
+ return
+
+ # Find all functions
+ functions = [node for node in self.context.nodes if isinstance(node, Function)]
+
+ # Build call graph
+ for func in functions:
+ func_name = func.name if hasattr(func, 'name') else str(func)
+ func_path = str(func.file.file_path) if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+
+ # Add node to call graph
+ if not self.call_graph.has_node(func_name):
+ self.call_graph.add_node(func_name, path=func_path, function=func)
+
+ # Process outgoing calls
+ if hasattr(func, 'calls'):
+ for call in func.calls:
+ called_func = None
+
+ # Try to resolve the call
+ if hasattr(call, 'resolved_symbol') and call.resolved_symbol:
+ called_func = call.resolved_symbol
+ elif hasattr(call, 'name'):
+ # Try to find by name
+ for other_func in functions:
+ if hasattr(other_func, 'name') and other_func.name == call.name:
+ called_func = other_func
+ break
+
+ if called_func:
+ called_name = called_func.name if hasattr(called_func, 'name') else str(called_func)
+ called_path = str(called_func.file.file_path) if hasattr(called_func, 'file') and hasattr(called_func.file, 'file_path') else "unknown"
+
+ # Add target node if needed
+ if not self.call_graph.has_node(called_name):
+ self.call_graph.add_node(called_name, path=called_path, function=called_func)
+
+ # Add edge to call graph
+ self.call_graph.add_edge(func_name, called_name, source_path=func_path, target_path=called_path)
+
+ # Check for recursive calls
+ if self.call_graph.has_edge(func_name, func_name):
+ self.issues.add(Issue(
+ message=f"Recursive function: {func_name}",
+ severity=IssueSeverity.INFO,
+ category=IssueCategory.DEPENDENCY_CYCLE,
+ location=CodeLocation(
+ file=func_path,
+ line=func.line if hasattr(func, 'line') else None
+ ),
+ symbol=func_name
+ ))
+
+ # Analyze call chains
+ self._analyze_deep_call_chains()
+
+ def _analyze_deep_call_chains(self) -> None:
+ """Analyze deep call chains in the call graph."""
+ # Find entry points (functions not called by others)
+ entry_points = [node for node in self.call_graph.nodes()
+ if self.call_graph.in_degree(node) == 0]
+
+ # Find leaf functions (functions that don't call others)
+ leaf_functions = [node for node in self.call_graph.nodes()
+ if self.call_graph.out_degree(node) == 0]
+
+ # Look for long paths
+ long_chains = []
+
+ for entry in entry_points:
+ for leaf in leaf_functions:
+ try:
+ if nx.has_path(self.call_graph, entry, leaf):
+ path = nx.shortest_path(self.call_graph, entry, leaf)
+
+ if len(path) > 5: # Threshold for "deep" call chains
+ long_chains.append({
+ "entry_point": entry,
+ "length": len(path),
+ "path": path
+ })
+
+ # Create issue for very deep call chains
+ if len(path) > 8: # Threshold for concerning depth
+ entry_path = self.call_graph.nodes[entry].get('path', 'unknown')
+
+ self.issues.add(Issue(
+ message=f"Deep call chain starting from {entry} ({len(path)} levels deep)",
+ severity=IssueSeverity.WARNING,
+ category=IssueCategory.COMPLEXITY,
+ location=CodeLocation(
+ file=entry_path,
+ line=None
+ ),
+ suggestion="Consider refactoring to reduce call depth"
+ ))
+ except nx.NetworkXNoPath:
+ pass
+
+ # Sort chains by length
+ long_chains.sort(key=lambda x: x['length'], reverse=True)
+
+ # Store top 10 longest chains
+ self.long_call_chains = long_chains[:10]
+
+ def _analyze_class_hierarchy(self) -> None:
+ """Analyze class inheritance hierarchy."""
+ # Skip if we don't have context
+ if not self.context:
+ return
+
+ # Find all classes
+ classes = [node for node in self.context.nodes if isinstance(node, Class)]
+
+ # Build inheritance graph
+ for cls in classes:
+ cls_name = cls.name if hasattr(cls, 'name') else str(cls)
+ cls_path = str(cls.file.file_path) if hasattr(cls, 'file') and hasattr(cls.file, 'file_path') else "unknown"
+
+ # Add node to class graph
+ if not self.class_hierarchy_graph.has_node(cls_name):
+ self.class_hierarchy_graph.add_node(cls_name, path=cls_path, class_obj=cls)
+
+ # Process superclasses
+ if hasattr(cls, 'superclasses'):
+ for superclass in cls.superclasses:
+ super_name = superclass.name if hasattr(superclass, 'name') else str(superclass)
+ super_path = str(superclass.file.file_path) if hasattr(superclass, 'file') and hasattr(superclass.file, 'file_path') else "unknown"
+
+ # Add superclass node if needed
+ if not self.class_hierarchy_graph.has_node(super_name):
+ self.class_hierarchy_graph.add_node(super_name, path=super_path, class_obj=superclass)
+
+ # Add inheritance edge
+ self.class_hierarchy_graph.add_edge(cls_name, super_name)
+
+ # Check for deep inheritance
+ for cls_name in self.class_hierarchy_graph.nodes():
+ # Calculate inheritance depth
+ depth = 0
+ current = cls_name
+
+ while self.class_hierarchy_graph.out_degree(current) > 0:
+ depth += 1
+ successors = list(self.class_hierarchy_graph.successors(current))
+ if not successors:
+ break
+ current = successors[0] # Follow first superclass
+
+ # Check if depth exceeds threshold
+ if depth > 3: # Threshold for deep inheritance
+ cls_path = self.class_hierarchy_graph.nodes[cls_name].get('path', 'unknown')
+
+ self.issues.add(Issue(
+ message=f"Deep inheritance: {cls_name} has an inheritance depth of {depth}",
+ severity=IssueSeverity.WARNING,
+ category=IssueCategory.DEPENDENCY_CYCLE,
+ location=CodeLocation(
+ file=cls_path,
+ line=None
+ ),
+ suggestion="Consider using composition instead of deep inheritance"
+ ))
+
+ def _export_call_graph(self) -> Dict[str, Any]:
+ """Export the call graph for the analysis result."""
+ nodes = []
+ edges = []
+
+ # Add nodes
+ for node in self.call_graph.nodes():
+ node_data = self.call_graph.nodes[node]
+ nodes.append({
+ "id": node,
+ "path": node_data.get('path', 'unknown')
+ })
+
+ # Add edges
+ for source, target in self.call_graph.edges():
+ edge_data = self.call_graph.get_edge_data(source, target)
+ edges.append({
+ "source": source,
+ "target": target,
+ "source_path": edge_data.get('source_path', 'unknown'),
+ "target_path": edge_data.get('target_path', 'unknown')
+ })
+
+ # Find entry points and leaf functions
+ entry_points = [node for node in self.call_graph.nodes()
+ if self.call_graph.in_degree(node) == 0]
+
+ leaf_functions = [node for node in self.call_graph.nodes()
+ if self.call_graph.out_degree(node) == 0]
+
+ return {
+ "nodes": nodes,
+ "edges": edges,
+ "entry_points": entry_points,
+ "leaf_functions": leaf_functions,
+ "deep_call_chains": self.long_call_chains if hasattr(self, 'long_call_chains') else []
+ }
+
+ def _export_class_hierarchy(self) -> Dict[str, Any]:
+ """Export the class hierarchy for the analysis result."""
+ nodes = []
+ edges = []
+
+ # Add nodes
+ for node in self.class_hierarchy_graph.nodes():
+ node_data = self.class_hierarchy_graph.nodes[node]
+ nodes.append({
+ "id": node,
+ "path": node_data.get('path', 'unknown')
+ })
+
+ # Add edges
+ for source, target in self.class_hierarchy_graph.edges():
+ edges.append({
+ "source": source,
+ "target": target
+ })
+
+ # Find root classes (no superclasses) and leaf classes (no subclasses)
+ root_classes = [node for node in self.class_hierarchy_graph.nodes()
+ if self.class_hierarchy_graph.out_degree(node) == 0]
+
+ leaf_classes = [node for node in self.class_hierarchy_graph.nodes()
+ if self.class_hierarchy_graph.in_degree(node) == 0]
+
+ return {
+ "nodes": nodes,
+ "edges": edges,
+ "root_classes": root_classes,
+ "leaf_classes": leaf_classes
+ }
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/dependency_analyzer.py b/codegen-on-oss/codegen_on_oss/analyzers/dependency_analyzer.py
new file mode 100644
index 000000000..56eff1440
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/dependency_analyzer.py
@@ -0,0 +1,484 @@
+#!/usr/bin/env python3
+"""
+Dependency Analyzer Module
+
+This module provides analysis of codebase dependencies, including
+import relationships, circular dependencies, and module coupling.
+"""
+
+import os
+import sys
+import logging
+import networkx as nx
+from typing import Dict, List, Set, Tuple, Any, Optional, Union
+
+from codegen_on_oss.analyzers.base_analyzer import BaseCodeAnalyzer
+from codegen_on_oss.analyzers.issue_types import Issue, IssueSeverity, AnalysisType, IssueCategory
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class DependencyAnalyzer(BaseCodeAnalyzer):
+ """
+ Analyzer for codebase dependencies.
+
+ This analyzer detects issues related to dependencies, including
+ import relationships, circular dependencies, and module coupling.
+ """
+
+ def analyze(self, analysis_type: AnalysisType = AnalysisType.DEPENDENCY) -> Dict[str, Any]:
+ """
+ Perform dependency analysis on the codebase.
+
+ Args:
+ analysis_type: Type of analysis to perform
+
+ Returns:
+ Dictionary containing analysis results
+ """
+ if not self.base_codebase:
+ raise ValueError("Codebase not initialized")
+
+ result = {
+ "metadata": {
+ "analysis_time": str(datetime.now()),
+ "analysis_type": analysis_type,
+ "repo_name": getattr(self.base_codebase.ctx, 'repo_name', None),
+ "language": str(getattr(self.base_codebase.ctx, 'programming_language', None)),
+ },
+ "summary": {},
+ }
+
+ # Reset issues list
+ self.issues = []
+
+ # Perform appropriate analysis based on type
+ if analysis_type == AnalysisType.DEPENDENCY:
+ # Run all dependency checks
+ result["import_dependencies"] = self._analyze_import_dependencies()
+ result["circular_dependencies"] = self._find_circular_dependencies()
+ result["module_coupling"] = self._analyze_module_coupling()
+ result["external_dependencies"] = self._analyze_external_dependencies()
+
+ # Add issues to the result
+ result["issues"] = [issue.to_dict() for issue in self.issues]
+ result["issue_counts"] = {
+ "total": len(self.issues),
+ "by_severity": {
+ "critical": sum(1 for issue in self.issues if issue.severity == IssueSeverity.CRITICAL),
+ "error": sum(1 for issue in self.issues if issue.severity == IssueSeverity.ERROR),
+ "warning": sum(1 for issue in self.issues if issue.severity == IssueSeverity.WARNING),
+ "info": sum(1 for issue in self.issues if issue.severity == IssueSeverity.INFO),
+ },
+ "by_category": {
+ category.value: sum(1 for issue in self.issues if issue.category == category)
+ for category in IssueCategory
+ if any(issue.category == category for issue in self.issues)
+ }
+ }
+
+ # Store results
+ self.results = result
+
+ return result
+
+ def _analyze_import_dependencies(self) -> Dict[str, Any]:
+ """
+ Analyze import dependencies in the codebase.
+
+ Returns:
+ Dictionary containing import dependencies analysis results
+ """
+ import_deps = {
+ "module_dependencies": [],
+ "file_dependencies": [],
+ "most_imported_modules": [],
+ "most_importing_modules": [],
+ "dependency_stats": {
+ "total_imports": 0,
+ "internal_imports": 0,
+ "external_imports": 0,
+ "relative_imports": 0
+ }
+ }
+
+ # Create a directed graph for module dependencies
+ G = nx.DiGraph()
+
+ # Track import counts
+ module_imports = {} # modules importing others
+ module_imported = {} # modules being imported
+
+ # Process all files to extract import information
+ for file in self.base_codebase.files:
+ # Skip if no imports
+ if not hasattr(file, 'imports') or not file.imports:
+ continue
+
+ # Get file path
+ file_path = file.filepath if hasattr(file, 'filepath') else str(file.path) if hasattr(file, 'path') else str(file)
+
+ # Extract module name from file path
+ file_parts = file_path.split('/')
+ module_name = '/'.join(file_parts[:-1]) if len(file_parts) > 1 else file_parts[0]
+
+ # Initialize import counts
+ if module_name not in module_imports:
+ module_imports[module_name] = 0
+
+ # Process imports
+ for imp in file.imports:
+ import_deps["dependency_stats"]["total_imports"] += 1
+
+ # Get imported module information
+ imported_file = None
+ imported_module = "unknown"
+ is_external = False
+
+ if hasattr(imp, 'resolved_file'):
+ imported_file = imp.resolved_file
+ elif hasattr(imp, 'resolved_symbol') and hasattr(imp.resolved_symbol, 'file'):
+ imported_file = imp.resolved_symbol.file
+
+ if imported_file:
+ # Get imported file path
+ imported_path = imported_file.filepath if hasattr(imported_file, 'filepath') else str(imported_file.path) if hasattr(imported_file, 'path') else str(imported_file)
+
+ # Extract imported module name
+ imported_parts = imported_path.split('/')
+ imported_module = '/'.join(imported_parts[:-1]) if len(imported_parts) > 1 else imported_parts[0]
+
+ # Check if external
+ is_external = hasattr(imported_file, 'is_external') and imported_file.is_external
+ else:
+ # If we couldn't resolve the import, use the import name
+ imported_module = imp.name if hasattr(imp, 'name') else "unknown"
+
+ # Assume external if we couldn't resolve
+ is_external = True
+
+ # Update import type counts
+ if is_external:
+ import_deps["dependency_stats"]["external_imports"] += 1
+ else:
+ import_deps["dependency_stats"]["internal_imports"] += 1
+
+ # Check if relative import
+ if hasattr(imp, 'is_relative') and imp.is_relative:
+ import_deps["dependency_stats"]["relative_imports"] += 1
+
+ # Update module import counts
+ module_imports[module_name] += 1
+
+ if imported_module not in module_imported:
+ module_imported[imported_module] = 0
+ module_imported[imported_module] += 1
+
+ # Add to dependency graph
+ if module_name != imported_module: # Skip self-imports
+ G.add_edge(module_name, imported_module)
+
+ # Add to file dependencies list
+ import_deps["file_dependencies"].append({
+ "source_file": file_path,
+ "target_file": imported_path if imported_file else "unknown",
+ "import_name": imp.name if hasattr(imp, 'name') else "unknown",
+ "is_external": is_external
+ })
+
+ # Extract module dependencies from graph
+ for source, target in G.edges():
+ import_deps["module_dependencies"].append({
+ "source_module": source,
+ "target_module": target
+ })
+
+ # Find most imported modules
+ most_imported = sorted(
+ [(module, count) for module, count in module_imported.items()],
+ key=lambda x: x[1],
+ reverse=True
+ )
+
+ for module, count in most_imported[:10]: # Top 10
+ import_deps["most_imported_modules"].append({
+ "module": module,
+ "import_count": count
+ })
+
+ # Find modules that import the most
+ most_importing = sorted(
+ [(module, count) for module, count in module_imports.items()],
+ key=lambda x: x[1],
+ reverse=True
+ )
+
+ for module, count in most_importing[:10]: # Top 10
+ import_deps["most_importing_modules"].append({
+ "module": module,
+ "import_count": count
+ })
+
+ return import_deps
+
+ def _find_circular_dependencies(self) -> Dict[str, Any]:
+ """
+ Find circular dependencies in the codebase.
+
+ Returns:
+ Dictionary containing circular dependencies analysis results
+ """
+ circular_deps = {
+ "circular_imports": [],
+ "circular_dependencies_count": 0,
+ "affected_modules": set()
+ }
+
+ # Create dependency graph if not already available
+ G = nx.DiGraph()
+
+ # Process all files to build dependency graph
+ for file in self.base_codebase.files:
+ # Skip if no imports
+ if not hasattr(file, 'imports') or not file.imports:
+ continue
+
+ # Get file path
+ file_path = file.filepath if hasattr(file, 'filepath') else str(file.path) if hasattr(file, 'path') else str(file)
+
+ # Process imports
+ for imp in file.imports:
+ # Get imported file
+ imported_file = None
+
+ if hasattr(imp, 'resolved_file'):
+ imported_file = imp.resolved_file
+ elif hasattr(imp, 'resolved_symbol') and hasattr(imp.resolved_symbol, 'file'):
+ imported_file = imp.resolved_symbol.file
+
+ if imported_file:
+ # Get imported file path
+ imported_path = imported_file.filepath if hasattr(imported_file, 'filepath') else str(imported_file.path) if hasattr(imported_file, 'path') else str(imported_file)
+
+ # Add edge to graph
+ G.add_edge(file_path, imported_path)
+
+ # Find cycles in the graph
+ try:
+ cycles = list(nx.simple_cycles(G))
+
+ for cycle in cycles:
+ circular_deps["circular_imports"].append({
+ "files": cycle,
+ "length": len(cycle)
+ })
+
+ # Add affected modules to set
+ for file_path in cycle:
+ module_path = '/'.join(file_path.split('/')[:-1])
+ circular_deps["affected_modules"].add(module_path)
+
+ # Add issue
+ if len(cycle) >= 2:
+ self.add_issue(Issue(
+ file=cycle[0],
+ line=None,
+ message=f"Circular dependency detected between {len(cycle)} files",
+ severity=IssueSeverity.ERROR,
+ category=IssueCategory.DEPENDENCY_CYCLE,
+ suggestion="Break the circular dependency by refactoring the code"
+ ))
+
+ except Exception as e:
+ logger.error(f"Error finding circular dependencies: {e}")
+
+ # Update cycle count
+ circular_deps["circular_dependencies_count"] = len(circular_deps["circular_imports"])
+ circular_deps["affected_modules"] = list(circular_deps["affected_modules"])
+
+ return circular_deps
+
+ def _analyze_module_coupling(self) -> Dict[str, Any]:
+ """
+ Analyze module coupling in the codebase.
+
+ Returns:
+ Dictionary containing module coupling analysis results
+ """
+ coupling = {
+ "high_coupling_modules": [],
+ "low_coupling_modules": [],
+ "coupling_metrics": {},
+ "average_coupling": 0.0
+ }
+
+ # Create module dependency graphs
+ modules = {} # Module name -> set of imported modules
+ module_files = {} # Module name -> list of files
+
+ # Process all files to extract module information
+ for file in self.base_codebase.files:
+ # Get file path
+ file_path = file.filepath if hasattr(file, 'filepath') else str(file.path) if hasattr(file, 'path') else str(file)
+
+ # Extract module name from file path
+ module_parts = file_path.split('/')
+ module_name = '/'.join(module_parts[:-1]) if len(module_parts) > 1 else module_parts[0]
+
+ # Initialize module structures
+ if module_name not in modules:
+ modules[module_name] = set()
+ module_files[module_name] = []
+
+ module_files[module_name].append(file_path)
+
+ # Skip if no imports
+ if not hasattr(file, 'imports') or not file.imports:
+ continue
+
+ # Process imports
+ for imp in file.imports:
+ # Get imported file
+ imported_file = None
+
+ if hasattr(imp, 'resolved_file'):
+ imported_file = imp.resolved_file
+ elif hasattr(imp, 'resolved_symbol') and hasattr(imp.resolved_symbol, 'file'):
+ imported_file = imp.resolved_symbol.file
+
+ if imported_file:
+ # Get imported file path
+ imported_path = imported_file.filepath if hasattr(imported_file, 'filepath') else str(imported_file.path) if hasattr(imported_file, 'path') else str(imported_file)
+
+ # Extract imported module name
+ imported_parts = imported_path.split('/')
+ imported_module = '/'.join(imported_parts[:-1]) if len(imported_parts) > 1 else imported_parts[0]
+
+ # Skip self-imports
+ if imported_module != module_name:
+ modules[module_name].add(imported_module)
+
+ # Calculate coupling metrics for each module
+ total_coupling = 0.0
+ module_count = 0
+
+ for module_name, imported_modules in modules.items():
+ # Calculate metrics
+ file_count = len(module_files[module_name])
+ import_count = len(imported_modules)
+
+ # Calculate coupling ratio (imports per file)
+ coupling_ratio = import_count / file_count if file_count > 0 else 0
+
+ # Add to metrics
+ coupling["coupling_metrics"][module_name] = {
+ "files": file_count,
+ "imported_modules": list(imported_modules),
+ "import_count": import_count,
+ "coupling_ratio": coupling_ratio
+ }
+
+ # Track total for average
+ total_coupling += coupling_ratio
+ module_count += 1
+
+ # Categorize coupling
+ if coupling_ratio > 3: # Threshold for "high coupling"
+ coupling["high_coupling_modules"].append({
+ "module": module_name,
+ "coupling_ratio": coupling_ratio,
+ "import_count": import_count,
+ "file_count": file_count
+ })
+
+ # Add issue
+ self.add_issue(Issue(
+ file=module_files[module_name][0] if module_files[module_name] else module_name,
+ line=None,
+ message=f"High module coupling: {coupling_ratio:.2f} imports per file",
+ severity=IssueSeverity.WARNING,
+ category=IssueCategory.DEPENDENCY_CYCLE,
+ suggestion="Consider refactoring to reduce coupling between modules"
+ ))
+ elif coupling_ratio < 0.5 and file_count > 1: # Threshold for "low coupling"
+ coupling["low_coupling_modules"].append({
+ "module": module_name,
+ "coupling_ratio": coupling_ratio,
+ "import_count": import_count,
+ "file_count": file_count
+ })
+
+ # Calculate average coupling
+ coupling["average_coupling"] = total_coupling / module_count if module_count > 0 else 0.0
+
+ # Sort coupling lists
+ coupling["high_coupling_modules"].sort(key=lambda x: x["coupling_ratio"], reverse=True)
+ coupling["low_coupling_modules"].sort(key=lambda x: x["coupling_ratio"])
+
+ return coupling
+
+ def _analyze_external_dependencies(self) -> Dict[str, Any]:
+ """
+ Analyze external dependencies in the codebase.
+
+ Returns:
+ Dictionary containing external dependencies analysis results
+ """
+ external_deps = {
+ "external_modules": [],
+ "external_module_usage": {},
+ "most_used_external_modules": []
+ }
+
+ # Track external module usage
+ external_usage = {} # Module name -> usage count
+
+ # Process all imports to find external dependencies
+ for file in self.base_codebase.files:
+ # Skip if no imports
+ if not hasattr(file, 'imports') or not file.imports:
+ continue
+
+ # Process imports
+ for imp in file.imports:
+ # Check if external import
+ is_external = False
+ external_name = None
+
+ if hasattr(imp, 'module_name'):
+ external_name = imp.module_name
+
+ # Check if this is an external module
+ if hasattr(imp, 'is_external'):
+ is_external = imp.is_external
+ elif external_name and '.' not in external_name and '/' not in external_name:
+ # Simple heuristic: single-word module names without dots or slashes
+ # are likely external modules
+ is_external = True
+
+ if is_external and external_name:
+ # Add to external modules list if not already there
+ if external_name not in external_usage:
+ external_usage[external_name] = 0
+ external_deps["external_modules"].append(external_name)
+
+ external_usage[external_name] += 1
+
+ # Add usage counts
+ for module, count in external_usage.items():
+ external_deps["external_module_usage"][module] = count
+
+ # Find most used external modules
+ most_used = sorted(
+ [(module, count) for module, count in external_usage.items()],
+ key=lambda x: x[1],
+ reverse=True
+ )
+
+ for module, count in most_used[:10]: # Top 10
+ external_deps["most_used_external_modules"].append({
+ "module": module,
+ "usage_count": count
+ })
+
+ return external_deps
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/error_analyzer.py b/codegen-on-oss/codegen_on_oss/analyzers/error_analyzer.py
new file mode 100644
index 000000000..104b72633
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/error_analyzer.py
@@ -0,0 +1,418 @@
+#!/usr/bin/env python3
+"""
+Error Analyzer Module (Legacy Interface)
+
+This module provides a backwards-compatible interface to the new analyzer modules.
+It serves as a bridge between old code using error_analyzer.py and the new modular
+analysis system.
+
+For new code, consider using the analyzers directly:
+- codegen_on_oss.analyzers.code_quality_analyzer.CodeQualityAnalyzer
+- codegen_on_oss.analyzers.dependency_analyzer.DependencyAnalyzer
+"""
+
+import os
+import sys
+import json
+import logging
+import warnings
+from typing import Dict, List, Set, Tuple, Any, Optional, Union
+
+# Import from our new analyzers
+try:
+ from codegen_on_oss.analyzers.base_analyzer import BaseCodeAnalyzer
+ from codegen_on_oss.analyzers.code_quality_analyzer import CodeQualityAnalyzer
+ from codegen_on_oss.analyzers.dependency_analyzer import DependencyAnalyzer
+ from codegen_on_oss.analyzers.issue_types import Issue, IssueSeverity, AnalysisType, IssueCategory
+ from codegen_on_oss.codebase_visualizer import CodebaseVisualizer, VisualizationType, OutputFormat
+except ImportError:
+ print("Error loading analyzer modules. Please make sure they are installed.")
+ sys.exit(1)
+
+# Import codegen SDK
+try:
+ from codegen.sdk.core.codebase import Codebase
+ from codegen.configs.models.codebase import CodebaseConfig
+ from codegen.configs.models.secrets import SecretsConfig
+ from codegen.sdk.codebase.config import ProjectConfig
+ from codegen.git.schemas.repo_config import RepoConfig
+ from codegen.git.repo_operator.repo_operator import RepoOperator
+ from codegen.shared.enums.programming_language import ProgrammingLanguage
+ from codegen.sdk.codebase.codebase_analysis import get_codebase_summary
+except ImportError:
+ print("Codegen SDK not found. Please install it first.")
+ sys.exit(1)
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+# Show deprecation warning
+warnings.warn(
+ "error_analyzer.py is deprecated. Please use analyzers directly from codegen_on_oss.analyzers package.",
+ DeprecationWarning,
+ stacklevel=2
+)
+
+class CodebaseAnalyzer:
+ """
+ Legacy interface to the new analyzer modules.
+
+ This class provides backwards compatibility with code that used the
+ old CodebaseAnalyzer class from error_analyzer.py.
+ """
+
+ def __init__(
+ self,
+ repo_url: Optional[str] = None,
+ repo_path: Optional[str] = None,
+ language: Optional[str] = None
+ ):
+ """
+ Initialize the CodebaseAnalyzer.
+
+ Args:
+ repo_url: URL of the repository to analyze
+ repo_path: Local path to the repository to analyze
+ language: Programming language of the codebase
+ """
+ # Create instances of the new analyzers
+ self.quality_analyzer = CodeQualityAnalyzer(
+ repo_url=repo_url,
+ repo_path=repo_path,
+ language=language
+ )
+
+ self.dependency_analyzer = DependencyAnalyzer(
+ repo_url=repo_url,
+ repo_path=repo_path,
+ language=language
+ )
+
+ # Set up legacy attributes
+ self.repo_url = repo_url
+ self.repo_path = repo_path
+ self.language = language
+ self.codebase = self.quality_analyzer.base_codebase
+ self.results = {}
+
+ # Initialize visualizer
+ self.visualizer = CodebaseVisualizer(
+ codebase=self.codebase
+ )
+
+ def analyze(self, categories: List[str] = None, output_format: str = "json", output_file: Optional[str] = None):
+ """
+ Perform a comprehensive analysis of the codebase.
+
+ Args:
+ categories: List of categories to analyze. If None, all categories are analyzed.
+ output_format: Format of the output (json, html, console)
+ output_file: Path to the output file
+
+ Returns:
+ Dict containing the analysis results
+ """
+ if not self.codebase:
+ raise ValueError("Codebase not initialized. Please initialize the codebase first.")
+
+ # Map old category names to new analyzers
+ category_map = {
+ "codebase_structure": "dependency",
+ "symbol_level": "code_quality",
+ "dependency_flow": "dependency",
+ "code_quality": "code_quality",
+ "visualization": "visualization",
+ "language_specific": "code_quality",
+ "code_metrics": "code_quality"
+ }
+
+ # Initialize results with metadata
+ self.results = {
+ "metadata": {
+ "repo_name": getattr(self.codebase.ctx, 'repo_name', None),
+ "analysis_time": str(datetime.now()),
+ "language": str(getattr(self.codebase.ctx, 'programming_language', None)),
+ "codebase_summary": get_codebase_summary(self.codebase)
+ },
+ "categories": {}
+ }
+
+ # Determine categories to analyze
+ if not categories:
+ # If no categories are specified, run all analysis types
+ analysis_types = ["code_quality", "dependency"]
+ else:
+ # Map the requested categories to analysis types
+ analysis_types = set()
+ for category in categories:
+ if category in category_map:
+ analysis_types.add(category_map[category])
+
+ # Run each analysis type
+ if "code_quality" in analysis_types:
+ quality_results = self.quality_analyzer.analyze(AnalysisType.CODE_QUALITY)
+
+ # Add results to the legacy format
+ for category in ["code_quality", "symbol_level", "language_specific", "code_metrics"]:
+ if category in categories or not categories:
+ self.results["categories"][category] = {}
+
+ # Map new results to old category structure
+ if category == "code_quality":
+ self.results["categories"][category].update({
+ "unused_functions": quality_results.get("dead_code", {}).get("unused_functions", []),
+ "unused_classes": quality_results.get("dead_code", {}).get("unused_classes", []),
+ "unused_variables": quality_results.get("dead_code", {}).get("unused_variables", []),
+ "unused_imports": quality_results.get("dead_code", {}).get("unused_imports", []),
+ "cyclomatic_complexity": quality_results.get("complexity", {}),
+ "cognitive_complexity": quality_results.get("complexity", {}),
+ "function_size_metrics": quality_results.get("style_issues", {}).get("long_functions", [])
+ })
+ elif category == "symbol_level":
+ self.results["categories"][category].update({
+ "function_parameter_analysis": [],
+ "function_complexity_metrics": quality_results.get("complexity", {}).get("function_complexity", [])
+ })
+ elif category == "code_metrics":
+ self.results["categories"][category].update({
+ "calculate_cyclomatic_complexity": quality_results.get("complexity", {}),
+ "calculate_maintainability_index": quality_results.get("maintainability", {})
+ })
+
+ if "dependency" in analysis_types:
+ dependency_results = self.dependency_analyzer.analyze(AnalysisType.DEPENDENCY)
+
+ # Add results to the legacy format
+ for category in ["codebase_structure", "dependency_flow"]:
+ if category in categories or not categories:
+ self.results["categories"][category] = {}
+
+ # Map new results to old category structure
+ if category == "codebase_structure":
+ self.results["categories"][category].update({
+ "import_dependency_map": dependency_results.get("import_dependencies", {}).get("module_dependencies", []),
+ "circular_imports": dependency_results.get("circular_dependencies", {}).get("circular_imports", []),
+ "module_coupling_metrics": dependency_results.get("module_coupling", {}),
+ "module_dependency_graph": dependency_results.get("import_dependencies", {}).get("module_dependencies", [])
+ })
+ elif category == "dependency_flow":
+ self.results["categories"][category].update({
+ "function_call_relationships": [],
+ "entry_point_analysis": [],
+ "dead_code_detection": quality_results.get("dead_code", {}) if "code_quality" in analysis_types else {}
+ })
+
+ # Output the results
+ if output_format == "json":
+ if output_file:
+ with open(output_file, 'w') as f:
+ json.dump(self.results, f, indent=2)
+ logger.info(f"Results saved to {output_file}")
+ else:
+ return self.results
+ elif output_format == "html":
+ self._generate_html_report(output_file)
+ elif output_format == "console":
+ self._print_console_report()
+
+ return self.results
+
+ def _generate_html_report(self, output_file: Optional[str] = None):
+ """
+ Generate an HTML report of the analysis results.
+
+ Args:
+ output_file: Path to the output file
+ """
+ # Simple HTML report for backwards compatibility
+ html_content = f"""
+
+
+
+
Codebase Analysis Report
+
+
+
+
Codebase Analysis Report
+
+
Metadata
+
Repository: {self.results['metadata'].get('repo_name', 'Unknown')}
+
Analysis Time: {self.results['metadata'].get('analysis_time', 'Unknown')}
+
Language: {self.results['metadata'].get('language', 'Unknown')}
+
+ """
+
+ # Add issues section
+ html_content += """
+
+
Issues
+
+ """
+
+ # Collect all issues
+ all_issues = []
+ if hasattr(self.quality_analyzer, 'issues'):
+ all_issues.extend(self.quality_analyzer.issues)
+ if hasattr(self.dependency_analyzer, 'issues'):
+ all_issues.extend(self.dependency_analyzer.issues)
+
+ # Sort issues by severity
+ all_issues.sort(key=lambda x: {
+ IssueSeverity.CRITICAL: 0,
+ IssueSeverity.ERROR: 1,
+ IssueSeverity.WARNING: 2,
+ IssueSeverity.INFO: 3
+ }.get(x.severity, 4))
+
+ # Add issues to HTML
+ for issue in all_issues:
+ severity_class = issue.severity.value
+ html_content += f"""
+
+
{issue.severity.value.upper()}: {issue.message}
+
File: {issue.file} {f"(Line {issue.line})" if issue.line else ""}
+
Symbol: {issue.symbol or 'N/A'}
+
Suggestion: {issue.suggestion or 'N/A'}
+
+ """
+
+ html_content += """
+
+
+ """
+
+ # Add summary of results
+ html_content += """
+
+
Analysis Results
+ """
+
+ for category, results in self.results.get('categories', {}).items():
+ html_content += f"""
+
{category}
+
{json.dumps(results, indent=2)}
+ """
+
+ html_content += """
+
+
+
+ """
+
+ # Save HTML to file or print to console
+ if output_file:
+ with open(output_file, 'w') as f:
+ f.write(html_content)
+ logger.info(f"HTML report saved to {output_file}")
+ else:
+ print(html_content)
+
+ def _print_console_report(self):
+ """Print a summary of the analysis results to the console."""
+ print("\n📊 Codebase Analysis Report 📊")
+ print("=" * 50)
+
+ # Print metadata
+ print(f"\n📌 Repository: {self.results['metadata'].get('repo_name', 'Unknown')}")
+ print(f"📆 Analysis Time: {self.results['metadata'].get('analysis_time', 'Unknown')}")
+ print(f"🔤 Language: {self.results['metadata'].get('language', 'Unknown')}")
+
+ # Print summary of issues
+ print("\n🚨 Issues Summary")
+ print("-" * 50)
+
+ # Collect all issues
+ all_issues = []
+ if hasattr(self.quality_analyzer, 'issues'):
+ all_issues.extend(self.quality_analyzer.issues)
+ if hasattr(self.dependency_analyzer, 'issues'):
+ all_issues.extend(self.dependency_analyzer.issues)
+
+ # Print issue counts by severity
+ severity_counts = {
+ IssueSeverity.CRITICAL: 0,
+ IssueSeverity.ERROR: 0,
+ IssueSeverity.WARNING: 0,
+ IssueSeverity.INFO: 0
+ }
+
+ for issue in all_issues:
+ severity_counts[issue.severity] += 1
+
+ print(f"Critical: {severity_counts[IssueSeverity.CRITICAL]}")
+ print(f"Errors: {severity_counts[IssueSeverity.ERROR]}")
+ print(f"Warnings: {severity_counts[IssueSeverity.WARNING]}")
+ print(f"Info: {severity_counts[IssueSeverity.INFO]}")
+ print(f"Total: {len(all_issues)}")
+
+ # Print top issues by severity
+ if all_issues:
+ print("\n🔍 Top Issues")
+ print("-" * 50)
+
+ # Sort issues by severity
+ all_issues.sort(key=lambda x: {
+ IssueSeverity.CRITICAL: 0,
+ IssueSeverity.ERROR: 1,
+ IssueSeverity.WARNING: 2,
+ IssueSeverity.INFO: 3
+ }.get(x.severity, 4))
+
+ # Print top 10 issues
+ for i, issue in enumerate(all_issues[:10]):
+ print(f"{i+1}. [{issue.severity.value.upper()}] {issue.message}")
+ print(f" File: {issue.file} {f'(Line {issue.line})' if issue.line else ''}")
+ print(f" Symbol: {issue.symbol or 'N/A'}")
+ print(f" Suggestion: {issue.suggestion or 'N/A'}")
+ print()
+
+ # Print summary of results by category
+ for category, results in self.results.get('categories', {}).items():
+ print(f"\n📋 {category.replace('_', ' ').title()}")
+ print("-" * 50)
+
+ # Print key statistics for each category
+ if category == "code_quality":
+ unused_funcs = len(results.get("unused_functions", []))
+ unused_vars = len(results.get("unused_variables", []))
+ print(f"Unused Functions: {unused_funcs}")
+ print(f"Unused Variables: {unused_vars}")
+
+ # Print complexity stats if available
+ complexity = results.get("cyclomatic_complexity", {})
+ if "function_complexity" in complexity:
+ high_complexity = [f for f in complexity["function_complexity"] if f.get("complexity", 0) > 10]
+ print(f"High Complexity Functions: {len(high_complexity)}")
+
+ elif category == "codebase_structure":
+ circular_imports = len(results.get("circular_imports", []))
+ print(f"Circular Imports: {circular_imports}")
+
+ module_deps = results.get("module_dependency_graph", [])
+ print(f"Module Dependencies: {len(module_deps)}")
+
+ elif category == "dependency_flow":
+ dead_code = results.get("dead_code_detection", {})
+ total_dead = (
+ len(dead_code.get("unused_functions", [])) +
+ len(dead_code.get("unused_classes", [])) +
+ len(dead_code.get("unused_variables", []))
+ )
+ print(f"Dead Code Items: {total_dead}")
+
+# For backwards compatibility, expose the CodebaseAnalyzer class as the main interface
+__all__ = ['CodebaseAnalyzer']
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/issue_analyzer.py b/codegen-on-oss/codegen_on_oss/analyzers/issue_analyzer.py
new file mode 100644
index 000000000..213db9bb0
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/issue_analyzer.py
@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""
+Issue Analyzer Module
+
+This module provides common functionality for detecting and tracking issues
+across different types of code analyzers. It provides standardized issue
+handling and categorization to ensure consistent issue reporting.
+"""
+
+import os
+import logging
+from typing import Dict, List, Set, Any, Optional, Union, Callable
+
+from codegen_on_oss.analyzers.base_analyzer import BaseCodeAnalyzer
+from codegen_on_oss.analyzers.issue_types import Issue, IssueSeverity, AnalysisType, IssueCategory
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class IssueAnalyzer(BaseCodeAnalyzer):
+ """
+ Base class for analyzers that detect and report issues.
+
+ This class builds on the BaseCodeAnalyzer to add standardized issue tracking,
+ categorization, and reporting capabilities.
+ """
+
+ def __init__(self, **kwargs):
+ """
+ Initialize the issue analyzer.
+
+ Args:
+ **kwargs: Arguments to pass to the BaseCodeAnalyzer
+ """
+ super().__init__(**kwargs)
+ self.issue_filters = []
+ self.issue_handlers = {}
+ self.issue_categories = set()
+ self.register_default_filters()
+
+ def register_default_filters(self):
+ """Register default issue filters."""
+ # Filter out issues in test files by default
+ self.add_issue_filter(lambda issue: "test" in issue.file.lower(),
+ "Skip issues in test files")
+
+ # Filter out issues in generated files by default
+ self.add_issue_filter(lambda issue: "generated" in issue.file.lower(),
+ "Skip issues in generated files")
+
+ def add_issue_filter(self, filter_func: Callable[[Issue], bool], description: str):
+ """
+ Add a filter function that determines if an issue should be skipped.
+
+ Args:
+ filter_func: Function that returns True if issue should be skipped
+ description: Description of the filter
+ """
+ self.issue_filters.append((filter_func, description))
+
+ def register_issue_handler(self, category: IssueCategory, handler: Callable):
+ """
+ Register a handler function for a specific issue category.
+
+ Args:
+ category: Issue category to handle
+ handler: Function that will detect issues of this category
+ """
+ self.issue_handlers[category] = handler
+ self.issue_categories.add(category)
+
+ def should_skip_issue(self, issue: Issue) -> bool:
+ """
+ Check if an issue should be skipped based on registered filters.
+
+ Args:
+ issue: Issue to check
+
+ Returns:
+ True if the issue should be skipped, False otherwise
+ """
+ for filter_func, _ in self.issue_filters:
+ try:
+ if filter_func(issue):
+ return True
+ except Exception as e:
+ logger.debug(f"Error applying issue filter: {e}")
+
+ return False
+
+ def add_issue(self, issue: Issue):
+ """
+ Add an issue to the list if it passes all filters.
+
+ Args:
+ issue: Issue to add
+ """
+ if self.should_skip_issue(issue):
+ return
+
+ super().add_issue(issue)
+
+ def detect_issues(self, categories: Optional[List[IssueCategory]] = None) -> Dict[IssueCategory, List[Issue]]:
+ """
+ Detect issues across specified categories.
+
+ Args:
+ categories: Categories of issues to detect (defaults to all registered categories)
+
+ Returns:
+ Dictionary mapping categories to lists of issues
+ """
+ result = {}
+
+ # Use all registered categories if none specified
+ if not categories:
+ categories = list(self.issue_categories)
+
+ # Process each requested category
+ for category in categories:
+ if category in self.issue_handlers:
+ # Clear existing issues of this category
+ self.issues = [i for i in self.issues if i.category != category]
+
+ # Run the handler to detect issues
+ try:
+ handler = self.issue_handlers[category]
+ handler_result = handler()
+ result[category] = handler_result
+ except Exception as e:
+ logger.error(f"Error detecting issues for category {category}: {e}")
+ result[category] = []
+ else:
+ logger.warning(f"No handler registered for issue category: {category}")
+ result[category] = []
+
+ return result
+
+ def get_issues_by_category(self) -> Dict[IssueCategory, List[Issue]]:
+ """
+ Group issues by category.
+
+ Returns:
+ Dictionary mapping categories to lists of issues
+ """
+ result = {}
+
+ for issue in self.issues:
+ if issue.category:
+ if issue.category not in result:
+ result[issue.category] = []
+ result[issue.category].append(issue)
+
+ return result
+
+ def get_issue_statistics(self) -> Dict[str, Any]:
+ """
+ Get statistics about detected issues.
+
+ Returns:
+ Dictionary with issue statistics
+ """
+ issues_by_category = self.get_issues_by_category()
+
+ return {
+ "total": len(self.issues),
+ "by_severity": {
+ "critical": sum(1 for issue in self.issues if issue.severity == IssueSeverity.CRITICAL),
+ "error": sum(1 for issue in self.issues if issue.severity == IssueSeverity.ERROR),
+ "warning": sum(1 for issue in self.issues if issue.severity == IssueSeverity.WARNING),
+ "info": sum(1 for issue in self.issues if issue.severity == IssueSeverity.INFO),
+ },
+ "by_category": {
+ category.value: len(issues)
+ for category, issues in issues_by_category.items()
+ }
+ }
+
+ def format_issues_report(self) -> str:
+ """
+ Format issues as a readable report.
+
+ Returns:
+ Formatted string with issue report
+ """
+ report_lines = [
+ "==== Issues Report ====",
+ f"Total issues: {len(self.issues)}",
+ ""
+ ]
+
+ # Group by severity
+ issues_by_severity = {}
+ for issue in self.issues:
+ if issue.severity not in issues_by_severity:
+ issues_by_severity[issue.severity] = []
+ issues_by_severity[issue.severity].append(issue)
+
+ # Add severity sections
+ for severity in [IssueSeverity.CRITICAL, IssueSeverity.ERROR, IssueSeverity.WARNING, IssueSeverity.INFO]:
+ if severity in issues_by_severity:
+ report_lines.append(f"==== {severity.value.upper()} ({len(issues_by_severity[severity])}) ====")
+
+ for issue in issues_by_severity[severity]:
+ location = f"{issue.file}:{issue.line}" if issue.line else issue.file
+ category = f"[{issue.category.value}]" if issue.category else ""
+ report_lines.append(f"{location} {category} {issue.message}")
+ if issue.suggestion:
+ report_lines.append(f" Suggestion: {issue.suggestion}")
+
+ report_lines.append("")
+
+ return "\n".join(report_lines)
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/issue_types.py b/codegen-on-oss/codegen_on_oss/analyzers/issue_types.py
new file mode 100644
index 000000000..a474d5f74
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/issue_types.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""
+Issue Types Module
+
+This module defines the common issue types and enumerations used across
+all analyzers in the system.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, List, Set, Tuple, Any, Optional, Union
+
+class AnalysisType(str, Enum):
+ """Types of analysis that can be performed."""
+ CODEBASE = "codebase"
+ PR = "pr"
+ COMPARISON = "comparison"
+ CODE_QUALITY = "code_quality"
+ SECURITY = "security"
+ PERFORMANCE = "performance"
+ DEPENDENCY = "dependency"
+ TYPE_CHECKING = "type_checking"
+
+class IssueSeverity(str, Enum):
+ """Severity levels for issues."""
+ CRITICAL = "critical"
+ ERROR = "error"
+ WARNING = "warning"
+ INFO = "info"
+
+class IssueCategory(str, Enum):
+ """Categories of issues that can be detected."""
+ DEAD_CODE = "dead_code"
+ COMPLEXITY = "complexity"
+ TYPE_ERROR = "type_error"
+ PARAMETER_MISMATCH = "parameter_mismatch"
+ IMPORT_ERROR = "import_error"
+ SECURITY_VULNERABILITY = "security_vulnerability"
+ PERFORMANCE_ISSUE = "performance_issue"
+ DEPENDENCY_CYCLE = "dependency_cycle"
+ API_CHANGE = "api_change"
+ STYLE_ISSUE = "style_issue"
+ DOCUMENTATION = "documentation"
+
+@dataclass
+class Issue:
+ """Represents an issue found during analysis."""
+ file: str
+ line: Optional[int]
+ message: str
+ severity: IssueSeverity
+ category: Optional[IssueCategory] = None
+ symbol: Optional[str] = None
+ code: Optional[str] = None
+ suggestion: Optional[str] = None
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Convert issue to dictionary representation."""
+ return {
+ "file": self.file,
+ "line": self.line,
+ "message": self.message,
+ "severity": self.severity,
+ "category": self.category,
+ "symbol": self.symbol,
+ "code": self.code,
+ "suggestion": self.suggestion
+ }
+
+ @classmethod
+ def from_dict(cls, data: Dict[str, Any]) -> 'Issue':
+ """Create an issue from a dictionary representation."""
+ return cls(
+ file=data["file"],
+ line=data.get("line"),
+ message=data["message"],
+ severity=IssueSeverity(data["severity"]),
+ category=IssueCategory(data["category"]) if "category" in data else None,
+ symbol=data.get("symbol"),
+ code=data.get("code"),
+ suggestion=data.get("suggestion")
+ )
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/issues.py b/codegen-on-oss/codegen_on_oss/analyzers/issues.py
new file mode 100644
index 000000000..f7880126c
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/issues.py
@@ -0,0 +1,493 @@
+#!/usr/bin/env python3
+"""
+Issues Module
+
+This module defines issue models, categories, and severities for code analysis.
+It provides a standardized way to represent and manage issues across different analyzers.
+"""
+
+import os
+import json
+import logging
+from dataclasses import dataclass, field, asdict
+from enum import Enum
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, Callable
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class AnalysisType(str, Enum):
+ """Types of analysis that can be performed."""
+ CODEBASE = "codebase"
+ PR = "pr"
+ COMPARISON = "comparison"
+ CODE_QUALITY = "code_quality"
+ DEPENDENCY = "dependency"
+ SECURITY = "security"
+ PERFORMANCE = "performance"
+ TYPE_CHECKING = "type_checking"
+
+class IssueSeverity(str, Enum):
+ """Severity levels for issues."""
+ CRITICAL = "critical" # Must be fixed immediately, blocks functionality
+ ERROR = "error" # Must be fixed, causes errors or undefined behavior
+ WARNING = "warning" # Should be fixed, may cause problems in future
+ INFO = "info" # Informational, could be improved but not critical
+
+class IssueCategory(str, Enum):
+ """Categories of issues that can be detected."""
+ # Code Quality Issues
+ DEAD_CODE = "dead_code" # Unused variables, functions, etc.
+ COMPLEXITY = "complexity" # Code too complex, needs refactoring
+ STYLE_ISSUE = "style_issue" # Code style issues (line length, etc.)
+ DOCUMENTATION = "documentation" # Missing or incomplete documentation
+
+ # Type and Parameter Issues
+ TYPE_ERROR = "type_error" # Type errors or inconsistencies
+ PARAMETER_MISMATCH = "parameter_mismatch" # Parameter type or count mismatch
+ RETURN_TYPE_ERROR = "return_type_error" # Return type error or mismatch
+
+ # Implementation Issues
+ IMPLEMENTATION_ERROR = "implementation_error" # Incorrect implementation
+ MISSING_IMPLEMENTATION = "missing_implementation" # Missing implementation
+
+ # Dependency Issues
+ IMPORT_ERROR = "import_error" # Import errors or issues
+ DEPENDENCY_CYCLE = "dependency_cycle" # Circular dependency
+ MODULE_COUPLING = "module_coupling" # High coupling between modules
+
+ # API Issues
+ API_CHANGE = "api_change" # API has changed in a breaking way
+ API_USAGE_ERROR = "api_usage_error" # Incorrect API usage
+
+ # Security Issues
+ SECURITY_VULNERABILITY = "security_vulnerability" # Security vulnerability
+
+ # Performance Issues
+ PERFORMANCE_ISSUE = "performance_issue" # Performance issue
+
+class IssueStatus(str, Enum):
+ """Status of an issue."""
+ OPEN = "open" # Issue is open and needs to be fixed
+ FIXED = "fixed" # Issue has been fixed
+ WONTFIX = "wontfix" # Issue will not be fixed
+ INVALID = "invalid" # Issue is invalid or not applicable
+ DUPLICATE = "duplicate" # Issue is a duplicate of another
+
+@dataclass
+class CodeLocation:
+ """Location of an issue in code."""
+ file: str
+ line: Optional[int] = None
+ column: Optional[int] = None
+ end_line: Optional[int] = None
+ end_column: Optional[int] = None
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Convert to dictionary representation."""
+ return {k: v for k, v in asdict(self).items() if v is not None}
+
+ @classmethod
+ def from_dict(cls, data: Dict[str, Any]) -> 'CodeLocation':
+ """Create from dictionary representation."""
+ return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+ def __str__(self) -> str:
+ """Convert to string representation."""
+ if self.line is not None:
+ if self.column is not None:
+ return f"{self.file}:{self.line}:{self.column}"
+ return f"{self.file}:{self.line}"
+ return self.file
+
+@dataclass
+class Issue:
+ """Represents an issue found during analysis."""
+ # Core fields
+ message: str
+ severity: IssueSeverity
+ location: CodeLocation
+
+ # Classification fields
+ category: Optional[IssueCategory] = None
+ analysis_type: Optional[AnalysisType] = None
+ status: IssueStatus = IssueStatus.OPEN
+
+ # Context fields
+ symbol: Optional[str] = None
+ code: Optional[str] = None
+ suggestion: Optional[str] = None
+ related_symbols: List[str] = field(default_factory=list)
+ related_locations: List[CodeLocation] = field(default_factory=list)
+
+ # Metadata fields
+ id: Optional[str] = None
+ hash: Optional[str] = None
+ metadata: Dict[str, Any] = field(default_factory=dict)
+
+ def __post_init__(self):
+ """Initialize derived fields."""
+ # Generate an ID if not provided
+ if self.id is None:
+ import hashlib
+ # Create a hash based on location and message
+ hash_input = f"{self.location.file}:{self.location.line}:{self.message}"
+ self.id = hashlib.md5(hash_input.encode()).hexdigest()[:12]
+
+ @property
+ def file(self) -> str:
+ """Get the file path."""
+ return self.location.file
+
+ @property
+ def line(self) -> Optional[int]:
+ """Get the line number."""
+ return self.location.line
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Convert to dictionary representation."""
+ result = {
+ "id": self.id,
+ "message": self.message,
+ "severity": self.severity.value,
+ "location": self.location.to_dict(),
+ "status": self.status.value,
+ }
+
+ # Add optional fields if present
+ if self.category:
+ result["category"] = self.category.value
+
+ if self.analysis_type:
+ result["analysis_type"] = self.analysis_type.value
+
+ if self.symbol:
+ result["symbol"] = self.symbol
+
+ if self.code:
+ result["code"] = self.code
+
+ if self.suggestion:
+ result["suggestion"] = self.suggestion
+
+ if self.related_symbols:
+ result["related_symbols"] = self.related_symbols
+
+ if self.related_locations:
+ result["related_locations"] = [loc.to_dict() for loc in self.related_locations]
+
+ if self.metadata:
+ result["metadata"] = self.metadata
+
+ return result
+
+ @classmethod
+ def from_dict(cls, data: Dict[str, Any]) -> 'Issue':
+ """Create from dictionary representation."""
+ # Convert string enums to actual enum values
+ if "severity" in data and isinstance(data["severity"], str):
+ data["severity"] = IssueSeverity(data["severity"])
+
+ if "category" in data and isinstance(data["category"], str):
+ data["category"] = IssueCategory(data["category"])
+
+ if "analysis_type" in data and isinstance(data["analysis_type"], str):
+ data["analysis_type"] = AnalysisType(data["analysis_type"])
+
+ if "status" in data and isinstance(data["status"], str):
+ data["status"] = IssueStatus(data["status"])
+
+ # Convert location dict to CodeLocation
+ if "location" in data and isinstance(data["location"], dict):
+ data["location"] = CodeLocation.from_dict(data["location"])
+
+ # Convert related_locations dicts to CodeLocation objects
+ if "related_locations" in data and isinstance(data["related_locations"], list):
+ data["related_locations"] = [
+ CodeLocation.from_dict(loc) if isinstance(loc, dict) else loc
+ for loc in data["related_locations"]
+ ]
+
+ return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+class IssueCollection:
+ """Collection of issues with filtering and grouping capabilities."""
+
+ def __init__(self, issues: Optional[List[Issue]] = None):
+ """
+ Initialize the issue collection.
+
+ Args:
+ issues: Initial list of issues
+ """
+ self.issues = issues or []
+ self._filters = []
+
+ def add_issue(self, issue: Issue):
+ """
+ Add an issue to the collection.
+
+ Args:
+ issue: Issue to add
+ """
+ self.issues.append(issue)
+
+ def add_issues(self, issues: List[Issue]):
+ """
+ Add multiple issues to the collection.
+
+ Args:
+ issues: Issues to add
+ """
+ self.issues.extend(issues)
+
+ def add_filter(self, filter_func: Callable[[Issue], bool], description: str = ""):
+ """
+ Add a filter function.
+
+ Args:
+ filter_func: Function that returns True if issue should be included
+ description: Description of the filter
+ """
+ self._filters.append((filter_func, description))
+
+ def get_issues(
+ self,
+ severity: Optional[IssueSeverity] = None,
+ category: Optional[IssueCategory] = None,
+ status: Optional[IssueStatus] = None,
+ file_path: Optional[str] = None,
+ symbol: Optional[str] = None
+ ) -> List[Issue]:
+ """
+ Get issues matching the specified criteria.
+
+ Args:
+ severity: Severity to filter by
+ category: Category to filter by
+ status: Status to filter by
+ file_path: File path to filter by
+ symbol: Symbol name to filter by
+
+ Returns:
+ List of matching issues
+ """
+ filtered_issues = self.issues
+
+ # Apply custom filters
+ for filter_func, _ in self._filters:
+ filtered_issues = [i for i in filtered_issues if filter_func(i)]
+
+ # Apply standard filters
+ if severity:
+ filtered_issues = [i for i in filtered_issues if i.severity == severity]
+
+ if category:
+ filtered_issues = [i for i in filtered_issues if i.category == category]
+
+ if status:
+ filtered_issues = [i for i in filtered_issues if i.status == status]
+
+ if file_path:
+ filtered_issues = [i for i in filtered_issues if i.location.file == file_path]
+
+ if symbol:
+ filtered_issues = [
+ i for i in filtered_issues
+ if (i.symbol == symbol or
+ (i.related_symbols and symbol in i.related_symbols))
+ ]
+
+ return filtered_issues
+
+ def group_by_severity(self) -> Dict[IssueSeverity, List[Issue]]:
+ """
+ Group issues by severity.
+
+ Returns:
+ Dictionary mapping severities to lists of issues
+ """
+ result = {severity: [] for severity in IssueSeverity}
+
+ for issue in self.issues:
+ result[issue.severity].append(issue)
+
+ return result
+
+ def group_by_category(self) -> Dict[IssueCategory, List[Issue]]:
+ """
+ Group issues by category.
+
+ Returns:
+ Dictionary mapping categories to lists of issues
+ """
+ result = {category: [] for category in IssueCategory}
+
+ for issue in self.issues:
+ if issue.category:
+ result[issue.category].append(issue)
+
+ return result
+
+ def group_by_file(self) -> Dict[str, List[Issue]]:
+ """
+ Group issues by file.
+
+ Returns:
+ Dictionary mapping file paths to lists of issues
+ """
+ result = {}
+
+ for issue in self.issues:
+ if issue.location.file not in result:
+ result[issue.location.file] = []
+
+ result[issue.location.file].append(issue)
+
+ return result
+
+ def statistics(self) -> Dict[str, Any]:
+ """
+ Get statistics about the issues.
+
+ Returns:
+ Dictionary with issue statistics
+ """
+ by_severity = self.group_by_severity()
+ by_category = self.group_by_category()
+ by_status = {status: [] for status in IssueStatus}
+ for issue in self.issues:
+ by_status[issue.status].append(issue)
+
+ return {
+ "total": len(self.issues),
+ "by_severity": {
+ severity.value: len(issues)
+ for severity, issues in by_severity.items()
+ },
+ "by_category": {
+ category.value: len(issues)
+ for category, issues in by_category.items()
+ if len(issues) > 0 # Only include non-empty categories
+ },
+ "by_status": {
+ status.value: len(issues)
+ for status, issues in by_status.items()
+ },
+ "file_count": len(self.group_by_file())
+ }
+
+ def to_dict(self) -> Dict[str, Any]:
+ """
+ Convert to dictionary representation.
+
+ Returns:
+ Dictionary representation of the issue collection
+ """
+ return {
+ "issues": [issue.to_dict() for issue in self.issues],
+ "statistics": self.statistics(),
+ "filters": [desc for _, desc in self._filters if desc]
+ }
+
+ @classmethod
+ def from_dict(cls, data: Dict[str, Any]) -> 'IssueCollection':
+ """
+ Create from dictionary representation.
+
+ Args:
+ data: Dictionary representation
+
+ Returns:
+ Issue collection
+ """
+ collection = cls()
+
+ if "issues" in data and isinstance(data["issues"], list):
+ collection.add_issues([
+ Issue.from_dict(issue) if isinstance(issue, dict) else issue
+ for issue in data["issues"]
+ ])
+
+ return collection
+
+ def save_to_file(self, file_path: str, format: str = "json"):
+ """
+ Save to file.
+
+ Args:
+ file_path: Path to save to
+ format: Format to save in
+ """
+ if format == "json":
+ with open(file_path, "w") as f:
+ json.dump(self.to_dict(), f, indent=2)
+ else:
+ raise ValueError(f"Unsupported format: {format}")
+
+ @classmethod
+ def load_from_file(cls, file_path: str) -> 'IssueCollection':
+ """
+ Load from file.
+
+ Args:
+ file_path: Path to load from
+
+ Returns:
+ Issue collection
+ """
+ with open(file_path, "r") as f:
+ data = json.load(f)
+
+ return cls.from_dict(data)
+
+
+def create_issue(
+ message: str,
+ severity: Union[str, IssueSeverity],
+ file: str,
+ line: Optional[int] = None,
+ category: Optional[Union[str, IssueCategory]] = None,
+ symbol: Optional[str] = None,
+ suggestion: Optional[str] = None
+) -> Issue:
+ """
+ Create an issue with simplified parameters.
+
+ Args:
+ message: Issue message
+ severity: Issue severity
+ file: File path
+ line: Line number
+ category: Issue category
+ symbol: Symbol name
+ suggestion: Suggested fix
+
+ Returns:
+ Issue object
+ """
+ # Convert string severity to enum
+ if isinstance(severity, str):
+ severity = IssueSeverity(severity)
+
+ # Convert string category to enum
+ if isinstance(category, str) and category:
+ category = IssueCategory(category)
+
+ # Create location
+ location = CodeLocation(file=file, line=line)
+
+ # Create issue
+ return Issue(
+ message=message,
+ severity=severity,
+ location=location,
+ category=category,
+ symbol=symbol,
+ suggestion=suggestion
+ )
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/models/analysis_result.py b/codegen-on-oss/codegen_on_oss/analyzers/models/analysis_result.py
new file mode 100644
index 000000000..0cd012609
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/models/analysis_result.py
@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""
+Analysis Result Model
+
+This module defines data models for analysis results, providing a standardized
+way to represent and serialize analysis outcomes.
+"""
+
+import json
+from dataclasses import dataclass, field, asdict
+from enum import Enum
+from typing import Dict, List, Set, Any, Optional, Union
+from datetime import datetime
+
+from codegen_on_oss.analyzers.issues import AnalysisType, IssueCollection
+
+@dataclass
+class AnalysisSummary:
+ """Summary statistics for an analysis."""
+ total_files: int = 0
+ total_functions: int = 0
+ total_classes: int = 0
+ total_issues: int = 0
+ analysis_time: str = field(default_factory=lambda: datetime.now().isoformat())
+ analysis_duration_ms: Optional[int] = None
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Convert to dictionary representation."""
+ return {k: v for k, v in asdict(self).items() if v is not None}
+
+@dataclass
+class CodeQualityResult:
+ """Results of code quality analysis."""
+ dead_code: Dict[str, Any] = field(default_factory=dict)
+ complexity: Dict[str, Any] = field(default_factory=dict)
+ parameter_issues: Dict[str, Any] = field(default_factory=dict)
+ style_issues: Dict[str, Any] = field(default_factory=dict)
+ implementation_issues: Dict[str, Any] = field(default_factory=dict)
+ maintainability: Dict[str, Any] = field(default_factory=dict)
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Convert to dictionary representation."""
+ return {k: v for k, v in asdict(self).items()}
+
+@dataclass
+class DependencyResult:
+ """Results of dependency analysis."""
+ import_dependencies: Dict[str, Any] = field(default_factory=dict)
+ circular_dependencies: Dict[str, Any] = field(default_factory=dict)
+ module_coupling: Dict[str, Any] = field(default_factory=dict)
+ external_dependencies: Dict[str, Any] = field(default_factory=dict)
+ call_graph: Dict[str, Any] = field(default_factory=dict)
+ class_hierarchy: Dict[str, Any] = field(default_factory=dict)
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Convert to dictionary representation."""
+ return {k: v for k, v in asdict(self).items()}
+
+@dataclass
+class PrAnalysisResult:
+ """Results of PR analysis."""
+ modified_symbols: List[Dict[str, Any]] = field(default_factory=list)
+ added_symbols: List[Dict[str, Any]] = field(default_factory=list)
+ removed_symbols: List[Dict[str, Any]] = field(default_factory=list)
+ signature_changes: List[Dict[str, Any]] = field(default_factory=list)
+ impact: Dict[str, Any] = field(default_factory=dict)
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Convert to dictionary representation."""
+ return {k: v for k, v in asdict(self).items()}
+
+@dataclass
+class SecurityResult:
+ """Results of security analysis."""
+ vulnerabilities: List[Dict[str, Any]] = field(default_factory=list)
+ secrets: List[Dict[str, Any]] = field(default_factory=list)
+ injection_risks: List[Dict[str, Any]] = field(default_factory=list)
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Convert to dictionary representation."""
+ return {k: v for k, v in asdict(self).items()}
+
+@dataclass
+class PerformanceResult:
+ """Results of performance analysis."""
+ bottlenecks: List[Dict[str, Any]] = field(default_factory=list)
+ optimization_opportunities: List[Dict[str, Any]] = field(default_factory=list)
+ memory_issues: List[Dict[str, Any]] = field(default_factory=list)
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Convert to dictionary representation."""
+ return {k: v for k, v in asdict(self).items()}
+
+@dataclass
+class MetadataEntry:
+ """Metadata about an analysis."""
+ key: str
+ value: Any
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Convert to dictionary representation."""
+ return {"key": self.key, "value": self.value}
+
+@dataclass
+class AnalysisResult:
+ """Comprehensive analysis result."""
+ # Core data
+ analysis_types: List[AnalysisType]
+ summary: AnalysisSummary = field(default_factory=AnalysisSummary)
+ issues: IssueCollection = field(default_factory=IssueCollection)
+
+ # Analysis results
+ code_quality: Optional[CodeQualityResult] = None
+ dependencies: Optional[DependencyResult] = None
+ pr_analysis: Optional[PrAnalysisResult] = None
+ security: Optional[SecurityResult] = None
+ performance: Optional[PerformanceResult] = None
+
+ # Metadata
+ metadata: Dict[str, Any] = field(default_factory=dict)
+ repo_name: Optional[str] = None
+ repo_path: Optional[str] = None
+ language: Optional[str] = None
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Convert to dictionary representation."""
+ result = {
+ "analysis_types": [at.value for at in self.analysis_types],
+ "summary": self.summary.to_dict(),
+ "issues": self.issues.to_dict(),
+ "metadata": self.metadata,
+ }
+
+ # Add optional sections if present
+ if self.repo_name:
+ result["repo_name"] = self.repo_name
+
+ if self.repo_path:
+ result["repo_path"] = self.repo_path
+
+ if self.language:
+ result["language"] = self.language
+
+ # Add analysis results if present
+ if self.code_quality:
+ result["code_quality"] = self.code_quality.to_dict()
+
+ if self.dependencies:
+ result["dependencies"] = self.dependencies.to_dict()
+
+ if self.pr_analysis:
+ result["pr_analysis"] = self.pr_analysis.to_dict()
+
+ if self.security:
+ result["security"] = self.security.to_dict()
+
+ if self.performance:
+ result["performance"] = self.performance.to_dict()
+
+ return result
+
+ def save_to_file(self, file_path: str, indent: int = 2):
+ """
+ Save analysis result to a file.
+
+ Args:
+ file_path: Path to save to
+ indent: JSON indentation level
+ """
+ with open(file_path, 'w') as f:
+ json.dump(self.to_dict(), f, indent=indent)
+
+ @classmethod
+ def from_dict(cls, data: Dict[str, Any]) -> 'AnalysisResult':
+ """
+ Create analysis result from dictionary.
+
+ Args:
+ data: Dictionary representation
+
+ Returns:
+ Analysis result object
+ """
+ # Convert analysis types
+ analysis_types = [
+ AnalysisType(at) if isinstance(at, str) else at
+ for at in data.get("analysis_types", [])
+ ]
+
+ # Create summary
+ summary = AnalysisSummary(**data.get("summary", {})) if "summary" in data else AnalysisSummary()
+
+ # Create issues collection
+ issues = IssueCollection.from_dict(data.get("issues", {})) if "issues" in data else IssueCollection()
+
+ # Create result object
+ result = cls(
+ analysis_types=analysis_types,
+ summary=summary,
+ issues=issues,
+ repo_name=data.get("repo_name"),
+ repo_path=data.get("repo_path"),
+ language=data.get("language"),
+ metadata=data.get("metadata", {})
+ )
+
+ # Add analysis results if present
+ if "code_quality" in data:
+ result.code_quality = CodeQualityResult(**data["code_quality"])
+
+ if "dependencies" in data:
+ result.dependencies = DependencyResult(**data["dependencies"])
+
+ if "pr_analysis" in data:
+ result.pr_analysis = PrAnalysisResult(**data["pr_analysis"])
+
+ if "security" in data:
+ result.security = SecurityResult(**data["security"])
+
+ if "performance" in data:
+ result.performance = PerformanceResult(**data["performance"])
+
+ return result
+
+ @classmethod
+ def load_from_file(cls, file_path: str) -> 'AnalysisResult':
+ """
+ Load analysis result from file.
+
+ Args:
+ file_path: Path to load from
+
+ Returns:
+ Analysis result object
+ """
+ with open(file_path, 'r') as f:
+ data = json.load(f)
+
+ return cls.from_dict(data)
+
+ def get_issue_count(self, severity: Optional[str] = None, category: Optional[str] = None) -> int:
+ """
+ Get count of issues matching criteria.
+
+ Args:
+ severity: Optional severity to filter by
+ category: Optional category to filter by
+
+ Returns:
+ Count of matching issues
+ """
+ issues_dict = self.issues.to_dict()
+
+ if severity and category:
+ # Count issues with specific severity and category
+ return sum(
+ 1 for issue in issues_dict.get("issues", [])
+ if issue.get("severity") == severity and issue.get("category") == category
+ )
+ elif severity:
+ # Count issues with specific severity
+ return issues_dict.get("statistics", {}).get("by_severity", {}).get(severity, 0)
+ elif category:
+ # Count issues with specific category
+ return issues_dict.get("statistics", {}).get("by_category", {}).get(category, 0)
+ else:
+ # Total issues
+ return issues_dict.get("statistics", {}).get("total", 0)
+
+ def merge(self, other: 'AnalysisResult') -> 'AnalysisResult':
+ """
+ Merge with another analysis result.
+
+ Args:
+ other: Analysis result to merge with
+
+ Returns:
+ New merged analysis result
+ """
+ # Create new result with combined analysis types
+ merged = AnalysisResult(
+ analysis_types=list(set(self.analysis_types + other.analysis_types)),
+ repo_name=self.repo_name or other.repo_name,
+ repo_path=self.repo_path or other.repo_path,
+ language=self.language or other.language,
+ )
+
+ # Merge issues
+ merged.issues.add_issues(self.issues.issues)
+ merged.issues.add_issues(other.issues.issues)
+
+ # Merge metadata
+ merged.metadata = {**self.metadata, **other.metadata}
+
+ # Merge analysis results (take non-None values)
+ merged.code_quality = self.code_quality or other.code_quality
+ merged.dependencies = self.dependencies or other.dependencies
+ merged.pr_analysis = self.pr_analysis or other.pr_analysis
+ merged.security = self.security or other.security
+ merged.performance = self.performance or other.performance
+
+ # Update summary
+ merged.summary = AnalysisSummary(
+ total_files=max(self.summary.total_files, other.summary.total_files),
+ total_functions=max(self.summary.total_functions, other.summary.total_functions),
+ total_classes=max(self.summary.total_classes, other.summary.total_classes),
+ total_issues=len(merged.issues.issues),
+ analysis_time=datetime.now().isoformat()
+ )
+
+ return merged
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/resolution/__init__.py b/codegen-on-oss/codegen_on_oss/analyzers/resolution/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/resolution/resolution_manager.py b/codegen-on-oss/codegen_on_oss/analyzers/resolution/resolution_manager.py
new file mode 100644
index 000000000..96f583358
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/resolution/resolution_manager.py
@@ -0,0 +1,761 @@
+#!/usr/bin/env python3
+"""
+Resolution Manager Module
+
+This module provides functionality for resolving code issues identified
+during codebase analysis. It integrates with the analyzer modules to
+apply automated fixes and track issue resolution.
+"""
+
+import os
+import logging
+import sys
+from enum import Enum
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, Callable
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class ResolutionStrategy(str, Enum):
+ """Strategies for resolving issues."""
+ AUTO_FIX = "auto_fix"
+ SUGGESTION = "suggestion"
+ MANUAL = "manual"
+ IGNORE = "ignore"
+
+class ResolutionStatus(str, Enum):
+ """Status of resolution attempts."""
+ PENDING = "pending"
+ IN_PROGRESS = "in_progress"
+ RESOLVED = "resolved"
+ FAILED = "failed"
+ IGNORED = "ignored"
+
+class ResolutionManager:
+ """
+ Manager for resolving code issues identified during analysis.
+
+ This class provides functionality to track, apply, and validate
+ resolutions for issues found in the codebase.
+ """
+
+ def __init__(
+ self,
+ analyzer=None,
+ codebase=None,
+ context=None,
+ auto_apply: bool = False,
+ strategies: Optional[Dict[str, ResolutionStrategy]] = None
+ ):
+ """
+ Initialize the ResolutionManager.
+
+ Args:
+ analyzer: Optional analyzer with analysis results
+ codebase: Optional codebase to resolve issues for
+ context: Optional context providing graph representation
+ auto_apply: Whether to automatically apply resolutions
+ strategies: Dictionary mapping issue types to resolution strategies
+ """
+ self.analyzer = analyzer
+ self.codebase = codebase or (analyzer.base_codebase if analyzer else None)
+ self.context = context or (analyzer.base_context if analyzer else None)
+ self.auto_apply = auto_apply
+ self.strategies = strategies or {}
+ self.resolutions = {}
+ self.resolution_history = []
+
+ # Initialize strategies if not provided
+ if not self.strategies:
+ self._init_default_strategies()
+
+ def _init_default_strategies(self):
+ """Initialize default resolution strategies for common issue types."""
+ self.strategies = {
+ "unused_import": ResolutionStrategy.AUTO_FIX,
+ "unused_variable": ResolutionStrategy.AUTO_FIX,
+ "unused_function": ResolutionStrategy.SUGGESTION,
+ "missing_return_type": ResolutionStrategy.AUTO_FIX,
+ "parameter_type_mismatch": ResolutionStrategy.SUGGESTION,
+ "circular_dependency": ResolutionStrategy.MANUAL,
+ "complex_function": ResolutionStrategy.SUGGESTION,
+ "dead_code": ResolutionStrategy.SUGGESTION,
+ "security_issue": ResolutionStrategy.MANUAL,
+ }
+
+ def load_issues(self):
+ """
+ Load issues from the analyzer.
+
+ Returns:
+ List of issues
+ """
+ if not self.analyzer:
+ logger.error("No analyzer available")
+ return []
+
+ if not hasattr(self.analyzer, "results") or not self.analyzer.results:
+ logger.error("No analysis results available")
+ return []
+
+ if "issues" not in self.analyzer.results:
+ logger.error("No issues found in analysis results")
+ return []
+
+ issues = self.analyzer.results["issues"]
+
+ # Initialize resolutions tracking
+ for issue in issues:
+ issue_id = issue.get("id")
+ if not issue_id:
+ continue
+
+ self.resolutions[issue_id] = {
+ "issue": issue,
+ "status": ResolutionStatus.PENDING,
+ "strategy": self.strategies.get(issue.get("type"), ResolutionStrategy.MANUAL),
+ "resolution_data": None,
+ "applied": False,
+ "validation_result": None
+ }
+
+ return issues
+
+ def get_resolution_candidates(self, filter_strategy: Optional[ResolutionStrategy] = None):
+ """
+ Get issues that can be resolved with the specified strategy.
+
+ Args:
+ filter_strategy: Optional strategy to filter issues by
+
+ Returns:
+ List of issues that can be resolved with the specified strategy
+ """
+ candidates = []
+
+ for issue_id, resolution in self.resolutions.items():
+ if filter_strategy and resolution["strategy"] != filter_strategy:
+ continue
+
+ if resolution["status"] == ResolutionStatus.PENDING:
+ candidates.append(resolution["issue"])
+
+ return candidates
+
+ def generate_resolutions(self):
+ """
+ Generate resolutions for all pending issues.
+
+ Returns:
+ Number of resolutions generated
+ """
+ count = 0
+
+ # Process auto-fix issues first
+ auto_fix_candidates = self.get_resolution_candidates(ResolutionStrategy.AUTO_FIX)
+ for issue in auto_fix_candidates:
+ if self._generate_resolution(issue):
+ count += 1
+
+ # Process suggestion issues next
+ suggestion_candidates = self.get_resolution_candidates(ResolutionStrategy.SUGGESTION)
+ for issue in suggestion_candidates:
+ if self._generate_resolution(issue):
+ count += 1
+
+ # Skip manual issues as they require human intervention
+
+ return count
+
+ def _generate_resolution(self, issue):
+ """
+ Generate a resolution for a specific issue.
+
+ Args:
+ issue: Issue to generate a resolution for
+
+ Returns:
+ True if a resolution was generated, False otherwise
+ """
+ issue_id = issue.get("id")
+ if not issue_id or issue_id not in self.resolutions:
+ return False
+
+ resolution = self.resolutions[issue_id]
+ resolution["status"] = ResolutionStatus.IN_PROGRESS
+
+ try:
+ # Generate resolution based on issue type
+ issue_type = issue.get("type")
+ issue_file = issue.get("file")
+ issue_line = issue.get("line")
+
+ # Special handling for common issue types
+ if issue_type == "unused_import":
+ resolution_data = self._resolve_unused_import(issue)
+ elif issue_type == "unused_variable":
+ resolution_data = self._resolve_unused_variable(issue)
+ elif issue_type == "unused_function":
+ resolution_data = self._resolve_unused_function(issue)
+ elif issue_type == "missing_return_type":
+ resolution_data = self._resolve_missing_return_type(issue)
+ elif issue_type == "parameter_type_mismatch":
+ resolution_data = self._resolve_parameter_type_mismatch(issue)
+ elif issue_type == "circular_dependency":
+ resolution_data = self._resolve_circular_dependency(issue)
+ elif issue_type == "complex_function":
+ resolution_data = self._resolve_complex_function(issue)
+ elif issue_type == "dead_code":
+ resolution_data = self._resolve_dead_code(issue)
+ else:
+ # No specific handler for this issue type
+ resolution["status"] = ResolutionStatus.PENDING
+ return False
+
+ if not resolution_data:
+ resolution["status"] = ResolutionStatus.FAILED
+ return False
+
+ resolution["resolution_data"] = resolution_data
+ resolution["status"] = ResolutionStatus.RESOLVED
+
+ # Auto-apply if configured
+ if self.auto_apply and resolution["strategy"] == ResolutionStrategy.AUTO_FIX:
+ self.apply_resolution(issue_id)
+
+ return True
+ except Exception as e:
+ logger.error(f"Error generating resolution for issue {issue_id}: {str(e)}")
+ resolution["status"] = ResolutionStatus.FAILED
+ return False
+
+ def apply_resolution(self, issue_id):
+ """
+ Apply a resolution to the codebase.
+
+ Args:
+ issue_id: ID of the issue to apply the resolution for
+
+ Returns:
+ True if the resolution was applied, False otherwise
+ """
+ if issue_id not in self.resolutions:
+ logger.error(f"Issue {issue_id} not found")
+ return False
+
+ resolution = self.resolutions[issue_id]
+ if resolution["status"] != ResolutionStatus.RESOLVED:
+ logger.error(f"Resolution for issue {issue_id} is not ready to apply")
+ return False
+
+ if resolution["applied"]:
+ logger.warning(f"Resolution for issue {issue_id} already applied")
+ return True
+
+ try:
+ # Apply the resolution
+ issue = resolution["issue"]
+ resolution_data = resolution["resolution_data"]
+
+ issue_type = issue.get("type")
+ issue_file = issue.get("file")
+
+ if not issue_file or not os.path.isfile(issue_file):
+ logger.error(f"Issue file not found: {issue_file}")
+ return False
+
+ # Special handling based on issue type
+ if issue_type == "unused_import" or issue_type == "unused_variable" or issue_type == "unused_function":
+ if "code_changes" in resolution_data:
+ self._apply_code_changes(issue_file, resolution_data["code_changes"])
+ elif issue_type == "missing_return_type":
+ if "code_changes" in resolution_data:
+ self._apply_code_changes(issue_file, resolution_data["code_changes"])
+ elif issue_type == "parameter_type_mismatch":
+ if "code_changes" in resolution_data:
+ self._apply_code_changes(issue_file, resolution_data["code_changes"])
+ elif issue_type == "circular_dependency":
+ if "code_changes" in resolution_data:
+ for file_path, changes in resolution_data["code_changes"].items():
+ self._apply_code_changes(file_path, changes)
+ else:
+ logger.warning(f"No implementation for applying resolution of type {issue_type}")
+ return False
+
+ # Record the application
+ resolution["applied"] = True
+ self.resolution_history.append({
+ "issue_id": issue_id,
+ "timestamp": datetime.now().isoformat(),
+ "action": "apply",
+ "success": True
+ })
+
+ return True
+ except Exception as e:
+ logger.error(f"Error applying resolution for issue {issue_id}: {str(e)}")
+ self.resolution_history.append({
+ "issue_id": issue_id,
+ "timestamp": datetime.now().isoformat(),
+ "action": "apply",
+ "success": False,
+ "error": str(e)
+ })
+ return False
+
+ def validate_resolution(self, issue_id):
+ """
+ Validate a resolution after it has been applied.
+
+ Args:
+ issue_id: ID of the issue to validate the resolution for
+
+ Returns:
+ True if the resolution is valid, False otherwise
+ """
+ if issue_id not in self.resolutions:
+ logger.error(f"Issue {issue_id} not found")
+ return False
+
+ resolution = self.resolutions[issue_id]
+ if not resolution["applied"]:
+ logger.error(f"Resolution for issue {issue_id} has not been applied")
+ return False
+
+ try:
+ # Validate the resolution
+ issue = resolution["issue"]
+ resolution_data = resolution["resolution_data"]
+
+ # Rerun the analyzer to check if the issue is fixed
+ if self.analyzer:
+ self.analyzer.analyze()
+
+ # Check if the issue still exists
+ if "issues" in self.analyzer.results:
+ for current_issue in self.analyzer.results["issues"]:
+ if current_issue.get("id") == issue_id:
+ # Issue still exists, resolution is invalid
+ resolution["validation_result"] = {
+ "valid": False,
+ "reason": "Issue still exists after resolution"
+ }
+ return False
+
+ # Issue no longer exists, resolution is valid
+ resolution["validation_result"] = {
+ "valid": True
+ }
+ return True
+ else:
+ logger.warning("No analyzer available for validation")
+ return True
+ except Exception as e:
+ logger.error(f"Error validating resolution for issue {issue_id}: {str(e)}")
+ resolution["validation_result"] = {
+ "valid": False,
+ "reason": f"Error during validation: {str(e)}"
+ }
+ return False
+
+ def rollback_resolution(self, issue_id):
+ """
+ Rollback a resolution that has been applied.
+
+ Args:
+ issue_id: ID of the issue to rollback the resolution for
+
+ Returns:
+ True if the resolution was rolled back, False otherwise
+ """
+ if issue_id not in self.resolutions:
+ logger.error(f"Issue {issue_id} not found")
+ return False
+
+ resolution = self.resolutions[issue_id]
+ if not resolution["applied"]:
+ logger.error(f"Resolution for issue {issue_id} has not been applied")
+ return False
+
+ try:
+ # Rollback the resolution
+ issue = resolution["issue"]
+ resolution_data = resolution["resolution_data"]
+
+ if "original_code" in resolution_data:
+ issue_file = issue.get("file")
+ with open(issue_file, "w") as f:
+ f.write(resolution_data["original_code"])
+
+ # Record the rollback
+ resolution["applied"] = False
+ resolution["validation_result"] = None
+ self.resolution_history.append({
+ "issue_id": issue_id,
+ "timestamp": datetime.now().isoformat(),
+ "action": "rollback",
+ "success": True
+ })
+
+ return True
+ except Exception as e:
+ logger.error(f"Error rolling back resolution for issue {issue_id}: {str(e)}")
+ self.resolution_history.append({
+ "issue_id": issue_id,
+ "timestamp": datetime.now().isoformat(),
+ "action": "rollback",
+ "success": False,
+ "error": str(e)
+ })
+ return False
+
+ def ignore_issue(self, issue_id, reason: str = ""):
+ """
+ Mark an issue as ignored.
+
+ Args:
+ issue_id: ID of the issue to ignore
+ reason: Reason for ignoring the issue
+
+ Returns:
+ True if the issue was marked as ignored, False otherwise
+ """
+ if issue_id not in self.resolutions:
+ logger.error(f"Issue {issue_id} not found")
+ return False
+
+ resolution = self.resolutions[issue_id]
+ resolution["status"] = ResolutionStatus.IGNORED
+ resolution["resolution_data"] = {
+ "reason": reason,
+ "timestamp": datetime.now().isoformat()
+ }
+
+ self.resolution_history.append({
+ "issue_id": issue_id,
+ "timestamp": datetime.now().isoformat(),
+ "action": "ignore",
+ "reason": reason
+ })
+
+ return True
+
+ def get_resolution_status(self, issue_id=None):
+ """
+ Get the status of resolutions.
+
+ Args:
+ issue_id: Optional ID of the issue to get the status for
+
+ Returns:
+ Resolution status information
+ """
+ if issue_id:
+ if issue_id not in self.resolutions:
+ logger.error(f"Issue {issue_id} not found")
+ return None
+
+ return self.resolutions[issue_id]
+ else:
+ # Get summary of all resolutions
+ summary = {
+ "total": len(self.resolutions),
+ "pending": 0,
+ "in_progress": 0,
+ "resolved": 0,
+ "applied": 0,
+ "failed": 0,
+ "ignored": 0,
+ "valid": 0,
+ "invalid": 0
+ }
+
+ for resolution in self.resolutions.values():
+ if resolution["status"] == ResolutionStatus.PENDING:
+ summary["pending"] += 1
+ elif resolution["status"] == ResolutionStatus.IN_PROGRESS:
+ summary["in_progress"] += 1
+ elif resolution["status"] == ResolutionStatus.RESOLVED:
+ summary["resolved"] += 1
+ if resolution["applied"]:
+ summary["applied"] += 1
+ if resolution["validation_result"] and resolution["validation_result"].get("valid"):
+ summary["valid"] += 1
+ elif resolution["validation_result"]:
+ summary["invalid"] += 1
+ elif resolution["status"] == ResolutionStatus.FAILED:
+ summary["failed"] += 1
+ elif resolution["status"] == ResolutionStatus.IGNORED:
+ summary["ignored"] += 1
+
+ return summary
+
+ def _apply_code_changes(self, file_path, changes):
+ """
+ Apply code changes to a file.
+
+ Args:
+ file_path: Path to the file to apply changes to
+ changes: List of changes to apply
+
+ Returns:
+ True if changes were applied, False otherwise
+ """
+ try:
+ # Read the file
+ with open(file_path, "r") as f:
+ lines = f.readlines()
+
+ # Apply the changes
+ for change in changes:
+ if "line" in change and "action" in change:
+ line_idx = change["line"] - 1 # Convert to 0-indexed
+
+ if change["action"] == "remove":
+ if 0 <= line_idx < len(lines):
+ lines[line_idx] = ""
+ elif change["action"] == "replace" and "new_text" in change:
+ if 0 <= line_idx < len(lines):
+ lines[line_idx] = change["new_text"] + "\n"
+ elif change["action"] == "insert" and "new_text" in change:
+ if 0 <= line_idx <= len(lines):
+ lines.insert(line_idx, change["new_text"] + "\n")
+
+ # Write the changes back to the file
+ with open(file_path, "w") as f:
+ f.writelines(lines)
+
+ return True
+ except Exception as e:
+ logger.error(f"Error applying code changes to {file_path}: {str(e)}")
+ return False
+
+ # Resolution generators for specific issue types
+ def _resolve_unused_import(self, issue):
+ """
+ Generate a resolution for an unused import issue.
+
+ Args:
+ issue: Issue to generate a resolution for
+
+ Returns:
+ Resolution data or None if no resolution could be generated
+ """
+ try:
+ issue_file = issue.get("file")
+ issue_line = issue.get("line")
+ import_name = issue.get("symbol")
+
+ if not issue_file or not os.path.isfile(issue_file) or not issue_line or not import_name:
+ return None
+
+ # Read the file
+ with open(issue_file, "r") as f:
+ lines = f.readlines()
+ original_code = "".join(lines)
+
+ # Find the import line
+ if 0 <= issue_line - 1 < len(lines):
+ import_line = lines[issue_line - 1]
+
+ # Check if it's a single import or part of a multi-import
+ if f"import {import_name}" in import_line or f"from " in import_line and f" import {import_name}" in import_line:
+ # Generate change
+ return {
+ "original_code": original_code,
+ "code_changes": [
+ {
+ "line": issue_line,
+ "action": "remove"
+ }
+ ]
+ }
+
+ return None
+ except Exception as e:
+ logger.error(f"Error resolving unused import: {str(e)}")
+ return None
+
+ def _resolve_unused_variable(self, issue):
+ """Resolution generator for unused variable issues."""
+ try:
+ issue_file = issue.get("file")
+ issue_line = issue.get("line")
+ var_name = issue.get("symbol")
+
+ if not issue_file or not os.path.isfile(issue_file) or not issue_line or not var_name:
+ return None
+
+ # Read the file
+ with open(issue_file, "r") as f:
+ lines = f.readlines()
+ original_code = "".join(lines)
+
+ # Find the variable declaration line
+ if 0 <= issue_line - 1 < len(lines):
+ var_line = lines[issue_line - 1]
+
+ # Check if it's a variable assignment
+ if f"{var_name} =" in var_line or f"{var_name}=" in var_line:
+ # Generate change
+ return {
+ "original_code": original_code,
+ "code_changes": [
+ {
+ "line": issue_line,
+ "action": "remove"
+ }
+ ]
+ }
+
+ return None
+ except Exception as e:
+ logger.error(f"Error resolving unused variable: {str(e)}")
+ return None
+
+ def _resolve_unused_function(self, issue):
+ """Resolution generator for unused function issues."""
+ try:
+ issue_file = issue.get("file")
+ issue_line = issue.get("line")
+ func_name = issue.get("symbol")
+
+ if not issue_file or not os.path.isfile(issue_file) or not issue_line or not func_name:
+ return None
+
+ # Read the file
+ with open(issue_file, "r") as f:
+ lines = f.readlines()
+ original_code = "".join(lines)
+
+ # Find the function declaration line
+ if 0 <= issue_line - 1 < len(lines):
+ func_line = lines[issue_line - 1]
+
+ # Check if it's a function declaration
+ if f"def {func_name}" in func_line:
+ # Find the end of the function
+ end_line = issue_line
+ indent_level = None
+
+ # Get indentation level of the function
+ for i, char in enumerate(func_line):
+ if char != " " and char != "\t":
+ indent_level = i
+ break
+
+ if indent_level is None:
+ return None
+
+ # Find all lines of the function
+ function_lines = []
+ for i in range(issue_line - 1, len(lines)):
+ # Skip empty lines
+ if not lines[i].strip():
+ continue
+
+ # Check indentation
+ current_indent = 0
+ for j, char in enumerate(lines[i]):
+ if char != " " and char != "\t":
+ current_indent = j
+ break
+
+ # If indentation is less than function, we've reached the end
+ if current_indent <= indent_level and i > issue_line - 1:
+ end_line = i
+ break
+
+ function_lines.append(lines[i])
+
+ # Generate change
+ changes = []
+ for i in range(issue_line - 1, end_line):
+ changes.append({
+ "line": i + 1,
+ "action": "remove"
+ })
+
+ return {
+ "original_code": original_code,
+ "code_changes": changes,
+ "function_text": "".join(function_lines)
+ }
+
+ return None
+ except Exception as e:
+ logger.error(f"Error resolving unused function: {str(e)}")
+ return None
+
+ def _resolve_missing_return_type(self, issue):
+ """Resolution generator for missing return type issues."""
+ try:
+ issue_file = issue.get("file")
+ issue_line = issue.get("line")
+ func_name = issue.get("symbol")
+ suggested_type = issue.get("suggested_type", "Any")
+
+ if not issue_file or not os.path.isfile(issue_file) or not issue_line or not func_name:
+ return None
+
+ # Read the file
+ with open(issue_file, "r") as f:
+ lines = f.readlines()
+ original_code = "".join(lines)
+
+ # Find the function declaration line
+ if 0 <= issue_line - 1 < len(lines):
+ func_line = lines[issue_line - 1]
+
+ # Check if it's a function declaration and doesn't have a return type
+ if f"def {func_name}" in func_line and "->" not in func_line:
+ # Find the closing parenthesis
+ close_paren_idx = func_line.rfind(")")
+ colon_idx = func_line.rfind(":")
+
+ if close_paren_idx != -1 and colon_idx != -1 and close_paren_idx < colon_idx:
+ # Insert return type
+ new_line = func_line[:close_paren_idx + 1] + f" -> {suggested_type}" + func_line[close_paren_idx + 1:]
+
+ # Generate change
+ return {
+ "original_code": original_code,
+ "code_changes": [
+ {
+ "line": issue_line,
+ "action": "replace",
+ "new_text": new_line.rstrip()
+ }
+ ]
+ }
+
+ return None
+ except Exception as e:
+ logger.error(f"Error resolving missing return type: {str(e)}")
+ return None
+
+ def _resolve_parameter_type_mismatch(self, issue):
+ """Resolution generator for parameter type mismatch issues."""
+ # Implementation would depend on the specific issue structure
+ return None
+
+ def _resolve_circular_dependency(self, issue):
+ """Resolution generator for circular dependency issues."""
+ # Implementation would involve analyzing the dependency graph
+ # and suggesting module reorganization
+ return None
+
+ def _resolve_complex_function(self, issue):
+ """Resolution generator for complex function issues."""
+ # Implementation would involve suggesting function refactoring
+ return None
+
+ def _resolve_dead_code(self, issue):
+ """Resolution generator for dead code issues."""
+ # Similar to unused function resolution
+ return None
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/snapshot/__init__.py b/codegen-on-oss/codegen_on_oss/analyzers/snapshot/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/snapshot/snapshot_manager.py b/codegen-on-oss/codegen_on_oss/analyzers/snapshot/snapshot_manager.py
new file mode 100644
index 000000000..adb9c82b4
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/snapshot/snapshot_manager.py
@@ -0,0 +1,780 @@
+#!/usr/bin/env python3
+"""
+Snapshot Manager Module
+
+This module provides functionality for creating, storing, and comparing
+codebase snapshots. It allows tracking changes over time and validating
+consistency between versions.
+"""
+
+import os
+import sys
+import json
+import logging
+import tempfile
+import shutil
+import hashlib
+from typing import Dict, List, Set, Tuple, Any, Optional, Union
+from datetime import datetime
+from pathlib import Path
+from dataclasses import dataclass, field
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class SnapshotMetadata:
+ """Metadata for a codebase snapshot."""
+ snapshot_id: str
+ timestamp: str
+ description: str
+ creator: str
+ base_path: str
+ commit_hash: Optional[str] = None
+ branch: Optional[str] = None
+ tag: Optional[str] = None
+ file_count: int = 0
+ total_lines: int = 0
+ language_stats: Dict[str, int] = field(default_factory=dict)
+ extra: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class FileSnapshot:
+ """Snapshot of a file in the codebase."""
+ path: str
+ relative_path: str
+ hash: str
+ size: int
+ lines: int
+ language: Optional[str] = None
+ content_hash: Optional[str] = None
+ ast_hash: Optional[str] = None
+ last_modified: Optional[str] = None
+ metadata: Dict[str, Any] = field(default_factory=dict)
+
+class CodebaseSnapshot:
+ """
+ Codebase snapshot representation.
+
+ This class stores a complete snapshot of a codebase at a point in time,
+ including all files and their metadata.
+ """
+
+ def __init__(
+ self,
+ base_path: str,
+ description: str = "",
+ creator: str = "snapshot_manager",
+ include_patterns: List[str] = None,
+ exclude_patterns: List[str] = None,
+ snapshot_id: Optional[str] = None,
+ store_content: bool = False
+ ):
+ """
+ Initialize a codebase snapshot.
+
+ Args:
+ base_path: Base path of the codebase
+ description: Description of the snapshot
+ creator: Creator of the snapshot
+ include_patterns: Patterns of files to include
+ exclude_patterns: Patterns of files to exclude
+ snapshot_id: Optional ID for the snapshot
+ store_content: Whether to store file content
+ """
+ self.base_path = os.path.abspath(base_path)
+ self.description = description
+ self.creator = creator
+ self.include_patterns = include_patterns or ["*"]
+ self.exclude_patterns = exclude_patterns or []
+ self.snapshot_id = snapshot_id or self._generate_id()
+ self.store_content = store_content
+ self.timestamp = datetime.now().isoformat()
+
+ # Initialize data structures
+ self.files: Dict[str, FileSnapshot] = {}
+ self.content: Dict[str, str] = {}
+ self.language_stats: Dict[str, int] = {}
+
+ # Get git information if available
+ self.commit_hash = self._get_git_commit_hash()
+ self.branch = self._get_git_branch()
+ self.tag = self._get_git_tag()
+
+ def _generate_id(self) -> str:
+ """
+ Generate a unique ID for the snapshot.
+
+ Returns:
+ Generated ID
+ """
+ timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+ random_suffix = hashlib.md5(os.urandom(16)).hexdigest()[:8]
+ return f"snapshot_{timestamp}_{random_suffix}"
+
+ def _get_git_commit_hash(self) -> Optional[str]:
+ """
+ Get the current Git commit hash.
+
+ Returns:
+ Commit hash if available, None otherwise
+ """
+ try:
+ import subprocess
+ result = subprocess.run(
+ ["git", "rev-parse", "HEAD"],
+ cwd=self.base_path,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ text=True,
+ check=False
+ )
+
+ if result.returncode == 0:
+ return result.stdout.strip()
+ return None
+ except Exception:
+ return None
+
+ def _get_git_branch(self) -> Optional[str]:
+ """
+ Get the current Git branch.
+
+ Returns:
+ Branch name if available, None otherwise
+ """
+ try:
+ import subprocess
+ result = subprocess.run(
+ ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+ cwd=self.base_path,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ text=True,
+ check=False
+ )
+
+ if result.returncode == 0:
+ return result.stdout.strip()
+ return None
+ except Exception:
+ return None
+
+ def _get_git_tag(self) -> Optional[str]:
+ """
+ Get the current Git tag.
+
+ Returns:
+ Tag name if available, None otherwise
+ """
+ try:
+ import subprocess
+ result = subprocess.run(
+ ["git", "describe", "--tags", "--exact-match"],
+ cwd=self.base_path,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ text=True,
+ check=False
+ )
+
+ if result.returncode == 0:
+ return result.stdout.strip()
+ return None
+ except Exception:
+ return None
+
+ def _get_file_language(self, file_path: str) -> Optional[str]:
+ """
+ Determine the programming language of a file based on its extension.
+
+ Args:
+ file_path: Path to the file
+
+ Returns:
+ Language name if recognized, None otherwise
+ """
+ extension = os.path.splitext(file_path)[1].lower()
+
+ language_map = {
+ ".py": "Python",
+ ".js": "JavaScript",
+ ".jsx": "JavaScript",
+ ".ts": "TypeScript",
+ ".tsx": "TypeScript",
+ ".java": "Java",
+ ".c": "C",
+ ".cpp": "C++",
+ ".h": "C/C++",
+ ".hpp": "C++",
+ ".cs": "C#",
+ ".go": "Go",
+ ".rb": "Ruby",
+ ".php": "PHP",
+ ".swift": "Swift",
+ ".kt": "Kotlin",
+ ".rs": "Rust",
+ ".scala": "Scala",
+ ".html": "HTML",
+ ".css": "CSS",
+ ".scss": "SCSS",
+ ".less": "LESS",
+ ".json": "JSON",
+ ".xml": "XML",
+ ".yaml": "YAML",
+ ".yml": "YAML",
+ ".md": "Markdown",
+ ".sql": "SQL",
+ ".sh": "Shell",
+ ".bat": "Batch",
+ ".ps1": "PowerShell",
+ }
+
+ return language_map.get(extension)
+
+ def _should_include_file(self, file_path: str) -> bool:
+ """
+ Check if a file should be included in the snapshot.
+
+ Args:
+ file_path: Path to the file
+
+ Returns:
+ True if the file should be included, False otherwise
+ """
+ import fnmatch
+
+ # Convert to relative path
+ rel_path = os.path.relpath(file_path, self.base_path)
+
+ # Check exclude patterns first
+ for pattern in self.exclude_patterns:
+ if fnmatch.fnmatch(rel_path, pattern):
+ return False
+
+ # Then check include patterns
+ for pattern in self.include_patterns:
+ if fnmatch.fnmatch(rel_path, pattern):
+ return True
+
+ return False
+
+ def _compute_file_hash(self, file_path: str) -> str:
+ """
+ Compute a hash of a file's content.
+
+ Args:
+ file_path: Path to the file
+
+ Returns:
+ Hash of the file content
+ """
+ hash_md5 = hashlib.md5()
+ with open(file_path, "rb") as f:
+ for chunk in iter(lambda: f.read(4096), b""):
+ hash_md5.update(chunk)
+ return hash_md5.hexdigest()
+
+ def _count_lines(self, file_path: str) -> int:
+ """
+ Count the number of lines in a file.
+
+ Args:
+ file_path: Path to the file
+
+ Returns:
+ Number of lines in the file
+ """
+ try:
+ with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+ return sum(1 for _ in f)
+ except Exception:
+ # Fallback for binary files
+ return 0
+
+ def create(self):
+ """
+ Create a snapshot of the codebase.
+
+ This method scans the codebase, collects file metadata, and
+ optionally stores file content.
+ """
+ if not os.path.isdir(self.base_path):
+ logger.error(f"Base path not found: {self.base_path}")
+ return
+
+ # Reset data structures
+ self.files = {}
+ self.content = {}
+ self.language_stats = {}
+
+ total_files = 0
+ total_lines = 0
+
+ # Walk the directory tree
+ for root, _, files in os.walk(self.base_path):
+ for file in files:
+ file_path = os.path.join(root, file)
+
+ # Skip if file should not be included
+ if not self._should_include_file(file_path):
+ continue
+
+ try:
+ # Get file stats
+ file_stats = os.stat(file_path)
+ file_size = file_stats.st_size
+ file_modified = datetime.fromtimestamp(file_stats.st_mtime).isoformat()
+
+ # Get file language
+ language = self._get_file_language(file_path)
+
+ # Count lines
+ line_count = self._count_lines(file_path)
+
+ # Compute hash
+ file_hash = self._compute_file_hash(file_path)
+
+ # Get relative path
+ rel_path = os.path.relpath(file_path, self.base_path)
+
+ # Create file snapshot
+ file_snapshot = FileSnapshot(
+ path=file_path,
+ relative_path=rel_path,
+ hash=file_hash,
+ size=file_size,
+ lines=line_count,
+ language=language,
+ last_modified=file_modified
+ )
+
+ # Store file content if requested
+ if self.store_content:
+ try:
+ with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+ file_content = f.read()
+ self.content[rel_path] = file_content
+ except Exception as e:
+ logger.warning(f"Could not read content of {file_path}: {str(e)}")
+
+ # Store file snapshot
+ self.files[rel_path] = file_snapshot
+
+ # Update language stats
+ if language:
+ self.language_stats[language] = self.language_stats.get(language, 0) + 1
+
+ # Update totals
+ total_files += 1
+ total_lines += line_count
+ except Exception as e:
+ logger.warning(f"Error processing file {file_path}: {str(e)}")
+
+ logger.info(f"Created snapshot with {total_files} files and {total_lines} lines")
+
+ def get_metadata(self) -> SnapshotMetadata:
+ """
+ Get metadata for the snapshot.
+
+ Returns:
+ Snapshot metadata
+ """
+ return SnapshotMetadata(
+ snapshot_id=self.snapshot_id,
+ timestamp=self.timestamp,
+ description=self.description,
+ creator=self.creator,
+ base_path=self.base_path,
+ commit_hash=self.commit_hash,
+ branch=self.branch,
+ tag=self.tag,
+ file_count=len(self.files),
+ total_lines=sum(file.lines for file in self.files.values()),
+ language_stats=self.language_stats
+ )
+
+ def save(self, output_path: Optional[str] = None) -> str:
+ """
+ Save the snapshot to disk.
+
+ Args:
+ output_path: Optional path to save the snapshot to
+
+ Returns:
+ Path to the saved snapshot
+ """
+ # Create a temporary directory if output_path is not provided
+ if not output_path:
+ output_dir = tempfile.mkdtemp(prefix="codebase_snapshot_")
+ output_path = os.path.join(output_dir, f"{self.snapshot_id}.json")
+
+ # Create output directory if it doesn't exist
+ os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+ # Convert snapshot to JSON
+ snapshot_data = {
+ "metadata": self.get_metadata().__dict__,
+ "files": {rel_path: file.__dict__ for rel_path, file in self.files.items()},
+ "content": self.content if self.store_content else {}
+ }
+
+ # Save to disk
+ with open(output_path, "w") as f:
+ json.dump(snapshot_data, f, indent=2)
+
+ logger.info(f"Saved snapshot to {output_path}")
+ return output_path
+
+ @classmethod
+ def load(cls, snapshot_path: str) -> 'CodebaseSnapshot':
+ """
+ Load a snapshot from disk.
+
+ Args:
+ snapshot_path: Path to the snapshot file
+
+ Returns:
+ Loaded snapshot
+ """
+ with open(snapshot_path, "r") as f:
+ snapshot_data = json.load(f)
+
+ # Extract metadata
+ metadata = snapshot_data["metadata"]
+
+ # Create snapshot instance
+ snapshot = cls(
+ base_path=metadata["base_path"],
+ description=metadata["description"],
+ creator=metadata["creator"],
+ snapshot_id=metadata["snapshot_id"]
+ )
+
+ # Set timestamp
+ snapshot.timestamp = metadata["timestamp"]
+
+ # Set Git information
+ snapshot.commit_hash = metadata.get("commit_hash")
+ snapshot.branch = metadata.get("branch")
+ snapshot.tag = metadata.get("tag")
+
+ # Load files
+ snapshot.files = {}
+ for rel_path, file_data in snapshot_data["files"].items():
+ snapshot.files[rel_path] = FileSnapshot(
+ path=file_data["path"],
+ relative_path=file_data["relative_path"],
+ hash=file_data["hash"],
+ size=file_data["size"],
+ lines=file_data["lines"],
+ language=file_data.get("language"),
+ last_modified=file_data.get("last_modified"),
+ metadata=file_data.get("metadata", {})
+ )
+
+ # Load content if available
+ snapshot.content = snapshot_data.get("content", {})
+ snapshot.store_content = bool(snapshot.content)
+
+ # Load language stats
+ snapshot.language_stats = metadata.get("language_stats", {})
+
+ logger.info(f"Loaded snapshot from {snapshot_path}")
+ return snapshot
+
+ def diff(self, other: 'CodebaseSnapshot') -> Dict[str, Any]:
+ """
+ Compare this snapshot with another snapshot.
+
+ Args:
+ other: Snapshot to compare with
+
+ Returns:
+ Diff between the snapshots
+ """
+ # Get sets of file paths
+ self_files = set(self.files.keys())
+ other_files = set(other.files.keys())
+
+ # Find added, deleted, and common files
+ added_files = other_files - self_files
+ deleted_files = self_files - other_files
+ common_files = self_files & other_files
+
+ # Find modified files
+ modified_files = []
+ for file_path in common_files:
+ self_file = self.files[file_path]
+ other_file = other.files[file_path]
+
+ if self_file.hash != other_file.hash:
+ modified_files.append(file_path)
+
+ # Calculate content diff for modified files if content is available
+ content_diff = {}
+ if self.store_content and other.store_content:
+ for file_path in modified_files:
+ if file_path in self.content and file_path in other.content:
+ try:
+ # Use difflib to generate unified diff
+ import difflib
+ diff = difflib.unified_diff(
+ self.content[file_path].splitlines(keepends=True),
+ other.content[file_path].splitlines(keepends=True),
+ fromfile=f"a/{file_path}",
+ tofile=f"b/{file_path}"
+ )
+ content_diff[file_path] = "".join(diff)
+ except Exception as e:
+ logger.warning(f"Error generating diff for {file_path}: {str(e)}")
+
+ # Calculate statistics
+ diff_stats = {
+ "files_added": len(added_files),
+ "files_deleted": len(deleted_files),
+ "files_modified": len(modified_files),
+ "files_unchanged": len(common_files) - len(modified_files),
+ "lines_added": sum(other.files[file_path].lines for file_path in added_files),
+ "lines_deleted": sum(self.files[file_path].lines for file_path in deleted_files),
+ "lines_modified": sum(other.files[file_path].lines - self.files[file_path].lines for file_path in modified_files if file_path in other.files and file_path in self.files),
+ }
+
+ # Calculate language stats diff
+ language_diff = {}
+ for language in set(self.language_stats.keys()) | set(other.language_stats.keys()):
+ self_count = self.language_stats.get(language, 0)
+ other_count = other.language_stats.get(language, 0)
+
+ if self_count != other_count:
+ language_diff[language] = other_count - self_count
+
+ return {
+ "added_files": list(added_files),
+ "deleted_files": list(deleted_files),
+ "modified_files": modified_files,
+ "stats": diff_stats,
+ "language_diff": language_diff,
+ "content_diff": content_diff,
+ "from_snapshot": self.snapshot_id,
+ "to_snapshot": other.snapshot_id,
+ "timestamp": datetime.now().isoformat()
+ }
+
+class SnapshotManager:
+ """
+ Manager for codebase snapshots.
+
+ This class provides functionality to create, store, load, and
+ compare codebase snapshots.
+ """
+
+ def __init__(self, storage_dir: Optional[str] = None):
+ """
+ Initialize the snapshot manager.
+
+ Args:
+ storage_dir: Directory to store snapshots in
+ """
+ self.storage_dir = storage_dir or os.path.join(tempfile.gettempdir(), "codebase_snapshots")
+ os.makedirs(self.storage_dir, exist_ok=True)
+
+ # Initialize data structures
+ self.snapshots: Dict[str, SnapshotMetadata] = {}
+ self.load_index()
+
+ def load_index(self):
+ """Load the snapshot index."""
+ index_path = os.path.join(self.storage_dir, "index.json")
+
+ if os.path.isfile(index_path):
+ try:
+ with open(index_path, "r") as f:
+ data = json.load(f)
+
+ self.snapshots = {}
+ for snapshot_id, metadata in data.items():
+ self.snapshots[snapshot_id] = SnapshotMetadata(**metadata)
+ except Exception as e:
+ logger.error(f"Error loading snapshot index: {str(e)}")
+ self.snapshots = {}
+
+ def save_index(self):
+ """Save the snapshot index."""
+ index_path = os.path.join(self.storage_dir, "index.json")
+
+ try:
+ with open(index_path, "w") as f:
+ json.dump({id: metadata.__dict__ for id, metadata in self.snapshots.items()}, f, indent=2)
+ except Exception as e:
+ logger.error(f"Error saving snapshot index: {str(e)}")
+
+ def create_snapshot(
+ self,
+ base_path: str,
+ description: str = "",
+ creator: str = "snapshot_manager",
+ include_patterns: List[str] = None,
+ exclude_patterns: List[str] = None,
+ snapshot_id: Optional[str] = None,
+ store_content: bool = False
+ ) -> str:
+ """
+ Create a new snapshot of a codebase.
+
+ Args:
+ base_path: Base path of the codebase
+ description: Description of the snapshot
+ creator: Creator of the snapshot
+ include_patterns: Patterns of files to include
+ exclude_patterns: Patterns of files to exclude
+ snapshot_id: Optional ID for the snapshot
+ store_content: Whether to store file content
+
+ Returns:
+ ID of the created snapshot
+ """
+ # Create the snapshot
+ snapshot = CodebaseSnapshot(
+ base_path=base_path,
+ description=description,
+ creator=creator,
+ include_patterns=include_patterns,
+ exclude_patterns=exclude_patterns,
+ snapshot_id=snapshot_id,
+ store_content=store_content
+ )
+
+ # Generate the snapshot
+ snapshot.create()
+
+ # Save the snapshot
+ snapshot_path = os.path.join(self.storage_dir, f"{snapshot.snapshot_id}.json")
+ snapshot.save(snapshot_path)
+
+ # Update the index
+ self.snapshots[snapshot.snapshot_id] = snapshot.get_metadata()
+ self.save_index()
+
+ return snapshot.snapshot_id
+
+ def get_snapshot(self, snapshot_id: str) -> Optional[CodebaseSnapshot]:
+ """
+ Get a snapshot by ID.
+
+ Args:
+ snapshot_id: ID of the snapshot
+
+ Returns:
+ Snapshot if found, None otherwise
+ """
+ if snapshot_id not in self.snapshots:
+ logger.error(f"Snapshot not found: {snapshot_id}")
+ return None
+
+ snapshot_path = os.path.join(self.storage_dir, f"{snapshot_id}.json")
+
+ if not os.path.isfile(snapshot_path):
+ logger.error(f"Snapshot file not found: {snapshot_path}")
+ return None
+
+ return CodebaseSnapshot.load(snapshot_path)
+
+ def delete_snapshot(self, snapshot_id: str) -> bool:
+ """
+ Delete a snapshot.
+
+ Args:
+ snapshot_id: ID of the snapshot
+
+ Returns:
+ True if the snapshot was deleted, False otherwise
+ """
+ if snapshot_id not in self.snapshots:
+ logger.error(f"Snapshot not found: {snapshot_id}")
+ return False
+
+ snapshot_path = os.path.join(self.storage_dir, f"{snapshot_id}.json")
+
+ if os.path.isfile(snapshot_path):
+ try:
+ os.remove(snapshot_path)
+ except Exception as e:
+ logger.error(f"Error deleting snapshot file: {str(e)}")
+ return False
+
+ # Update the index
+ del self.snapshots[snapshot_id]
+ self.save_index()
+
+ return True
+
+ def compare_snapshots(self, snapshot_id1: str, snapshot_id2: str) -> Optional[Dict[str, Any]]:
+ """
+ Compare two snapshots.
+
+ Args:
+ snapshot_id1: ID of the first snapshot
+ snapshot_id2: ID of the second snapshot
+
+ Returns:
+ Diff between the snapshots if both exist, None otherwise
+ """
+ snapshot1 = self.get_snapshot(snapshot_id1)
+ snapshot2 = self.get_snapshot(snapshot_id2)
+
+ if not snapshot1 or not snapshot2:
+ return None
+
+ return snapshot1.diff(snapshot2)
+
+ def get_latest_snapshot(self, base_path: Optional[str] = None) -> Optional[str]:
+ """
+ Get the latest snapshot ID.
+
+ Args:
+ base_path: Optional base path to filter snapshots
+
+ Returns:
+ ID of the latest snapshot if any exist, None otherwise
+ """
+ if not self.snapshots:
+ return None
+
+ filtered_snapshots = self.snapshots
+
+ if base_path:
+ filtered_snapshots = {
+ id: metadata for id, metadata in self.snapshots.items()
+ if metadata.base_path == base_path
+ }
+
+ if not filtered_snapshots:
+ return None
+
+ # Sort by timestamp and get the latest
+ latest_id = max(filtered_snapshots.keys(), key=lambda id: filtered_snapshots[id].timestamp)
+ return latest_id
+
+ def list_snapshots(self, base_path: Optional[str] = None) -> List[SnapshotMetadata]:
+ """
+ List all snapshots.
+
+ Args:
+ base_path: Optional base path to filter snapshots
+
+ Returns:
+ List of snapshot metadata
+ """
+ if base_path:
+ return [
+ metadata for metadata in self.snapshots.values()
+ if metadata.base_path == base_path
+ ]
+ else:
+ return list(self.snapshots.values())
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/unified_analyzer.py b/codegen-on-oss/codegen_on_oss/analyzers/unified_analyzer.py
new file mode 100644
index 000000000..bf204f042
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/unified_analyzer.py
@@ -0,0 +1,1633 @@
+#!/usr/bin/env python3
+"""
+Unified Codebase Analyzer Module
+
+This module consolidates various analyzer functionalities into a cohesive architecture,
+reducing code duplication and providing a standard interface for all types of codebase analysis.
+It enables comprehensive analysis of codebases including code quality, dependencies,
+structural patterns, and issue detection.
+"""
+
+import os
+import sys
+import json
+import logging
+import tempfile
+import networkx as nx
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, Type
+from enum import Enum
+
+try:
+ from codegen.sdk.core.codebase import Codebase
+ from codegen.configs.models.codebase import CodebaseConfig
+ from codegen.configs.models.secrets import SecretsConfig
+ from codegen.sdk.codebase.config import ProjectConfig
+ from codegen.git.schemas.repo_config import RepoConfig
+ from codegen.git.repo_operator.repo_operator import RepoOperator
+ from codegen.shared.enums.programming_language import ProgrammingLanguage
+ from codegen.sdk.codebase.codebase_analysis import get_codebase_summary, get_file_summary
+ from codegen.sdk.core.file import SourceFile
+ from codegen.sdk.enums import EdgeType, SymbolType
+ from codegen.sdk.core.symbol import Symbol
+ from codegen.sdk.core.function import Function
+ from codegen.sdk.core.class_definition import Class
+
+ # Import from our own modules
+ from codegen_on_oss.context_codebase import CodebaseContext, get_node_classes, GLOBAL_FILE_IGNORE_LIST
+ from codegen_on_oss.current_code_codebase import get_selected_codebase
+ from codegen_on_oss.analyzers.issue_types import Issue, IssueSeverity, AnalysisType, IssueCategory
+except ImportError:
+ print("Codegen SDK or required modules not found.")
+ sys.exit(1)
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class AnalyzerRegistry:
+ """
+ Registry of analyzer plugins.
+
+ This singleton maintains a registry of all analyzer plugins and their
+ associated analysis types.
+ """
+ _instance = None
+
+ def __new__(cls):
+ if cls._instance is None:
+ cls._instance = super(AnalyzerRegistry, cls).__new__(cls)
+ cls._instance._analyzers = {}
+ return cls._instance
+
+ def register(self, analysis_type: AnalysisType, analyzer_class: Type['AnalyzerPlugin']):
+ """
+ Register an analyzer plugin for a specific analysis type.
+
+ Args:
+ analysis_type: Type of analysis the plugin handles
+ analyzer_class: Class of the analyzer plugin
+ """
+ self._analyzers[analysis_type] = analyzer_class
+
+ def get_analyzer(self, analysis_type: AnalysisType) -> Optional[Type['AnalyzerPlugin']]:
+ """
+ Get the analyzer plugin for a specific analysis type.
+
+ Args:
+ analysis_type: Type of analysis to get plugin for
+
+ Returns:
+ The analyzer plugin class, or None if not found
+ """
+ return self._analyzers.get(analysis_type)
+
+ def list_analyzers(self) -> Dict[AnalysisType, Type['AnalyzerPlugin']]:
+ """
+ Get all registered analyzers.
+
+ Returns:
+ Dictionary mapping analysis types to analyzer plugin classes
+ """
+ return self._analyzers.copy()
+
+class AnalyzerPlugin:
+ """
+ Base class for analyzer plugins.
+
+ Analyzer plugins implement specific analysis functionality for different
+ types of codebase analysis.
+ """
+
+ def __init__(self, analyzer: 'UnifiedCodeAnalyzer'):
+ """
+ Initialize the analyzer plugin.
+
+ Args:
+ analyzer: Parent analyzer that owns this plugin
+ """
+ self.analyzer = analyzer
+ self.issues = []
+
+ def analyze(self) -> Dict[str, Any]:
+ """
+ Perform analysis using this plugin.
+
+ Returns:
+ Dictionary containing analysis results
+ """
+ raise NotImplementedError("Analyzer plugins must implement analyze()")
+
+ def add_issue(self, issue: Issue):
+ """
+ Add an issue to the list.
+
+ Args:
+ issue: Issue to add
+ """
+ self.analyzer.add_issue(issue)
+ self.issues.append(issue)
+
+class CodeQualityAnalyzerPlugin(AnalyzerPlugin):
+ """
+ Plugin for code quality analysis.
+
+ This plugin detects issues related to code quality, including
+ dead code, complexity, style, and maintainability.
+ """
+
+ def analyze(self) -> Dict[str, Any]:
+ """
+ Perform code quality analysis.
+
+ Returns:
+ Dictionary containing code quality analysis results
+ """
+ result = {}
+
+ # Perform code quality checks
+ result["dead_code"] = self._find_dead_code()
+ result["complexity"] = self._analyze_code_complexity()
+ result["style_issues"] = self._check_style_issues()
+ result["maintainability"] = self._calculate_maintainability()
+
+ return result
+
+ def _find_dead_code(self) -> Dict[str, Any]:
+ """Find unused code (dead code) in the codebase."""
+ codebase = self.analyzer.base_codebase
+
+ dead_code = {
+ "unused_functions": [],
+ "unused_classes": [],
+ "unused_variables": [],
+ "unused_imports": []
+ }
+
+ # Find unused functions
+ if hasattr(codebase, 'functions'):
+ for func in codebase.functions:
+ # Skip if function should be excluded
+ if self.analyzer.should_skip_symbol(func):
+ continue
+
+ # Skip decorated functions (as they might be used indirectly)
+ if hasattr(func, 'decorators') and func.decorators:
+ continue
+
+ # Check if function has no call sites or usages
+ has_call_sites = hasattr(func, 'call_sites') and len(func.call_sites) > 0
+ has_usages = hasattr(func, 'usages') and len(func.usages) > 0
+
+ if not has_call_sites and not has_usages:
+ # Get file path and name safely
+ file_path = func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Skip main entry points
+ if func_name in ["main", "__main__"]:
+ continue
+
+ # Add to dead code list
+ dead_code["unused_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None
+ })
+
+ # Add issue
+ self.add_issue(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Unused function: {func_name}",
+ severity=IssueSeverity.WARNING,
+ category=IssueCategory.DEAD_CODE,
+ symbol=func_name,
+ suggestion="Consider removing this unused function or documenting why it's needed"
+ ))
+
+ # Find unused classes
+ if hasattr(codebase, 'classes'):
+ for cls in codebase.classes:
+ # Skip if class should be excluded
+ if self.analyzer.should_skip_symbol(cls):
+ continue
+
+ # Check if class has no usages
+ has_usages = hasattr(cls, 'usages') and len(cls.usages) > 0
+
+ if not has_usages:
+ # Get file path and name safely
+ file_path = cls.file.file_path if hasattr(cls, 'file') and hasattr(cls.file, 'file_path') else "unknown"
+ cls_name = cls.name if hasattr(cls, 'name') else str(cls)
+
+ # Add to dead code list
+ dead_code["unused_classes"].append({
+ "name": cls_name,
+ "file": file_path,
+ "line": cls.line if hasattr(cls, 'line') else None
+ })
+
+ # Add issue
+ self.add_issue(Issue(
+ file=file_path,
+ line=cls.line if hasattr(cls, 'line') else None,
+ message=f"Unused class: {cls_name}",
+ severity=IssueSeverity.WARNING,
+ category=IssueCategory.DEAD_CODE,
+ symbol=cls_name,
+ suggestion="Consider removing this unused class or documenting why it's needed"
+ ))
+
+ # Summarize findings
+ dead_code["summary"] = {
+ "unused_functions_count": len(dead_code["unused_functions"]),
+ "unused_classes_count": len(dead_code["unused_classes"]),
+ "unused_variables_count": len(dead_code["unused_variables"]),
+ "unused_imports_count": len(dead_code["unused_imports"]),
+ "total_dead_code_count": (
+ len(dead_code["unused_functions"]) +
+ len(dead_code["unused_classes"]) +
+ len(dead_code["unused_variables"]) +
+ len(dead_code["unused_imports"])
+ )
+ }
+
+ return dead_code
+
+ def _analyze_code_complexity(self) -> Dict[str, Any]:
+ """Analyze code complexity."""
+ codebase = self.analyzer.base_codebase
+
+ complexity_result = {
+ "function_complexity": [],
+ "high_complexity_functions": [],
+ "average_complexity": 0.0,
+ "complexity_distribution": {
+ "low": 0,
+ "medium": 0,
+ "high": 0,
+ "very_high": 0
+ }
+ }
+
+ # Process all functions to calculate complexity
+ total_complexity = 0
+ function_count = 0
+
+ if hasattr(codebase, 'functions'):
+ for func in codebase.functions:
+ # Skip if function should be excluded
+ if self.analyzer.should_skip_symbol(func):
+ continue
+
+ # Skip if no code block
+ if not hasattr(func, 'code_block'):
+ continue
+
+ # Calculate cyclomatic complexity
+ complexity = self._calculate_cyclomatic_complexity(func)
+
+ # Get file path and name safely
+ file_path = func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Add to complexity list
+ complexity_result["function_complexity"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "complexity": complexity
+ })
+
+ # Track total complexity
+ total_complexity += complexity
+ function_count += 1
+
+ # Categorize complexity
+ if complexity <= 5:
+ complexity_result["complexity_distribution"]["low"] += 1
+ elif complexity <= 10:
+ complexity_result["complexity_distribution"]["medium"] += 1
+ elif complexity <= 15:
+ complexity_result["complexity_distribution"]["high"] += 1
+ else:
+ complexity_result["complexity_distribution"]["very_high"] += 1
+
+ # Flag high complexity functions
+ if complexity > 10:
+ complexity_result["high_complexity_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "complexity": complexity
+ })
+
+ # Add issue
+ severity = IssueSeverity.WARNING if complexity <= 15 else IssueSeverity.ERROR
+ self.add_issue(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"High cyclomatic complexity: {complexity}",
+ severity=severity,
+ category=IssueCategory.COMPLEXITY,
+ symbol=func_name,
+ suggestion="Consider refactoring this function to reduce complexity"
+ ))
+
+ # Calculate average complexity
+ complexity_result["average_complexity"] = total_complexity / function_count if function_count > 0 else 0.0
+
+ # Sort high complexity functions by complexity
+ complexity_result["high_complexity_functions"].sort(key=lambda x: x["complexity"], reverse=True)
+
+ return complexity_result
+
+ def _calculate_cyclomatic_complexity(self, function) -> int:
+ """Calculate cyclomatic complexity for a function."""
+ complexity = 1 # Base complexity
+
+ def analyze_statement(statement):
+ nonlocal complexity
+
+ # Check for if statements (including elif branches)
+ if hasattr(statement, 'if_clause'):
+ complexity += 1
+
+ # Count elif branches
+ if hasattr(statement, 'elif_statements'):
+ complexity += len(statement.elif_statements)
+
+ # Count else branches
+ if hasattr(statement, 'else_clause') and statement.else_clause:
+ complexity += 1
+
+ # Count for loops
+ if hasattr(statement, 'is_for_loop') and statement.is_for_loop:
+ complexity += 1
+
+ # Count while loops
+ if hasattr(statement, 'is_while_loop') and statement.is_while_loop:
+ complexity += 1
+
+ # Count try/except blocks (each except adds a path)
+ if hasattr(statement, 'is_try_block') and statement.is_try_block:
+ if hasattr(statement, 'except_clauses'):
+ complexity += len(statement.except_clauses)
+
+ # Recursively process nested statements
+ if hasattr(statement, 'statements'):
+ for nested_stmt in statement.statements:
+ analyze_statement(nested_stmt)
+
+ # Process all statements in the function's code block
+ if hasattr(function, 'code_block') and hasattr(function.code_block, 'statements'):
+ for statement in function.code_block.statements:
+ analyze_statement(statement)
+
+ return complexity
+
+ def _check_style_issues(self) -> Dict[str, Any]:
+ """Check for code style issues."""
+ codebase = self.analyzer.base_codebase
+
+ style_result = {
+ "long_functions": [],
+ "long_lines": [],
+ "inconsistent_naming": [],
+ "summary": {
+ "long_functions_count": 0,
+ "long_lines_count": 0,
+ "inconsistent_naming_count": 0
+ }
+ }
+
+ # Check for long functions (too many lines)
+ if hasattr(codebase, 'functions'):
+ for func in codebase.functions:
+ # Skip if function should be excluded
+ if self.analyzer.should_skip_symbol(func):
+ continue
+
+ # Get function code
+ if hasattr(func, 'source'):
+ code = func.source
+ lines = code.split('\n')
+
+ # Check function length
+ if len(lines) > 50: # Threshold for "too long"
+ # Get file path and name safely
+ file_path = func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Add to long functions list
+ style_result["long_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "line_count": len(lines)
+ })
+
+ # Add issue
+ self.add_issue(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Long function: {len(lines)} lines",
+ severity=IssueSeverity.INFO,
+ category=IssueCategory.STYLE_ISSUE,
+ symbol=func_name,
+ suggestion="Consider breaking this function into smaller, more focused functions"
+ ))
+
+ # Update summary
+ style_result["summary"]["long_functions_count"] = len(style_result["long_functions"])
+ style_result["summary"]["long_lines_count"] = len(style_result["long_lines"])
+ style_result["summary"]["inconsistent_naming_count"] = len(style_result["inconsistent_naming"])
+
+ return style_result
+
+ def _calculate_maintainability(self) -> Dict[str, Any]:
+ """Calculate maintainability metrics."""
+ import math
+ codebase = self.analyzer.base_codebase
+
+ maintainability_result = {
+ "function_maintainability": [],
+ "low_maintainability_functions": [],
+ "average_maintainability": 0.0,
+ "maintainability_distribution": {
+ "high": 0,
+ "medium": 0,
+ "low": 0
+ }
+ }
+
+ # Process all functions to calculate maintainability
+ total_maintainability = 0
+ function_count = 0
+
+ if hasattr(codebase, 'functions'):
+ for func in codebase.functions:
+ # Skip if function should be excluded
+ if self.analyzer.should_skip_symbol(func):
+ continue
+
+ # Skip if no code block
+ if not hasattr(func, 'code_block'):
+ continue
+
+ # Calculate metrics
+ complexity = self._calculate_cyclomatic_complexity(func)
+
+ # Calculate Halstead volume (approximation)
+ operators = 0
+ operands = 0
+
+ if hasattr(func, 'source'):
+ code = func.source
+ # Simple approximation of operators and operands
+ operators = len([c for c in code if c in '+-*/=<>!&|^~%'])
+ # Counting words as potential operands
+ import re
+ operands = len(re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', code))
+
+ halstead_volume = operators * operands * math.log2(operators + operands) if operators + operands > 0 else 0
+
+ # Count lines of code
+ loc = len(func.source.split('\n')) if hasattr(func, 'source') else 0
+
+ # Calculate maintainability index
+ # Formula: 171 - 5.2 * ln(Halstead Volume) - 0.23 * (Cyclomatic Complexity) - 16.2 * ln(LOC)
+ halstead_term = 5.2 * math.log(max(1, halstead_volume)) if halstead_volume > 0 else 0
+ complexity_term = 0.23 * complexity
+ loc_term = 16.2 * math.log(max(1, loc)) if loc > 0 else 0
+
+ maintainability = 171 - halstead_term - complexity_term - loc_term
+
+ # Normalize to 0-100 scale
+ maintainability = max(0, min(100, maintainability * 100 / 171))
+
+ # Get file path and name safely
+ file_path = func.file.file_path if hasattr(func, 'file') and hasattr(func.file, 'file_path') else "unknown"
+ func_name = func.name if hasattr(func, 'name') else str(func)
+
+ # Add to maintainability list
+ maintainability_result["function_maintainability"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "maintainability": maintainability,
+ "complexity": complexity,
+ "halstead_volume": halstead_volume,
+ "loc": loc
+ })
+
+ # Track total maintainability
+ total_maintainability += maintainability
+ function_count += 1
+
+ # Categorize maintainability
+ if maintainability >= 70:
+ maintainability_result["maintainability_distribution"]["high"] += 1
+ elif maintainability >= 50:
+ maintainability_result["maintainability_distribution"]["medium"] += 1
+ else:
+ maintainability_result["maintainability_distribution"]["low"] += 1
+
+ # Flag low maintainability functions
+ maintainability_result["low_maintainability_functions"].append({
+ "name": func_name,
+ "file": file_path,
+ "line": func.line if hasattr(func, 'line') else None,
+ "maintainability": maintainability,
+ "complexity": complexity,
+ "halstead_volume": halstead_volume,
+ "loc": loc
+ })
+
+ # Add issue
+ self.add_issue(Issue(
+ file=file_path,
+ line=func.line if hasattr(func, 'line') else None,
+ message=f"Low maintainability index: {maintainability:.1f}",
+ severity=IssueSeverity.WARNING,
+ category=IssueCategory.COMPLEXITY,
+ symbol=func_name,
+ suggestion="Consider refactoring this function to improve maintainability"
+ ))
+
+ # Calculate average maintainability
+ maintainability_result["average_maintainability"] = total_maintainability / function_count if function_count > 0 else 0.0
+
+ # Sort low maintainability functions
+ maintainability_result["low_maintainability_functions"].sort(key=lambda x: x["maintainability"])
+
+ return maintainability_result
+
+class DependencyAnalyzerPlugin(AnalyzerPlugin):
+ """
+ Plugin for dependency analysis.
+
+ This plugin detects issues related to dependencies, including
+ import relationships, circular dependencies, and module coupling.
+ """
+
+ def analyze(self) -> Dict[str, Any]:
+ """
+ Perform dependency analysis.
+
+ Returns:
+ Dictionary containing dependency analysis results
+ """
+ result = {}
+
+ # Perform dependency checks
+ result["import_dependencies"] = self._analyze_import_dependencies()
+ result["circular_dependencies"] = self._find_circular_dependencies()
+ result["module_coupling"] = self._analyze_module_coupling()
+ result["external_dependencies"] = self._analyze_external_dependencies()
+
+ return result
+
+ def _analyze_import_dependencies(self) -> Dict[str, Any]:
+ """Analyze import dependencies in the codebase."""
+ codebase = self.analyzer.base_codebase
+
+ import_deps = {
+ "module_dependencies": [],
+ "file_dependencies": [],
+ "most_imported_modules": [],
+ "most_importing_modules": [],
+ "dependency_stats": {
+ "total_imports": 0,
+ "internal_imports": 0,
+ "external_imports": 0,
+ "relative_imports": 0
+ }
+ }
+
+ # Create a directed graph for module dependencies
+ G = nx.DiGraph()
+
+ # Track import counts
+ module_imports = {} # modules importing others
+ module_imported = {} # modules being imported
+
+ # Process all files to extract import information
+ for file in codebase.files:
+ # Skip if no imports
+ if not hasattr(file, 'imports') or not file.imports:
+ continue
+
+ # Skip if file should be excluded
+ if self.analyzer.should_skip_file(file):
+ continue
+
+ # Get file path
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file.path) if hasattr(file, 'path') else str(file)
+
+ # Extract module name from file path
+ file_parts = file_path.split('/')
+ module_name = '/'.join(file_parts[:-1]) if len(file_parts) > 1 else file_parts[0]
+
+ # Initialize import counts
+ if module_name not in module_imports:
+ module_imports[module_name] = 0
+
+ # Process imports
+ for imp in file.imports:
+ import_deps["dependency_stats"]["total_imports"] += 1
+
+ # Get imported module information
+ imported_file = None
+ imported_module = "unknown"
+ is_external = False
+
+ if hasattr(imp, 'resolved_file'):
+ imported_file = imp.resolved_file
+ elif hasattr(imp, 'resolved_symbol') and hasattr(imp.resolved_symbol, 'file'):
+ imported_file = imp.resolved_symbol.file
+
+ if imported_file:
+ # Get imported file path
+ imported_path = imported_file.file_path if hasattr(imported_file, 'file_path') else str(imported_file.path) if hasattr(imported_file, 'path') else str(imported_file)
+
+ # Extract imported module name
+ imported_parts = imported_path.split('/')
+ imported_module = '/'.join(imported_parts[:-1]) if len(imported_parts) > 1 else imported_parts[0]
+
+ # Check if external
+ is_external = hasattr(imported_file, 'is_external') and imported_file.is_external
+ else:
+ # If we couldn't resolve the import, use the import name
+ imported_module = imp.name if hasattr(imp, 'name') else "unknown"
+
+ # Assume external if we couldn't resolve
+ is_external = True
+
+ # Update import type counts
+ if is_external:
+ import_deps["dependency_stats"]["external_imports"] += 1
+ else:
+ import_deps["dependency_stats"]["internal_imports"] += 1
+
+ # Check if relative import
+ if hasattr(imp, 'is_relative') and imp.is_relative:
+ import_deps["dependency_stats"]["relative_imports"] += 1
+
+ # Update module import counts
+ module_imports[module_name] += 1
+
+ if imported_module not in module_imported:
+ module_imported[imported_module] = 0
+ module_imported[imported_module] += 1
+
+ # Add to dependency graph
+ if module_name != imported_module: # Skip self-imports
+ G.add_edge(module_name, imported_module)
+
+ # Add to file dependencies list
+ import_deps["file_dependencies"].append({
+ "source_file": file_path,
+ "target_file": imported_path if imported_file else "unknown",
+ "import_name": imp.name if hasattr(imp, 'name') else "unknown",
+ "is_external": is_external
+ })
+
+ # Extract module dependencies from graph
+ for source, target in G.edges():
+ import_deps["module_dependencies"].append({
+ "source_module": source,
+ "target_module": target
+ })
+
+ # Find most imported modules
+ most_imported = sorted(
+ [(module, count) for module, count in module_imported.items()],
+ key=lambda x: x[1],
+ reverse=True
+ )
+
+ for module, count in most_imported[:10]: # Top 10
+ import_deps["most_imported_modules"].append({
+ "module": module,
+ "import_count": count
+ })
+
+ # Find modules that import the most
+ most_importing = sorted(
+ [(module, count) for module, count in module_imports.items()],
+ key=lambda x: x[1],
+ reverse=True
+ )
+
+ for module, count in most_importing[:10]: # Top 10
+ import_deps["most_importing_modules"].append({
+ "module": module,
+ "import_count": count
+ })
+
+ return import_deps
+
+ def _find_circular_dependencies(self) -> Dict[str, Any]:
+ """Find circular dependencies in the codebase."""
+ codebase = self.analyzer.base_codebase
+
+ circular_deps = {
+ "circular_imports": [],
+ "circular_dependencies_count": 0,
+ "affected_modules": set()
+ }
+
+ # Create dependency graph if not already available
+ G = nx.DiGraph()
+
+ # Process all files to build dependency graph
+ for file in codebase.files:
+ # Skip if no imports
+ if not hasattr(file, 'imports') or not file.imports:
+ continue
+
+ # Skip if file should be excluded
+ if self.analyzer.should_skip_file(file):
+ continue
+
+ # Get file path
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file.path) if hasattr(file, 'path') else str(file)
+
+ # Process imports
+ for imp in file.imports:
+ # Get imported file
+ imported_file = None
+
+ if hasattr(imp, 'resolved_file'):
+ imported_file = imp.resolved_file
+ elif hasattr(imp, 'resolved_symbol') and hasattr(imp.resolved_symbol, 'file'):
+ imported_file = imp.resolved_symbol.file
+
+ if imported_file:
+ # Get imported file path
+ imported_path = imported_file.file_path if hasattr(imported_file, 'file_path') else str(imported_file.path) if hasattr(imported_file, 'path') else str(imported_file)
+
+ # Add edge to graph
+ G.add_edge(file_path, imported_path)
+
+ # Find cycles in the graph
+ try:
+ cycles = list(nx.simple_cycles(G))
+
+ for cycle in cycles:
+ circular_deps["circular_imports"].append({
+ "files": cycle,
+ "length": len(cycle)
+ })
+
+ # Add affected modules to set
+ for file_path in cycle:
+ module_path = '/'.join(file_path.split('/')[:-1])
+ circular_deps["affected_modules"].add(module_path)
+
+ # Add issue
+ if len(cycle) >= 2:
+ self.add_issue(Issue(
+ file=cycle[0],
+ line=None,
+ message=f"Circular dependency detected between {len(cycle)} files",
+ severity=IssueSeverity.ERROR,
+ category=IssueCategory.DEPENDENCY_CYCLE,
+ suggestion="Break the circular dependency by refactoring the code"
+ ))
+
+ except Exception as e:
+ logger.error(f"Error finding circular dependencies: {e}")
+
+ # Update cycle count
+ circular_deps["circular_dependencies_count"] = len(circular_deps["circular_imports"])
+ circular_deps["affected_modules"] = list(circular_deps["affected_modules"])
+
+ return circular_deps
+
+ def _analyze_module_coupling(self) -> Dict[str, Any]:
+ """Analyze module coupling in the codebase."""
+ codebase = self.analyzer.base_codebase
+
+ coupling = {
+ "high_coupling_modules": [],
+ "low_coupling_modules": [],
+ "coupling_metrics": {},
+ "average_coupling": 0.0
+ }
+
+ # Create module dependency graphs
+ modules = {} # Module name -> set of imported modules
+ module_files = {} # Module name -> list of files
+
+ # Process all files to extract module information
+ for file in codebase.files:
+ # Skip if file should be excluded
+ if self.analyzer.should_skip_file(file):
+ continue
+
+ # Get file path
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file.path) if hasattr(file, 'path') else str(file)
+
+ # Extract module name from file path
+ module_parts = file_path.split('/')
+ module_name = '/'.join(module_parts[:-1]) if len(module_parts) > 1 else module_parts[0]
+
+ # Initialize module structures
+ if module_name not in modules:
+ modules[module_name] = set()
+ module_files[module_name] = []
+
+ module_files[module_name].append(file_path)
+
+ # Skip if no imports
+ if not hasattr(file, 'imports') or not file.imports:
+ continue
+
+ # Process imports
+ for imp in file.imports:
+ # Get imported file
+ imported_file = None
+
+ if hasattr(imp, 'resolved_file'):
+ imported_file = imp.resolved_file
+ elif hasattr(imp, 'resolved_symbol') and hasattr(imp.resolved_symbol, 'file'):
+ imported_file = imp.resolved_symbol.file
+
+ if imported_file:
+ # Get imported file path
+ imported_path = imported_file.file_path if hasattr(imported_file, 'file_path') else str(imported_file.path) if hasattr(imported_file, 'path') else str(imported_file)
+
+ # Extract imported module name
+ imported_parts = imported_path.split('/')
+ imported_module = '/'.join(imported_parts[:-1]) if len(imported_parts) > 1 else imported_parts[0]
+
+ # Skip self-imports
+ if imported_module != module_name:
+ modules[module_name].add(imported_module)
+
+ # Calculate coupling metrics for each module
+ total_coupling = 0.0
+ module_count = 0
+
+ for module_name, imported_modules in modules.items():
+ # Calculate metrics
+ file_count = len(module_files[module_name])
+ import_count = len(imported_modules)
+
+ # Calculate coupling ratio (imports per file)
+ coupling_ratio = import_count / file_count if file_count > 0 else 0
+
+ # Add to metrics
+ coupling["coupling_metrics"][module_name] = {
+ "files": file_count,
+ "imported_modules": list(imported_modules),
+ "import_count": import_count,
+ "coupling_ratio": coupling_ratio
+ }
+
+ # Track total for average
+ total_coupling += coupling_ratio
+ module_count += 1
+
+ # Categorize coupling
+ if coupling_ratio > 3: # Threshold for "high coupling"
+ coupling["high_coupling_modules"].append({
+ "module": module_name,
+ "coupling_ratio": coupling_ratio,
+ "import_count": import_count,
+ "file_count": file_count
+ })
+
+ # Add issue
+ self.add_issue(Issue(
+ file=module_files[module_name][0] if module_files[module_name] else module_name,
+ line=None,
+ message=f"High module coupling: {coupling_ratio:.2f} imports per file",
+ severity=IssueSeverity.WARNING,
+ category=IssueCategory.DEPENDENCY_CYCLE,
+ suggestion="Consider refactoring to reduce coupling between modules"
+ ))
+ elif coupling_ratio < 0.5 and file_count > 1: # Threshold for "low coupling"
+ coupling["low_coupling_modules"].append({
+ "module": module_name,
+ "coupling_ratio": coupling_ratio,
+ "import_count": import_count,
+ "file_count": file_count
+ })
+
+ # Calculate average coupling
+ coupling["average_coupling"] = total_coupling / module_count if module_count > 0 else 0.0
+
+ # Sort coupling lists
+ coupling["high_coupling_modules"].sort(key=lambda x: x["coupling_ratio"], reverse=True)
+ coupling["low_coupling_modules"].sort(key=lambda x: x["coupling_ratio"])
+
+ return coupling
+
+ def _analyze_external_dependencies(self) -> Dict[str, Any]:
+ """Analyze external dependencies in the codebase."""
+ codebase = self.analyzer.base_codebase
+
+ external_deps = {
+ "external_modules": [],
+ "external_module_usage": {},
+ "most_used_external_modules": []
+ }
+
+ # Track external module usage
+ external_usage = {} # Module name -> usage count
+
+ # Process all imports to find external dependencies
+ for file in codebase.files:
+ # Skip if no imports
+ if not hasattr(file, 'imports') or not file.imports:
+ continue
+
+ # Skip if file should be excluded
+ if self.analyzer.should_skip_file(file):
+ continue
+
+ # Process imports
+ for imp in file.imports:
+ # Check if external import
+ is_external = False
+ external_name = None
+
+ if hasattr(imp, 'module_name'):
+ external_name = imp.module_name
+
+ # Check if this is an external module
+ if hasattr(imp, 'is_external'):
+ is_external = imp.is_external
+ elif external_name and '.' not in external_name and '/' not in external_name:
+ # Simple heuristic: single-word module names without dots or slashes
+ # are likely external modules
+ is_external = True
+
+ if is_external and external_name:
+ # Add to external modules list if not already there
+ if external_name not in external_usage:
+ external_usage[external_name] = 0
+ external_deps["external_modules"].append(external_name)
+
+ external_usage[external_name] += 1
+
+ # Add usage counts
+ for module, count in external_usage.items():
+ external_deps["external_module_usage"][module] = count
+
+ # Find most used external modules
+ most_used = sorted(
+ [(module, count) for module, count in external_usage.items()],
+ key=lambda x: x[1],
+ reverse=True
+ )
+
+ for module, count in most_used[:10]: # Top 10
+ external_deps["most_used_external_modules"].append({
+ "module": module,
+ "usage_count": count
+ })
+
+ return external_deps
+
+class UnifiedCodeAnalyzer:
+ """
+ Unified Codebase Analyzer.
+
+ This class provides a comprehensive framework for analyzing codebases,
+ with support for pluggable analyzers for different types of analysis.
+ """
+
+ def __init__(
+ self,
+ repo_url: Optional[str] = None,
+ repo_path: Optional[str] = None,
+ base_branch: str = "main",
+ pr_number: Optional[int] = None,
+ language: Optional[str] = None,
+ file_ignore_list: Optional[List[str]] = None,
+ config: Optional[Dict[str, Any]] = None
+ ):
+ """
+ Initialize the unified analyzer.
+
+ Args:
+ repo_url: URL of the repository to analyze
+ repo_path: Local path to the repository to analyze
+ base_branch: Base branch for comparison
+ pr_number: PR number to analyze
+ language: Programming language of the codebase
+ file_ignore_list: List of file patterns to ignore
+ config: Additional configuration options
+ """
+ self.repo_url = repo_url
+ self.repo_path = repo_path
+ self.base_branch = base_branch
+ self.pr_number = pr_number
+ self.language = language
+
+ # Use custom ignore list or default global list
+ self.file_ignore_list = file_ignore_list or GLOBAL_FILE_IGNORE_LIST
+
+ # Configuration options
+ self.config = config or {}
+
+ # Codebase and context objects
+ self.base_codebase = None
+ self.pr_codebase = None
+ self.base_context = None
+ self.pr_context = None
+
+ # Analysis results
+ self.issues = []
+ self.results = {}
+
+ # PR comparison data
+ self.pr_diff = None
+ self.commit_shas = None
+ self.modified_symbols = None
+ self.pr_branch = None
+
+ # Initialize codebase(s) based on provided parameters
+ if repo_url:
+ self._init_from_url(repo_url, language)
+ elif repo_path:
+ self._init_from_path(repo_path, language)
+
+ # If PR number is provided, initialize PR-specific data
+ if self.pr_number is not None and self.base_codebase is not None:
+ self._init_pr_data(self.pr_number)
+
+ # Initialize contexts
+ self._init_contexts()
+
+ # Initialize analyzers
+ self._init_analyzers()
+
+ def _init_from_url(self, repo_url: str, language: Optional[str] = None):
+ """
+ Initialize codebase from a repository URL.
+
+ Args:
+ repo_url: URL of the repository
+ language: Programming language of the codebase
+ """
+ try:
+ # Extract repository information
+ if repo_url.endswith('.git'):
+ repo_url = repo_url[:-4]
+
+ parts = repo_url.rstrip('/').split('/')
+ repo_name = parts[-1]
+ owner = parts[-2]
+ repo_full_name = f"{owner}/{repo_name}"
+
+ # Create temporary directory for cloning
+ tmp_dir = tempfile.mkdtemp(prefix="analyzer_")
+
+ # Set up configuration
+ config = CodebaseConfig(
+ debug=False,
+ allow_external=True,
+ py_resolve_syspath=True,
+ )
+
+ secrets = SecretsConfig()
+
+ # Determine programming language
+ prog_lang = None
+ if language:
+ prog_lang = ProgrammingLanguage(language.upper())
+
+ # Initialize the codebase
+ logger.info(f"Initializing codebase from {repo_url}")
+
+ self.base_codebase = Codebase.from_github(
+ repo_full_name=repo_full_name,
+ tmp_dir=tmp_dir,
+ language=prog_lang,
+ config=config,
+ secrets=secrets
+ )
+
+ logger.info(f"Successfully initialized codebase from {repo_url}")
+
+ except Exception as e:
+ logger.error(f"Error initializing codebase from URL: {e}")
+ raise
+
+ def _init_from_path(self, repo_path: str, language: Optional[str] = None):
+ """
+ Initialize codebase from a local repository path.
+
+ Args:
+ repo_path: Path to the repository
+ language: Programming language of the codebase
+ """
+ try:
+ # Set up configuration
+ config = CodebaseConfig(
+ debug=False,
+ allow_external=True,
+ py_resolve_syspath=True,
+ )
+
+ secrets = SecretsConfig()
+
+ # Initialize the codebase
+ logger.info(f"Initializing codebase from {repo_path}")
+
+ # Determine programming language
+ prog_lang = None
+ if language:
+ prog_lang = ProgrammingLanguage(language.upper())
+
+ # Set up repository configuration
+ repo_config = RepoConfig.from_repo_path(repo_path)
+ repo_config.respect_gitignore = False
+ repo_operator = RepoOperator(repo_config=repo_config, bot_commit=False)
+
+ # Create project configuration
+ project_config = ProjectConfig(
+ repo_operator=repo_operator,
+ programming_language=prog_lang if prog_lang else None
+ )
+
+ # Initialize codebase
+ self.base_codebase = Codebase(
+ projects=[project_config],
+ config=config,
+ secrets=secrets
+ )
+
+ logger.info(f"Successfully initialized codebase from {repo_path}")
+
+ except Exception as e:
+ logger.error(f"Error initializing codebase from path: {e}")
+ raise
+
+ def _init_pr_data(self, pr_number: int):
+ """
+ Initialize PR-specific data.
+
+ Args:
+ pr_number: PR number to analyze
+ """
+ try:
+ logger.info(f"Fetching PR #{pr_number} data")
+ result = self.base_codebase.get_modified_symbols_in_pr(pr_number)
+
+ # Unpack the result tuple
+ if len(result) >= 3:
+ self.pr_diff, self.commit_shas, self.modified_symbols = result[:3]
+ if len(result) >= 4:
+ self.pr_branch = result[3]
+
+ logger.info(f"Found {len(self.modified_symbols)} modified symbols in PR")
+
+ # Initialize PR codebase
+ self._init_pr_codebase()
+
+ except Exception as e:
+ logger.error(f"Error initializing PR data: {e}")
+ raise
+
+ def _init_pr_codebase(self):
+ """Initialize PR codebase by checking out the PR branch."""
+ if not self.base_codebase or not self.pr_number:
+ logger.error("Base codebase or PR number not initialized")
+ return
+
+ try:
+ # Get PR data if not already fetched
+ if not self.pr_branch:
+ self._init_pr_data(self.pr_number)
+
+ if not self.pr_branch:
+ logger.error("Failed to get PR branch")
+ return
+
+ # Clone the base codebase
+ self.pr_codebase = self.base_codebase
+
+ # Checkout PR branch
+ logger.info(f"Checking out PR branch: {self.pr_branch}")
+ self.pr_codebase.checkout(self.pr_branch)
+
+ logger.info("Successfully initialized PR codebase")
+
+ except Exception as e:
+ logger.error(f"Error initializing PR codebase: {e}")
+ raise
+
+ def _init_contexts(self):
+ """Initialize CodebaseContext objects for both base and PR codebases."""
+ if self.base_codebase:
+ try:
+ self.base_context = CodebaseContext(
+ codebase=self.base_codebase,
+ base_path=self.repo_path,
+ pr_branch=None,
+ base_branch=self.base_branch
+ )
+ logger.info("Successfully initialized base context")
+ except Exception as e:
+ logger.error(f"Error initializing base context: {e}")
+
+ if self.pr_codebase:
+ try:
+ self.pr_context = CodebaseContext(
+ codebase=self.pr_codebase,
+ base_path=self.repo_path,
+ pr_branch=self.pr_branch,
+ base_branch=self.base_branch
+ )
+ logger.info("Successfully initialized PR context")
+ except Exception as e:
+ logger.error(f"Error initializing PR context: {e}")
+
+ def _init_analyzers(self):
+ """Initialize analyzer plugins."""
+ # Register default analyzers
+ registry = AnalyzerRegistry()
+ registry.register(AnalysisType.CODE_QUALITY, CodeQualityAnalyzerPlugin)
+ registry.register(AnalysisType.DEPENDENCY, DependencyAnalyzerPlugin)
+
+ def add_issue(self, issue: Issue):
+ """
+ Add an issue to the list of detected issues.
+
+ Args:
+ issue: Issue to add
+ """
+ # Check if issue should be skipped
+ if self.should_skip_issue(issue):
+ return
+
+ self.issues.append(issue)
+
+ def should_skip_issue(self, issue: Issue) -> bool:
+ """
+ Check if an issue should be skipped based on file patterns.
+
+ Args:
+ issue: Issue to check
+
+ Returns:
+ True if the issue should be skipped, False otherwise
+ """
+ # Skip issues in ignored files
+ file_path = issue.file
+
+ # Check against ignore list
+ for pattern in self.file_ignore_list:
+ if pattern in file_path:
+ return True
+
+ # Check if the file is a test file
+ if "test" in file_path.lower() or "tests" in file_path.lower():
+ # Skip low-severity issues in test files
+ if issue.severity in [IssueSeverity.INFO, IssueSeverity.WARNING]:
+ return True
+
+ return False
+
+ def should_skip_file(self, file) -> bool:
+ """
+ Check if a file should be skipped during analysis.
+
+ Args:
+ file: File to check
+
+ Returns:
+ True if the file should be skipped, False otherwise
+ """
+ # Skip binary files
+ if hasattr(file, 'is_binary') and file.is_binary:
+ return True
+
+ # Get file path
+ file_path = file.file_path if hasattr(file, 'file_path') else str(file.path) if hasattr(file, 'path') else str(file)
+
+ # Check against ignore list
+ for pattern in self.file_ignore_list:
+ if pattern in file_path:
+ return True
+
+ return False
+
+ def should_skip_symbol(self, symbol) -> bool:
+ """
+ Check if a symbol should be skipped during analysis.
+
+ Args:
+ symbol: Symbol to check
+
+ Returns:
+ True if the symbol should be skipped, False otherwise
+ """
+ # Skip symbols without a file
+ if not hasattr(symbol, 'file'):
+ return True
+
+ # Skip symbols in skipped files
+ return self.should_skip_file(symbol.file)
+
+ def get_issues(self, severity: Optional[IssueSeverity] = None, category: Optional[IssueCategory] = None) -> List[Issue]:
+ """
+ Get all issues matching the specified criteria.
+
+ Args:
+ severity: Optional severity level to filter by
+ category: Optional category to filter by
+
+ Returns:
+ List of matching issues
+ """
+ filtered_issues = self.issues
+
+ if severity:
+ filtered_issues = [i for i in filtered_issues if i.severity == severity]
+
+ if category:
+ filtered_issues = [i for i in filtered_issues if i.category == category]
+
+ return filtered_issues
+
+ def analyze(self, analysis_types: Optional[List[AnalysisType]] = None) -> Dict[str, Any]:
+ """
+ Perform analysis on the codebase.
+
+ Args:
+ analysis_types: List of analysis types to perform. If None, performs CODE_QUALITY and DEPENDENCY analysis.
+
+ Returns:
+ Dictionary containing analysis results
+ """
+ if not self.base_codebase:
+ raise ValueError("Codebase not initialized")
+
+ # Default to code quality and dependency analysis
+ if analysis_types is None:
+ analysis_types = [AnalysisType.CODE_QUALITY, AnalysisType.DEPENDENCY]
+
+ # Initialize results
+ self.results = {
+ "metadata": {
+ "analysis_time": datetime.now().isoformat(),
+ "analysis_types": [t.value for t in analysis_types],
+ "repo_name": getattr(self.base_codebase.ctx, 'repo_name', None),
+ "language": str(getattr(self.base_codebase.ctx, 'programming_language', None)),
+ },
+ "summary": get_codebase_summary(self.base_codebase),
+ "results": {}
+ }
+
+ # Clear issues
+ self.issues = []
+
+ # Run each analyzer
+ registry = AnalyzerRegistry()
+
+ for analysis_type in analysis_types:
+ analyzer_class = registry.get_analyzer(analysis_type)
+
+ if analyzer_class:
+ logger.info(f"Running {analysis_type.value} analysis")
+ analyzer = analyzer_class(self)
+ analysis_result = analyzer.analyze()
+
+ # Add results to unified results
+ self.results["results"][analysis_type.value] = analysis_result
+ else:
+ logger.warning(f"No analyzer found for {analysis_type.value}")
+
+ # Add issues to results
+ self.results["issues"] = [issue.to_dict() for issue in self.issues]
+
+ # Add issue statistics
+ self.results["issue_stats"] = {
+ "total": len(self.issues),
+ "by_severity": {
+ "critical": sum(1 for issue in self.issues if issue.severity == IssueSeverity.CRITICAL),
+ "error": sum(1 for issue in self.issues if issue.severity == IssueSeverity.ERROR),
+ "warning": sum(1 for issue in self.issues if issue.severity == IssueSeverity.WARNING),
+ "info": sum(1 for issue in self.issues if issue.severity == IssueSeverity.INFO),
+ },
+ "by_category": {
+ category.value: sum(1 for issue in self.issues if issue.category == category)
+ for category in IssueCategory
+ if any(issue.category == category for issue in self.issues)
+ }
+ }
+
+ return self.results
+
+ def save_results(self, output_file: str, format: str = "json"):
+ """
+ Save analysis results to a file.
+
+ Args:
+ output_file: Path to the output file
+ format: Output format (json, html, or console)
+ """
+ if format == "json":
+ with open(output_file, 'w') as f:
+ json.dump(self.results, f, indent=2)
+ elif format == "html":
+ self._generate_html_report(output_file)
+ else:
+ # Default to JSON
+ with open(output_file, 'w') as f:
+ json.dump(self.results, f, indent=2)
+
+ logger.info(f"Results saved to {output_file}")
+
+ def _generate_html_report(self, output_file: str):
+ """
+ Generate an HTML report of the analysis results.
+
+ Args:
+ output_file: Path to the output file
+ """
+ html_content = f"""
+
+
+
+
Codebase Analysis Report
+
+
+
+
Codebase Analysis Report
+
+
Summary
+
Repository: {self.results['metadata'].get('repo_name', 'Unknown')}
+
Language: {self.results['metadata'].get('language', 'Unknown')}
+
Analysis Time: {self.results['metadata'].get('analysis_time', 'Unknown')}
+
Analysis Types: {', '.join(self.results['metadata'].get('analysis_types', []))}
+
Total Issues: {len(self.issues)}
+
+ - Critical: {self.results['issue_stats']['by_severity'].get('critical', 0)}
+ - Errors: {self.results['issue_stats']['by_severity'].get('error', 0)}
+ - Warnings: {self.results['issue_stats']['by_severity'].get('warning', 0)}
+ - Info: {self.results['issue_stats']['by_severity'].get('info', 0)}
+
+
+
+
+
Issues
+ """
+
+ # Add issues grouped by severity
+ for severity in [IssueSeverity.CRITICAL, IssueSeverity.ERROR, IssueSeverity.WARNING, IssueSeverity.INFO]:
+ severity_issues = [issue for issue in self.issues if issue.severity == severity]
+
+ if severity_issues:
+ html_content += f"""
+
{severity.value.upper()} Issues ({len(severity_issues)})
+
+ """
+
+ for issue in severity_issues:
+ location = f"{issue.file}:{issue.line}" if issue.line else issue.file
+ category = f"[{issue.category.value}]" if issue.category else ""
+
+ html_content += f"""
+
+
{location} {category} {issue.message}
+
{issue.suggestion}
+
+ """
+
+ html_content += """
+
+ """
+
+ # Add detailed analysis sections
+ html_content += """
+
+
Detailed Analysis
+ """
+
+ for analysis_type, results in self.results.get('results', {}).items():
+ html_content += f"""
+
{analysis_type}
+
{json.dumps(results, indent=2)}
+ """
+
+ html_content += """
+
+
+
+ """
+
+ with open(output_file, 'w') as f:
+ f.write(html_content)
+
+def main():
+ """Command-line entry point for the unified analyzer."""
+ import argparse
+
+ parser = argparse.ArgumentParser(description="Unified Codebase Analyzer")
+
+ # Repository source options
+ source_group = parser.add_mutually_exclusive_group(required=True)
+ source_group.add_argument("--repo-url", help="URL of the repository to analyze")
+ source_group.add_argument("--repo-path", help="Local path to the repository to analyze")
+
+ # Analysis options
+ parser.add_argument("--analysis-types", nargs="+", choices=[at.value for at in AnalysisType],
+ default=["code_quality", "dependency"],
+ help="Types of analysis to perform")
+ parser.add_argument("--language", choices=["python", "typescript"],
+ help="Programming language (auto-detected if not provided)")
+ parser.add_argument("--base-branch", default="main",
+ help="Base branch for PR comparison (default: main)")
+ parser.add_argument("--pr-number", type=int,
+ help="PR number to analyze")
+
+ # Output options
+ parser.add_argument("--output-format", choices=["json", "html", "console"], default="json",
+ help="Output format")
+ parser.add_argument("--output-file",
+ help="Path to the output file")
+
+ args = parser.parse_args()
+
+ try:
+ # Initialize the analyzer
+ analyzer = UnifiedCodeAnalyzer(
+ repo_url=args.repo_url,
+ repo_path=args.repo_path,
+ base_branch=args.base_branch,
+ pr_number=args.pr_number,
+ language=args.language
+ )
+
+ # Perform the analysis
+ analysis_types = [AnalysisType(at) for at in args.analysis_types]
+ results = analyzer.analyze(analysis_types)
+
+ # Output the results
+ if args.output_format == "json":
+ if args.output_file:
+ analyzer.save_results(args.output_file, "json")
+ else:
+ print(json.dumps(results, indent=2))
+ elif args.output_format == "html":
+ output_file = args.output_file or "codebase_analysis_report.html"
+ analyzer.save_results(output_file, "html")
+ elif args.output_format == "console":
+ # Print summary to console
+ print(f"\n===== Codebase Analysis Report =====")
+ print(f"Repository: {results['metadata'].get('repo_name', 'Unknown')}")
+ print(f"Language: {results['metadata'].get('language', 'Unknown')}")
+ print(f"Analysis Time: {results['metadata'].get('analysis_time', 'Unknown')}")
+ print(f"Analysis Types: {', '.join(results['metadata'].get('analysis_types', []))}")
+
+ print(f"\n===== Issues Summary =====")
+ print(f"Total: {results['issue_stats']['total']}")
+ print(f"Critical: {results['issue_stats']['by_severity'].get('critical', 0)}")
+ print(f"Errors: {results['issue_stats']['by_severity'].get('error', 0)}")
+ print(f"Warnings: {results['issue_stats']['by_severity'].get('warning', 0)}")
+ print(f"Info: {results['issue_stats']['by_severity'].get('info', 0)}")
+
+ print(f"\n===== Top Issues =====")
+ for i, issue in enumerate(analyzer.issues[:10]):
+ severity = issue.severity.value.upper()
+ location = f"{issue.file}:{issue.line}" if issue.line else issue.file
+ category = f"[{issue.category.value}]" if issue.category else ""
+ print(f"{i+1}. [{severity}] {location} {category} {issue.message}")
+ print(f" Suggestion: {issue.suggestion}")
+ print()
+
+ except Exception as e:
+ import traceback
+ print(f"Error: {e}")
+ traceback.print_exc()
+ sys.exit(1)
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/visualization/__init__.py b/codegen-on-oss/codegen_on_oss/analyzers/visualization/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/visualization/analysis_visualizer.py b/codegen-on-oss/codegen_on_oss/analyzers/visualization/analysis_visualizer.py
new file mode 100644
index 000000000..3d7ea333a
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/visualization/analysis_visualizer.py
@@ -0,0 +1,522 @@
+#!/usr/bin/env python3
+"""
+Analysis Visualizer Module
+
+This module provides visualization capabilities for code analysis results
+including dead code detection, cyclomatic complexity, and issue heatmaps.
+"""
+
+import logging
+from typing import Dict, List, Optional, Any, Union
+from enum import Enum
+
+from .visualizer import BaseVisualizer, VisualizationType, OutputFormat
+
+try:
+ import networkx as nx
+ import matplotlib.pyplot as plt
+ from matplotlib.colors import LinearSegmentedColormap
+except ImportError:
+ logging.warning("Visualization dependencies not found. Please install them with: pip install networkx matplotlib")
+
+logger = logging.getLogger(__name__)
+
+class AnalysisVisualizer(BaseVisualizer):
+ """
+ Visualizer for code analysis results.
+
+ This class provides methods to visualize analysis results such as
+ dead code detection, cyclomatic complexity, and issue heatmaps.
+ """
+
+ def __init__(self, analyzer=None, codebase=None, context=None, **kwargs):
+ """
+ Initialize the AnalysisVisualizer.
+
+ Args:
+ analyzer: Analyzer with analysis results
+ codebase: Codebase instance to visualize
+ context: Context providing graph representation
+ **kwargs: Additional configuration options
+ """
+ super().__init__(**kwargs)
+ self.analyzer = analyzer
+ self.codebase = codebase or (analyzer.base_codebase if analyzer else None)
+ self.context = context or (analyzer.base_context if analyzer else None)
+
+ def visualize_dead_code(self, path_filter: Optional[str] = None):
+ """
+ Generate a visualization of dead (unused) code in the codebase.
+
+ Args:
+ path_filter: Optional path to filter files
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ entity_name = path_filter or "codebase"
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Check for analyzer
+ if not self.analyzer:
+ logger.error("Analyzer required for dead code visualization")
+ return None
+
+ # Check for analysis results
+ if not hasattr(self.analyzer, "results") or not self.analyzer.results:
+ logger.error("Analysis results not available")
+ return None
+
+ # Extract dead code information from analysis results
+ dead_code = {}
+ if "static_analysis" in self.analyzer.results and "dead_code" in self.analyzer.results["static_analysis"]:
+ dead_code = self.analyzer.results["static_analysis"]["dead_code"]
+
+ if not dead_code:
+ logger.warning("No dead code detected in analysis results")
+ return None
+
+ # Create file nodes for containing dead code
+ file_nodes = {}
+
+ # Process unused functions
+ if "unused_functions" in dead_code:
+ for unused_func in dead_code["unused_functions"]:
+ file_path = unused_func.get("file", "")
+
+ # Skip if path filter is specified and doesn't match
+ if path_filter and not file_path.startswith(path_filter):
+ continue
+
+ # Add file node if not already added
+ if file_path not in file_nodes:
+ # Find file in codebase
+ file_obj = None
+ for file in self.codebase.files:
+ if hasattr(file, "path") and str(file.path) == file_path:
+ file_obj = file
+ break
+
+ if file_obj:
+ file_name = file_path.split("/")[-1]
+ file_id = self._add_node(
+ file_obj,
+ name=file_name,
+ color=self.config.color_palette.get("File"),
+ file_path=file_path
+ )
+
+ file_nodes[file_path] = file_obj
+
+ # Add unused function node
+ func_name = unused_func.get("name", "")
+ func_line = unused_func.get("line", None)
+
+ # Create a placeholder for the function (we don't have the actual object)
+ func_obj = {"name": func_name, "file_path": file_path, "line": func_line, "type": "Function"}
+
+ func_id = self._add_node(
+ func_obj,
+ name=func_name,
+ color=self.config.color_palette.get("Dead"),
+ file_path=file_path,
+ line=func_line,
+ is_dead=True
+ )
+
+ # Add edge from file to function
+ if file_path in file_nodes:
+ self._add_edge(
+ file_nodes[file_path],
+ func_obj,
+ type="contains_dead"
+ )
+
+ # Process unused variables
+ if "unused_variables" in dead_code:
+ for unused_var in dead_code["unused_variables"]:
+ file_path = unused_var.get("file", "")
+
+ # Skip if path filter is specified and doesn't match
+ if path_filter and not file_path.startswith(path_filter):
+ continue
+
+ # Add file node if not already added
+ if file_path not in file_nodes:
+ # Find file in codebase
+ file_obj = None
+ for file in self.codebase.files:
+ if hasattr(file, "path") and str(file.path) == file_path:
+ file_obj = file
+ break
+
+ if file_obj:
+ file_name = file_path.split("/")[-1]
+ file_id = self._add_node(
+ file_obj,
+ name=file_name,
+ color=self.config.color_palette.get("File"),
+ file_path=file_path
+ )
+
+ file_nodes[file_path] = file_obj
+
+ # Add unused variable node
+ var_name = unused_var.get("name", "")
+ var_line = unused_var.get("line", None)
+
+ # Create a placeholder for the variable
+ var_obj = {"name": var_name, "file_path": file_path, "line": var_line, "type": "Variable"}
+
+ var_id = self._add_node(
+ var_obj,
+ name=var_name,
+ color=self.config.color_palette.get("Dead"),
+ file_path=file_path,
+ line=var_line,
+ is_dead=True
+ )
+
+ # Add edge from file to variable
+ if file_path in file_nodes:
+ self._add_edge(
+ file_nodes[file_path],
+ var_obj,
+ type="contains_dead"
+ )
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.DEAD_CODE, entity_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.DEAD_CODE, entity_name, fig)
+
+ def visualize_cyclomatic_complexity(self, path_filter: Optional[str] = None):
+ """
+ Generate a heatmap visualization of cyclomatic complexity.
+
+ Args:
+ path_filter: Optional path to filter files
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ entity_name = path_filter or "codebase"
+
+ # Check for analyzer
+ if not self.analyzer:
+ logger.error("Analyzer required for complexity visualization")
+ return None
+
+ # Check for analysis results
+ if not hasattr(self.analyzer, "results") or not self.analyzer.results:
+ logger.error("Analysis results not available")
+ return None
+
+ # Extract complexity information from analysis results
+ complexity_data = {}
+ if "static_analysis" in self.analyzer.results and "code_complexity" in self.analyzer.results["static_analysis"]:
+ complexity_data = self.analyzer.results["static_analysis"]["code_complexity"]
+
+ if not complexity_data:
+ logger.warning("No complexity data found in analysis results")
+ return None
+
+ # Extract function complexities
+ functions = []
+ if "function_complexity" in complexity_data:
+ for func_data in complexity_data["function_complexity"]:
+ # Skip if path filter is specified and doesn't match
+ if path_filter and not func_data.get("file", "").startswith(path_filter):
+ continue
+
+ functions.append({
+ "name": func_data.get("name", ""),
+ "file": func_data.get("file", ""),
+ "complexity": func_data.get("complexity", 1),
+ "line": func_data.get("line", None)
+ })
+
+ # Sort functions by complexity (descending)
+ functions.sort(key=lambda x: x.get("complexity", 0), reverse=True)
+
+ # Generate heatmap visualization
+ plt.figure(figsize=(12, 10))
+
+ # Extract data for heatmap
+ func_names = [f"{func['name']} ({func['file'].split('/')[-1]})" for func in functions[:30]]
+ complexities = [func.get("complexity", 0) for func in functions[:30]]
+
+ # Create horizontal bar chart
+ bars = plt.barh(func_names, complexities)
+
+ # Color bars by complexity
+ norm = plt.Normalize(1, max(10, max(complexities)))
+ cmap = plt.cm.get_cmap('YlOrRd')
+
+ for i, bar in enumerate(bars):
+ complexity = complexities[i]
+ bar.set_color(cmap(norm(complexity)))
+
+ # Add labels and title
+ plt.xlabel('Cyclomatic Complexity')
+ plt.title('Top Functions by Cyclomatic Complexity')
+ plt.grid(axis='x', linestyle='--', alpha=0.6)
+
+ # Add colorbar
+ plt.colorbar(plt.cm.ScalarMappable(norm=norm, cmap=cmap), label='Complexity')
+
+ # Save and return visualization
+ return self._save_visualization(VisualizationType.CYCLOMATIC_COMPLEXITY, entity_name, plt.gcf())
+
+ def visualize_issues_heatmap(self, severity=None, path_filter: Optional[str] = None):
+ """
+ Generate a heatmap visualization of issues in the codebase.
+
+ Args:
+ severity: Optional severity level to filter issues
+ path_filter: Optional path to filter files
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ entity_name = f"{severity.value if severity else 'all'}_issues"
+
+ # Check for analyzer
+ if not self.analyzer:
+ logger.error("Analyzer required for issues visualization")
+ return None
+
+ # Check for analysis results
+ if not hasattr(self.analyzer, "results") or "issues" not in self.analyzer.results:
+ logger.error("Issues not available in analysis results")
+ return None
+
+ issues = self.analyzer.results["issues"]
+
+ # Filter issues by severity if specified
+ if severity:
+ issues = [issue for issue in issues if issue.get("severity") == severity]
+
+ # Filter issues by path if specified
+ if path_filter:
+ issues = [issue for issue in issues if issue.get("file", "").startswith(path_filter)]
+
+ if not issues:
+ logger.warning("No issues found matching the criteria")
+ return None
+
+ # Group issues by file
+ file_issues = {}
+ for issue in issues:
+ file_path = issue.get("file", "")
+ if file_path not in file_issues:
+ file_issues[file_path] = []
+
+ file_issues[file_path].append(issue)
+
+ # Generate heatmap visualization
+ plt.figure(figsize=(12, 10))
+
+ # Extract data for heatmap
+ files = list(file_issues.keys())
+ file_names = [file_path.split("/")[-1] for file_path in files]
+ issue_counts = [len(file_issues[file_path]) for file_path in files]
+
+ # Sort by issue count
+ sorted_data = sorted(zip(file_names, issue_counts, files), key=lambda x: x[1], reverse=True)
+ file_names, issue_counts, files = zip(*sorted_data)
+
+ # Create horizontal bar chart
+ bars = plt.barh(file_names[:20], issue_counts[:20])
+
+ # Color bars by issue count
+ norm = plt.Normalize(1, max(5, max(issue_counts[:20])))
+ cmap = plt.cm.get_cmap('OrRd')
+
+ for i, bar in enumerate(bars):
+ count = issue_counts[i]
+ bar.set_color(cmap(norm(count)))
+
+ # Add labels and title
+ plt.xlabel('Number of Issues')
+ severity_text = f" ({severity.value})" if severity else ""
+ plt.title(f'Files with the Most Issues{severity_text}')
+ plt.grid(axis='x', linestyle='--', alpha=0.6)
+
+ # Add colorbar
+ plt.colorbar(plt.cm.ScalarMappable(norm=norm, cmap=cmap), label='Issue Count')
+
+ # Save and return visualization
+ return self._save_visualization(VisualizationType.ISSUES_HEATMAP, entity_name, plt.gcf())
+
+ def visualize_pr_comparison(self):
+ """
+ Generate a visualization comparing base branch with PR.
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ # Check for analyzer with PR data
+ if not self.analyzer or not hasattr(self.analyzer, "pr_codebase") or not self.analyzer.pr_codebase or not self.analyzer.base_codebase:
+ logger.error("PR comparison requires analyzer with PR data")
+ return None
+
+ entity_name = f"pr_{self.analyzer.pr_number}" if hasattr(self.analyzer, "pr_number") and self.analyzer.pr_number else "pr_comparison"
+
+ # Check for analysis results
+ if not hasattr(self.analyzer, "results") or "comparison" not in self.analyzer.results:
+ logger.error("Comparison data not available in analysis results")
+ return None
+
+ comparison = self.analyzer.results["comparison"]
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Process symbol comparison data
+ if "symbol_comparison" in comparison:
+ for symbol_data in comparison["symbol_comparison"]:
+ symbol_name = symbol_data.get("name", "")
+ in_base = symbol_data.get("in_base", False)
+ in_pr = symbol_data.get("in_pr", False)
+
+ # Create a placeholder for the symbol
+ symbol_obj = {
+ "name": symbol_name,
+ "in_base": in_base,
+ "in_pr": in_pr,
+ "type": "Symbol"
+ }
+
+ # Determine node color based on presence in base and PR
+ if in_base and in_pr:
+ color = "#A5D6A7" # Light green (modified)
+ elif in_base:
+ color = "#EF9A9A" # Light red (removed)
+ else:
+ color = "#90CAF9" # Light blue (added)
+
+ # Add node for symbol
+ symbol_id = self._add_node(
+ symbol_obj,
+ name=symbol_name,
+ color=color,
+ in_base=in_base,
+ in_pr=in_pr
+ )
+
+ # Process parameter changes if available
+ if "parameter_changes" in symbol_data:
+ param_changes = symbol_data["parameter_changes"]
+
+ # Process removed parameters
+ for param in param_changes.get("removed", []):
+ param_obj = {
+ "name": param,
+ "change_type": "removed",
+ "type": "Parameter"
+ }
+
+ param_id = self._add_node(
+ param_obj,
+ name=param,
+ color="#EF9A9A", # Light red (removed)
+ change_type="removed"
+ )
+
+ self._add_edge(
+ symbol_obj,
+ param_obj,
+ type="removed_parameter"
+ )
+
+ # Process added parameters
+ for param in param_changes.get("added", []):
+ param_obj = {
+ "name": param,
+ "change_type": "added",
+ "type": "Parameter"
+ }
+
+ param_id = self._add_node(
+ param_obj,
+ name=param,
+ color="#90CAF9", # Light blue (added)
+ change_type="added"
+ )
+
+ self._add_edge(
+ symbol_obj,
+ param_obj,
+ type="added_parameter"
+ )
+
+ # Process return type changes if available
+ if "return_type_change" in symbol_data:
+ return_type_change = symbol_data["return_type_change"]
+ old_type = return_type_change.get("old", "None")
+ new_type = return_type_change.get("new", "None")
+
+ return_obj = {
+ "name": f"{old_type} -> {new_type}",
+ "old_type": old_type,
+ "new_type": new_type,
+ "type": "ReturnType"
+ }
+
+ return_id = self._add_node(
+ return_obj,
+ name=f"{old_type} -> {new_type}",
+ color="#FFD54F", # Amber (changed)
+ old_type=old_type,
+ new_type=new_type
+ )
+
+ self._add_edge(
+ symbol_obj,
+ return_obj,
+ type="return_type_change"
+ )
+
+ # Process call site issues if available
+ if "call_site_issues" in symbol_data:
+ for issue in symbol_data["call_site_issues"]:
+ issue_file = issue.get("file", "")
+ issue_line = issue.get("line", None)
+ issue_text = issue.get("issue", "")
+
+ # Create a placeholder for the issue
+ issue_obj = {
+ "name": issue_text,
+ "file": issue_file,
+ "line": issue_line,
+ "type": "Issue"
+ }
+
+ issue_id = self._add_node(
+ issue_obj,
+ name=f"{issue_file.split('/')[-1]}:{issue_line}",
+ color="#EF5350", # Red (error)
+ file_path=issue_file,
+ line=issue_line,
+ issue_text=issue_text
+ )
+
+ self._add_edge(
+ symbol_obj,
+ issue_obj,
+ type="call_site_issue"
+ )
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.PR_COMPARISON, entity_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.PR_COMPARISON, entity_name, fig)
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/visualization/code_visualizer.py b/codegen-on-oss/codegen_on_oss/analyzers/visualization/code_visualizer.py
new file mode 100644
index 000000000..b6b196b7a
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/visualization/code_visualizer.py
@@ -0,0 +1,504 @@
+#!/usr/bin/env python3
+"""
+Code Structure Visualizer
+
+This module provides visualization capabilities for code structures such as
+call graphs, dependency graphs, class methods, and blast radius.
+"""
+
+import logging
+from typing import Dict, List, Set, Tuple, Any, Optional, Union
+
+from .visualizer import BaseVisualizer, VisualizationType, OutputFormat
+
+try:
+ import networkx as nx
+ import matplotlib.pyplot as plt
+except ImportError:
+ logging.warning("Visualization dependencies not found. Please install them with: pip install networkx matplotlib")
+
+logger = logging.getLogger(__name__)
+
+class CodeVisualizer(BaseVisualizer):
+ """
+ Visualizer for code structures such as call graphs and dependencies.
+
+ This class provides methods to visualize relationships between code entities
+ including functions, classes, and modules.
+ """
+
+ def __init__(self, codebase=None, context=None, **kwargs):
+ """
+ Initialize the CodeVisualizer.
+
+ Args:
+ codebase: Codebase instance to visualize
+ context: Context providing graph representation
+ **kwargs: Additional configuration options
+ """
+ super().__init__(**kwargs)
+ self.codebase = codebase
+ self.context = context
+
+ # Initialize codebase if needed
+ if not self.codebase and not self.context and 'analyzer' in kwargs:
+ self.codebase = kwargs['analyzer'].base_codebase
+ self.context = kwargs['analyzer'].base_context
+
+ def visualize_call_graph(self, function_name: str, max_depth: Optional[int] = None):
+ """
+ Generate a call graph visualization for a function.
+
+ Args:
+ function_name: Name of the function to visualize
+ max_depth: Maximum depth of the call graph (overrides config)
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ # Set max depth
+ current_max_depth = max_depth if max_depth is not None else self.config.max_depth
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Find the function in the codebase
+ function = None
+ for func in self.codebase.functions:
+ if func.name == function_name:
+ function = func
+ break
+
+ if not function:
+ logger.error(f"Function {function_name} not found in codebase")
+ return None
+
+ # Add root node
+ root_id = self._add_node(
+ function,
+ name=function_name,
+ color=self.config.color_palette.get("Root"),
+ is_root=True
+ )
+
+ # Recursively add call relationships
+ visited = set([function])
+
+ def add_calls(func, depth=0):
+ if depth >= current_max_depth:
+ return
+
+ # Skip if no function calls attribute
+ if not hasattr(func, "function_calls"):
+ return
+
+ for call in func.function_calls:
+ # Skip recursive calls
+ if call.name == func.name:
+ continue
+
+ # Get the called function
+ called_func = call.function_definition
+ if not called_func:
+ continue
+
+ # Skip external modules if configured
+ if self.config.ignore_external and hasattr(called_func, "is_external") and called_func.is_external:
+ continue
+
+ # Generate name for display
+ if hasattr(called_func, "is_method") and called_func.is_method and hasattr(called_func, "parent_class"):
+ called_name = f"{called_func.parent_class.name}.{called_func.name}"
+ else:
+ called_name = called_func.name
+
+ # Add node for called function
+ called_id = self._add_node(
+ called_func,
+ name=called_name,
+ color=self.config.color_palette.get("Function"),
+ file_path=called_func.file.path if hasattr(called_func, "file") and hasattr(called_func.file, "path") else None
+ )
+
+ # Add edge for call relationship
+ self._add_edge(
+ function,
+ called_func,
+ type="call",
+ file_path=call.filepath if hasattr(call, "filepath") else None,
+ line=call.line if hasattr(call, "line") else None
+ )
+
+ # Recursively process called function
+ if called_func not in visited:
+ visited.add(called_func)
+ add_calls(called_func, depth + 1)
+
+ # Start from the root function
+ add_calls(function)
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.CALL_GRAPH, function_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.CALL_GRAPH, function_name, fig)
+
+ def visualize_dependency_graph(self, symbol_name: str, max_depth: Optional[int] = None):
+ """
+ Generate a dependency graph visualization for a symbol.
+
+ Args:
+ symbol_name: Name of the symbol to visualize
+ max_depth: Maximum depth of the dependency graph (overrides config)
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ # Set max depth
+ current_max_depth = max_depth if max_depth is not None else self.config.max_depth
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Find the symbol in the codebase
+ symbol = None
+ for sym in self.codebase.symbols:
+ if hasattr(sym, "name") and sym.name == symbol_name:
+ symbol = sym
+ break
+
+ if not symbol:
+ logger.error(f"Symbol {symbol_name} not found in codebase")
+ return None
+
+ # Add root node
+ root_id = self._add_node(
+ symbol,
+ name=symbol_name,
+ color=self.config.color_palette.get("Root"),
+ is_root=True
+ )
+
+ # Recursively add dependencies
+ visited = set([symbol])
+
+ def add_dependencies(sym, depth=0):
+ if depth >= current_max_depth:
+ return
+
+ # Skip if no dependencies attribute
+ if not hasattr(sym, "dependencies"):
+ return
+
+ for dep in sym.dependencies:
+ dep_symbol = None
+
+ if hasattr(dep, "__class__") and dep.__class__.__name__ == "Symbol":
+ dep_symbol = dep
+ elif hasattr(dep, "resolved_symbol"):
+ dep_symbol = dep.resolved_symbol
+
+ if not dep_symbol:
+ continue
+
+ # Skip external modules if configured
+ if self.config.ignore_external and hasattr(dep_symbol, "is_external") and dep_symbol.is_external:
+ continue
+
+ # Add node for dependency
+ dep_id = self._add_node(
+ dep_symbol,
+ name=dep_symbol.name if hasattr(dep_symbol, "name") else str(dep_symbol),
+ color=self.config.color_palette.get(dep_symbol.__class__.__name__, "#BBBBBB"),
+ file_path=dep_symbol.file.path if hasattr(dep_symbol, "file") and hasattr(dep_symbol.file, "path") else None
+ )
+
+ # Add edge for dependency relationship
+ self._add_edge(
+ sym,
+ dep_symbol,
+ type="depends_on"
+ )
+
+ # Recursively process dependency
+ if dep_symbol not in visited:
+ visited.add(dep_symbol)
+ add_dependencies(dep_symbol, depth + 1)
+
+ # Start from the root symbol
+ add_dependencies(symbol)
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.DEPENDENCY_GRAPH, symbol_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.DEPENDENCY_GRAPH, symbol_name, fig)
+
+ def visualize_blast_radius(self, symbol_name: str, max_depth: Optional[int] = None):
+ """
+ Generate a blast radius visualization for a symbol.
+
+ Args:
+ symbol_name: Name of the symbol to visualize
+ max_depth: Maximum depth of the blast radius (overrides config)
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ # Set max depth
+ current_max_depth = max_depth if max_depth is not None else self.config.max_depth
+
+ # Initialize graph
+ self._initialize_graph()
+
+ # Find the symbol in the codebase
+ symbol = None
+ for sym in self.codebase.symbols:
+ if hasattr(sym, "name") and sym.name == symbol_name:
+ symbol = sym
+ break
+
+ if not symbol:
+ logger.error(f"Symbol {symbol_name} not found in codebase")
+ return None
+
+ # Add root node
+ root_id = self._add_node(
+ symbol,
+ name=symbol_name,
+ color=self.config.color_palette.get("Root"),
+ is_root=True
+ )
+
+ # Recursively add usages (reverse dependencies)
+ visited = set([symbol])
+
+ def add_usages(sym, depth=0):
+ if depth >= current_max_depth:
+ return
+
+ # Skip if no usages attribute
+ if not hasattr(sym, "usages"):
+ return
+
+ for usage in sym.usages:
+ # Skip if no usage symbol
+ if not hasattr(usage, "usage_symbol"):
+ continue
+
+ usage_symbol = usage.usage_symbol
+
+ # Skip external modules if configured
+ if self.config.ignore_external and hasattr(usage_symbol, "is_external") and usage_symbol.is_external:
+ continue
+
+ # Add node for usage
+ usage_id = self._add_node(
+ usage_symbol,
+ name=usage_symbol.name if hasattr(usage_symbol, "name") else str(usage_symbol),
+ color=self.config.color_palette.get(usage_symbol.__class__.__name__, "#BBBBBB"),
+ file_path=usage_symbol.file.path if hasattr(usage_symbol, "file") and hasattr(usage_symbol.file, "path") else None
+ )
+
+ # Add edge for usage relationship
+ self._add_edge(
+ sym,
+ usage_symbol,
+ type="used_by"
+ )
+
+ # Recursively process usage
+ if usage_symbol not in visited:
+ visited.add(usage_symbol)
+ add_usages(usage_symbol, depth + 1)
+
+ # Start from the root symbol
+ add_usages(symbol)
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.BLAST_RADIUS, symbol_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.BLAST_RADIUS, symbol_name, fig)
+
+ def visualize_class_methods(self, class_name: str):
+ """
+ Generate a class methods visualization.
+
+ Args:
+ class_name: Name of the class to visualize
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ # Initialize graph
+ self._initialize_graph()
+
+ # Find the class in the codebase
+ class_obj = None
+ for cls in self.codebase.classes:
+ if cls.name == class_name:
+ class_obj = cls
+ break
+
+ if not class_obj:
+ logger.error(f"Class {class_name} not found in codebase")
+ return None
+
+ # Add class node
+ class_id = self._add_node(
+ class_obj,
+ name=class_name,
+ color=self.config.color_palette.get("Class"),
+ is_root=True
+ )
+
+ # Skip if no methods attribute
+ if not hasattr(class_obj, "methods"):
+ logger.error(f"Class {class_name} has no methods attribute")
+ return None
+
+ # Add method nodes and connections
+ method_ids = {}
+ for method in class_obj.methods:
+ method_name = f"{class_name}.{method.name}"
+
+ # Add method node
+ method_id = self._add_node(
+ method,
+ name=method_name,
+ color=self.config.color_palette.get("Function"),
+ file_path=method.file.path if hasattr(method, "file") and hasattr(method.file, "path") else None
+ )
+
+ method_ids[method.name] = method_id
+
+ # Add edge from class to method
+ self._add_edge(
+ class_obj,
+ method,
+ type="contains"
+ )
+
+ # Add call relationships between methods
+ for method in class_obj.methods:
+ # Skip if no function calls attribute
+ if not hasattr(method, "function_calls"):
+ continue
+
+ for call in method.function_calls:
+ # Get the called function
+ called_func = call.function_definition
+ if not called_func:
+ continue
+
+ # Only add edges between methods of this class
+ if hasattr(called_func, "is_method") and called_func.is_method and \
+ hasattr(called_func, "parent_class") and called_func.parent_class == class_obj:
+ self._add_edge(
+ method,
+ called_func,
+ type="calls",
+ line=call.line if hasattr(call, "line") else None
+ )
+
+ # Generate visualization data
+ if self.config.output_format == OutputFormat.JSON:
+ data = self._convert_graph_to_json()
+ return self._save_visualization(VisualizationType.CLASS_METHODS, class_name, data)
+ else:
+ fig = self._plot_graph()
+ return self._save_visualization(VisualizationType.CLASS_METHODS, class_name, fig)
+
+ def visualize_module_dependencies(self, module_path: str):
+ """
+ Generate a module dependencies visualization.
+
+ Args:
+ module_path: Path to the module to visualize
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ # Initialize graph
+ self._initialize_graph()
+
+ # Get all files in the module
+ module_files = []
+ for file in self.codebase.files:
+ if hasattr(file, "path") and str(file.path).startswith(module_path):
+ module_files.append(file)
+
+ if not module_files:
+ logger.error(f"No files found in module {module_path}")
+ return None
+
+ # Add file nodes
+ module_node_ids = {}
+ for file in module_files:
+ file_name = str(file.path).split("/")[-1]
+ file_module = "/".join(str(file.path).split("/")[:-1])
+
+ # Add file node
+ file_id = self._add_node(
+ file,
+ name=file_name,
+ module=file_module,
+ color=self.config.color_palette.get("File"),
+ file_path=str(file.path)
+ )
+
+ module_node_ids[str(file.path)] = file_id
+
+ # Add import relationships
+ for file in module_files:
+ # Skip if no imports attribute
+ if not hasattr(file, "imports"):
+ continue
+
+ for imp in file.imports:
+ imported_file = None
+
+ # Try to get imported file
+ if hasattr(imp, "resolved_file"):
+ imported_file = imp.resolved_file
+ elif hasattr(imp, "resolved_symbol") and hasattr(imp.resolved_symbol, "file"):
+ imported_file = imp.resolved_symbol.file
+
+ if not imported_file:
+ continue
+
+ # Skip external modules if configured
+ if self.config.ignore_external and hasattr(imported_file, "is_external") and imported_file.is_external:
+ continue
+
+ # Add node for imported file if not already added
+ imported_path = str(imported_file.path) if hasattr(imported_file, "path") else ""
+
+ if imported_path not in module_node_ids:
+ imported_name = imported_path.split("/")[-1]
+ imported_module = "/".join(imported_path.split("/")[:-1])
+
+ imported_id = self._add_node(
+ imported_file,
+ name=imported_name,
+ module=imported_module,
+ color=self.config.color_palette.get("External" if imported_path.startswith(module_path) else "File"),
+ file_path=imported_path
+ )
+
+ module_node_ids[imported_path] = imported_id
+
+ # Add edge for import relationship
+ self._add_edge(
+ file,
+ imported_file,
+ type="imports",
+ import_name=imp.name if hasattr(imp, "name") else ""
+ )
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/visualization/codebase_visualizer.py b/codegen-on-oss/codegen_on_oss/analyzers/visualization/codebase_visualizer.py
new file mode 100644
index 000000000..a7198f9a3
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/visualization/codebase_visualizer.py
@@ -0,0 +1,426 @@
+#!/usr/bin/env python3
+"""
+Codebase Visualizer Module
+
+This module provides a unified interface to all visualization capabilities
+for codebases. It integrates the specialized visualizers into a single,
+easy-to-use API for generating various types of visualizations.
+"""
+
+import os
+import sys
+import logging
+import argparse
+from typing import Dict, List, Optional, Any, Union
+
+from .visualizer import BaseVisualizer, VisualizationType, OutputFormat, VisualizationConfig
+from .code_visualizer import CodeVisualizer
+from .analysis_visualizer import AnalysisVisualizer
+
+# Configure logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+class CodebaseVisualizer:
+ """
+ Main visualizer class providing a unified interface to all visualization capabilities.
+
+ This class acts as a facade to the specialized visualizers, simplifying
+ the generation of different types of visualizations for codebases.
+ """
+
+ def __init__(
+ self,
+ analyzer=None,
+ codebase=None,
+ context=None,
+ config=None
+ ):
+ """
+ Initialize the CodebaseVisualizer.
+
+ Args:
+ analyzer: Optional analyzer with analysis results
+ codebase: Optional codebase to visualize
+ context: Optional context providing graph representation
+ config: Visualization configuration options
+ """
+ self.analyzer = analyzer
+ self.codebase = codebase or (analyzer.base_codebase if analyzer else None)
+ self.context = context or (analyzer.base_context if analyzer else None)
+ self.config = config or VisualizationConfig()
+
+ # Initialize specialized visualizers
+ self.code_visualizer = CodeVisualizer(
+ analyzer=analyzer,
+ codebase=self.codebase,
+ context=self.context,
+ config=self.config
+ )
+
+ self.analysis_visualizer = AnalysisVisualizer(
+ analyzer=analyzer,
+ codebase=self.codebase,
+ context=self.context,
+ config=self.config
+ )
+
+ # Create visualization directory if specified
+ if self.config.output_directory:
+ os.makedirs(self.config.output_directory, exist_ok=True)
+
+ # Initialize codebase if needed
+ if not self.codebase and not self.context:
+ try:
+ from codegen_on_oss.current_code_codebase import get_selected_codebase
+ from codegen_on_oss.analyzers.context_codebase import CodebaseContext
+
+ logger.info("No codebase or context provided, initializing from current directory")
+ self.codebase = get_selected_codebase()
+ self.context = CodebaseContext(
+ codebase=self.codebase,
+ base_path=os.getcwd()
+ )
+
+ # Update specialized visualizers
+ self.code_visualizer.codebase = self.codebase
+ self.code_visualizer.context = self.context
+ self.analysis_visualizer.codebase = self.codebase
+ self.analysis_visualizer.context = self.context
+ except ImportError:
+ logger.error("Could not automatically initialize codebase. Please provide a codebase or context.")
+
+ def visualize(self, visualization_type: VisualizationType, **kwargs):
+ """
+ Generate a visualization of the specified type.
+
+ Args:
+ visualization_type: Type of visualization to generate
+ **kwargs: Additional arguments for the specific visualization
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ # Route to the appropriate specialized visualizer based on visualization type
+ if visualization_type in [
+ VisualizationType.CALL_GRAPH,
+ VisualizationType.DEPENDENCY_GRAPH,
+ VisualizationType.BLAST_RADIUS,
+ VisualizationType.CLASS_METHODS,
+ VisualizationType.MODULE_DEPENDENCIES
+ ]:
+ # Code structure visualizations
+ return self._visualize_code_structure(visualization_type, **kwargs)
+ elif visualization_type in [
+ VisualizationType.DEAD_CODE,
+ VisualizationType.CYCLOMATIC_COMPLEXITY,
+ VisualizationType.ISSUES_HEATMAP,
+ VisualizationType.PR_COMPARISON
+ ]:
+ # Analysis result visualizations
+ return self._visualize_analysis_results(visualization_type, **kwargs)
+ else:
+ logger.error(f"Unsupported visualization type: {visualization_type}")
+ return None
+
+ def _visualize_code_structure(self, visualization_type: VisualizationType, **kwargs):
+ """
+ Generate a code structure visualization.
+
+ Args:
+ visualization_type: Type of visualization to generate
+ **kwargs: Additional arguments for the specific visualization
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ if visualization_type == VisualizationType.CALL_GRAPH:
+ return self.code_visualizer.visualize_call_graph(
+ function_name=kwargs.get("entity"),
+ max_depth=kwargs.get("max_depth")
+ )
+ elif visualization_type == VisualizationType.DEPENDENCY_GRAPH:
+ return self.code_visualizer.visualize_dependency_graph(
+ symbol_name=kwargs.get("entity"),
+ max_depth=kwargs.get("max_depth")
+ )
+ elif visualization_type == VisualizationType.BLAST_RADIUS:
+ return self.code_visualizer.visualize_blast_radius(
+ symbol_name=kwargs.get("entity"),
+ max_depth=kwargs.get("max_depth")
+ )
+ elif visualization_type == VisualizationType.CLASS_METHODS:
+ return self.code_visualizer.visualize_class_methods(
+ class_name=kwargs.get("entity")
+ )
+ elif visualization_type == VisualizationType.MODULE_DEPENDENCIES:
+ return self.code_visualizer.visualize_module_dependencies(
+ module_path=kwargs.get("entity")
+ )
+
+ def _visualize_analysis_results(self, visualization_type: VisualizationType, **kwargs):
+ """
+ Generate an analysis results visualization.
+
+ Args:
+ visualization_type: Type of visualization to generate
+ **kwargs: Additional arguments for the specific visualization
+
+ Returns:
+ Visualization data or path to saved file
+ """
+ if not self.analyzer:
+ logger.error(f"Analyzer required for {visualization_type} visualization")
+ return None
+
+ if visualization_type == VisualizationType.DEAD_CODE:
+ return self.analysis_visualizer.visualize_dead_code(
+ path_filter=kwargs.get("path_filter")
+ )
+ elif visualization_type == VisualizationType.CYCLOMATIC_COMPLEXITY:
+ return self.analysis_visualizer.visualize_cyclomatic_complexity(
+ path_filter=kwargs.get("path_filter")
+ )
+ elif visualization_type == VisualizationType.ISSUES_HEATMAP:
+ return self.analysis_visualizer.visualize_issues_heatmap(
+ severity=kwargs.get("severity"),
+ path_filter=kwargs.get("path_filter")
+ )
+ elif visualization_type == VisualizationType.PR_COMPARISON:
+ return self.analysis_visualizer.visualize_pr_comparison()
+
+ # Convenience methods for common visualizations
+ def visualize_call_graph(self, function_name: str, max_depth: Optional[int] = None):
+ """Convenience method for call graph visualization."""
+ return self.visualize(
+ VisualizationType.CALL_GRAPH,
+ entity=function_name,
+ max_depth=max_depth
+ )
+
+ def visualize_dependency_graph(self, symbol_name: str, max_depth: Optional[int] = None):
+ """Convenience method for dependency graph visualization."""
+ return self.visualize(
+ VisualizationType.DEPENDENCY_GRAPH,
+ entity=symbol_name,
+ max_depth=max_depth
+ )
+
+ def visualize_blast_radius(self, symbol_name: str, max_depth: Optional[int] = None):
+ """Convenience method for blast radius visualization."""
+ return self.visualize(
+ VisualizationType.BLAST_RADIUS,
+ entity=symbol_name,
+ max_depth=max_depth
+ )
+
+ def visualize_class_methods(self, class_name: str):
+ """Convenience method for class methods visualization."""
+ return self.visualize(
+ VisualizationType.CLASS_METHODS,
+ entity=class_name
+ )
+
+ def visualize_module_dependencies(self, module_path: str):
+ """Convenience method for module dependencies visualization."""
+ return self.visualize(
+ VisualizationType.MODULE_DEPENDENCIES,
+ entity=module_path
+ )
+
+ def visualize_dead_code(self, path_filter: Optional[str] = None):
+ """Convenience method for dead code visualization."""
+ return self.visualize(
+ VisualizationType.DEAD_CODE,
+ path_filter=path_filter
+ )
+
+ def visualize_cyclomatic_complexity(self, path_filter: Optional[str] = None):
+ """Convenience method for cyclomatic complexity visualization."""
+ return self.visualize(
+ VisualizationType.CYCLOMATIC_COMPLEXITY,
+ path_filter=path_filter
+ )
+
+ def visualize_issues_heatmap(self, severity=None, path_filter: Optional[str] = None):
+ """Convenience method for issues heatmap visualization."""
+ return self.visualize(
+ VisualizationType.ISSUES_HEATMAP,
+ severity=severity,
+ path_filter=path_filter
+ )
+
+ def visualize_pr_comparison(self):
+ """Convenience method for PR comparison visualization."""
+ return self.visualize(
+ VisualizationType.PR_COMPARISON
+ )
+
+# Command-line interface
+def main():
+ """
+ Command-line interface for the codebase visualizer.
+
+ This function parses command-line arguments and generates visualizations
+ based on the specified parameters.
+ """
+ parser = argparse.ArgumentParser(
+ description="Generate visualizations of codebase structure and analysis."
+ )
+
+ # Repository options
+ repo_group = parser.add_argument_group("Repository Options")
+ repo_group.add_argument(
+ "--repo-url",
+ help="URL of the repository to analyze"
+ )
+ repo_group.add_argument(
+ "--repo-path",
+ help="Local path to the repository to analyze"
+ )
+ repo_group.add_argument(
+ "--language",
+ help="Programming language of the codebase"
+ )
+
+ # Visualization options
+ viz_group = parser.add_argument_group("Visualization Options")
+ viz_group.add_argument(
+ "--type",
+ choices=[t.value for t in VisualizationType],
+ required=True,
+ help="Type of visualization to generate"
+ )
+ viz_group.add_argument(
+ "--entity",
+ help="Name of the entity to visualize (function, class, file, etc.)"
+ )
+ viz_group.add_argument(
+ "--max-depth",
+ type=int,
+ default=5,
+ help="Maximum depth for recursive visualizations"
+ )
+ viz_group.add_argument(
+ "--ignore-external",
+ action="store_true",
+ help="Ignore external dependencies"
+ )
+ viz_group.add_argument(
+ "--severity",
+ help="Filter issues by severity"
+ )
+ viz_group.add_argument(
+ "--path-filter",
+ help="Filter by file path"
+ )
+
+ # PR options
+ pr_group = parser.add_argument_group("PR Options")
+ pr_group.add_argument(
+ "--pr-number",
+ type=int,
+ help="PR number to analyze"
+ )
+ pr_group.add_argument(
+ "--base-branch",
+ default="main",
+ help="Base branch for comparison"
+ )
+
+ # Output options
+ output_group = parser.add_argument_group("Output Options")
+ output_group.add_argument(
+ "--output-format",
+ choices=[f.value for f in OutputFormat],
+ default="json",
+ help="Output format for the visualization"
+ )
+ output_group.add_argument(
+ "--output-directory",
+ help="Directory to save visualizations"
+ )
+ output_group.add_argument(
+ "--layout",
+ choices=["spring", "kamada_kawai", "spectral"],
+ default="spring",
+ help="Layout algorithm for graph visualization"
+ )
+
+ args = parser.parse_args()
+
+ # Create visualizer configuration
+ config = VisualizationConfig(
+ max_depth=args.max_depth,
+ ignore_external=args.ignore_external,
+ output_format=OutputFormat(args.output_format),
+ output_directory=args.output_directory,
+ layout_algorithm=args.layout
+ )
+
+ try:
+ # Import analyzer only if needed
+ if args.type in ["pr_comparison", "dead_code", "cyclomatic_complexity", "issues_heatmap"] or args.pr_number:
+ from codegen_on_oss.analyzers.codebase_analyzer import CodebaseAnalyzer
+
+ # Create analyzer
+ analyzer = CodebaseAnalyzer(
+ repo_url=args.repo_url,
+ repo_path=args.repo_path,
+ base_branch=args.base_branch,
+ pr_number=args.pr_number,
+ language=args.language
+ )
+ else:
+ analyzer = None
+ except ImportError:
+ logger.warning("CodebaseAnalyzer not available. Some visualizations may not work.")
+ analyzer = None
+
+ # Create visualizer
+ visualizer = CodebaseVisualizer(
+ analyzer=analyzer,
+ config=config
+ )
+
+ # Generate visualization based on type
+ viz_type = VisualizationType(args.type)
+ result = None
+
+ # Process specific requirements for each visualization type
+ if viz_type in [
+ VisualizationType.CALL_GRAPH,
+ VisualizationType.DEPENDENCY_GRAPH,
+ VisualizationType.BLAST_RADIUS,
+ VisualizationType.CLASS_METHODS,
+ VisualizationType.MODULE_DEPENDENCIES
+ ] and not args.entity:
+ logger.error(f"Entity name required for {viz_type} visualization")
+ sys.exit(1)
+
+ if viz_type == VisualizationType.PR_COMPARISON and not args.pr_number and not (analyzer and hasattr(analyzer, "pr_number")):
+ logger.error("PR number required for PR comparison visualization")
+ sys.exit(1)
+
+ # Generate visualization
+ result = visualizer.visualize(
+ viz_type,
+ entity=args.entity,
+ max_depth=args.max_depth,
+ severity=args.severity,
+ path_filter=args.path_filter
+ )
+
+ # Output result
+ if result:
+ logger.info(f"Visualization completed: {result}")
+ else:
+ logger.error("Failed to generate visualization")
+ sys.exit(1)
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/codegen-on-oss/codegen_on_oss/analyzers/visualization/visualizer.py b/codegen-on-oss/codegen_on_oss/analyzers/visualization/visualizer.py
new file mode 100644
index 000000000..7614dfaf5
--- /dev/null
+++ b/codegen-on-oss/codegen_on_oss/analyzers/visualization/visualizer.py
@@ -0,0 +1,337 @@
+#!/usr/bin/env python3
+"""
+Core Visualization Module
+
+This module provides the base visualization capabilities for codebases and PR analyses.
+It defines the core classes and interfaces for generating visual representations
+of code structure, dependencies, and issues.
+"""
+
+import os
+import sys
+import json
+import logging
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Set, Tuple, Any, Optional, Union, TypeVar, cast, Callable
+from datetime import datetime
+from dataclasses import dataclass, field
+
+try:
+ import networkx as nx
+ import matplotlib.pyplot as plt
+ from matplotlib.colors import LinearSegmentedColormap
+except ImportError:
+ logging.warning("Visualization dependencies not found. Please install them with: pip install networkx matplotlib")
+
+class VisualizationType(str, Enum):
+ """Types of visualizations supported by this module."""
+ CALL_GRAPH = "call_graph"
+ DEPENDENCY_GRAPH = "dependency_graph"
+ BLAST_RADIUS = "blast_radius"
+ CLASS_METHODS = "class_methods"
+ MODULE_DEPENDENCIES = "module_dependencies"
+ DEAD_CODE = "dead_code"
+ CYCLOMATIC_COMPLEXITY = "cyclomatic_complexity"
+ ISSUES_HEATMAP = "issues_heatmap"
+ PR_COMPARISON = "pr_comparison"
+
+class OutputFormat(str, Enum):
+ """Output formats for visualizations."""
+ JSON = "json"
+ PNG = "png"
+ SVG = "svg"
+ HTML = "html"
+ DOT = "dot"
+
+@dataclass
+class VisualizationConfig:
+ """Configuration for visualization generation."""
+ max_depth: int = 5
+ ignore_external: bool = True
+ ignore_tests: bool = True
+ node_size_base: int = 300
+ edge_width_base: float = 1.0
+ filename_filter: Optional[List[str]] = None
+ symbol_filter: Optional[List[str]] = None
+ output_format: OutputFormat = OutputFormat.JSON
+ output_directory: Optional[str] = None
+ layout_algorithm: str = "spring"
+ highlight_nodes: List[str] = field(default_factory=list)
+ highlight_color: str = "#ff5555"
+ color_palette: Dict[str, str] = field(default_factory=lambda: {
+ "Function": "#a277ff", # Purple
+ "Class": "#ffca85", # Orange
+ "File": "#80CBC4", # Teal
+ "Module": "#81D4FA", # Light Blue
+ "Variable": "#B39DDB", # Light Purple
+ "Root": "#ef5350", # Red
+ "Warning": "#FFCA28", # Amber
+ "Error": "#EF5350", # Red
+ "Dead": "#78909C", # Gray
+ "External": "#B0BEC5", # Light Gray
+ })
+
+class BaseVisualizer:
+ """
+ Base visualizer providing common functionality for different visualization types.
+
+ This class implements the core operations needed for visualization, including
+ graph creation, node and edge management, and output generation.
+ """
+
+ def __init__(
+ self,
+ config: Optional[VisualizationConfig] = None
+ ):
+ """
+ Initialize the BaseVisualizer.
+
+ Args:
+ config: Visualization configuration options
+ """
+ self.config = config or VisualizationConfig()
+
+ # Create visualization directory if specified
+ if self.config.output_directory:
+ os.makedirs(self.config.output_directory, exist_ok=True)
+
+ # Initialize graph for visualization
+ self.graph = nx.DiGraph()
+
+ # Tracking current visualization
+ self.current_visualization_type = None
+ self.current_entity_name = None
+
+ def _initialize_graph(self):
+ """Initialize a fresh graph for visualization."""
+ self.graph = nx.DiGraph()
+
+ def _add_node(self, node: Any, **attrs):
+ """
+ Add a node to the visualization graph with attributes.
+
+ Args:
+ node: Node object to add
+ **attrs: Node attributes
+ """
+ # Skip if node already exists
+ if self.graph.has_node(node):
+ return
+
+ # Generate node ID (memory address for unique identification)
+ node_id = id(node)
+
+ # Get node name
+ if "name" in attrs:
+ node_name = attrs["name"]
+ elif hasattr(node, "name"):
+ node_name = node.name
+ elif hasattr(node, "path"):
+ node_name = str(node.path).split("/")[-1]
+ else:
+ node_name = str(node)
+
+ # Determine node type and color
+ node_type = node.__class__.__name__
+ color = attrs.get("color", self.config.color_palette.get(node_type, "#BBBBBB"))
+
+ # Add node with attributes
+ self.graph.add_node(
+ node_id,
+ original_node=node,
+ name=node_name,
+ type=node_type,
+ color=color,
+ **attrs
+ )
+
+ return node_id
+
+ def _add_edge(self, source: Any, target: Any, **attrs):
+ """
+ Add an edge to the visualization graph with attributes.
+
+ Args:
+ source: Source node
+ target: Target node
+ **attrs: Edge attributes
+ """
+ # Get node IDs
+ source_id = id(source)
+ target_id = id(target)
+
+ # Add edge with attributes
+ self.graph.add_edge(
+ source_id,
+ target_id,
+ **attrs
+ )
+
+ def _generate_filename(self, visualization_type: VisualizationType, entity_name: str):
+ """
+ Generate a filename for the visualization.
+
+ Args:
+ visualization_type: Type of visualization
+ entity_name: Name of the entity being visualized
+
+ Returns:
+ Generated filename
+ """
+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+ sanitized_name = entity_name.replace("/", "_").replace("\\", "_").replace(".", "_")
+ return f"{visualization_type.value}_{sanitized_name}_{timestamp}.{self.config.output_format.value}"
+
+ def _save_visualization(self, visualization_type: VisualizationType, entity_name: str, data: Any):
+ """
+ Save a visualization to file or return it.
+
+ Args:
+ visualization_type: Type of visualization
+ entity_name: Name of the entity being visualized
+ data: Visualization data to save
+
+ Returns:
+ Path to saved file or visualization data
+ """
+ self.current_visualization_type = visualization_type
+ self.current_entity_name = entity_name
+
+ filename = self._generate_filename(visualization_type, entity_name)
+
+ if self.config.output_directory:
+ filepath = os.path.join(self.config.output_directory, filename)
+ else:
+ filepath = filename
+
+ if self.config.output_format == OutputFormat.JSON:
+ with open(filepath, 'w') as f:
+ json.dump(data, f, indent=2)
+ elif self.config.output_format in [OutputFormat.PNG, OutputFormat.SVG]:
+ # Save matplotlib figure
+ plt.savefig(filepath, format=self.config.output_format.value, bbox_inches='tight')
+ plt.close()
+ elif self.config.output_format == OutputFormat.DOT:
+ # Save as DOT file for Graphviz
+ try:
+ from networkx.drawing.nx_agraph import write_dot
+ write_dot(self.graph, filepath)
+ except ImportError:
+ logging.error("networkx.drawing.nx_agraph not available. Install pygraphviz for DOT format.")
+ return None
+
+ logging.info(f"Visualization saved to {filepath}")
+ return filepath
+
+ def _convert_graph_to_json(self):
+ """
+ Convert the networkx graph to a JSON-serializable dictionary.
+
+ Returns:
+ Dictionary representation of the graph
+ """
+ nodes = []
+ for node, attrs in self.graph.nodes(data=True):
+ # Create a serializable node
+ node_data = {
+ "id": node,
+ "name": attrs.get("name", ""),
+ "type": attrs.get("type", ""),
+ "color": attrs.get("color", "#BBBBBB"),
+ }
+
+ # Add file path if available
+ if "file_path" in attrs:
+ node_data["file_path"] = attrs["file_path"]
+
+ # Add other attributes
+ for key, value in attrs.items():
+ if key not in ["name", "type", "color", "file_path", "original_node"]:
+ if isinstance(value, (str, int, float, bool, list, dict)) or value is None:
+ node_data[key] = value
+
+ nodes.append(node_data)
+
+ edges = []
+ for source, target, attrs in self.graph.edges(data=True):
+ # Create a serializable edge
+ edge_data = {
+ "source": source,
+ "target": target,
+ }
+
+ # Add other attributes
+ for key, value in attrs.items():
+ if isinstance(value, (str, int, float, bool, list, dict)) or value is None:
+ edge_data[key] = value
+
+ edges.append(edge_data)
+
+ return {
+ "nodes": nodes,
+ "edges": edges,
+ "metadata": {
+ "visualization_type": self.current_visualization_type,
+ "entity_name": self.current_entity_name,
+ "timestamp": datetime.now().isoformat(),
+ "node_count": len(nodes),
+ "edge_count": len(edges),
+ }
+ }
+
+ def _plot_graph(self):
+ """
+ Plot the graph using matplotlib.
+
+ Returns:
+ Matplotlib figure
+ """
+ plt.figure(figsize=(12, 10))
+
+ # Extract node positions using specified layout algorithm
+ if self.config.layout_algorithm == "spring":
+ pos = nx.spring_layout(self.graph, seed=42)
+ elif self.config.layout_algorithm == "kamada_kawai":
+ pos = nx.kamada_kawai_layout(self.graph)
+ elif self.config.layout_algorithm == "spectral":
+ pos = nx.spectral_layout(self.graph)
+ else:
+ # Default to spring layout
+ pos = nx.spring_layout(self.graph, seed=42)
+
+ # Extract node colors
+ node_colors = [attrs.get("color", "#BBBBBB") for _, attrs in self.graph.nodes(data=True)]
+
+ # Extract node sizes (can be based on some metric)
+ node_sizes = [self.config.node_size_base for _ in self.graph.nodes()]
+
+ # Draw nodes
+ nx.draw_networkx_nodes(
+ self.graph, pos,
+ node_color=node_colors,
+ node_size=node_sizes,
+ alpha=0.8
+ )
+
+ # Draw edges
+ nx.draw_networkx_edges(
+ self.graph, pos,
+ width=self.config.edge_width_base,
+ alpha=0.6,
+ arrows=True,
+ arrowsize=10
+ )
+
+ # Draw labels
+ nx.draw_networkx_labels(
+ self.graph, pos,
+ labels={node: attrs.get("name", "") for node, attrs in self.graph.nodes(data=True)},
+ font_size=8,
+ font_weight="bold"
+ )
+
+ plt.title(f"{self.current_visualization_type} - {self.current_entity_name}")
+ plt.axis("off")
+
+ return plt.gcf()
\ No newline at end of file
diff --git a/organize_codebase.py b/organize_codebase.py
new file mode 100644
index 000000000..d12d4f660
--- /dev/null
+++ b/organize_codebase.py
@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""
+Codebase Organizer Script
+
+This script helps organize a codebase by analyzing file contents and moving
+related files into appropriate directories based on their functionality.
+"""
+
+import os
+import re
+import shutil
+from pathlib import Path
+from typing import Dict, List, Set, Tuple
+
+# Define categories and their related patterns
+CATEGORIES = {
+ "analyzers": [
+ r"analyzer", r"analysis", r"analyze"
+ ],
+ "code_quality": [
+ r"code_quality", r"quality", r"lint"
+ ],
+ "context": [
+ r"context", r"codebase_context"
+ ],
+ "dependencies": [
+ r"dependenc", r"import"
+ ],
+ "issues": [
+ r"issue", r"error"
+ ],
+ "visualization": [
+ r"visual", r"display", r"render"
+ ],
+}
+
+def read_file_content(file_path: str) -> str:
+ """Read the content of a file."""
+ try:
+ with open(file_path, 'r', encoding='utf-8') as f:
+ return f.read()
+ except Exception as e:
+ print(f"Error reading {file_path}: {e}")
+ return ""
+
+def categorize_file(file_path: str, categories: Dict[str, List[str]]) -> List[str]:
+ """Categorize a file based on its content and name."""
+ file_categories = []
+ content = read_file_content(file_path)
+ filename = os.path.basename(file_path)
+
+ # Check filename and content against category patterns
+ for category, patterns in categories.items():
+ for pattern in patterns:
+ if re.search(pattern, filename, re.IGNORECASE) or re.search(pattern, content, re.IGNORECASE):
+ file_categories.append(category)
+ break
+
+ return file_categories
+
+def analyze_imports(file_path: str) -> Set[str]:
+ """Analyze imports in a Python file."""
+ imports = set()
+ content = read_file_content(file_path)
+
+ # Find import statements
+ import_patterns = [
+ r'import\s+([a-zA-Z0-9_\.]+)',
+ r'from\s+([a-zA-Z0-9_\.]+)\s+import'
+ ]
+
+ for pattern in import_patterns:
+ for match in re.finditer(pattern, content):
+ imports.add(match.group(1))
+
+ return imports
+
+def build_dependency_graph(files: List[str]) -> Dict[str, Set[str]]:
+ """Build a dependency graph for the files."""
+ graph = {}
+ module_to_file = {}
+
+ # Map module names to files
+ for file_path in files:
+ if not file_path.endswith('.py'):
+ continue
+
+ module_name = os.path.splitext(os.path.basename(file_path))[0]
+ module_to_file[module_name] = file_path
+
+ # Build the graph
+ for file_path in files:
+ if not file_path.endswith('.py'):
+ continue
+
+ imports = analyze_imports(file_path)
+ graph[file_path] = set()
+
+ for imp in imports:
+ # Check if this is a local import
+ parts = imp.split('.')
+ if parts[0] in module_to_file:
+ graph[file_path].add(module_to_file[parts[0]])
+
+ return graph
+
+def find_related_files(graph: Dict[str, Set[str]], file_path: str) -> Set[str]:
+ """Find files related to the given file based on the dependency graph."""
+ related = set()
+
+ # Files that this file imports
+ if file_path in graph:
+ related.update(graph[file_path])
+
+ # Files that import this file
+ for other_file, deps in graph.items():
+ if file_path in deps:
+ related.add(other_file)
+
+ return related
+
+def organize_files(directory: str, dry_run: bool = True) -> Dict[str, List[str]]:
+ """
+ Organize files in the directory into categories.
+
+ Args:
+ directory: The directory containing the files to organize
+ dry_run: If True, only print the planned changes without making them
+
+ Returns:
+ A dictionary mapping categories to lists of files
+ """
+ # Get all Python files
+ py_files = [os.path.join(directory, f) for f in os.listdir(directory)
+ if f.endswith('.py') and os.path.isfile(os.path.join(directory, f))]
+
+ # Build dependency graph
+ graph = build_dependency_graph(py_files)
+
+ # Categorize files
+ categorized_files = {}
+ for category in CATEGORIES:
+ categorized_files[category] = []
+
+ # Special case for README and init files
+ categorized_files["root"] = []
+
+ for file_path in py_files:
+ filename = os.path.basename(file_path)
+
+ # Keep some files in the root directory
+ if filename in ['__init__.py', 'README.md']:
+ categorized_files["root"].append(file_path)
+ continue
+
+ # Categorize the file
+ categories = categorize_file(file_path, CATEGORIES)
+
+ if not categories:
+ # If no category found, use related files to determine category
+ related = find_related_files(graph, file_path)
+ for related_file in related:
+ related_categories = categorize_file(related_file, CATEGORIES)
+ categories.extend(related_categories)
+
+ # Remove duplicates
+ categories = list(set(categories))
+
+ if not categories:
+ # If still no category, put in a default category based on filename
+ if "analyzer" in filename:
+ categories = ["analyzers"]
+ elif "context" in filename:
+ categories = ["context"]
+ elif "issue" in filename or "error" in filename:
+ categories = ["issues"]
+ elif "visual" in filename:
+ categories = ["visualization"]
+ elif "depend" in filename:
+ categories = ["dependencies"]
+ elif "quality" in filename:
+ categories = ["code_quality"]
+ else:
+ # Default to analyzers if nothing else matches
+ categories = ["analyzers"]
+
+ # Use the first category (most relevant)
+ primary_category = categories[0]
+ categorized_files[primary_category].append(file_path)
+
+ # Print and execute the organization plan
+ for category, files in categorized_files.items():
+ if not files:
+ continue
+
+ print(f"\nCategory: {category}")
+ for file_path in files:
+ print(f" - {os.path.basename(file_path)}")
+
+ if not dry_run and category != "root":
+ # Create the category directory if it doesn't exist
+ category_dir = os.path.join(directory, category)
+ os.makedirs(category_dir, exist_ok=True)
+
+ # Move files to the category directory
+ for file_path in files:
+ if category != "root":
+ dest_path = os.path.join(category_dir, os.path.basename(file_path))
+ shutil.move(file_path, dest_path)
+ print(f" Moved to {dest_path}")
+
+ return categorized_files
+
+def main():
+ """Main function to organize the codebase."""
+ import argparse
+
+ parser = argparse.ArgumentParser(description='Organize a codebase by categorizing files.')
+ parser.add_argument('directory', help='The directory containing the files to organize')
+ parser.add_argument('--execute', action='store_true', help='Execute the organization plan (default is dry run)')
+
+ args = parser.parse_args()
+
+ print(f"Analyzing files in {args.directory}...")
+ organize_files(args.directory, dry_run=not args.execute)
+
+ if not args.execute:
+ print("\nThis was a dry run. Use --execute to actually move the files.")
+ else:
+ print("\nFiles have been organized.")
+
+if __name__ == "__main__":
+ main()
+
diff --git a/organize_specific_codebase.py b/organize_specific_codebase.py
new file mode 100644
index 000000000..cfe8f534d
--- /dev/null
+++ b/organize_specific_codebase.py
@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""
+Specific Codebase Organizer
+
+This script organizes the specific codebase structure shown in the screenshot,
+with 5 folders and 21 Python files in the root directory.
+"""
+
+import os
+import re
+import shutil
+from pathlib import Path
+from typing import Dict, List, Set
+
+# Define the organization structure based on the files in the screenshot
+ORGANIZATION_PLAN = {
+ "analyzers": [
+ "analyzer.py",
+ "analyzer_manager.py",
+ "base_analyzer.py",
+ "code_quality_analyzer.py",
+ "codebase_analyzer.py",
+ "dependency_analyzer.py",
+ "error_analyzer.py",
+ "unified_analyzer.py"
+ ],
+ "code_quality": [
+ "code_quality.py"
+ ],
+ "context": [
+ "codebase_context.py",
+ "context_codebase.py",
+ "current_code_codebase.py"
+ ],
+ "issues": [
+ "issue_analyzer.py",
+ "issue_types.py",
+ "issues.py"
+ ],
+ "dependencies": [
+ "dependencies.py"
+ ],
+ # Files to keep in root
+ "root": [
+ "__init__.py",
+ "api.py",
+ "README.md"
+ ]
+}
+
+def organize_specific_codebase(directory: str, dry_run: bool = True) -> None:
+ """
+ Organize the specific codebase structure.
+
+ Args:
+ directory: The directory containing the files to organize
+ dry_run: If True, only print the planned changes without making them
+ """
+ print(f"Organizing codebase in {directory}...")
+
+ # Create directories if they don't exist (unless dry run)
+ if not dry_run:
+ for category in ORGANIZATION_PLAN:
+ if category != "root":
+ os.makedirs(os.path.join(directory, category), exist_ok=True)
+
+ # Process each file according to the plan
+ for category, files in ORGANIZATION_PLAN.items():
+ print(f"\nCategory: {category}")
+
+ for filename in files:
+ source_path = os.path.join(directory, filename)
+
+ # Skip if file doesn't exist
+ if not os.path.exists(source_path):
+ print(f" - {filename} (not found, skipping)")
+ continue
+
+ print(f" - {filename}")
+
+ # Move the file if not a dry run and not in root category
+ if not dry_run and category != "root":
+ dest_path = os.path.join(directory, category, filename)
+ shutil.move(source_path, dest_path)
+ print(f" Moved to {dest_path}")
+
+ # Handle any remaining Python files not explicitly categorized
+ all_planned_files = [f for files in ORGANIZATION_PLAN.values() for f in files]
+ remaining_files = [f for f in os.listdir(directory)
+ if f.endswith('.py') and os.path.isfile(os.path.join(directory, f))
+ and f not in all_planned_files]
+
+ if remaining_files:
+ print("\nRemaining Python files (not categorized):")
+ for filename in remaining_files:
+ print(f" - {filename}")
+
+ # Try to categorize based on filename
+ if "analyzer" in filename.lower():
+ category = "analyzers"
+ elif "context" in filename.lower() or "codebase" in filename.lower():
+ category = "context"
+ elif "visual" in filename.lower():
+ category = "visualization"
+ elif "issue" in filename.lower() or "error" in filename.lower():
+ category = "issues"
+ elif "depend" in filename.lower():
+ category = "dependencies"
+ elif "quality" in filename.lower():
+ category = "code_quality"
+ else:
+ # Default to analyzers
+ category = "analyzers"
+
+ print(f" Suggested category: {category}")
+
+ # Move the file if not a dry run
+ if not dry_run:
+ os.makedirs(os.path.join(directory, category), exist_ok=True)
+ dest_path = os.path.join(directory, category, filename)
+ shutil.move(os.path.join(directory, filename), dest_path)
+ print(f" Moved to {dest_path}")
+
+def main():
+ """Main function to organize the specific codebase."""
+ import argparse
+
+ parser = argparse.ArgumentParser(description='Organize the specific codebase structure.')
+ parser.add_argument('directory', help='The directory containing the files to organize')
+ parser.add_argument('--execute', action='store_true', help='Execute the organization plan (default is dry run)')
+
+ args = parser.parse_args()
+
+ organize_specific_codebase(args.directory, dry_run=not args.execute)
+
+ if not args.execute:
+ print("\nThis was a dry run. Use --execute to actually move the files.")
+ else:
+ print("\nFiles have been organized according to the plan.")
+
+ print("\nAfter organizing, you may need to update imports in your code.")
+ print("You can use the Codegen SDK to automatically update imports:")
+ print("""
+ # Example code to update imports after moving files
+ from codegen.sdk import Codebase
+
+ # Initialize the codebase
+ codebase = Codebase("path/to/your/codebase")
+
+ # Commit the changes to ensure the codebase is up-to-date
+ codebase.commit()
+ """)
+
+if __name__ == "__main__":
+ main()
+
diff --git a/organize_with_codegen_sdk.py b/organize_with_codegen_sdk.py
new file mode 100644
index 000000000..263947c1b
--- /dev/null
+++ b/organize_with_codegen_sdk.py
@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+Codebase Organizer using Codegen SDK
+
+This script uses the Codegen SDK to programmatically organize a codebase by
+moving symbols between files and updating imports automatically.
+"""
+
+import os
+import sys
+from typing import Dict, List, Set, Optional
+
+try:
+ from codegen.sdk import Codebase
+except ImportError:
+ print("Error: Codegen SDK not found. Please install it with:")
+ print("pip install codegen-sdk")
+ sys.exit(1)
+
+# Define the organization structure based on the files in the screenshot
+ORGANIZATION_PLAN = {
+ "analyzers": [
+ "analyzer.py",
+ "analyzer_manager.py",
+ "base_analyzer.py",
+ "code_quality_analyzer.py",
+ "codebase_analyzer.py",
+ "dependency_analyzer.py",
+ "error_analyzer.py",
+ "unified_analyzer.py"
+ ],
+ "code_quality": [
+ "code_quality.py"
+ ],
+ "context": [
+ "codebase_context.py",
+ "context_codebase.py",
+ "current_code_codebase.py"
+ ],
+ "issues": [
+ "issue_analyzer.py",
+ "issue_types.py",
+ "issues.py"
+ ],
+ "dependencies": [
+ "dependencies.py"
+ ],
+ # Files to keep in root
+ "root": [
+ "__init__.py",
+ "api.py",
+ "README.md"
+ ]
+}
+
+def organize_with_codegen_sdk(directory: str, dry_run: bool = True) -> None:
+ """
+ Organize the codebase using Codegen SDK.
+
+ Args:
+ directory: The directory containing the files to organize
+ dry_run: If True, only print the planned changes without making them
+ """
+ print(f"Organizing codebase in {directory} using Codegen SDK...")
+
+ # Initialize the codebase
+ codebase = Codebase(directory)
+
+ # Create directories if they don't exist (unless dry run)
+ if not dry_run:
+ for category in ORGANIZATION_PLAN:
+ if category != "root":
+ os.makedirs(os.path.join(directory, category), exist_ok=True)
+
+ # Process each file according to the plan
+ for category, files in ORGANIZATION_PLAN.items():
+ if category == "root":
+ continue # Skip files that should stay in root
+
+ print(f"\nCategory: {category}")
+
+ for filename in files:
+ source_path = os.path.join(directory, filename)
+
+ # Skip if file doesn't exist
+ if not os.path.exists(source_path):
+ print(f" - {filename} (not found, skipping)")
+ continue
+
+ print(f" - {filename}")
+
+ # Move the file if not a dry run
+ if not dry_run:
+ try:
+ # Get the source file
+ source_file = codebase.get_file(filename)
+
+ # Create the destination file path
+ dest_path = os.path.join(category, filename)
+
+ # Create the destination file if it doesn't exist
+ if not os.path.exists(os.path.join(directory, dest_path)):
+ dest_file = codebase.create_file(dest_path)
+ else:
+ dest_file = codebase.get_file(dest_path)
+
+ # Move all symbols from source to destination
+ for symbol in source_file.symbols:
+ print(f" Moving symbol: {symbol.name}")
+ symbol.move_to_file(
+ dest_file,
+ include_dependencies=True,
+ strategy="update_all_imports"
+ )
+
+ # Commit changes to ensure the codebase is up-to-date
+ codebase.commit()
+
+ print(f" Moved to {dest_path} with imports updated")
+ except Exception as e:
+ print(f" Error moving {filename}: {e}")
+
+ # Handle any remaining Python files not explicitly categorized
+ all_planned_files = [f for files in ORGANIZATION_PLAN.values() for f in files]
+ remaining_files = [f for f in os.listdir(directory)
+ if f.endswith('.py') and os.path.isfile(os.path.join(directory, f))
+ and f not in all_planned_files]
+
+ if remaining_files:
+ print("\nRemaining Python files (not categorized):")
+ for filename in remaining_files:
+ print(f" - {filename}")
+
+ # Try to categorize based on filename
+ if "analyzer" in filename.lower():
+ category = "analyzers"
+ elif "context" in filename.lower() or "codebase" in filename.lower():
+ category = "context"
+ elif "visual" in filename.lower():
+ category = "visualization"
+ elif "issue" in filename.lower() or "error" in filename.lower():
+ category = "issues"
+ elif "depend" in filename.lower():
+ category = "dependencies"
+ elif "quality" in filename.lower():
+ category = "code_quality"
+ else:
+ # Default to analyzers
+ category = "analyzers"
+
+ print(f" Suggested category: {category}")
+
+ # Move the file if not a dry run
+ if not dry_run:
+ try:
+ # Get the source file
+ source_file = codebase.get_file(filename)
+
+ # Create the destination file path
+ dest_path = os.path.join(category, filename)
+
+ # Create the destination file if it doesn't exist
+ if not os.path.exists(os.path.join(directory, dest_path)):
+ dest_file = codebase.create_file(dest_path)
+ else:
+ dest_file = codebase.get_file(dest_path)
+
+ # Move all symbols from source to destination
+ for symbol in source_file.symbols:
+ print(f" Moving symbol: {symbol.name}")
+ symbol.move_to_file(
+ dest_file,
+ include_dependencies=True,
+ strategy="update_all_imports"
+ )
+
+ # Commit changes to ensure the codebase is up-to-date
+ codebase.commit()
+
+ print(f" Moved to {dest_path} with imports updated")
+ except Exception as e:
+ print(f" Error moving {filename}: {e}")
+
+def main():
+ """Main function to organize the codebase using Codegen SDK."""
+ import argparse
+
+ parser = argparse.ArgumentParser(description='Organize the codebase using Codegen SDK.')
+ parser.add_argument('directory', help='The directory containing the files to organize')
+ parser.add_argument('--execute', action='store_true', help='Execute the organization plan (default is dry run)')
+
+ args = parser.parse_args()
+
+ organize_with_codegen_sdk(args.directory, dry_run=not args.execute)
+
+ if not args.execute:
+ print("\nThis was a dry run. Use --execute to actually move the files.")
+ else:
+ print("\nFiles have been organized according to the plan.")
+
+if __name__ == "__main__":
+ main()
+