centicodehelp 0.2.0__py3-none-any.whl

centicodehelp/analysis/detector.py

@@ -0,0 +1,80 @@
+from pathlib import Path
+from typing import Optional, Dict
+
+EXTENSION_MAP: Dict[str, str] = {
+    ".py": "python",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".hpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".cs": "csharp",
+    ".java": "java",
+    ".rs": "rust",
+    ".go": "go",
+    ".rb": "ruby",
+    ".php": "php",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".ps1": "powershell",
+    ".html": "html",
+    ".css": "css",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".sql": "sql",
+}
+
+BINARY_EXTENSIONS = {
+    ".exe", ".dll", ".so", ".dylib", ".bin", ".elf", ".sys", ".drv", ".ocx"
+}
+
+def is_binary_file(file_path: Path) -> bool:
+    """Check if the given file is a binary executable/library."""
+    if file_path.suffix.lower() in BINARY_EXTENSIONS:
+        return True
+
+    # Check magic bytes if file exists
+    if file_path.exists() and file_path.is_file():
+        try:
+            with open(file_path, "rb") as f:
+                header = f.read(4)
+                if header.startswith(b"MZ"):  # PE executable
+                    return True
+                if header.startswith(b"\x7fELF"):  # ELF executable
+                    return True
+                if header in (b"\xfe\xed\xfa\xce", b"\xfe\xed\xfa\xcf", b"\xce\xfa\xed\xfe", b"\xcf\xfa\xed\xfe"):  # Mach-O
+                    return True
+        except Exception:
+            pass
+
+    return False
+
+
+def detect_language(file_path: Path) -> Optional[str]:
+    """Detect programming language from file path extension or shebang."""
+    if is_binary_file(file_path):
+        return "binary"
+
+    ext = file_path.suffix.lower()
+    if ext in EXTENSION_MAP:
+        return EXTENSION_MAP[ext]
+
+    # Inspect first line for shebang
+    if file_path.exists() and file_path.is_file():
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                first_line = f.readline()
+                if first_line.startswith("#!"):
+                    for lang in ["python", "bash", "sh", "ruby", "perl", "node"]:
+                        if lang in first_line.lower():
+                            return lang
+        except Exception:
+            pass
+
+    return None

centicodehelp/analysis/parser.py

@@ -0,0 +1,41 @@
+import logging
+from typing import Optional, Any
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class CodeParser:
+    """Tree-sitter and AST parser for multi-language code analysis."""
+
+    def __init__(self, language: str):
+        self.language = language.lower()
+        self.ts_parser = None
+        self.ts_language = None
+        self._init_parser()
+
+    def _init_parser(self):
+        try:
+            import tree_sitter
+            if self.language == "python":
+                import tree_sitter_python
+                from tree_sitter import Language, Parser
+                self.ts_language = Language(tree_sitter_python.language())
+                self.ts_parser = Parser(self.ts_language)
+            # Future language grammar bindings (c, cpp, java, csharp, etc.) can be loaded here
+        except Exception as e:
+            logger.debug(f"Tree-sitter parser init failed for {self.language}: {e}")
+            self.ts_parser = None
+
+    def parse_bytes(self, source_bytes: bytes) -> Optional[Any]:
+        if self.ts_parser:
+            try:
+                return self.ts_parser.parse(source_bytes)
+            except Exception as e:
+                logger.error(f"Tree-sitter parse error: {e}")
+        return None
+
+    def parse_file(self, file_path: Path) -> Optional[Any]:
+        if not file_path.exists():
+            return None
+        with open(file_path, "rb") as f:
+            return self.parse_bytes(f.read())

centicodehelp/analysis/static_analyzer.py

