Local SE Agent Masterclass

# Architecture Reviewer - Enterprise Operational Guidelines

## Role & Mission
คุณทำหน้าที่เป็น Principal Software Architect และ Security Lead ทำหน้าที่บังคับใช้มาตรฐานโครงสร้างซอฟต์แวร์ (Architectural Governance) และความปลอดภัยของซอร์สโค้ด

## Layer Dependency Invariant (Clean Architecture)
กฎทิศทางการอ้างอิงที่ห้ามละเมิดโดยเด็ดขาด:
1. **Core Domain (`domain/**`)**:
   - ต้องเป็น Pure Business Logic
   - **ห้าม** Import หรือมี Dependency ใดๆ ไปยัง Controller, Web, Infrastructure, หรือ Database Libraries (เช่น Spring Data, JPA, JDBC) โดยตรง
2. **Application / Service Layer (`service/**`, `usecase/**`)**:
   - อ้างอิง Domain ได้
   - สื่อสารกับ Infrastructure ผ่าน Interface/Port เท่านั้น
3. **Infrastructure / Controller Layer (`controller/**`, `infra/**`)**:
   - อยู่รอบนอกสุด สามารถ Import เลเยอร์ภายในได้ แต่เลเยอร์ภายในห้ามเรียกกลับ (Inversion of Control)

## Violation Severity Matrix
- **BLOCKER**: มีการรั่วไหลของ Secret/Credential, SQL Injection, หรือ Circular Dependency ระหว่างโมดูล
- **CRITICAL**: Layer Boundary Inversion (เช่น Domain Model อ้างอิง Infrastructure Repository โดยตรง)
- **WARNING**: God Class (>500 lines), Method parameter ล้นหลาม (>5 params), Missing interface abstractions

import re
from pathlib import Path
from typing import Dict, List, Any

# กฎทิศทางต้องห้าม (Source Layer Pattern -> Banned Target Pattern)
BOUNDARY_RULES = [
    {
        "source": r".*/domain/.*",
        "banned": [r".*\.controller\..*", r".*\.infra\..*", r".*\.repository\..*", r"java\.sql\..*"],
        "reason": "Domain entity must not depend on external layers, controllers, or database drivers."
    },
    {
        "source": r".*/service/.*",
        "banned": [r".*\.controller\..*"],
        "reason": "Application services must not have upward dependencies to presentation/controller layers."
    }
]

# กฎตรวจจับ Security Smells เบื้องต้น
SECURITY_PATTERNS = [
    (r"(?i)(api[_-]?key|secret|password|bearer)\s*=\s*['\"][A-Za-z0-9_\\-]{8,}['\"]", "Hardcoded Credentials Detected", "BLOCKER"),
    (r"SELECT\s+.*\s+FROM\s+.*\s*\+\s*[a-zA-Z0-9_]+", "Possible Dynamic SQL String Concatenation (SQLi Risk)", "BLOCKER"),
    (r"System\.out\.print", "Production Code using stdout instead of Structured Logger", "WARNING")
]

def verify_layer_dependencies(files_with_imports: Dict[str, List[str]]) -> List[Dict[str, str]]:
    """
    ตรวจสอบว่าแต่ละไฟล์มีการ import ฝ่าฝืน Layer Boundary หรือไม่
    files_with_imports: { "src/domain/Order.java": ["com.app.infra.OrderRepository", "java.util.List"] }
    """
    violations = []
    for filepath, imports in files_with_imports.items():
        for rule in BOUNDARY_RULES:
            if re.match(rule["source"], filepath):
                for imp in imports:
                    for banned_pattern in rule["banned"]:
                        if re.match(banned_pattern, imp):
                            violations.append({
                                "file": filepath,
                                "violating_import": imp,
                                "reason": rule["reason"],
                                "severity": "CRITICAL"
                            })
    return violations

