class AICodeAnalyzer:
"""AI Agent for advanced code analysis using Griffe"""
def __init__(self):
self.analysis_cache = {}
self.dependency_graph = nx.DiGraph()
def analyze_package(self, package_name: str, search_paths: List(str) = None) -> Dict(str, Any):
"""Comprehensive package analysis for AI decision making"""
try:
pkg = griffe.load(package_name, search_paths=search_paths, try_relative_path=False)
analysis = {
'package_name': package_name,
'total_modules': 0,
'total_classes': 0,
'total_functions': 0,
'complexity_score': 0,
'api_surface': (),
'inheritance_tree': {},
'risk_factors': ()
}
self._analyze_object(pkg, analysis)
analysis('complexity_score') = self._calculate_complexity(analysis)
analysis('risk_factors') = self._identify_risks(pkg, analysis)
self.analysis_cache(package_name) = analysis
return analysis
except Exception as e:
return {'error': f"Failed to analyze {package_name}: {str(e)}"}
def analyze_simple_module(self, module_name: str) -> Dict(str, Any):
"""Analyze a simple module without deep dependency resolution"""
try:
import importlib
module = importlib.import_module(module_name)
analysis = {
'package_name': module_name,
'total_modules': 1,
'total_classes': 0,
'total_functions': 0,
'complexity_score': 0,
'api_surface': (),
'inheritance_tree': {},
'risk_factors': ()
}
for attr_name in dir(module):
if not attr_name.startswith('_'):
attr = getattr(module, attr_name)
if isinstance(attr, type):
analysis('total_classes') += 1
analysis('api_surface').append({
'name': f"{module_name}.{attr_name}",
'type': 'class',
'public': True,
'docstring': bool(attr.__doc__),
'methods': len((m for m in dir(attr) if not m.startswith('_')))
})
elif callable(attr):
analysis('total_functions') += 1
analysis('api_surface').append({
'name': f"{module_name}.{attr_name}",
'type': 'function',
'public': True,
'docstring': bool(attr.__doc__),
'parameters': 0
})
analysis('complexity_score') = self._calculate_complexity(analysis)
analysis('risk_factors') = self._identify_basic_risks(analysis)
self.analysis_cache(module_name) = analysis
return analysis
except Exception as e:
return {'error': f"Failed to analyze {module_name}: {str(e)}"}
def _analyze_object(self, obj, analysis: Dict(str, Any), path: str = ""):
"""Recursively analyze package objects"""
try:
current_path = f"{path}.{obj.name}" if path else obj.name
if hasattr(obj, 'kind'):
if obj.kind.value == 'module':
analysis('total_modules') += 1
elif obj.kind.value == 'class':
analysis('total_classes') += 1
analysis('api_surface').append({
'name': current_path,
'type': 'class',
'public': not obj.name.startswith('_'),
'docstring': bool(obj.docstring),
'methods': len((m for m in obj.members.values() if hasattr(m, 'kind') and m.kind.value == 'function'))
})
if hasattr(obj, 'bases') and obj.bases:
analysis('inheritance_tree')(current_path) = (str(base) for base in obj.bases)
elif obj.kind.value == 'function':
analysis('total_functions') += 1
analysis('api_surface').append({
'name': current_path,
'type': 'function',
'public': not obj.name.startswith('_'),
'docstring': bool(obj.docstring),
'parameters': len(obj.parameters) if hasattr(obj, 'parameters') else 0
})
if hasattr(obj, 'members'):
for member in obj.members.values():
self._analyze_object(member, analysis, current_path)
except Exception as e:
pass
def _calculate_complexity(self, analysis: Dict(str, Any)) -> float:
"""Calculate package complexity score for AI decision making"""
base_score = (analysis('total_classes') * 2 +
analysis('total_functions') * 1 +
analysis('total_modules') * 0.5)
inheritance_penalty = len(analysis('inheritance_tree')) * 1.5
documented_items = sum(1 for item in analysis('api_surface') if item('docstring'))
total_items = len(analysis('api_surface'))
doc_penalty = (total_items - documented_items) * 0.3 if total_items > 0 else 0
return base_score + inheritance_penalty + doc_penalty
def _identify_risks(self, pkg, analysis: Dict(str, Any)) -> List(str):
"""Identify potential risks for AI agent decision making"""
risks = ()
if len(analysis('api_surface')) > 50:
risks.append("Large API surface - potential maintenance burden")
documented = sum(1 for item in analysis('api_surface') if item('docstring'))
total = len(analysis('api_surface'))
if total > 0 and documented / total < 0.5:
risks.append("Poor documentation coverage")
max_inheritance_depth = 0
for bases in analysis('inheritance_tree').values():
max_inheritance_depth = max(max_inheritance_depth, len(bases))
if max_inheritance_depth > 3:
risks.append("Deep inheritance hierarchy detected")
return risks
def _identify_basic_risks(self, analysis: Dict(str, Any)) -> List(str):
"""Basic risk identification for simple module analysis"""
risks = ()
if len(analysis('api_surface')) > 30:
risks.append("Large API surface")
documented = sum(1 for item in analysis('api_surface') if item('docstring'))
total = len(analysis('api_surface'))
if total > 0 and documented / total < 0.4:
risks.append("Limited documentation")
return risks
def compare_packages(self, pkg1: str, pkg2: str) -> Dict(str, Any):
"""Compare two packages for AI decision making"""
analysis1 = self.analyze_package(pkg1)
if 'error' in analysis1:
analysis1 = self.analyze_simple_module(pkg1)
analysis2 = self.analyze_package(pkg2)
if 'error' in analysis2:
analysis2 = self.analyze_simple_module(pkg2)
if 'error' in analysis1 or 'error' in analysis2:
return {'error': 'Failed to compare packages'}
comparison = {
'package_comparison': {
'complexity': {
pkg1: analysis1('complexity_score'),
pkg2: analysis2('complexity_score'),
'winner': pkg1 if analysis1('complexity_score') < analysis2('complexity_score') else pkg2
},
'api_size': {
pkg1: len(analysis1('api_surface')),
pkg2: len(analysis2('api_surface')),
'winner': pkg1 if len(analysis1('api_surface')) < len(analysis2('api_surface')) else pkg2
},
'documentation': {
pkg1: self._doc_coverage(analysis1),
pkg2: self._doc_coverage(analysis2),
'winner': pkg1 if self._doc_coverage(analysis1) > self._doc_coverage(analysis2) else pkg2
}
},
'recommendation': self._make_recommendation(analysis1, analysis2, pkg1, pkg2)
}
return comparison
def _doc_coverage(self, analysis: Dict(str, Any)) -> float:
"""Calculate documentation coverage percentage"""
if not analysis('api_surface'):
return 0.0
documented = sum(1 for item in analysis('api_surface') if item('docstring'))
return (documented / len(analysis('api_surface'))) * 100
def _make_recommendation(self, a1: Dict, a2: Dict, pkg1: str, pkg2: str) -> str:
"""Make AI recommendation based on analysis"""
score1 = (100 - a1('complexity_score')) + self._doc_coverage(a1)
score2 = (100 - a2('complexity_score')) + self._doc_coverage(a2)
if score1 > score2:
return f"Recommend {pkg1}: Better complexity/documentation balance"
elif score2 > score1:
return f"Recommend {pkg2}: Better complexity/documentation balance"
else:
return "Packages are equivalent in key metrics"
def visualize_analysis(self, package_name: str):
"""Create visualizations for AI insights"""
if package_name not in self.analysis_cache:
analysis = self.analyze_package(package_name)
if 'error' in analysis:
analysis = self.analyze_simple_module(package_name)
analysis = self.analysis_cache(package_name)
if 'error' in analysis:
print(f"❌ Cannot visualize {package_name}: {analysis('error')}")
return
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
fig.suptitle(f'AI Analysis Dashboard: {package_name}', fontsize=16, fontweight="bold")
components = ('Modules', 'Classes', 'Functions')
counts = (analysis('total_modules'), analysis('total_classes'), analysis('total_functions'))
colors = ('#FF6B6B', '#4ECDC4', '#45B7D1')
non_zero_components = ()
non_zero_counts = ()
non_zero_colors = ()
for i, count in enumerate(counts):
if count > 0:
non_zero_components.append(components(i))
non_zero_counts.append(count)
non_zero_colors.append(colors(i))
if non_zero_counts:
ax1.pie(non_zero_counts, labels=non_zero_components, colors=non_zero_colors,
autopct="%1.1f%%", startangle=90)
else:
ax1.text(0.5, 0.5, 'No components found', ha="center", va="center", transform=ax1.transAxes)
ax1.set_title('Component Distribution')
public_items = sum(1 for item in analysis('api_surface') if item('public'))
private_items = len(analysis('api_surface')) - public_items
ax2.bar(('Public API', 'Private API'), (public_items, private_items),
color=('#2ECC71', '#E74C3C'))
ax2.set_title('API Surface Analysis')
ax2.set_ylabel('Count')
documented = sum(1 for item in analysis('api_surface') if item('docstring'))
undocumented = len(analysis('api_surface')) - documented
ax3.bar(('Documented', 'Undocumented'), (documented, undocumented),
color=('#3498DB', '#F39C12'))
ax3.set_title('Documentation Coverage')
ax3.set_ylabel('Count')
complexity = analysis('complexity_score')
ax4.barh(('Complexity Score'), (complexity), color="#9B59B6")
ax4.set_title('Package Complexity')
ax4.set_xlabel('Score')
plt.tight_layout()
plt.show()
print(f"\n🤖 AI INSIGHTS for {package_name}:")
print(f"📊 Complexity Score: {complexity:.2f}")
print(f"📈 Total API Elements: {len(analysis('api_surface'))}")
print(f"📚 Documentation Coverage: {self._doc_coverage(analysis):.1f}%")
if analysis('risk_factors'):
print(f"⚠️ Risk Factors:")
for risk in analysis('risk_factors'):
print(f" • {risk}")
else:
print("✅ No major risk factors detected")