@@ -0,0 +1,194 @@
+import re
+from pathlib import Path
+from typing import List, Optional
+from centicodehelp.core.models import Finding, Severity
+from centicodehelp.analysis.parser import CodeParser
+
+class StaticAnalyzer:
+    """Multi-language rule-based static analyzer with AST and pattern rules."""
+
+    def __init__(self):
+        pass
+
+    def analyze_file(self, file_path: Path, language: str) -> List[Finding]:
+        findings: List[Finding] = []
+        if not file_path.exists():
+            return findings
+
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            return findings
+
+        lines = content.splitlines()
+
+        # Run language-agnostic & language-specific rules
+        findings.extend(self._check_hardcoded_secrets(lines, str(file_path), language))
+        findings.extend(self._check_debug_statements(lines, str(file_path), language))
+        findings.extend(self._check_empty_exception_blocks(lines, str(file_path), language))
+        findings.extend(self._check_insecure_functions(lines, str(file_path), language))
+        findings.extend(self._check_todo_placeholders(lines, str(file_path), language))
+
+        # AST analysis (Tree-sitter Python check)
+        if language == "python":
+            findings.extend(self._check_python_ast(content, str(file_path)))
+
+        return findings
+
+    def _check_hardcoded_secrets(self, lines: List[str], file_path: str, language: str) -> List[Finding]:
+        findings = []
+        patterns = [
+            (r'(?i)(api[_-]?(key|secret)|secret[_-]?key|auth[_-]?token|password)\s*[:=]\s*["\'][a-zA-Z0-9_\-]{8,}["\']', "SEC001", "Hardcoded API key or credential detected", Severity.CRITICAL),
+            (r'-----BEGIN\s+(RSA|OPENSSH|EC)?\s*PRIVATE\s+KEY-----', "SEC002", "Hardcoded private cryptographic key found", Severity.CRITICAL),
+        ]
+        for idx, line in enumerate(lines, 1):
+            for pat, rule_id, desc, sev in patterns:
+                if re.search(pat, line):
+                    findings.append(Finding(
+                        file_path=file_path,
+                        line=idx,
+                        rule_id=rule_id,
+                        severity=sev,
+                        description=desc,
+                        code_snippet=line.strip(),
+                        suggested_fix="Store secrets in environment variables or a secure key vault.",
+                        language=language
+                    ))
+        return findings
+
+    def _check_debug_statements(self, lines: List[str], file_path: str, language: str) -> List[Finding]:
+        findings = []
+        debug_patterns = {
+            "javascript": [(r'console\.(log|debug|info)\s*\(', "DEBUG001", "console.log left in production code")],
+            "typescript": [(r'console\.(log|debug|info)\s*\(', "DEBUG001", "console.log left in production code")],
+            "python": [(r'breakpoint\(\)|print\s*\(.*DEBUG.*\)', "DEBUG002", "Debug statement/breakpoint found")],
+        }
+        for pat, rule_id, desc in debug_patterns.get(language, []):
+            for idx, line in enumerate(lines, 1):
+                if re.search(pat, line):
+                    findings.append(Finding(
+                        file_path=file_path,
+                        line=idx,
+                        rule_id=rule_id,
+                        severity=Severity.LOW,
+                        description=desc,
+                        code_snippet=line.strip(),
+                        suggested_fix="Remove debugging calls or replace with proper logging framework.",
+                        language=language
+                    ))
+        return findings
+
+    def _check_empty_exception_blocks(self, lines: List[str], file_path: str, language: str) -> List[Finding]:
+        findings = []
+        if language == "python":
+            for idx, line in enumerate(lines, 1):
+                # Pattern: except ... : followed by pass
+                if re.search(r'except(\s+\w+)?:\s*pass\b', line):
+                    findings.append(Finding(
+                        file_path=file_path,
+                        line=idx,
+                        rule_id=rule_id if (rule_id := "ERR001") else "ERR001",
+                        severity=Severity.HIGH,
+                        description="Silent exception suppression ('except: pass') masks errors",
+                        code_snippet=line.strip(),
+                        suggested_fix="Handle the exception or log error details.",
+                        language=language
+                    ))
+        elif language in ("javascript", "typescript", "java", "csharp", "cpp"):
+            for idx, line in enumerate(lines, 1):
+                if re.search(r'catch\s*\([^)]*\)\s*\{\s*\}', line):
+                    findings.append(Finding(
+                        file_path=file_path,
+                        line=idx,
+                        rule_id="ERR002",
+                        severity=Severity.HIGH,
+                        description="Empty catch block silently swallowing exceptions",
+                        code_snippet=line.strip(),
+                        suggested_fix="Add error handling, recovery, or logging inside the catch block.",
+                        language=language
+                    ))
+        return findings
+
+    def _check_insecure_functions(self, lines: List[str], file_path: str, language: str) -> List[Finding]:
+        findings = []
+        insecure = {
+            "python": [
+                (r'\beval\s*\(', "SEC101", "eval() is dangerous and allows arbitrary code execution", Severity.HIGH),
+                (r'\bexec\s*\(', "SEC102", "exec() is dangerous and allows arbitrary code execution", Severity.HIGH),
+                (r'subprocess\.(Popen|call|run)\(.*shell=True.*\)', "SEC103", "subprocess with shell=True is vulnerable to shell injection", Severity.HIGH),
+            ],
+            "javascript": [
+                (r'\beval\s*\(', "SEC101", "eval() is dangerous and allows arbitrary code execution", Severity.HIGH),
+            ],
+            "c": [
+                (r'\bgets\s*\(', "SEC201", "gets() is deprecated and vulnerable to buffer overflow", Severity.CRITICAL),
+                (r'\bstrcpy\s*\(', "SEC202", "strcpy() may cause buffer overflow; use strncpy_s or strlcpy", Severity.MEDIUM),
+            ],
+            "cpp": [
+                (r'\bgets\s*\(', "SEC201", "gets() is deprecated and vulnerable to buffer overflow", Severity.CRITICAL),
+                (r'\bstrcpy\s*\(', "SEC202", "strcpy() may cause buffer overflow; use strncpy_s or std::string", Severity.MEDIUM),
+            ]
+        }
+        for pat, rule_id, desc, sev in insecure.get(language, []):
+            for idx, line in enumerate(lines, 1):
+                if re.search(pat, line):
+                    findings.append(Finding(
+                        file_path=file_path,
+                        line=idx,
+                        rule_id=rule_id,
+                        severity=sev,
+                        description=desc,
+                        code_snippet=line.strip(),
+                        suggested_fix="Use safer alternative function or sanitize inputs.",
+                        language=language
+                    ))
+        return findings
+
+    def _check_todo_placeholders(self, lines: List[str], file_path: str, language: str) -> List[Finding]:
+        findings = []
+        for idx, line in enumerate(lines, 1):
+            if re.search(r'(?i)\b(TODO|FIXME|XXX|HACK|WIP)\b', line):
+                findings.append(Finding(
+                    file_path=file_path,
+                    line=idx,
+                    rule_id="QUAL001",
+                    severity=Severity.INFO,
+                    description=f"Incomplete code / unresolved marker found: {line.strip()}",
+                    code_snippet=line.strip(),
+                    suggested_fix="Complete implementation and remove TODO.",
+                    language=language
+                ))
+        return findings
+
+    def _check_python_ast(self, content: str, file_path: str) -> List[Finding]:
+        findings = []
+        try:
+            import ast
+            tree = ast.parse(content)
+            for node in ast.walk(tree):
+                # Check for bare except:
+                if isinstance(node, ast.ExceptHandler) and node.type is None:
+                    findings.append(Finding(
+                        file_path=file_path,
+                        line=node.lineno,
+                        rule_id="ERR003",
+                        severity=Severity.MEDIUM,
+                        description="Bare 'except:' catches SystemExit and KeyboardInterrupt. Use 'except Exception:'.",
+                        code_snippet="except:",
+                        suggested_fix="Change 'except:' to 'except Exception:'.",
+                        language="python"
+                    ))
+        except SyntaxError as e:
+            findings.append(Finding(
+                file_path=file_path,
+                line=e.lineno,
+                rule_id="SYNTAX001",
+                severity=Severity.CRITICAL,
+                description=f"Syntax Error: {e.msg}",
+                suggested_fix="Fix syntax error.",
+                language="python"
+            ))
+        except Exception:
+            pass
+        return findings
+

