ai-codeindex 0.7.0__py3-none-any.whl

codeindex/tech_debt_formatters.py

@@ -0,0 +1,234 @@
+"""Formatters for technical debt reports.
+
+This module provides different output formatters for technical debt reports:
+- ConsoleFormatter: Human-readable console output with colors
+- MarkdownFormatter: Markdown format for documentation
+- JSONFormatter: Machine-readable JSON format
+"""
+
+import json
+from abc import ABC, abstractmethod
+
+from codeindex.tech_debt import DebtSeverity, TechDebtReport
+
+
+class ReportFormatter(ABC):
+    """Abstract base class for report formatters."""
+
+    @abstractmethod
+    def format(self, report: TechDebtReport) -> str:
+        """Format a technical debt report.
+
+        Args:
+            report: TechDebtReport to format
+
+        Returns:
+            Formatted report as string
+        """
+        pass
+
+
+class ConsoleFormatter(ReportFormatter):
+    """Formatter for console output with ANSI colors."""
+
+    # ANSI color codes
+    RED = "\033[91m"
+    YELLOW = "\033[93m"
+    GREEN = "\033[92m"
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+
+    def format(self, report: TechDebtReport) -> str:
+        """Format report for console output.
+
+        Args:
+            report: TechDebtReport to format
+
+        Returns:
+            Formatted string with ANSI colors
+        """
+        lines = []
+
+        # Header
+        lines.append(f"\n{self.BOLD}Technical Debt Report{self.RESET}")
+        lines.append("=" * 50)
+
+        # Summary
+        lines.append(f"\n{self.BOLD}Summary:{self.RESET}")
+        lines.append(f"  Files analyzed: {report.total_files} files analyzed")
+        lines.append(f"  Total issues: {report.total_issues} issues found")
+        lines.append(f"  Quality Score: {report.average_quality_score:.1f}")
+
+        # Severity breakdown
+        if report.total_issues > 0:
+            lines.append(f"\n{self.BOLD}Issues by Severity:{self.RESET}")
+            if report.critical_issues > 0:
+                lines.append(f"  {self.RED}CRITICAL: {report.critical_issues}{self.RESET}")
+            if report.high_issues > 0:
+                lines.append(f"  {self.YELLOW}HIGH: {report.high_issues}{self.RESET}")
+            if report.medium_issues > 0:
+                lines.append(f"  MEDIUM: {report.medium_issues}")
+            if report.low_issues > 0:
+                lines.append(f"  LOW: {report.low_issues}")
+
+        # File details
+        if report.file_reports:
+            lines.append(f"\n{self.BOLD}Files:{self.RESET}")
+            for file_report in report.file_reports:
+                if file_report.total_issues > 0:
+                    lines.append(f"\n  {file_report.file_path}:")
+                    for issue in file_report.debt_analysis.issues:
+                        severity_color = self._get_severity_color(issue.severity)
+                        lines.append(
+                            f"    {severity_color}{issue.severity.name}{self.RESET} "
+                            f"[{issue.category}] {issue.description}"
+                        )
+
+        lines.append("")
+        return "\n".join(lines)
+
+    def _get_severity_color(self, severity: DebtSeverity) -> str:
+        """Get ANSI color code for severity level."""
+        if severity == DebtSeverity.CRITICAL:
+            return self.RED
+        elif severity == DebtSeverity.HIGH:
+            return self.YELLOW
+        else:
+            return ""
+
+
+class MarkdownFormatter(ReportFormatter):
+    """Formatter for Markdown output."""
+
+    def format(self, report: TechDebtReport) -> str:
+        """Format report as Markdown.
+
+        Args:
+            report: TechDebtReport to format
+
+        Returns:
+            Formatted Markdown string
+        """
+        lines = []
+
+        # Header
+        lines.append("# Technical Debt Report")
+        lines.append("")
+
+        # Summary
+        lines.append("## Summary")
+        lines.append("")
+        lines.append(f"- **Files Analyzed:** {report.total_files}")
+        lines.append(f"- **Total Issues:** {report.total_issues}")
+        lines.append(f"- **Quality Score:** {report.average_quality_score:.1f}/100")
+        lines.append("")
+
+        # Severity breakdown
+        if report.total_issues > 0:
+            lines.append("### Issues by Severity")
+            lines.append("")
+            lines.append(f"- **CRITICAL:** {report.critical_issues}")
+            lines.append(f"- **HIGH:** {report.high_issues}")
+            lines.append(f"- **MEDIUM:** {report.medium_issues}")
+            lines.append(f"- **LOW:** {report.low_issues}")
+            lines.append("")
+
+        # Issues by severity level
+        if report.total_issues > 0:
+            lines.append("## Issues by Severity")
+            lines.append("")
+
+            # CRITICAL issues
+            if report.critical_issues > 0:
+                lines.append(f"### CRITICAL ({report.critical_issues})")
+                lines.append("")
+                lines.extend(self._format_issues_table(report, DebtSeverity.CRITICAL))
+                lines.append("")
+
+            # HIGH issues
+            if report.high_issues > 0:
+                lines.append(f"### HIGH ({report.high_issues})")
+                lines.append("")
+                lines.extend(self._format_issues_table(report, DebtSeverity.HIGH))
+                lines.append("")
+
+            # MEDIUM issues
+            if report.medium_issues > 0:
+                lines.append(f"### MEDIUM ({report.medium_issues})")
+                lines.append("")
+                lines.extend(self._format_issues_table(report, DebtSeverity.MEDIUM))
+                lines.append("")
+
+            # LOW issues
+            if report.low_issues > 0:
+                lines.append(f"### LOW ({report.low_issues})")
+                lines.append("")
+                lines.extend(self._format_issues_table(report, DebtSeverity.LOW))
+                lines.append("")
+
+        return "\n".join(lines)
+
+    def _format_issues_table(
+        self, report: TechDebtReport, severity: DebtSeverity
+    ) -> list[str]:
+        """Format issues of a specific severity as a markdown table."""
+        lines = []
+        lines.append("| File | Category | Description | Suggestion |")
+        lines.append("| --- | --- | --- | --- |")
+
+        for file_report in report.file_reports:
+            for issue in file_report.debt_analysis.issues:
+                if issue.severity == severity:
+                    file_path = issue.file_path.name
+                    lines.append(
+                        f"| {file_path} | {issue.category} | "
+                        f"{issue.description} | {issue.suggestion} |"
+                    )
+
+        return lines
+
+
+class JSONFormatter(ReportFormatter):
+    """Formatter for JSON output."""
+
+    def format(self, report: TechDebtReport) -> str:
+        """Format report as JSON.
+
+        Args:
+            report: TechDebtReport to format
+
+        Returns:
+            Formatted JSON string
+        """
+        data = {
+            "total_files": report.total_files,
+            "total_issues": report.total_issues,
+            "critical_issues": report.critical_issues,
+            "high_issues": report.high_issues,
+            "medium_issues": report.medium_issues,
+            "low_issues": report.low_issues,
+            "average_quality_score": report.average_quality_score,
+            "file_reports": [
+                {
+                    "file_path": str(file_report.file_path),
+                    "quality_score": file_report.debt_analysis.quality_score,
+                    "file_lines": file_report.debt_analysis.file_lines,
+                    "total_symbols": file_report.debt_analysis.total_symbols,
+                    "total_issues": file_report.total_issues,
+                    "issues": [
+                        {
+                            "severity": issue.severity.name,
+                            "category": issue.category,
+                            "metric_value": issue.metric_value,
+                            "threshold": issue.threshold,
+                            "description": issue.description,
+                            "suggestion": issue.suggestion,
+                        }
+                        for issue in file_report.debt_analysis.issues
+                    ],
+                }
+                for file_report in report.file_reports
+            ],
+        }
+
+        return json.dumps(data, indent=2)

