socratic-analyzer 0.1.0__py3-none-any.whl

socratic_analyzer/__init__.py

@@ -0,0 +1,42 @@
+"""Socratic Analyzer - Production-grade code analysis package."""
+
+__version__ = "0.1.0"
+__author__ = "Socratic Analyzer"
+__email__ = "info@socratic-analyzer.dev"
+
+from .async_client import AsyncAnalyzerClient
+from .client import AnalyzerClient
+from .exceptions import (
+    AnalysisError,
+    AnalyzerError,
+    ConfigurationError,
+    LLMAnalysisError,
+    ParsingError,
+    PatternDetectionError,
+    ProviderNotFoundError,
+    ReportError,
+    ReportFormatError,
+)
+from .models import Analysis, AnalyzerConfig, CodeIssue, MetricResult, ProjectAnalysis
+
+__all__ = [
+    # Client
+    "AnalyzerClient",
+    "AsyncAnalyzerClient",
+    # Models
+    "Analysis",
+    "AnalyzerConfig",
+    "CodeIssue",
+    "MetricResult",
+    "ProjectAnalysis",
+    # Exceptions
+    "AnalyzerError",
+    "AnalysisError",
+    "ConfigurationError",
+    "ParsingError",
+    "PatternDetectionError",
+    "ReportError",
+    "ReportFormatError",
+    "ProviderNotFoundError",
+    "LLMAnalysisError",
+]

socratic_analyzer/async_client.py

@@ -0,0 +1,109 @@
+"""Async analyzer client interface."""
+
+import asyncio
+from typing import List, Optional
+
+from socratic_analyzer.client import AnalyzerClient
+from socratic_analyzer.models import Analysis, AnalyzerConfig
+
+
+class AsyncAnalyzerClient(AnalyzerClient):
+    """Async analyzer client interface.
+
+    Provides async/await support for analyzing Python code.
+    """
+
+    async def analyze_file_async(self, file_path: str) -> Analysis:
+        """Analyze a single Python file asynchronously.
+
+        Args:
+            file_path: Path to the Python file
+
+        Returns:
+            Analysis object with results
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            IOError: If file can't be read
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self.analyze_file, file_path)
+
+    async def analyze_code_async(
+        self, code: str, file_path: str = "unknown.py"
+    ) -> Analysis:
+        """Analyze Python code asynchronously.
+
+        Args:
+            code: Python source code
+            file_path: Path to file (for reporting, optional)
+
+        Returns:
+            Analysis object with results
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None, self.analyze_code, code, file_path
+        )
+
+    async def analyze_files_async(self, file_paths: List[str]) -> List[Analysis]:
+        """Analyze multiple Python files asynchronously.
+
+        Args:
+            file_paths: List of paths to Python files
+
+        Returns:
+            List of Analysis objects
+
+        Raises:
+            FileNotFoundError: If any file doesn't exist
+            IOError: If any file can't be read
+        """
+        tasks = [self.analyze_file_async(fp) for fp in file_paths]
+        return await asyncio.gather(*tasks)
+
+    async def batch_analyze_code_async(
+        self, code_samples: List[tuple]
+    ) -> List[Analysis]:
+        """Analyze multiple code samples asynchronously.
+
+        Args:
+            code_samples: List of (code, file_path) tuples
+
+        Returns:
+            List of Analysis objects
+        """
+        tasks = [
+            self.analyze_code_async(code, fp or "unknown.py")
+            for code, fp in code_samples
+        ]
+        return await asyncio.gather(*tasks)
+
+    async def generate_report_async(
+        self, analysis: Analysis, format: str = "text"
+    ) -> str:
+        """Generate formatted report asynchronously.
+
+        Args:
+            analysis: Analysis object
+            format: Report format ("text", "json", "markdown")
+
+        Returns:
+            Formatted report string
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None, self.generate_report, analysis, format
+        )
+
+    async def get_recommendations_async(self, analysis: Analysis) -> List[str]:
+        """Get actionable recommendations asynchronously.
+
+        Args:
+            analysis: Analysis object
+
+        Returns:
+            List of recommendations
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self.get_recommendations, analysis)

socratic_analyzer/client.py

