Day 9: Dynamic Exemplar Mining

#!/usr/bin/env python3
"""
scripts/harvest-exemplars.py
Standard: agentskills Standard v1.0 (Phase 3 Reference Architecture)
Scans existing test suites in the repository, filters out anti-patterns,
and emits a concise (< 250 tokens) PRS exemplar card of idiomatic repository code.
"""
import os
import sys
import re
from pathlib import Path

# // [TODAY'S LESSON PLUGS IN HERE: HEURISTIC QUALITY SCORING & SLICING]
def score_test_content(content: str) -> int:
    """Calculates canonical quality score. Disqualifies anti-patterns immediately."""
    # Negative Invariant Gate: Disqualify immediately if legacy Mockito or Spring runner present
    if re.search(r"org\.mockito|@SpringBootTest|@DataJpaTest|@ExtendWith\(SpringExtension", content):
        return -9999

    score = 0
    if "io.mockk" in content: score += 40
    if "confirmVerified" in content: score += 20
    if "runTest" in content: score += 15
    if "// Arrange" in content and "// Act" in content and "// Assert" in content: score += 30
    if "assertThat(" in content: score += 20
    return score

def extract_surgical_slice(file_path: Path) -> str:
    """Extracts mock dependencies and the first canonical test method from the candidate file."""
    try:
        text = file_path.read_text(encoding="utf-8", errors="ignore")
    except Exception:
        return ""

    lines = text.splitlines()
    mock_declarations = []
    test_method_lines = []
    inside_test = False
    brace_count = 0
    test_captured = False

    for line in lines:
        stripped = line.strip()
        
        # 1. Capture Mock declarations: private val foo = mockk<Foo>()
        if ("mockk<" in stripped or "mockk(" in stripped) and ("val " in stripped or "var " in stripped):
            if len(mock_declarations) < 3:
                mock_declarations.append(stripped)

        # 2. Capture First Canonical @Test Method
        if not test_captured:
            if "@Test" in stripped:
                inside_test = True
                test_method_lines.append(line)
                brace_count += line.count("{") - line.count("}")
                continue

            if inside_test:
                test_method_lines.append(line)
                brace_count += line.count("{") - line.count("}")
                if brace_count <= 0 and len(test_method_lines) > 2:
                    inside_test = False
                    test_captured = True

    if not test_method_lines:
        return ""

    # Format dense PRS card
    card = [
        f"### 💎 DYNAMIC REPO EXEMPLAR: `{file_path.name}`",
        "#### [P] Target Sibling Pattern:",
        f"Mined from existing codebase at `{file_path}`.",
        "#### [R] Idiomatic Conventions Observed in Project:",
        "- Dependencies instantiated via constructor MockK.",
        "- AAA structure followed with explicit assertion assertions.",
        "#### [S] Canonical Repository Code Snippet:",
        "```kotlin"
    ]
    if mock_declarations:
        card.extend(mock_declarations)
        card.append("")
    card.extend(test_method_lines[:25]) # Truncate method to prevent context flooding
    card.append("```")
    return "\n".join(card)

def harvest_exemplar(target_path_str: str, search_root: str = "src/test/kotlin") -> str:
    root = Path(search_root)
    if not root.exists():
        root = Path(".")

    target_name = Path(target_path_str).stem
    candidates = []

    # Traverse existing tests
    for p in root.rglob("*Test.kt"):
        try:
            content = p.read_text(encoding="utf-8", errors="ignore")
            score = score_test_content(content)
            if score > 50: # Only high-scoring canonical candidates
                candidates.append((score, p))
        except Exception:
            continue

    if not candidates:
        return "### ℹ️ NO LOCAL EXEMPLAR MINED (Follow baseline SKILL.md standards)"

    # Sort by quality score descending
    candidates.sort(key=lambda x: x[0], reverse=True)
    best_candidate = candidates[0][1]

    return extract_surgical_slice(best_candidate)

def main():
    target_file = sys.argv[1] if len(sys.argv) > 1 else "UnknownService.kt"
    slice_card = harvest_exemplar(target_file)
    sys.stdout.write(slice_card + "\n")

if __name__ == "__main__":
    main()