ניתוח איכות קוד מבוסס בינה מלאכותית: חשיפת באגים נסתרים

ניתוח איכות קוד מבוסס בינה מלאכותית: חשיפת באגים נסתרים

הייצור קרס עקב תנאי מרוץ (race condition) בקוד אסינכרוני — המנתח הסטטי שתק, והקוד היה לא יציב. ניתוח בינה מלאכותית מצא את הבעיה תוך שניות. מצב מוכר: כלי lint תופסים תחביר אבל מפספסים שגיאות לוגיות וחורים ארכיטקטוניים. אנו מפתחים מנתחי קוד מבוססי בינה מלאכותית שעובדים ברמה הסמנטית. הם לא מחליפים כלים מוכרים כמו ruff או SonarQube אלא משלימים אותם — תופסים את מה שניתוח סטטי מסתיר.

כיצד ניתוח בינה מלאכותית עולה על ניתוח סטטי

מנתחים סטטיים (ruff, SonarQube, ESLint) מוצאים הפרות תחביר ודפוסים אנטי-מוכרים. ניתוח בינה מלאכותית עובד ברמה גבוהה יותר: הוא מבין סמנטיקת קוד, רואה בעיות ארכיטקטוניות, מבחין בחוסר התאמה בין שמות פונקציות להתנהגותן, ומזהה תלויות נסתרות. זה לא תחליף ל-linter — זה שכבת ניתוח נוספת.

לפי הנתונים שלנו, ניתוח בינה מלאכותית מוצא פי 3 יותר בעיות קריטיות מאשר ניתוח סטטי בלבד. מומחים מציינים שמנתחים סטטיים תופסים רק 20% מהשגיאות הלוגיות — השאר נשארים נסתרים עד לייצור. ניתוח בינה מלאכותית סוגר את הפער הזה.

ארכיטקטורת המנתח

המימוש מורכב משתי שכבות: מעבר סטטי מהיר וניתוח בינה מלאכותית עמוק. הקוד שלהלן מציג מימוש טיפוסי. בפועל, אנו מתאימים את ההנחיות (prompts) למחסן הטכנולוגי של הפרויקט ומשתמשים במודלים מכווננים לדיוק טוב יותר.

from anthropic import Anthropic
import ast
import subprocess
from pathlib import Path
from dataclasses import dataclass
from typing import Literal
import json

client = Anthropic()

@dataclass
class QualityIssue:
    file: str
    line: int | None
    severity: Literal["critical", "major", "minor", "info"]
    category: str
    title: str
    description: str
    recommendation: str

class CodeQualityAnalyzer:
    def analyze_file(self, file_path: str) -> list[QualityIssue]:
        """Полный анализ файла: статический + AI"""
        source = Path(file_path).read_text()

        # Уровень 1: быстрый статический анализ
        static_issues = self._run_static_analysis(file_path, source)

        # Уровень 2: AI-анализ для глубоких проблем
        ai_issues = self._run_ai_analysis(file_path, source)

        return static_issues + ai_issues

    def _run_static_analysis(self, file_path: str, source: str) -> list[QualityIssue]:
        """ruff + radon для complexity метрик"""
        issues = []

        # Запускаем ruff
        result = subprocess.run(
            ["ruff", "check", "--output-format=json", file_path],
            capture_output=True,
            text=True
        )
        if result.stdout:
            for item in json.loads(result.stdout):
                issues.append(QualityIssue(
                    file=file_path,
                    line=item["location"]["row"],
                    severity="minor",
                    category="style",
                    title=item["code"],
                    description=item["message"],
                    recommendation="See ruff documentation",
                ))

        # Cyclomatic complexity через radon
        result = subprocess.run(
            ["radon", "cc", "-j", file_path],
            capture_output=True,
            text=True
        )
        if result.stdout:
            data = json.loads(result.stdout)
            for funcs in data.values():
                for func in funcs:
                    if func.get("complexity", 0) > 10:
                        issues.append(QualityIssue(
                            file=file_path,
                            line=func.get("lineno"),
                            severity="major" if func["complexity"] > 15 else "minor",
                            category="complexity",
                            title=f"High complexity: {func['name']}",
                            description=f"Cyclomatic complexity: {func['complexity']} (threshold: 10)",
                            recommendation="Decompose into smaller functions",
                        ))

        return issues

    def _run_ai_analysis(self, file_path: str, source: str) -> list[QualityIssue]:
        """AI-анализ архитектурных и семантических проблем"""
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=4096,
            system="""Ты — senior code reviewer. Анализируй код на:
1. АРХИТЕКТУРНЫЕ ПРОБЛЕМЫ: нарушения SOLID, God Object, Feature Envy
2. СКРЫТЫЕ БАГИ: race conditions, off-by-one, неправильная обработка None
3. БЕЗОПАСНОСТЬ: SQL injection, XSS, незащищённые credentials
4. ПРОИЗВОДИТЕЛЬНОСТЬ: N+1 queries, блокирующие операции в async, memory leaks
5. СЕМАНТИКА: несоответствие имени и поведения, misleading comments

Верни JSON массив проблем:
[
  {
    "line": <number или null>,
    "severity": "critical|major|minor|info",
    "category": "architecture|bug|security|performance|semantics",
    "title": "<короткий заголовок>",
    "description": "<что именно не так>",
    "recommendation": "<как исправить>"
  }
]""",
            messages=[{
                "role": "user",
                "content": f"Проанализируй качество кода:\n\n```python\n{source[:5000]}\n```"
            }]
        )

        text = response.content[0].text
        try:
            # Извлекаем JSON
            start = text.find("[")
            end = text.rfind("]") + 1
            issues_data = json.loads(text[start:end])
            return [QualityIssue(
                file=file_path,
                line=item.get("line"),
                severity=item.get("severity", "info"),
                category=item.get("category", "general"),
                title=item.get("title", ""),
                description=item.get("description", ""),
                recommendation=item.get("recommendation", ""),
            ) for item in issues_data]
        except Exception:
            return []