@@ -0,0 +1,475 @@
+"""Main analyzer client interface."""
+
+from typing import List, Optional
+
+from socratic_analyzer.analyzers.complexity import ComplexityAnalyzer
+from socratic_analyzer.analyzers.imports import ImportAnalyzer
+from socratic_analyzer.analyzers.metrics import MetricsAnalyzer
+from socratic_analyzer.analyzers.static import StaticAnalyzer
+from socratic_analyzer.analyzers.patterns import PatternAnalyzer
+from socratic_analyzer.analyzers.smells import CodeSmellDetector
+from socratic_analyzer.analyzers.performance import PerformanceAnalyzer
+from socratic_analyzer.models import Analysis, AnalyzerConfig, CodeIssue, MetricResult
+from socratic_analyzer.utils.quality_scorer import QualityScorer
+
+
+class AnalyzerClient:
+    """Main analyzer client interface.
+
+    Provides a unified interface for analyzing Python code with multiple
+    specialized analyzers.
+    """
+
+    def __init__(self, config: Optional[AnalyzerConfig] = None) -> None:
+        """Initialize analyzer client.
+
+        Args:
+            config: AnalyzerConfig object. If None, uses default configuration.
+        """
+        self.config = config or AnalyzerConfig()
+
+        # Initialize analyzers
+        self._static_analyzer = StaticAnalyzer()
+        self._complexity_analyzer = ComplexityAnalyzer(
+            max_complexity=self.config.max_complexity
+        )
+        self._metrics_analyzer = MetricsAnalyzer()
+        self._import_analyzer = ImportAnalyzer()
+        self._pattern_analyzer = PatternAnalyzer()
+        self._smell_detector = CodeSmellDetector()
+        self._performance_analyzer = PerformanceAnalyzer()
+
+    def analyze_file(self, file_path: str) -> Analysis:
+        """Analyze a single Python file.
+
+        Args:
+            file_path: Path to the Python file
+
+        Returns:
+            Analysis object with results
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            IOError: If file can't be read
+        """
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                code = f.read()
+        except FileNotFoundError:
+            raise FileNotFoundError(f"File not found: {file_path}")
+        except IOError as e:
+            raise IOError(f"Error reading file {file_path}: {e}")
+
+        return self.analyze_code(code, file_path)
+
+    def analyze_code(self, code: str, file_path: str = "unknown.py") -> Analysis:
+        """Analyze Python code.
+
+        Args:
+            code: Python source code
+            file_path: Path to file (for reporting, optional)
+
+        Returns:
+            Analysis object with results
+        """
+        # Get file size
+        file_size = len(code.encode("utf-8"))
+
+        # Collect all issues
+        issues = []
+
+        # Run static analysis
+        if self.config.analyze_types or self.config.analyze_docstrings:
+            issues.extend(self._static_analyzer.analyze(code, file_path))
+
+        # Run complexity analysis
+        issues.extend(self._complexity_analyzer.analyze(code, file_path))
+
+        # Run import analysis
+        issues.extend(self._import_analyzer.analyze(code, file_path))
+
+        # Run pattern analysis
+        issues.extend(self._pattern_analyzer.analyze(code, file_path))
+
+        # Run code smell detection
+        issues.extend(self._smell_detector.analyze(code, file_path))
+
+        # Run performance analysis
+        issues.extend(self._performance_analyzer.analyze(code, file_path))
+
+        # Collect metrics
+        metrics = []
+        if self.config.include_metrics:
+            metrics.extend(self._metrics_analyzer.calculate_metrics(code))
+
+        # Detect patterns
+        patterns = self._detect_patterns(code, issues)
+
+        # Create analysis
+        analysis = Analysis(
+            file_path=file_path,
+            file_size=file_size,
+            language="python",
+            issues=issues,
+            metrics=metrics,
+            patterns=patterns,
+        )
+
+        return analysis
+
+    def _detect_patterns(self, code: str, issues: List[CodeIssue]) -> List[str]:
+        """Detect code patterns from issues and code.
+
+        Args:
+            code: Source code
+            issues: Detected issues
+
+        Returns:
+            List of detected patterns
+        """
+        patterns = []
+
+        # Extract patterns from issue types
+        issue_types = set(i.issue_type for i in issues)
+
+        if "complexity" in issue_types:
+            patterns.append("High cyclomatic complexity detected")
+
+        if any("unused" in i.message.lower() for i in issues):
+            patterns.append("Unused variables detected")
+
+        if any("long" in i.message.lower() for i in issues):
+            patterns.append("Long lines detected")
+
+        if any("docstring" in i.message.lower() for i in issues):
+            patterns.append("Missing documentation detected")
+
+        if any("wildcard" in i.message.lower() for i in issues):
+            patterns.append("Wildcard imports detected")
+
+        if any("nesting" in i.message.lower() for i in issues):
+            patterns.append("Deep nesting detected")
+
+        # Check for specific code patterns
+        if "class " in code and "def __init__" in code:
+            patterns.append("Object-oriented design detected")
+
+        if "@property" in code:
+            patterns.append("Property decorators used")
+
+        if "async def" in code:
+            patterns.append("Async/await usage detected")
+
+        if "try:" in code and "except" in code:
+            patterns.append("Exception handling detected")
+
+        return patterns
+
+    def generate_report(
+        self, analysis: Analysis, format: str = "text"
+    ) -> str:
+        """Generate formatted report.
+
+        Args:
+            analysis: Analysis object
+            format: Report format ("text", "json", "markdown")
+
+        Returns:
+            Formatted report string
+
+        Raises:
+            ValueError: If format is not supported
+        """
+        if format == "json":
+            return self._format_json(analysis)
+        elif format == "markdown":
+            return self._format_markdown(analysis)
+        elif format == "text":
+            return self._format_text(analysis)
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+
+    def _format_text(self, analysis: Analysis) -> str:
+        """Format analysis as text report.
+
+        Args:
+            analysis: Analysis object
+
+        Returns:
+            Text report
+        """
+        lines = []
+        lines.append("=" * 80)
+        lines.append(f"Analysis Report: {analysis.file_path}")
+        lines.append("=" * 80)
+        lines.append("")
+
+        # Summary
+        lines.append("SUMMARY")
+        lines.append(f"  File size: {analysis.file_size:,} bytes")
+        lines.append(f"  Language: {analysis.language}")
+        lines.append(f"  Total issues: {analysis.total_issues}")
+        lines.append(f"    - Critical: {analysis.critical_issues}")
+        lines.append(f"    - High: {analysis.high_issues}")
+        lines.append("")
+
+        # Issues
+        if analysis.issues:
+            lines.append("ISSUES")
+            for issue in analysis.issues:
+                severity_label = issue.severity.upper()
+                lines.append(f"  {severity_label}: {issue.location}")
+                lines.append(f"    {issue.message}")
+                if issue.suggestion:
+                    lines.append(f"    Suggestion: {issue.suggestion}")
+                lines.append("")
+        else:
+            lines.append("No issues found!")
+            lines.append("")
+
+        # Metrics
+        if analysis.metrics:
+            lines.append("METRICS")
+            for metric in analysis.metrics:
+                status_indicator = "[OK]" if metric.status == "ok" else "[!]"
+                lines.append(
+                    f"  {status_indicator} {metric.name}: {metric.value:.1f}"
+                )
+                if metric.description:
+                    lines.append(f"    {metric.description}")
+            lines.append("")
+
+        # Patterns
+        if analysis.patterns:
+            lines.append("PATTERNS DETECTED")
+            for pattern in analysis.patterns:
+                lines.append(f"  - {pattern}")
+            lines.append("")
+
+        lines.append("=" * 80)
+        return "\n".join(lines)
+
+    def _format_json(self, analysis: Analysis) -> str:
+        """Format analysis as JSON report.
+
+        Args:
+            analysis: Analysis object
+
+        Returns:
+            JSON report
+        """
+        import json
+        from datetime import datetime
+
+        data = {
+            "file_path": analysis.file_path,
+            "file_size": analysis.file_size,
+            "language": analysis.language,
+            "timestamp": analysis.timestamp.isoformat(),
+            "summary": {
+                "total_issues": analysis.total_issues,
+                "critical_issues": analysis.critical_issues,
+                "high_issues": analysis.high_issues,
+            },
+            "issues": [
+                {
+                    "type": issue.issue_type,
+                    "severity": issue.severity,
+                    "location": issue.location,
+                    "message": issue.message,
+                    "suggestion": issue.suggestion,
+                }
+                for issue in analysis.issues
+            ],
+            "metrics": [
+                {
+                    "name": metric.name,
+                    "value": metric.value,
+                    "threshold": metric.threshold,
+                    "status": metric.status,
+                    "description": metric.description,
+                }
+                for metric in analysis.metrics
+            ],
+            "patterns": analysis.patterns,
+        }
+
+        return json.dumps(data, indent=2)
+
+    def _format_markdown(self, analysis: Analysis) -> str:
+        """Format analysis as Markdown report.
+
+        Args:
+            analysis: Analysis object
+
+        Returns:
+            Markdown report
+        """
+        lines = []
+        lines.append(f"# Analysis Report: {analysis.file_path}")
+        lines.append("")
+
+        # Summary
+        lines.append("## Summary")
+        lines.append(
+            f"- **File size**: {analysis.file_size:,} bytes"
+        )
+        lines.append(f"- **Language**: {analysis.language}")
+        lines.append(f"- **Issues**: {analysis.total_issues}")
+        lines.append(f"  - Critical: {analysis.critical_issues}")
+        lines.append(f"  - High: {analysis.high_issues}")
+        lines.append("")
+
+        # Issues by severity
+        if analysis.issues:
+            lines.append("## Issues")
+
+            critical = [i for i in analysis.issues if i.severity == "critical"]
+            if critical:
+                lines.append("### Critical")
+                for issue in critical:
+                    lines.append(f"- **{issue.location}**: {issue.message}")
+                    if issue.suggestion:
+                        lines.append(f"  - Suggestion: {issue.suggestion}")
+                lines.append("")
+
+            high = [i for i in analysis.issues if i.severity == "high"]
+            if high:
+                lines.append("### High")
+                for issue in high:
+                    lines.append(f"- **{issue.location}**: {issue.message}")
+                lines.append("")
+
+            medium = [i for i in analysis.issues if i.severity == "medium"]
+            if medium:
+                lines.append("### Medium")
+                for issue in medium:
+                    lines.append(f"- {issue.location}: {issue.message}")
+                lines.append("")
+
+            low = [i for i in analysis.issues if i.severity in ("low", "info")]
+            if low:
+                lines.append("### Low/Info")
+                for issue in low:
+                    lines.append(f"- {issue.location}: {issue.message}")
+                lines.append("")
+        else:
+            lines.append("## Issues")
+            lines.append("No issues found! ✅")
+            lines.append("")
+
+        # Metrics
+        if analysis.metrics:
+            lines.append("## Metrics")
+            for metric in analysis.metrics:
+                lines.append(
+                    f"- **{metric.name}**: {metric.value:.1f} "
+                    f"(status: {metric.status})"
+                )
+            lines.append("")
+
+        # Patterns
+        if analysis.patterns:
+            lines.append("## Patterns Detected")
+            for pattern in analysis.patterns:
+                lines.append(f"- {pattern}")
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def get_recommendations(self, analysis: Analysis) -> List[str]:
+        """Get actionable recommendations from analysis.
+
+        Args:
+            analysis: Analysis object
+
+        Returns:
+            List of recommendations
+        """
+        recommendations = []
+
+        # Add quality score and rating
+        quality_report = QualityScorer.create_quality_report(analysis)
+        score = quality_report["overall_score"]
+        rating = quality_report["rating"]
+        recommendations.append(f"[SCORE] Quality Score: {score}/100 ({rating})")
+
+        # Critical issues
+        critical_count = analysis.critical_issues
+        if critical_count > 0:
+            recommendations.append(
+                f"[CRITICAL] Fix {critical_count} critical issue(s) immediately"
+            )
+
+        # High severity issues
+        high_count = analysis.high_issues
+        if high_count > 0:
+            recommendations.append(
+                f"[HIGH] Address {high_count} high-severity issue(s)"
+            )
+
+        # Complexity issues
+        complexity_issues = [i for i in analysis.issues if i.issue_type == "complexity"]
+        if complexity_issues:
+            recommendations.append(
+                "[COMPLEXITY] Refactor complex functions (consider breaking into smaller functions)"
+            )
+
+        # Performance issues
+        performance_issues = [i for i in analysis.issues if i.issue_type == "performance"]
+        if performance_issues:
+            recommendations.append(
+                f"[PERFORMANCE] Optimize {len(performance_issues)} performance issue(s)"
+            )
+
+        # Code smell issues
+        smell_issues = [i for i in analysis.issues if i.issue_type == "smell"]
+        if smell_issues:
+            recommendations.append(
+                f"[SMELL] Address {len(smell_issues)} code smell(s) for maintainability"
+            )
+
+        # Pattern-related recommendations
+        pattern_issues = [i for i in analysis.issues if i.issue_type == "pattern"]
+        if pattern_issues:
+            recommendations.append(
+                f"[PATTERNS] Review {len(pattern_issues)} design pattern(s)"
+            )
+
+        # Documentation issues
+        doc_issues = [
+            i for i in analysis.issues if "docstring" in i.message.lower()
+        ]
+        if doc_issues:
+            recommendations.append(
+                f"[DOCS] Add documentation to {len(doc_issues)} item(s)"
+            )
+
+        # Style issues
+        style_issues = [i for i in analysis.issues if i.issue_type == "style"]
+        if len(style_issues) > 5:
+            recommendations.append(
+                "[STYLE] Address multiple style issues (consider using a code formatter)"
+            )
+
+        # Maintainability
+        if analysis.metrics:
+            maintainability = next(
+                (m for m in analysis.metrics if m.name == "maintainability_index"),
+                None,
+            )
+            if maintainability and maintainability.value < 50:
+                recommendations.append(
+                    "[MAINTAINABILITY] Maintainability is low - consider refactoring"
+                )
+
+        # Add quality scorer suggestions if score is low
+        if score < 70:
+            for suggestion in quality_report.get("suggestions", []):
+                if not any(rec.startswith("[") for rec in [suggestion]):
+                    recommendations.append(f"[IMPROVEMENT] {suggestion}")
+
+        if len(recommendations) == 1:  # Only has quality score
+            recommendations.append("[OK] Code quality is acceptable")
+
+        return recommendations