codeindex/writer.py

@@ -0,0 +1,164 @@
+"""Markdown writer for README_AI.md files."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from .parser import ParseResult
+
+
+@dataclass
+class WriteResult:
+    """Result of writing a README_AI.md file."""
+
+    path: Path
+    success: bool
+    error: str = ""
+
+
+def format_symbols_for_prompt(results: list[ParseResult]) -> str:
+    """Format parsed symbols into a readable string for LLM prompt."""
+    lines = []
+
+    for result in results:
+        if result.error:
+            lines.append(f"- {result.path.name}: [parse error] {result.error}")
+            continue
+
+        lines.append(f"\n### {result.path.name}")
+
+        if result.module_docstring:
+            lines.append(f"Module: {result.module_docstring[:200]}...")
+
+        for symbol in result.symbols:
+            if symbol.kind == "class":
+                lines.append(f"\n**{symbol.kind}** `{symbol.signature}`")
+                if symbol.docstring:
+                    lines.append(f"  {symbol.docstring[:150]}...")
+            elif symbol.kind in ("function", "method"):
+                indent = "  " if symbol.kind == "method" else ""
+                lines.append(f"{indent}- `{symbol.signature}`")
+                if symbol.docstring:
+                    lines.append(f"{indent}  {symbol.docstring[:100]}...")
+
+    return "\n".join(lines) if lines else "No symbols found."
+
+
+def format_imports_for_prompt(results: list[ParseResult]) -> str:
+    """Format imports into a readable string for LLM prompt."""
+    all_imports: dict[str, set[str]] = {}
+
+    for result in results:
+        for imp in result.imports:
+            if imp.module not in all_imports:
+                all_imports[imp.module] = set()
+            all_imports[imp.module].update(imp.names)
+
+    if not all_imports:
+        return "No imports found."
+
+    lines = []
+    for module, names in sorted(all_imports.items()):
+        if names:
+            lines.append(f"- {module}: {', '.join(sorted(names))}")
+        else:
+            lines.append(f"- {module}")
+
+    return "\n".join(lines)
+
+
+def format_files_for_prompt(results: list[ParseResult]) -> str:
+    """Format file list for LLM prompt."""
+    lines = []
+    for result in results:
+        if result.error:
+            lines.append(f"- {result.path.name} [error]")
+        else:
+            symbol_count = len(result.symbols)
+            lines.append(f"- {result.path.name} ({symbol_count} symbols)")
+
+    return "\n".join(lines) if lines else "No files found."
+
+
+def write_readme(
+    dir_path: Path,
+    content: str,
+    output_file: str = "README_AI.md",
+) -> WriteResult:
+    """
+    Write the README_AI.md file.
+
+    Args:
+        dir_path: Directory to write to
+        content: Content from AI CLI
+        output_file: Output filename
+
+    Returns:
+        WriteResult indicating success or failure
+    """
+    output_path = dir_path / output_file
+
+    try:
+        # Add a small header with metadata
+        timestamp = datetime.now().isoformat()
+        header = f"<!-- Generated by codeindex at {timestamp} -->\n\n"
+
+        with open(output_path, "w") as f:
+            f.write(header)
+            f.write(content)
+
+        return WriteResult(path=output_path, success=True)
+
+    except Exception as e:
+        return WriteResult(path=output_path, success=False, error=str(e))
+
+
+def generate_fallback_readme(
+    dir_path: Path,
+    results: list[ParseResult],
+    output_file: str = "README_AI.md",
+) -> WriteResult:
+    """
+    Generate a basic README_AI.md without AI, using just parsed data.
+
+    Useful when AI CLI is not available or fails.
+
+    Args:
+        dir_path: Directory to write to
+        results: Parse results from the parser
+        output_file: Output filename
+
+    Returns:
+        WriteResult indicating success or failure
+    """
+    output_path = dir_path / output_file
+
+    try:
+        timestamp = datetime.now().isoformat()
+
+        lines = [
+            f"<!-- Generated by codeindex (fallback mode) at {timestamp} -->",
+            "",
+            f"# {dir_path.name}",
+            "",
+            "## Files",
+            "",
+            format_files_for_prompt(results),
+            "",
+            "## Symbols",
+            "",
+            format_symbols_for_prompt(results),
+            "",
+            "## Dependencies",
+            "",
+            format_imports_for_prompt(results),
+            "",
+        ]
+
+        with open(output_path, "w") as f:
+            f.write("\n".join(lines))
+
+        return WriteResult(path=output_path, success=True)
+
+    except Exception as e:
+        return WriteResult(path=output_path, success=False, error=str(e))