centicodehelp/cli/banner.py

@@ -0,0 +1,60 @@
+"""ASCII logo and brand banner generator with smooth gradients for CentiCodeHelp."""
+
+from rich.text import Text
+from rich.panel import Panel
+from rich.align import Align
+from centicodehelp import __version__
+from centicodehelp.cli.theme import console
+
+# Block letters for CENTICODEHELP
+LOGO_LINES = [
+    "  ██████╗███████╗███╗   ██╗████████╗██╗ ██████╗ ██████╗ ██████╗ ███████╗██╗  ██╗███████╗██╗     ██████╗ ",
+    " ██╔════╝██╔════╝████╗  ██║╚══██╔══╝██║██╔════╝██╔═══██╗██╔══██╗██╔════╝██║  ██║██╔════╝██║     ██╔══██╗",
+    " ██║     █████╗  ██╔██╗ ██║   ██║   ██║██║     ██║   ██║██║  ██║█████╗  ███████║█████╗  ██║     ██████╔╝",
+    " ██║     ██╔══╝  ██║╚██╗██║   ██║   ██║██║     ██║   ██║██║  ██║██╔══╝  ██╔══██║██╔══╝  ██║     ██╔═══╝ ",
+    " ╚██████╗███████╗██║ ╚████║   ██║   ██║╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║███████╗███████╗██║     ",
+    "  ╚═════╝╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚═╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝╚══════╝╚══════╝╚═╝     ",
+]
+
+def _interpolate_color(start_hex: str, end_hex: str, factor: float) -> str:
+    """Linearly interpolate between two hex colors."""
+    s_r, s_g, s_b = int(start_hex[1:3], 16), int(start_hex[3:5], 16), int(start_hex[5:7], 16)
+    e_r, e_g, e_b = int(end_hex[1:3], 16), int(end_hex[3:5], 16), int(end_hex[5:7], 16)
+
+    r = int(s_r + factor * (e_r - s_r))
+    g = int(s_g + factor * (e_g - s_g))
+    b = int(s_b + factor * (e_b - s_b))
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def get_gradient_logo_text() -> Text:
+    """Generate the ASCII logo with horizontal Purple (#C084FC) to Blue (#38BDF8) gradient."""
+    combined_text = Text()
+    num_lines = len(LOGO_LINES)
+
+    for line_idx, line in enumerate(LOGO_LINES):
+        line_len = max(len(line), 1)
+        for char_idx, char in enumerate(line):
+            factor = (char_idx / line_len * 0.75) + (line_idx / num_lines * 0.25)
+            factor = max(0.0, min(1.0, factor))
+            color = _interpolate_color("#C084FC", "#38BDF8", factor)
+            combined_text.append(char, style=f"bold {color}")
+        combined_text.append("\n")
+
+    return combined_text
+
+
+def print_banner(include_slogan: bool = True):
+    """Print the complete stylized CentiCodeHelp banner."""
+    logo = get_gradient_logo_text()
+
+    console.print(logo)
+
+    if include_slogan:
+        tagline = Text()
+        tagline.append("  ⚡ Dein Code. Besser. Sauber.  ", style="bold #e0e0e0")
+        tagline.append("•  ", style="dim white")
+        tagline.append(f"v{__version__}  ", style="bold #818CF8")
+        tagline.append("•  ", style="dim white")
+        tagline.append("centi09.de\n", style="italic #C084FC")
+        console.print(tagline)