socratic_analyzer/exceptions.py

@@ -0,0 +1,55 @@
+"""Custom exceptions for Socratic Analyzer."""
+
+
+class AnalyzerError(Exception):
+    """Base exception for analyzer operations."""
+
+    pass
+
+
+class AnalysisError(AnalyzerError):
+    """Error during code analysis."""
+
+    pass
+
+
+class ConfigurationError(AnalyzerError):
+    """Error in analyzer configuration."""
+
+    pass
+
+
+class ParsingError(AnalysisError):
+    """Error parsing code."""
+
+    pass
+
+
+class PatternDetectionError(AnalysisError):
+    """Error detecting patterns."""
+
+    pass
+
+
+class ReportError(AnalyzerError):
+    """Error generating report."""
+
+    pass
+
+
+class ReportFormatError(ReportError):
+    """Unsupported report format."""
+
+    pass
+
+
+class ProviderNotFoundError(AnalyzerError):
+    """Provider not found."""
+
+    pass
+
+
+class LLMAnalysisError(AnalyzerError):
+    """Error in LLM-powered analysis."""
+
+    pass

socratic_analyzer/models.py

@@ -0,0 +1,193 @@
+"""Data models for Socratic Analyzer."""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class CodeIssue:
+    """Detected code issue."""
+
+    issue_type: str  # "complexity", "style", "security", "performance", "maintenance"
+    severity: str  # "critical", "high", "medium", "low", "info"
+    location: str  # "file.py:123" or "module.function:456"
+    message: str
+    suggestion: Optional[str] = None
+    code_snippet: Optional[str] = None
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        return f"{self.severity.upper()}: {self.location} - {self.message}"
+
+
+@dataclass
+class MetricResult:
+    """Code quality metric result."""
+
+    name: str  # "cyclomatic_complexity", "maintainability_index", etc.
+    value: float
+    threshold: Optional[float] = None
+    status: str = "info"  # "ok", "warning", "critical"
+    description: Optional[str] = None
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        return f"{self.name}: {self.value} (status: {self.status})"
+
+
+@dataclass
+class Analysis:
+    """Complete code analysis for a single file."""
+
+    file_path: str
+    file_size: int
+    language: str
+    issues: List[CodeIssue] = field(default_factory=list)
+    metrics: List[MetricResult] = field(default_factory=list)
+    patterns: List[str] = field(default_factory=list)
+    timestamp: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+    @property
+    def critical_issues(self) -> int:
+        """Count of critical issues."""
+        return len([i for i in self.issues if i.severity == "critical"])
+
+    @property
+    def high_issues(self) -> int:
+        """Count of high severity issues."""
+        return len([i for i in self.issues if i.severity == "high"])
+
+    @property
+    def total_issues(self) -> int:
+        """Total number of issues."""
+        return len(self.issues)
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        return f"Analysis({self.file_path}, issues={self.total_issues}, patterns={len(self.patterns)})"
+
+
+@dataclass
+class ProjectAnalysis:
+    """Project-wide analysis aggregating multiple file analyses."""
+
+    project_path: str
+    files_analyzed: int
+    analyses: List[Analysis] = field(default_factory=list)
+    timestamp: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+    @property
+    def total_issues(self) -> int:
+        """Total issues across all files."""
+        return sum(a.total_issues for a in self.analyses)
+
+    @property
+    def critical_issues(self) -> int:
+        """Total critical issues across all files."""
+        return sum(a.critical_issues for a in self.analyses)
+
+    @property
+    def high_issues(self) -> int:
+        """Total high severity issues across all files."""
+        return sum(a.high_issues for a in self.analyses)
+
+    @property
+    def overall_score(self) -> float:
+        """Overall quality score (0-100)."""
+        if not self.analyses:
+            return 100.0
+
+        # Calculate score based on issues
+        total_issues = self.total_issues
+        critical_weight = 10
+        high_weight = 5
+        medium_weight = 2
+        low_weight = 1
+
+        weighted_issues = 0
+        for analysis in self.analyses:
+            for issue in analysis.issues:
+                if issue.severity == "critical":
+                    weighted_issues += critical_weight
+                elif issue.severity == "high":
+                    weighted_issues += high_weight
+                elif issue.severity == "medium":
+                    weighted_issues += medium_weight
+                elif issue.severity == "low":
+                    weighted_issues += low_weight
+
+        # Scale: 100 - (weighted_issues / total_issues_possible) * 100
+        # Cap the score between 0 and 100
+        score = max(0.0, 100.0 - (weighted_issues / max(1, total_issues * 5)))
+        return min(100.0, score)
+
+    @property
+    def recommendations(self) -> List[str]:
+        """Get recommendations based on analysis."""
+        recommendations = []
+
+        if self.critical_issues > 0:
+            recommendations.append(f"Fix {self.critical_issues} critical issue(s) immediately")
+
+        if self.high_issues > 5:
+            recommendations.append(f"Address {self.high_issues} high-severity issues")
+
+        avg_issues = self.total_issues / max(1, self.files_analyzed)
+        if avg_issues > 5:
+            recommendations.append("High issue density - consider refactoring affected files")
+
+        return recommendations
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        return (
+            f"ProjectAnalysis({self.project_path}, "
+            f"files={self.files_analyzed}, "
+            f"issues={self.total_issues}, "
+            f"score={self.overall_score:.1f})"
+        )
+
+
+@dataclass
+class AnalyzerConfig:
+    """Configuration for Socratic Analyzer."""
+
+    # Analysis options
+    analyze_types: bool = True  # Check type hints
+    analyze_docstrings: bool = True  # Check documentation
+    analyze_security: bool = True  # Check security issues
+    analyze_performance: bool = True  # Check performance antipatterns
+    analyze_patterns: bool = True  # Detect design patterns
+
+    # Thresholds
+    max_complexity: int = 10  # Max cyclomatic complexity
+    max_line_length: int = 120  # Max line length
+    min_docstring_length: int = 10  # Min docstring length
+
+    # Output
+    include_metrics: bool = True
+    include_patterns: bool = True
+    detailed_output: bool = False
+
+    # Optional LLM analysis
+    use_llm: bool = False
+    llm_provider: str = "anthropic"
+    llm_model: str = "claude-opus"
+
+    def __post_init__(self) -> None:
+        """Validate configuration."""
+        if self.max_complexity <= 0:
+            raise ValueError("max_complexity must be positive")
+        if self.max_line_length <= 0:
+            raise ValueError("max_line_length must be positive")
+        if self.min_docstring_length < 0:
+            raise ValueError("min_docstring_length must be non-negative")
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        return (
+            f"AnalyzerConfig(complexity={self.max_complexity}, "
+            f"line_length={self.max_line_length}, "
+            f"llm={self.use_llm})"
+        )