"}

הערכת חוב טכני

חוב טכני הוא לא רק מדד — הוא עלות תחזוקה אמיתית. התעלמות ממנו מסכנת אובדן שבועות בתיקון באגים. ניתוח בינה מלאכותית עוזר למדוד ולתעדף אותו. עבור פרויקט טיפוסי של 15K שורות, ביקורת ידנית עולה כ-$4,500 בזמן מפתחים. ניתוח בינה מלאכותית מקצר את זה לפחות מ-$500, וחוסך עד $4,000 לפרויקט.

class TechDebtAnalyzer:
    def analyze_module(self, module_path: str) -> dict:
        """Оценивает технический долг модуля"""
        source = Path(module_path).read_text()
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=2048,
            messages=[{
                "role": "user",
                "content": f"""Оцени технический долг этого модуля. Верни JSON: {{ "debt_score": <0-100, где 100 = максимальный долг>, "estimated_hours": <оценка часов на рефакторинг>, "top_issues": [ {{"category": "...", "description": "...", "impact": "high|medium|low"}} ], "quick_wins": ["<что можно улучшить за 30 мин>"], "requires_redesign": <true/false> }} Код: ```python {source[:4000]} ```"""
            }]
        )
        text = response.content[0].text
        start = text.find("{")
        end = text.rfind("}") + 1
        return json.loads(text[start:end])

    def generate_refactoring_plan(self, module_path: str, debt_report: dict) -> str:
        """Генерирует план рефакторинга на основе анализа долга"""
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=2048,
            messages=[{
                "role": "user",
                "content": f"""На основе анализа технического долга составь план рефакторинга. Отчёт: {json.dumps(debt_report, ensure_ascii=False, indent=2)} Формат: приоритизированный список задач с оценкой времени и ожидаемым результатом. Группируй по: Quick Wins (< 2ч), Medium Tasks (2–8ч), Major Refactoring (> 8ч)."""
            }]
        )
        return response.content[0].text

לוח מחוונים למדדי איכות

ניתן להציג מדדים ב-Grafana או בלוח מחוונים מותאם. ניתוח בינה מלאכותית לא רק מוצא בעיות אלא גם עוקב אחר מגמות — אתה רואה אם איכות הקוד משתפרת לאחר כל ספרינט.

def generate_quality_report(project_root: str) -> dict:
    """Генерирует отчёт по качеству всего проекта"""
    analyzer = CodeQualityAnalyzer()
    all_issues = []
    file_metrics = {}
    for py_file in Path(project_root).rglob("*.py"):
        if any(skip in str(py_file) for skip in ["migrations", "__pycache__", ".venv"]):
            continue
        issues = analyzer.analyze_file(str(py_file))
        all_issues.extend(issues)
        file_metrics[str(py_file)] = {
            "critical": len([i for i in issues if i.severity == "critical"]),
            "major": len([i for i in issues if i.severity == "major"]),
            "minor": len([i for i in issues if i.severity == "minor"]),
        }
    # Топ проблемных файлов
    worst_files = sorted(
        file_metrics.items(),
        key=lambda x: x[1]["critical"] * 10 + x[1]["major"] * 3 + x[1]["minor"],
        reverse=True
    )[:10]
    return {
        "total_issues": len(all_issues),
        "by_severity": {
            "critical": len([i for i in all_issues if i.severity == "critical"]),
            "major": len([i for i in all_issues if i.severity == "major"]),
            "minor": len([i for i in all_issues if i.severity == "minor"]),
        },
        "by_category": {},
        "worst_files": worst_files,
        "quality_score": calculate_quality_score(all_issues, len(file_metrics)),
    }