def scan_security_smells(file_contents: Dict[str, str]) -> List[Dict[str, str]]:
    """สแกนหาข้อบกพร่องด้านความปลอดภัยและ Code Smells ในเนื้อไฟล์"""
    findings = []
    for filepath, content in file_contents.items():
        lines = content.splitlines()
        for idx, line in enumerate(lines, 1):
            for pattern, desc, severity in SECURITY_PATTERNS:
                if re.search(pattern, line):
                    findings.append({
                        "file": filepath,
                        "line": idx,
                        "finding": desc,
                        "severity": severity,
                        "snippet": line.strip()
                    })
    return findings

def generate_architecture_report(violations: List[Dict[str, str]], smells: List[Dict[str, str]]) -> str:
    """รวบรวมข้อค้นพบทั้งหมดเป็นรายงาน Markdown เชิงวิศวกรรม"""
    status = "PASSED" if not violations and not any(s["severity"] == "BLOCKER" for s in smells) else "FAILED"

    violation_lines = []
    for v in violations:
        violation_lines.append(f"- **[{v['severity']}]** `{v['file']}`: Imports forbidden `{v['violating_import']}`\n  *Rationale: {v['reason']}*")
    violations_block = "\n".join(violation_lines) if violation_lines else "- No layer boundary violations found."

    smell_lines = []
    for s in smells:
        smell_lines.append(f"- **[{s['severity']}]** `{s['file']}:{s['line']}`: {s['finding']}\n  `{s['snippet']}`")
    smells_block = "\n".join(smell_lines) if smell_lines else "- No security risks or code smells detected."

    return f"""# Architecture & Quality Conformance Report

**Gate Status**: `[{status}]`

### 1. Layer Boundary Violations
{violations_block}

### 2. Security Findings & Code Smells
{smells_block}

### 3. Recommendation & Next Steps
{"- Clean up layer inversions and remove critical smells prior to merging." if status == "FAILED" else "- Code architecture adheres to enterprise clean architecture standards. Approved."}
"""

from skills.architecture_reviewer.tools import (
    verify_layer_dependencies,
    scan_security_smells,
    generate_architecture_report
)

def test_architecture_review_pipeline():
    print("=== Testing Day 26: Advanced Architecture Review Skill ===")

    # 1. จำลองโค้ดที่มีทั้งการละเมิด Layer และ Security Smells
    mock_files_imports = {
        "src/main/java/com/domain/Order.java": [
            "java.util.UUID",
            "com.app.infra.OrderRepository"  # ละเมิด: Domain แอบ import Infra
        ],
        "src/main/java/com/service/PaymentService.java": [
            "com.domain.Order",
            "java.util.List"
        ]
    }

    mock_file_contents = {
        "src/main/java/com/domain/Order.java": """
package com.domain;
import com.app.infra.OrderRepository;

public class Order {
    private String apiKey = "secret_ak_live_994829104812"; // BLOCKER: Hardcoded secret
    public void save() {
        System.out.println("Saving order..."); // WARNING: stdout
    }
}
"""
    }

    # 2. ทำการตรวจสอบ Boundary และ Code Smells
    violations = verify_layer_dependencies(mock_files_imports)
    smells = scan_security_smells(mock_file_contents)

    # 3. ตรวจสอบ Assertions
    assert len(violations) == 1
    assert violations[0]["severity"] == "CRITICAL"
    assert "OrderRepository" in violations[0]["violating_import"]

    blocker_smells = [s for s in smells if s["severity"] == "BLOCKER"]
    assert len(blocker_smells) == 1
    assert "Hardcoded Credentials" in blocker_smells[0]["finding"]

    # 4. สังเคราะห์รายงาน Architecture Conformance
    report = generate_architecture_report(violations, smells)
    print("\n--- Architecture Conformance Report Preview ---")
    print(report)

    assert "[FAILED]" in report
    print("\nVerification Successful: Architecture Review Skill correctly flagged violations!")

if __name__ == "__main__":
    test_architecture_review_pipeline()