socratic_analyzer-0.1.0.dist-info/METADATA

@@ -0,0 +1,414 @@
+Metadata-Version: 2.4
+Name: socratic-analyzer
+Version: 0.1.0
+Summary: Production-grade code analysis package with LLM-powered insights
+Author-email: Socratic Analyzer <info@socratic-analyzer.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/Nireus79/Socratic-analyzer
+Project-URL: Documentation, https://github.com/Nireus79/Socratic-analyzer/tree/main/docs
+Project-URL: Repository, https://github.com/Nireus79/Socratic-analyzer.git
+Project-URL: Issues, https://github.com/Nireus79/Socratic-analyzer/issues
+Keywords: code-analysis,static-analysis,metrics,linting,quality,insights
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: socrates-nexus>=0.1.0
+Provides-Extra: openclaw
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1.0; extra == "langchain"
+Provides-Extra: llm
+Requires-Dist: socrates-nexus>=0.1.0; extra == "llm"
+Provides-Extra: all
+Requires-Dist: langchain>=0.1.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-benchmark>=4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: langchain>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# Socratic Analyzer
+
+Production-grade code analysis package with LLM-powered insights. Analyze Python code for issues, metrics, patterns, and get intelligent recommendations.
+
+[![Python 3.9+](https://img.shields.io/badge/Python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![PyPI Status](https://img.shields.io/badge/PyPI-Coming%20Soon-blue.svg)](https://pypi.org/)
+
+## Overview
+
+Socratic Analyzer provides automated code analysis with static analysis, complexity metrics, pattern detection, and LLM-powered recommendations. Perfect for code quality assurance, refactoring guidance, and architectural insights.
+
+### Key Features
+
+- **Static Code Analysis** - Detect issues, violations, and code smells
+- **Complexity Metrics** - Calculate cyclomatic complexity, maintainability index, and more
+- **Pattern Detection** - Identify antipatterns, design patterns, and performance issues
+- **Security Analysis** - Find potential security vulnerabilities
+- **Documentation Analysis** - Check docstrings and type hints
+- **Project-Wide Analysis** - Aggregate metrics across entire projects
+- **Quality Scoring** - Get overall code quality score (0-100)
+- **LLM Integration** - Get intelligent recommendations via Socrates Nexus
+- **Multiple Formats** - Generate reports in text, JSON, and Markdown
+- **Framework Integration** - Use as Openclaw skill or LangChain tool
+
+## Installation
+
+```bash
+# Basic installation
+pip install socratic-analyzer
+
+# With Openclaw support
+pip install socratic-analyzer[openclaw]
+
+# With LangChain support
+pip install socratic-analyzer[langchain]
+
+# With all features
+pip install socratic-analyzer[all]
+
+# Development
+pip install socratic-analyzer[dev]
+```
+
+## Quick Start
+
+### Basic File Analysis
+
+```python
+from socratic_analyzer import AnalyzerClient, AnalyzerConfig
+
+# Create analyzer
+analyzer = AnalyzerClient(AnalyzerConfig())
+
+# Analyze a file
+analysis = analyzer.analyze_file("mycode.py")
+
+# Print results
+print(f"Issues: {analysis.total_issues}")
+print(f"Patterns detected: {len(analysis.patterns)}")
+
+# Generate report
+report = analyzer.generate_report(analysis, format="text")
+print(report)
+```
+
+### Project Analysis
+
+```python
+from socratic_analyzer import AnalyzerClient
+
+analyzer = AnalyzerClient()
+
+# Analyze entire project
+project_analysis = analyzer.analyze_project("./src")
+
+print(f"Files analyzed: {project_analysis.files_analyzed}")
+print(f"Total issues: {project_analysis.total_issues}")
+print(f"Quality score: {project_analysis.overall_score:.1f}/100")
+
+# Get recommendations
+for recommendation in project_analysis.recommendations:
+    print(f"- {recommendation}")
+```
+
+### LLM-Powered Analysis
+
+```python
+from socratic_analyzer import AnalyzerClient
+from socratic_analyzer.llm import LLMPoweredAnalyzer
+from socrates_nexus import LLMClient
+
+# Create components
+analyzer = AnalyzerClient()
+llm_client = LLMClient(provider="anthropic", model="claude-opus")
+
+# Create LLM-powered analyzer
+llm_analyzer = LLMPoweredAnalyzer(analyzer, llm_client)
+
+# Get analysis with intelligent insights
+result = llm_analyzer.analyze_with_insights("complex_module.py")
+print(result["llm_insights"])
+```
+
+### Openclaw Integration
+
+```python
+from socratic_analyzer.integrations.openclaw import AnalyzerSkill
+
+# Use in Openclaw
+skill = AnalyzerSkill(detailed=True)
+result = skill.analyze("mycode.py")
+```
+
+### LangChain Integration
+
+```python
+from socratic_analyzer.integrations.langchain import SocraticAnalyzerTool
+from langchain.agents import AgentType, initialize_agent, Tool
+from langchain.llms import OpenAI
+
+# Create tool
+analyzer_tool = SocraticAnalyzerTool()
+
+# Use in LangChain agent
+tools = [
+    Tool(
+        name="analyze_code",
+        func=analyzer_tool._run,
+        description="Analyze Python code for issues and patterns"
+    )
+]
+
+agent = initialize_agent(
+    tools,
+    OpenAI(temperature=0),
+    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+    verbose=True
+)
+```
+
+## Architecture
+
+### Core Components
+
+**Analyzers** - Pluggable analysis strategies:
+- StaticAnalyzer - Code issues and violations
+- ComplexityAnalyzer - Cyclomatic complexity
+- MetricsAnalyzer - Code metrics
+- DocstringAnalyzer - Documentation quality
+- TypeHintAnalyzer - Type hint completeness
+- SecurityAnalyzer - Security issues
+
+**Patterns** - Pattern detection:
+- AntipatternDetector - Common antipatterns
+- DesignPatternDetector - Design patterns
+- PerformancePatternDetector - Performance issues
+
+**Reports** - Output formats:
+- TextReportFormatter
+- JSONReportFormatter
+- MarkdownReportFormatter
+
+**Insights** - Intelligence generation:
+- Scoring system (0-100 quality score)
+- Recommendation generator
+- LLM integration for intelligent insights
+
+## Configuration
+
+```python
+from socratic_analyzer import AnalyzerConfig, AnalyzerClient
+
+config = AnalyzerConfig(
+    # Analysis options
+    analyze_types=True,           # Check type hints
+    analyze_docstrings=True,      # Check documentation
+    analyze_security=True,        # Check security issues
+    analyze_performance=True,     # Check performance antipatterns
+
+    # Thresholds
+    max_complexity=10,            # Max cyclomatic complexity
+    max_line_length=120,          # Max line length
+    min_docstring_length=10,      # Min docstring length
+
+    # Output
+    include_metrics=True,
+    include_patterns=True,
+    detailed_output=False,
+
+    # LLM Integration
+    use_llm=True,
+    llm_provider="anthropic",
+    llm_model="claude-opus",
+)
+
+analyzer = AnalyzerClient(config)
+```
+
+## Output Formats
+
+### Text Report
+
+```
+=== Analysis Report: example.py ===
+
+FILE INFORMATION
+  Size: 2,048 bytes
+  Lines: 45
+
+ISSUES (5 total)
+  CRITICAL: example.py:12 - Function 'process_data' is too complex (CC: 15)
+    Suggestion: Refactor into smaller functions
+
+  HIGH: example.py:25 - Unused variable 'temp_result'
+
+  MEDIUM: example.py:8 - Missing type hints
+
+METRICS
+  Cyclomatic Complexity: 15 (threshold: 10)
+  Maintainability Index: 62.5
+
+PATTERNS DETECTED
+  - Unused variable pattern
+  - Long function pattern
+```
+
+### JSON Report
+
+```json
+{
+  "file_path": "example.py",
+  "total_issues": 5,
+  "critical_issues": 1,
+  "issues": [
+    {
+      "type": "complexity",
+      "severity": "critical",
+      "location": "example.py:12",
+      "message": "Function too complex",
+      "suggestion": "Refactor..."
+    }
+  ],
+  "metrics": [...],
+  "overall_score": 62.5
+}
+```
+
+### Markdown Report
+
+```markdown
+# Analysis Report: example.py
+
+## Summary
+- **Files analyzed**: 1
+- **Issues**: 5 (1 critical, 1 high, 3 medium)
+- **Quality score**: 62.5/100
+
+## Critical Issues
+1. **Function 'process_data' too complex** (CC: 15)
+   - Location: `example.py:12`
+   - Suggestion: Refactor into smaller functions
+
+## Recommendations
+- Fix critical issues immediately
+- Address high-severity issues
+```
+
+## Examples
+
+See the `examples/` directory for complete working examples:
+
+- `01_basic_analysis.py` - Analyze a single file
+- `02_pattern_detection.py` - Detect code patterns
+- `03_scoring_analysis.py` - Get quality scores
+- `04_project_analysis.py` - Analyze entire projects
+- `05_openclaw_integration.py` - Use as Openclaw skill
+- `06_langchain_integration.py` - Use in LangChain agents
+- `07_llm_powered_analysis.py` - Get LLM insights
+
+## Testing
+
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=src/socratic_analyzer
+
+# Run specific test
+pytest tests/test_models.py::TestAnalyzerConfig
+
+# Run benchmarks
+pytest tests/benchmarks/ -v
+```
+
+## API Reference
+
+### AnalyzerClient
+
+Main interface for code analysis.
+
+```python
+class AnalyzerClient:
+    def analyze_file(self, file_path: str) -> Analysis
+    def analyze_project(self, project_path: str) -> ProjectAnalysis
+    def generate_report(self, analysis, format: str) -> str
+```
+
+### Analysis Model
+
+```python
+@dataclass
+class Analysis:
+    file_path: str
+    file_size: int
+    language: str
+    issues: List[CodeIssue]
+    metrics: List[MetricResult]
+    patterns: List[str]
+    timestamp: datetime
+```
+
+### CodeIssue Model
+
+```python
+@dataclass
+class CodeIssue:
+    issue_type: str        # "complexity", "style", "security", etc.
+    severity: str          # "critical", "high", "medium", "low", "info"
+    location: str          # "file.py:123"
+    message: str
+    suggestion: Optional[str]
+```
+
+## Performance
+
+Based on benchmarks:
+
+- **Single file** (1-5 KB): ~10-50ms
+- **Medium file** (50 KB): ~100-200ms
+- **Large file** (500 KB): ~500ms-1s
+- **Batch operation**: 10-15ms per file
+
+## Integration with Socrates Ecosystem
+
+Socratic Analyzer integrates seamlessly with:
+
+- **Socrates Nexus** - Multi-provider LLM client for intelligent recommendations
+- **Openclaw** - Available as reusable skill
+- **LangChain** - Available as tool for agents
+
+## Contributing
+
+Contributions are welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for details.
+
+## Support
+
+- GitHub Issues: https://github.com/Nireus79/Socratic-analyzer/issues
+- Documentation: https://github.com/Nireus79/Socratic-analyzer/tree/main/docs
+- Email: info@socratic-analyzer.dev
+
+---
+
+**Built with ❤️ as part of the Socrates ecosystem**
+
+Made by [@Nireus79](https://github.com/Nireus79)

socratic_analyzer-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+socratic_analyzer/__init__.py,sha256=35c0Sto5Fjoebe8bfu84BCuHeFHodsgAbN6F2s6IpL8,975
+socratic_analyzer/async_client.py,sha256=Yb4K5r9Grgvhv6H00PlgwHi-eo_WNT4ZKyCTKy7Rdgo,3195
+socratic_analyzer/client.py,sha256=0gcP7Wdevu8kdGZCdcx3UMVshvGQd9dJmPYnY4zrKgw,16188
+socratic_analyzer/exceptions.py,sha256=jaYAV2wnEW7pLL3zCoYh4ucTRi6G4LXkq0tiEpnCTbE,838
+socratic_analyzer/models.py,sha256=DsioZ_kEG8iV_5mfad0WjZStQaNTSCh2joqyExw6bcg,6399
+socratic_analyzer-0.1.0.dist-info/licenses/LICENSE,sha256=p8Gke7rq86rZFh4asQGnpwd8eE9Uryt736OXxnNsFWM,1087
+socratic_analyzer-0.1.0.dist-info/METADATA,sha256=oNd9ILl2tQloA9WKrjoDMdw7ViiQ557BW7q7Yndd0M0,11543
+socratic_analyzer-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+socratic_analyzer-0.1.0.dist-info/top_level.txt,sha256=nafJktQlDC-B50uKGvJXGoXkIBKBk5eOyPCbTCqg7AY,18
+socratic_analyzer-0.1.0.dist-info/RECORD,,

socratic_analyzer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

socratic_analyzer-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Socratic Analyzer Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

socratic_analyzer-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+socratic_analyzer