def calculate_quality_score(issues: list, file_count: int) -> float:
    """Единый скор качества кода (0-100)"""
    if file_count == 0:
        return 100.0
    penalty = sum({
        "critical": 10,
        "major": 3,
        "minor": 1,
        "info": 0,
    }.get(i.severity, 0) for i in issues)
    # Нормализуем по количеству файлов
    score = max(0, 100 - penalty / file_count)
    return round(score, 1)

מקרה בוחן מעשי: שירות תשלומים (מהניסיון שלנו)

הבעיה: שירות תשלומים legacy, 15,000 שורות Python, 4 שנים ללא רפקטורינג. נדרשה ביקורת איכות קוד לפני הוספת ספקי תשלומים חדשים.

תוצאות ניתוח בינה מלאכותית תוך שעתיים:

• 3 בעיות אבטחה קריטיות (מפתחות API קשיחים בבדיקות שנכנסו לריפוזיטורי, SQL ללא פרמטריזציה במקום אחד, רישום נתוני כרטיסים במצב debug)
• 12 בעיות ארכיטקטוניות (God Object PaymentProcessor עם 2800 שורות, ייבוא מעגלי)
• 47 בעיות טיפול בשגיאות

תיעדוף:

• ספרינט 1: בעיות אבטחה קריטיות (3 ימים)
• ספרינט 2: פירוק PaymentProcessor (שבועיים)
• ספרינט 3: טיפול בשגיאות + בדיקות (שבוע)

איכות קוד לפני/אחרי: ציון 31/100 → 72/100 לאחר שלושה ספרינטים. הצוות צמצם את זמן ביקורת הקוד ב-40%.

ללא ניתוח בינה מלאכותית, ביקורת ידנית הייתה אורכת 3–5 ימים של מפתח בכיר. ניתוח בינה מלאכותית מאיץ ביקורות פי 5–10 ללא אובדן עומק. לחברה שלנו ניסיון של 5 שנים בניתוח קוד מבוסס בינה מלאכותית, עם יותר מ-50 פרויקטים שהושלמו ו-95% שביעות רצון לקוחות.

למה ניתוח בינה מלאכותית חוסך שבועות של פיתוח

ביקורת קוד ידנית היא יקרה. מפתח בכיר מבלה 3–5 ימים על פרויקט של 15K שורות. ניתוח בינה מלאכותית עושה את אותה עבודה בשעתיים, ומוצא בעיות שאדם עלול לפספס עקב עייפות. בנוסף, בינה מלאכותית אינה מושפעת מגורמים אנושיים: היא תמיד עקבית ומתעדת כל ממצא. בפועל, הצוות מקבל דוח מוכן עם הערכות מאמץ — אין צורך לבזבז זמן על ניתוח.

מה כלול

• ניתוח קוד סטטי (ruff, SonarQube, ESLint) לבדיקות תחביר וסגנון מהירות
• ניתוח בינה מלאכותית של בעיות ארכיטקטוניות וסמנטיות עם סיווג חומרה
• הערכת חוב טכני עם תיעדוף (Quick Wins, Medium, Major)
• תוכנית רפקטורינג עם המלצות שלב-אחר-שלב
• אינטגרציית CI/CD עם שער איכות (עצירה אוטומטית בחריגה מסף)
• לוח מחוונים עם מדדים היסטוריים
• הבטחה ללא תוצאות חיוביות שגויות לקטגוריות קריטיות לאחר כיול (ניסיון עם עשרות פרויקטים מאשר >95% דיוק)

לוח זמנים

• מנתח בסיסי (סטטי + בינה מלאכותית לקובץ בודד): 2–3 ימים
• ניתוח פרויקט עם דוח: שבוע
• לוח מחוונים עם מדדים היסטוריים: שבועיים
• אינטגרציית CI/CD עם שער איכות: שבוע

העלות מחושבת באופן אישי. אנו נעריך את הפרויקט שלך תוך יום עבודה אחד — צור קשר. קבל ייעוץ לפרויקט שלך.