centicodehelp/cli/commands/ai.py

@@ -0,0 +1,128 @@
+import os
+from pathlib import Path
+from typing import Optional, List
+import click
+from rich.table import Table
+from rich.panel import Panel
+
+from centicodehelp.core.models import Finding, Severity
+from centicodehelp.core.config import load_config
+from centicodehelp.analysis.detector import detect_language
+from centicodehelp.analysis.static_analyzer import StaticAnalyzer
+from centicodehelp.ai.llm_client import LLMClient
+from centicodehelp.ai.reviewer import AIReviewer, AIReviewResult
+from centicodehelp.cli.commands.scan import collect_files
+from centicodehelp.cli.theme import (
+    console,
+    COLOR_PURPLE,
+    COLOR_BLUE,
+    COLOR_INDIGO,
+    COLOR_SUCCESS,
+    COLOR_ERROR,
+    COLOR_CRITICAL,
+    COLOR_HIGH,
+    COLOR_MEDIUM,
+    COLOR_LOW,
+    COLOR_INFO,
+    COLOR_TEXT,
+)
+
+SEVERITY_STYLES = {
+    Severity.CRITICAL: (COLOR_CRITICAL, "🔴 CRITICAL"),
+    Severity.HIGH: (f"bold {COLOR_HIGH}", "🟠 HIGH"),
+    Severity.MEDIUM: (f"bold {COLOR_MEDIUM}", "🟡 MEDIUM"),
+    Severity.LOW: (f"{COLOR_LOW}", "🔵 LOW"),
+    Severity.INFO: (f"{COLOR_INFO}", "⚪ INFO"),
+}
+
+@click.command(name="ai", help="Reine KI-Tiefenanalyse (ohne Code-Änderungen).")
+@click.argument("path", default=".", type=click.Path(exists=False), required=False)
+@click.option("--provider", default=None, help="KI-Anbieter (Standard: ollama).")
+@click.option("--model", default=None, help="Modellname (Standard: llama3.2).")
+def ai_cmd(path: str, provider: Optional[str], model: Optional[str]):
+    """
+    ct ai [pfad] - KI-Codeanalyse mit Ollama (oder Cloud-Anbietern).
+    Untersucht Code semantisch auf Logikfehler und Sicherheitslücken.
+    """
+    target = Path(path)
+    if not target.exists():
+        console.print(f"\n[bold {COLOR_ERROR}]❌ Pfad nicht gefunden:[/bold {COLOR_ERROR}] [white]{target}[/white]\n")
+        return
+
+    files = collect_files(target)
+    if not files:
+        console.print(f"\n[bold {COLOR_MEDIUM}]⚠️ Keine Dateien in {target} gefunden.[/bold {COLOR_MEDIUM}]\n")
+        return
+
+    config = load_config()
+    sel_provider = provider or config.default_provider
+    sel_model = model or config.default_model
+
+    console.print(
+        Panel(
+            f"[bold]Ziel:[/bold] [yellow]{target}[/yellow] ({len(files)} Datei(en))\n"
+            f"[bold]KI-Engine:[/bold] [bold {COLOR_PURPLE}]{sel_provider}/{sel_model}[/bold {COLOR_PURPLE}]",
+            title=f"[bold {COLOR_PURPLE}]🤖 centicodehelp KI-ANALYSE[/bold {COLOR_PURPLE}]",
+            border_style=COLOR_INDIGO,
+            expand=False,
+        )
+    )
+    console.print()
+
+    try:
+        client = LLMClient(provider=sel_provider, model=sel_model)
+        reviewer = AIReviewer(client)
+    except Exception as e:
+        console.print(f"[bold {COLOR_ERROR}]❌ {e}[/bold {COLOR_ERROR}]\n")
+        return
+
+    static_analyzer = StaticAnalyzer()
+    analyzed_count = 0
+
+    for f_path in files[:5]:  # KI-Analyse für bis zu 5 Zieldateien
+        lang = detect_language(f_path)
+        if not lang or lang == "binary":
+            continue
+
+        analyzed_count += 1
+        static_findings = static_analyzer.analyze_file(f_path, lang)
+
+        with console.status(f"[bold {COLOR_PURPLE}]Analysiere {f_path.name} mit {sel_provider}/{sel_model}...[/bold {COLOR_PURPLE}]", spinner="dots12"):
+            res: AIReviewResult = reviewer.review_with_details(f_path, lang, static_findings)
+
+        if res.error:
+            console.print(f"[bold {COLOR_ERROR}]❌ Fehler bei {f_path.name}:[/bold {COLOR_ERROR}] {res.error}\n")
+            continue
+
+        lines = [
+            f"[bold white]Datei:[/bold white] [cyan]{f_path.name}[/cyan]",
+            f"[bold white]Zusammenfassung:[/bold white] {res.summary or 'Keine Auffälligkeiten.'}",
+        ]
+        if res.findings:
+            lines.append(f"\n[bold {COLOR_PURPLE}]Erkannte Punkte ({len(res.findings)}):[/bold {COLOR_PURPLE}]")
+            for idx, issue in enumerate(res.findings, 1):
+                color, badge = SEVERITY_STYLES.get(issue.severity, ("white", issue.severity.value))
+                line_info = f"Zeile {issue.line}" if issue.line else "Allgemein"
+                lines.append(f"  {idx}. [{color}]{badge}[/{color}] [cyan]({line_info})[/cyan]: {issue.description}")
+                if issue.suggested_fix:
+                    lines.append(f"     [dim italic]💡 Tipp: {issue.suggested_fix}[/dim italic]")
+        else:
+            lines.append(f"\n[bold {COLOR_SUCCESS}]✅ Keine zusätzlichen Probleme durch KI gefunden.[/bold {COLOR_SUCCESS}]")
+
+        lines.append(
+            f"\n[dim]Dauer: {res.duration_seconds}s • Tokens: {res.total_tokens} • Modell: {res.model}[/dim]"
+        )
+
+        console.print(
+            Panel(
+                "\n".join(lines),
+                title=f"[bold {COLOR_PURPLE}]🤖 KI-Review für {f_path.name}[/bold {COLOR_PURPLE}]",
+                border_style=COLOR_INDIGO,
+                expand=False,
+            )
+        )
+        console.print()
+
+    if analyzed_count == 0:
+        console.print(f"[dim]Keine unterstützten Quellcode-Dateien für KI-Analyse gefunden.[/dim]\n")
+