igel-qe-core 1.0.0

package/knowledge_base/generation/tc_transformer.py

@@ -0,0 +1,368 @@
+"""
+Faithful test-case generation: transform (gold TC), expand (partial), vs synthesize (topic-only).
+
+Orchestrates classification, optional light RAG for supplement, and fidelity-oriented prompts.
+"""
+from __future__ import annotations
+
+import logging
+import re
+import time
+from dataclasses import dataclass, field
+
+from knowledge_base.generation.input_classifier import (
+    Classification,
+    DetailLevel,
+    InputMode,
+    classify_input,
+)
+from knowledge_base.generation.manual_tc_parser import parse_manual_tc
+from knowledge_base.generation.prompts import (
+    EXPAND_SYSTEM_ADDON,
+    TRANSFORM_SYSTEM_ADDON,
+    build_expand_markdown_user_prompt,
+    build_system_prompt,
+    build_transform_markdown_user_prompt,
+    build_transform_python_user_prompt,
+    format_kb_retrieval_references_markdown,
+    format_kb_retrieval_references_python_comment,
+    format_parsed_steps_table,
+    kb_trace_lines,
+    load_pytest_exemplar,
+)
+from knowledge_base.retrieval.unified_query import unified_query
+from knowledge_base.validators.step_fidelity import (
+    validate_expand_preservation,
+    validate_transform_fidelity,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _bundle_retrieval_metadata(bundle) -> dict:
+    return {
+        "chunk_count": len(bundle.results),
+        "kg_nodes": bundle.kg_context.node_count,
+        "kg_edges": bundle.kg_context.edge_count,
+        "reranker_applied": bundle.debug.reranker_applied,
+        "precedence_attribution": bundle.precedence_attribution,
+        "precedence_conflicts": bundle.precedence_conflicts,
+    }
+
+
+def _bundle_kg_entities(bundle) -> dict | None:
+    if not bundle.kg_context.node_count:
+        return None
+    return {
+        "node_count": bundle.kg_context.node_count,
+        "edge_count": bundle.kg_context.edge_count,
+        "node_ids": bundle.kg_context.node_ids,
+    }
+
+
+def _tg_call_gpt(system: str, user: str, **kwargs):
+    from knowledge_base.generation import test_generator as tg
+
+    return tg._call_gpt(system, user, **kwargs)
+
+
+def _tg_strip(code: str) -> str:
+    from knowledge_base.generation import test_generator as tg
+
+    return tg._strip_code_fences(code)
+
+
+def _tg_validate_py(code: str):
+    from knowledge_base.generation import test_generator as tg
+
+    return tg._validate_python_syntax(code)
+
+
+def _tg_import_warnings(code: str):
+    from knowledge_base.generation import test_generator as tg
+
+    return tg._check_required_imports(code)
+
+
+def _infer_feature(topic: str) -> str:
+    from knowledge_base.generation import test_generator as tg
+
+    return tg._infer_feature_area(topic)
+
+
+@dataclass
+class FaithfulGenerationResult:
+    classification: Classification
+    test_id: str
+    topic: str
+    feature_area: str
+    product: str | None
+    markdown_content: str | None = None
+    python_content: str | None = None
+    kb_sources: list[str] = field(default_factory=list)
+    kb_chunk_count: int = 0
+    tokens_used: int = 0
+    generation_time_sec: float = 0.0
+    syntax_valid: bool = True
+    warnings: list[str] = field(default_factory=list)
+    traceability_table: str = ""
+    retrieved_chunks: list = field(default_factory=list)
+    retrieval_metadata: dict = field(default_factory=dict)
+    kg_entities: dict | None = None
+    precedence_conflicts: list[dict] = field(default_factory=list)
+
+
+def _derive_supplementary_query(topic: str, source_tc: str | None) -> str:
+    blob = (source_tc or "") + "\n" + (topic or "")
+    m = re.search(r"\[([A-Z]+-\d+)\]", blob, re.I)
+    if m:
+        return m.group(1)
+    lines = (topic or "").strip().split("\n", 1)
+    if lines and len(lines[0]) < 200:
+        return lines[0]
+    return (topic or blob[:400]).strip()[:220]
+
+
+def _detail_instruction(d: DetailLevel) -> str:
+    if d == DetailLevel.CONCISE:
+        return "CONCISE — keep steps short; expert-oriented; no padding."
+    if d == DetailLevel.DETAILED:
+        return "DETAILED — novice executable; full TC Setup paths and observable expected results."
+    return "BALANCED — clear steps with concrete expected results."
+
+
+def run_faithful_generation(
+    topic: str,
+    *,
+    source_tc: str | None,
+    product: str | None,
+    test_id: str,
+    feature_area: str | None,
+    top_k: int,
+    output_format: str,
+    detail_level: str | DetailLevel = DetailLevel.AUTO,
+) -> FaithfulGenerationResult:
+    t0 = time.time()
+    cls = classify_input(topic, source_tc, detail_level=detail_level)
+    warnings: list[str] = [f"pipeline:{cls.mode.value} — {cls.reason}"]
+
+    feature = feature_area or _infer_feature(topic)
+    combined_source = (source_tc or "").strip() or (topic if cls.mode != InputMode.SYNTHESIZE else "")
+    parsed = parse_manual_tc(combined_source) if combined_source else []
+
+    if cls.mode == InputMode.TRANSFORM:
+        return _run_transform(
+            topic, source_tc or topic, parsed, cls, test_id, feature, product,
+            top_k, output_format, warnings, t0,
+        )
+    if cls.mode == InputMode.EXPAND:
+        return _run_expand(
+            topic, source_tc or topic, parsed, cls, test_id, feature, product,
+            top_k, output_format, warnings, t0,
+        )
+
+    raise ValueError("SYNTHESIZE mode should use standard generate_test_cases path")
+
+
+def _run_transform(
+    topic: str,
+    source_full: str,
+    parsed,
+    cls: Classification,
+    test_id: str,
+    feature: str,
+    product: str | None,
+    top_k: int,
+    output_format: str,
+    warnings: list[str],
+    t0: float,
+) -> FaithfulGenerationResult:
+    q = _derive_supplementary_query(topic, source_full)
+    uq = unified_query(query=q, top_k=min(top_k, 6), product=product)
+    bundle = uq.rag
+
+    sup_parts = []
+    if bundle.kg_context.text_block:
+        sup_parts.append(bundle.kg_context.text_block.strip())
+    if uq.web_block:
+        sup_parts.append(uq.web_block.strip())
+    if uq.mcp.block:
+        sup_parts.append(uq.mcp.block.strip())
+    if bundle.results:
+        sup_parts.append(
+            "\n\n".join(
+                f"---\nKB_REF {i}: {getattr(r, 'section_title', '')}\n{(r.parent_content or '')[:2500]}"
+                for i, r in enumerate(bundle.results[:6], start=1)
+            )
+        )
+    supplementary = "\n\n".join(sup_parts)
+
+    detail_note = _detail_instruction(cls.detail_level)
+    system = build_system_prompt() + TRANSFORM_SYSTEM_ADDON
+
+    md_out = None
+    py_out = None
+    syntax_ok = True
+
+    if output_format in ("md", "both"):
+        md_user = build_transform_markdown_user_prompt(
+            test_id=test_id,
+            feature_area=feature,
+            product=product,
+            source_tc_full=source_full,
+            supplementary_context=supplementary,
+            detail_note=detail_note,
+        )
+        md_out = _tg_call_gpt(system, md_user, max_tokens=8192, temperature=0.1)
+
+    if output_format in ("py", "both"):
+        md_for_py = md_out or source_full[:12000]
+        exemplar = load_pytest_exemplar()
+        py_user = build_transform_python_user_prompt(
+            test_id=test_id,
+            topic=topic,
+            feature_area=feature,
+            product=product,
+            markdown_spec=md_for_py,
+            exemplar_py=exemplar,
+        )
+        raw = _tg_call_gpt(system, py_user, max_tokens=8192, temperature=0.05)
+        py_out = _tg_strip(raw)
+        syntax_ok, errs = _tg_validate_py(py_out)
+        warnings.extend(errs)
+        warnings.extend(_tg_import_warnings(py_out))
+        py_ref = format_kb_retrieval_references_python_comment(bundle.results)
+        if py_ref:
+            py_out = py_out.rstrip() + py_ref
+
+    warnings.extend(validate_transform_fidelity(parsed, py_out, md_out))
+    elapsed = round(time.time() - t0, 1)
+
+    return FaithfulGenerationResult(
+        classification=cls,
+        test_id=test_id,
+        topic=topic,
+        feature_area=feature,
+        product=product,
+        markdown_content=md_out,
+        python_content=py_out,
+        kb_sources=kb_trace_lines(bundle.results) if bundle.results else [],
+        kb_chunk_count=len(bundle.results),
+        tokens_used=bundle.debug.total_tokens_used if bundle else 0,
+        generation_time_sec=elapsed,
+        syntax_valid=syntax_ok,
+        warnings=warnings,
+        traceability_table=format_kb_retrieval_references_markdown(bundle.results),
+        retrieved_chunks=bundle.results,
+        retrieval_metadata=_bundle_retrieval_metadata(bundle),
+        kg_entities=_bundle_kg_entities(bundle),
+        precedence_conflicts=bundle.precedence_conflicts,
+    )
+
+
+def _run_expand(
+    topic: str,
+    source_full: str,
+    parsed,
+    cls: Classification,
+    test_id: str,
+    feature: str,
+    product: str | None,
+    top_k: int,
+    output_format: str,
+    warnings: list[str],
+    t0: float,
+) -> FaithfulGenerationResult:
+    q = _derive_supplementary_query(topic, source_full)
+    uq = unified_query(query=q, top_k=top_k, product=product)
+    bundle = uq.rag
+    if not bundle.results:
+        warnings.append("EXPAND: No KB hits — output may rely on source text only.")
+
+    prefix = []
+    if bundle.kg_context.text_block:
+        prefix.append(bundle.kg_context.text_block.strip())
+    if bundle.image_block:
+        prefix.append(bundle.image_block.strip())
+    if uq.web_block:
+        prefix.append(uq.web_block.strip())
+    if uq.mcp.block:
+        prefix.append(uq.mcp.block.strip())
+    kg_img = "\n\n".join(prefix)
+
+    ctx_chunks = bundle.results
+    kb_block = "\n\n".join(
+        f"=== SOURCE {i} (KB_REF={i}) | {getattr(r, 'section_title', '')} ===\n"
+        f"{(r.parent_content or '').strip()}"
+        for i, r in enumerate(ctx_chunks[:12], start=1)
+    )
+
+    detail_note = _detail_instruction(cls.detail_level)
+    system = build_system_prompt() + EXPAND_SYSTEM_ADDON
+
+    parsed_table = format_parsed_steps_table(parsed)
+
+    md_out = None
+    py_out = None
+    syntax_ok = True
+
+    if output_format in ("md", "both"):
+        md_user = build_expand_markdown_user_prompt(
+            test_id=test_id,
+            topic=topic,
+            feature_area=feature,
+            product=product,
+            source_tc_full=source_full,
+            parsed_steps_table=parsed_table,
+            kb_context_block=kb_block,
+            kg_image_prefix=kg_img,
+            detail_note=detail_note,
+        )
+        md_out = _tg_call_gpt(system, md_user, max_tokens=8192, temperature=0.15)
+        md_ref = format_kb_retrieval_references_markdown(bundle.results)
+        if md_ref:
+            md_out = md_out.rstrip() + "\n\n---\n\n" + md_ref
+
+    if output_format in ("py", "both"):
+        md_for_py = md_out or source_full[:10000]
+        exemplar = load_pytest_exemplar()
+        py_user = build_transform_python_user_prompt(
+            test_id=test_id,
+            topic=topic,
+            feature_area=feature,
+            product=product,
+            markdown_spec=md_for_py,
+            exemplar_py=exemplar,
+        )
+        raw = _tg_call_gpt(system, py_user, max_tokens=8192, temperature=0.05)
+        py_out = _tg_strip(raw)
+        syntax_ok, errs = _tg_validate_py(py_out)
+        warnings.extend(errs)
+        warnings.extend(_tg_import_warnings(py_out))
+        py_ref = format_kb_retrieval_references_python_comment(bundle.results)
+        if py_ref:
+            py_out = py_out.rstrip() + py_ref
+
+    warnings.extend(validate_expand_preservation(parsed, md_out))
+    elapsed = round(time.time() - t0, 1)
+
+    return FaithfulGenerationResult(
+        classification=cls,
+        test_id=test_id,
+        topic=topic,
+        feature_area=feature,
+        product=product,
+        markdown_content=md_out,
+        python_content=py_out,
+        kb_sources=kb_trace_lines(bundle.results),
+        kb_chunk_count=len(bundle.results),
+        tokens_used=bundle.debug.total_tokens_used,
+        generation_time_sec=elapsed,
+        syntax_valid=syntax_ok,
+        warnings=warnings,
+        traceability_table=format_kb_retrieval_references_markdown(bundle.results),
+        retrieved_chunks=bundle.results,
+        retrieval_metadata=_bundle_retrieval_metadata(bundle),
+        kg_entities=_bundle_kg_entities(bundle),
+        precedence_conflicts=bundle.precedence_conflicts,
+    )