igel-qe-core 1.0.0

package/knowledge_base/feedback/applier.py

@@ -0,0 +1,93 @@
+"""Apply curated feedback to the knowledge base — Phase 2."""
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+from knowledge_base.db.client import get_conn
+from knowledge_base.db.feedback_schema import get_feedback_event, list_promotions
+from knowledge_base.db.schema import ensure_knowledge_graph_tables
+from knowledge_base.feedback.handler import apply_feedback, apply_promotion
+
+logger = logging.getLogger(__name__)
+
+_REGISTRY_RE = re.compile(r"\b([a-z][a-z0-9_]*(?:\.[a-z0-9_]+)+)\b", re.I)
+_UI_PATH_RE = re.compile(r"(UMS[^>\n]{3,200})", re.I)
+
+
+def apply_curated_feedback(event_id: str, actor_id: str | None = None) -> dict[str, Any]:
+    """
+    Apply an approved feedback event to the system.
+
+    Strategies:
+    - registry_key corrections → upsert into KG
+    - ui_path corrections → upsert into KG
+    - pattern corrections → stored for Cognee ingestion (Phase 4)
+    """
+    event = get_feedback_event(event_id)
+    if not event:
+        raise ValueError(f"Event not found: {event_id}")
+    if event["status"] != "approved":
+        raise ValueError(f"Event must be approved before apply (status={event['status']})")
+
+    ensure_knowledge_graph_tables()
+    applied: list[str] = []
+    feedback_data = event.get("feedback_data") or {}
+
+    registry_key = feedback_data.get("registry_key") or feedback_data.get("corrected_registry_key")
+    ui_path = feedback_data.get("ui_path") or feedback_data.get("corrected_ui_path")
+
+    if registry_key:
+        _upsert_kg_node("registry_key", registry_key)
+        applied.append(f"registry_key:{registry_key}")
+
+    if ui_path:
+        _upsert_kg_node("ui_path", ui_path)
+        applied.append(f"ui_path:{ui_path}")
+
+    correction_text = feedback_data.get("correction") or feedback_data.get("notes") or ""
+    if correction_text and not registry_key:
+        for key in _REGISTRY_RE.findall(correction_text):
+            if key.count(".") >= 2:
+                _upsert_kg_node("registry_key", key)
+                applied.append(f"registry_key:{key}")
+
+    if correction_text and not ui_path:
+        for path in _UI_PATH_RE.findall(correction_text):
+            if ">" in path or "Console" in path:
+                _upsert_kg_node("ui_path", path.strip())
+                applied.append(f"ui_path:{path.strip()}")
+
+    action = "updated_kg" if applied else "refined_prompt"
+    apply_feedback(event_id, action, actor_id=actor_id)
+
+    return {"event_id": event_id, "applied_action": action, "changes": applied}
+
+
+def apply_pending_promotions(limit: int = 10, actor_id: str | None = None) -> list[dict]:
+    """Apply all pending promotions (batch)."""
+    promotions = list_promotions(status="pending", limit=limit)
+    results = []
+    for promo in promotions:
+        try:
+            result = apply_curated_feedback(promo["feedback_event_id"], actor_id=actor_id)
+            apply_promotion(promo["id"], actor_id=actor_id)
+            result["promotion_id"] = promo["id"]
+            results.append(result)
+        except Exception as e:
+            logger.error("Failed to apply promotion %s: %s", promo["id"], e)
+            results.append({"promotion_id": promo["id"], "error": str(e)})
+    return results
+
+
+def _upsert_kg_node(node_type: str, value: str) -> None:
+    normalized = value.lower()[:2000]
+    sql = """
+    INSERT INTO knowledge_graph_nodes (node_type, value, normalized)
+    VALUES (%s, %s, %s)
+    ON CONFLICT (node_type, normalized) DO UPDATE SET value = EXCLUDED.value
+    """
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql, (node_type, value[:4000], normalized))

package/knowledge_base/feedback/curator.py

@@ -0,0 +1,49 @@
+"""Feedback curation logic — Phase 2 human-in-the-loop workflow."""
+from __future__ import annotations
+
+import logging
+
+from knowledge_base.db.feedback_schema import get_feedback_event, list_feedback_events, list_promotions
+from knowledge_base.feedback.handler import apply_feedback, apply_promotion, curate_feedback
+
+logger = logging.getLogger(__name__)
+
+
+def list_pending(limit: int = 10, offset: int = 0) -> list[dict]:
+    return list_feedback_events(status="pending", limit=limit, offset=offset)
+
+
+def get_event(event_id: str) -> dict | None:
+    return get_feedback_event(event_id)
+
+
+def approve(event_id: str, curator_id: str, notes: str | None = None) -> None:
+    """Approve feedback and create promotion record."""
+    event = get_feedback_event(event_id)
+    if not event:
+        raise ValueError(f"Feedback event not found: {event_id}")
+    if event["status"] not in ("pending", "reviewed"):
+        raise ValueError(f"Cannot approve event in status '{event['status']}'")
+
+    curate_feedback(event_id, "approved", curator_id, notes)
+    logger.info("Feedback approved: %s by %s", event_id, curator_id)
+
+
+def reject(event_id: str, curator_id: str, notes: str | None = None) -> None:
+    event = get_feedback_event(event_id)
+    if not event:
+        raise ValueError(f"Feedback event not found: {event_id}")
+    curate_feedback(event_id, "rejected", curator_id, notes)
+    logger.info("Feedback rejected: %s by %s", event_id, curator_id)
+
+
+def mark_reviewed(event_id: str, curator_id: str, notes: str | None = None) -> None:
+    curate_feedback(event_id, "reviewed", curator_id, notes)
+
+
+def list_approved_promotions(limit: int = 20) -> list[dict]:
+    return list_promotions(status="pending", limit=limit)
+
+
+def list_applied_promotions(limit: int = 20) -> list[dict]:
+    return list_promotions(status="applied", limit=limit)

package/knowledge_base/feedback/handler.py

@@ -0,0 +1,151 @@
+"""
+Feedback capture and processing for IGEL KB System (Phase 1+).
+
+Two-step flow: Capture → Curate → Promote → Apply
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from knowledge_base.db.feedback_schema import (
+    insert_feedback_audit,
+    insert_feedback_event,
+    insert_feedback_promotion,
+    mark_feedback_applied,
+    mark_promotion_applied,
+    update_feedback_curation,
+)
+
+logger = logging.getLogger(__name__)
+
+VALID_FEEDBACK_TYPES = frozenset({
+    "rating",
+    "correction",
+    "edit",
+    "rejection",
+    "execution_failure",
+})
+
+
+def capture_feedback(
+    query: str,
+    generated_output: dict,
+    feedback_type: str,
+    feedback_data: dict,
+    *,
+    generation_metadata: dict | None = None,
+    user_id: str | None = None,
+    session_id: str | None = None,
+    source_context: dict | None = None,
+) -> str:
+    """
+    Capture a user feedback event. Returns feedback event UUID.
+    """
+    if feedback_type not in VALID_FEEDBACK_TYPES:
+        raise ValueError(
+            f"Invalid feedback_type '{feedback_type}'. "
+            f"Must be one of: {', '.join(sorted(VALID_FEEDBACK_TYPES))}"
+        )
+
+    event_id = insert_feedback_event(
+        query=query,
+        generated_output=generated_output,
+        feedback_type=feedback_type,
+        feedback_data=feedback_data,
+        generation_metadata=generation_metadata,
+        user_id=user_id,
+        session_id=session_id,
+        source_context=source_context,
+    )
+
+    insert_feedback_audit(
+        feedback_event_id=event_id,
+        action="feedback_captured",
+        actor_id=user_id,
+        details={"feedback_type": feedback_type},
+    )
+
+    logger.info("Feedback captured: id=%s type=%s", event_id, feedback_type)
+    return event_id
+
+
+def curate_feedback(
+    event_id: str,
+    status: str,
+    curator_id: str,
+    curator_notes: str | None = None,
+) -> None:
+    """
+    Update curation status: reviewed, approved, rejected.
+    """
+    if status not in ("reviewed", "approved", "rejected"):
+        raise ValueError(f"Invalid curation status: {status}")
+
+    update_feedback_curation(
+        event_id=event_id,
+        status=status,
+        curator_id=curator_id,
+        curator_notes=curator_notes,
+    )
+
+    insert_feedback_audit(
+        feedback_event_id=event_id,
+        action=f"feedback_{status}",
+        actor_id=curator_id,
+        details={"curator_notes": curator_notes},
+    )
+
+    if status == "approved":
+        insert_feedback_promotion(
+            feedback_event_id=event_id,
+            curator_id=curator_id,
+            promoted_content={"curator_notes": curator_notes},
+            curator_notes=curator_notes,
+        )
+
+
+def apply_feedback(
+    event_id: str,
+    applied_action: str,
+    actor_id: str | None = None,
+) -> None:
+    """
+    Mark feedback as applied to the system (KG update, prompt refinement, etc.).
+    """
+    mark_feedback_applied(event_id=event_id, applied_action=applied_action)
+    insert_feedback_audit(
+        feedback_event_id=event_id,
+        action="feedback_applied",
+        actor_id=actor_id,
+        details={"applied_action": applied_action},
+    )
+
+
+def apply_promotion(promotion_id: str, actor_id: str | None = None) -> None:
+    """Mark a curated promotion as applied (ready for Cognee ingestion in Phase 4)."""
+    mark_promotion_applied(promotion_id=promotion_id, actor_id=actor_id)
+
+
+def build_generation_output_payload(
+    *,
+    test_id: str,
+    topic: str,
+    feature_area: str,
+    markdown_content: str | None,
+    python_content: str | None,
+    kb_sources: list[str],
+    confidence: dict | None = None,
+    warnings: list[str] | None = None,
+) -> dict[str, Any]:
+    """Build a JSON-serializable payload for feedback storage."""
+    return {
+        "test_id": test_id,
+        "topic": topic,
+        "feature_area": feature_area,
+        "markdown": markdown_content,
+        "python": python_content,
+        "kb_sources": kb_sources,
+        "confidence": confidence,
+        "warnings": warnings or [],
+    }

package/knowledge_base/generation/__init__.py

@@ -0,0 +1,5 @@
+"""Test case generation pipeline."""
+
+from . import test_generator
+
+__all__ = ["test_generator"]

package/knowledge_base/generation/input_classifier.py

@@ -0,0 +1,148 @@
+"""
+Classify user/test-case inputs for routing: transform (gold TC), expand (partial), or synthesize (topic-only).
+
+Also picks target detail level (concise / detailed) for generation prompts.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from enum import Enum
+
+from knowledge_base.generation.manual_tc_parser import parse_manual_tc, count_parsed_steps
+
+
+class InputMode(str, Enum):
+    """How the pipeline should treat the primary input."""
+
+    TRANSFORM = "transform"  # Full gold TC — preserve structure
+    EXPAND = "expand"  # Partial TC — fill gaps only
+    SYNTHESIZE = "synthesize"  # Topic/query only — RAG synthesis
+
+
+class DetailLevel(str, Enum):
+    CONCISE = "concise"
+    DETAILED = "detailed"
+    AUTO = "auto"
+
+
+@dataclass
+class Classification:
+    mode: InputMode
+    detail_level: DetailLevel
+    reason: str
+    parsed_step_count: int
+
+
+_JIRA_KEY = re.compile(
+    r"\b(QCL|QCAPPS|QC|TC)-?\d+\b",
+    re.IGNORECASE,
+)
+
+
+def classify_input(
+    topic: str,
+    source_tc: str | None,
+    *,
+    detail_level: DetailLevel | str = DetailLevel.AUTO,
+) -> Classification:
+    """
+    Decide pipeline mode from topic + optional pasted manual test case text.
+
+    Rules:
+    - If `source_tc` is non-empty and parses as 3+ structured steps → TRANSFORM.
+    - If `source_tc` is non-empty but 1–2 steps or missing expected results → EXPAND.
+    - If only `topic` with structured steps inside topic (rare) → TRANSFORM if parse succeeds.
+    - Else → SYNTHESIZE.
+    """
+    raw = (source_tc or "").strip()
+    topic_clean = (topic or "").strip()
+
+    # Explicit detail override
+    if isinstance(detail_level, str):
+        try:
+            dl = DetailLevel(detail_level.lower())
+        except ValueError:
+            dl = DetailLevel.AUTO
+    else:
+        dl = detail_level
+
+    # Heuristic: partial = has JIRA id + narrative but few steps
+    if raw or (not raw and _looks_like_pasted_tc(topic_clean)):
+        combined = raw or topic_clean
+        has_jira = bool(_JIRA_KEY.search(combined))
+        has_expected_col = "expected result" in combined.lower()
+        steps = parse_manual_tc(combined)
+        n = count_parsed_steps(steps)
+
+        if n >= 3 and _steps_look_complete(steps, has_expected_col):
+            reason = f"Structured TC with {n} steps — transform mode (preserve fidelity)."
+            return Classification(
+                InputMode.TRANSFORM,
+                _resolve_detail(dl, n, topic_clean),
+                reason,
+                n,
+            )
+        if n >= 1 or (has_jira and len(combined) > 200):
+            reason = (
+                f"Partial TC ({n} parsed steps) — expand mode with KB fill-in."
+                if n
+                else "JIRA-style text with little step structure — expand mode."
+            )
+            return Classification(
+                InputMode.EXPAND,
+                _resolve_detail(dl, n, topic_clean or combined[:80]),
+                reason,
+                n,
+            )
+
+    # Topic-only synthesis
+    return Classification(
+        InputMode.SYNTHESIZE,
+        _resolve_detail(dl, 0, topic_clean),
+        "No structured manual TC provided — synthesize from KB.",
+        0,
+    )
+
+
+def _looks_like_pasted_tc(text: str) -> bool:
+    if not text or len(text) < 80:
+        return False
+    low = text.lower()
+    if "test data" in low and ("expected result" in low or "step" in low):
+        return True
+    if "#,step,test data" in low.replace(" ", "").lower():
+        return True
+    if re.search(r"(?m)^\s*\"?#\"?\s*,\s*Step\s*,\s*Test Data", text, re.I):
+        return True
+    # Many numbered lines like "1,Verify"
+    numbered = len(re.findall(r"(?m)^\s*\d+\s*,\s*[^\n]", text))
+    return numbered >= 3
+
+
+def _steps_look_complete(steps: list, has_expected_column_hint: bool) -> bool:
+    if not steps:
+        return False
+    # JIRA/Confluence exports often list "Expected Result" in the header but cells are not parsed.
+    if has_expected_column_hint and len(steps) >= 3:
+        return True
+    with_exp = sum(1 for s in steps if (s.expected_result or "").strip())
+    if has_expected_column_hint and with_exp < max(1, len(steps) // 3):
+        return False
+    titled = sum(1 for s in steps if (s.step_title or "").strip())
+    return titled >= max(1, len(steps) // 2)
+
+
+def _resolve_detail(dl: DetailLevel, step_count: int, topic: str) -> DetailLevel:
+    if dl != DetailLevel.AUTO:
+        return dl
+    low = topic.lower()
+    if "brief" in low or "concise" in low or "short" in low:
+        return DetailLevel.CONCISE
+    if "detailed" in low or "novice" in low or "verbose" in low:
+        return DetailLevel.DETAILED
+    if step_count >= 12:
+        return DetailLevel.DETAILED
+    if step_count >= 4:
+        return DetailLevel.CONCISE
+    return DetailLevel.DETAILED

package/knowledge_base/generation/manual_tc_parser.py

@@ -0,0 +1,180 @@
+"""
+Parse pasted IGEL manual test cases (CSV export or JIRA-ish markdown) into structured steps.
+"""
+from __future__ import annotations
+
+import csv
+import io
+import re
+from dataclasses import dataclass
+
+
+@dataclass
+class ParsedStep:
+    step_id: str
+    step_title: str
+    test_data: str
+    expected_result: str
+
+
+def parse_manual_tc(text: str) -> list[ParsedStep]:
+    text = (text or "").strip()
+    if not text:
+        return []
+
+    low_head = text[:800].lower()
+    if "test data" in low_head and "expected result" in low_head and _is_csv_like(text):
+        parsed = _parse_csv_tc(text)
+        if parsed:
+            return parsed
+
+    if re.search(r"(?m)^\s*\"?#\"?\s*,\s*step\s*,", text[:2000], re.I):
+        parsed = _parse_csv_tc(text)
+        if parsed:
+            return parsed
+
+    jira_steps = _parse_jira_id_column_layout(text)
+    if len(jira_steps) >= 3:
+        return jira_steps
+
+    return _parse_loose_numbered_tc(text)
+
+
+def count_parsed_steps(steps: list[ParsedStep]) -> int:
+    return len(steps)
+
+
+def _is_csv_like(text: str) -> bool:
+    first = text.split("\n", 1)[0]
+    return first.count(",") >= 2
+
+
+def _parse_csv_tc(text: str) -> list[ParsedStep]:
+    """Handle TestSteps*.csv style: #,Step,Test Data,Expected Result"""
+    stream = io.StringIO(text)
+    try:
+        reader = csv.DictReader(stream)
+    except Exception:
+        return []
+    if not reader.fieldnames:
+        return []
+
+    lower_to_key: dict[str, str] = {}
+    for k in reader.fieldnames:
+        lower_to_key[k.strip().strip('"').lower()] = k
+
+    def pick(*cands: str) -> str | None:
+        for c in cands:
+            lk = c.lower().strip()
+            if lk in lower_to_key:
+                return lower_to_key[lk]
+        return None
+
+    k_id = pick("#", "step id", "id")
+    k_step = pick("step")
+    k_data = pick("test data", "testdata")
+    k_exp = pick("expected result", "expected")
+
+    steps: list[ParsedStep] = []
+    for row in reader:
+        if not row:
+            continue
+        if not any((row.get(k) or "").strip() for k in reader.fieldnames):
+            continue
+
+        def gv(k: str | None) -> str:
+            if not k:
+                return ""
+            return (row.get(k) or "").strip()
+
+        sid = gv(k_id)
+        title = gv(k_step)
+        data = gv(k_data)
+        exp = gv(k_exp)
+        if not data and title:
+            data = title
+        if not sid and not title and not data:
+            continue
+        steps.append(
+            ParsedStep(
+                step_id=sid or str(len(steps) + 1),
+                step_title=title or (data[:120] if data else f"Step {len(steps) + 1}"),
+                test_data=data or title,
+                expected_result=exp,
+            )
+        )
+    return steps
+
+
+def _parse_jira_id_column_layout(text: str) -> list[ParsedStep]:
+    """
+    JIRA / Confluence exports: step id alone on a line, following lines are step content until next id.
+    """
+    lines = text.splitlines()
+    steps: list[ParsedStep] = []
+    i = 0
+    while i < len(lines):
+        raw = lines[i]
+        stripped = raw.strip()
+        if re.match(r"^\d{1,3}$", stripped):
+            sid = stripped
+            i += 1
+            buf: list[str] = []
+            while i < len(lines):
+                nxt = lines[i].strip()
+                if re.match(r"^\d{1,3}$", nxt) and not buf:
+                    break
+                if re.match(r"^\d{1,3}$", nxt) and buf:
+                    break
+                buf.append(lines[i].rstrip())
+                i += 1
+            blob = "\n".join(buf).strip()
+            if blob and len(blob) > 3:
+                title = blob.split("\n", 1)[0].strip()[:200]
+                steps.append(
+                    ParsedStep(
+                        step_id=sid,
+                        step_title=title,
+                        test_data=blob,
+                        expected_result="",
+                    )
+                )
+            continue
+        i += 1
+    return steps
+
+
+def _parse_loose_numbered_tc(text: str) -> list[ParsedStep]:
+    """
+    Best-effort for JIRA PDF/markdown exports: find lines starting with an integer step id.
+    """
+    steps: list[ParsedStep] = []
+    # Pattern: start of line, digits, whitespace, rest of line
+    parts = re.split(r"(?m)^(\d{1,3})\s{2,}(.+?)\s*$", text)
+    # re.split with groups returns alternating chunks; skip preamble
+    i = 1
+    while i < len(parts):
+        if i + 1 >= len(parts):
+            break
+        sid = parts[i]
+        first_line = parts[i + 1].strip()
+        i += 2
+        block = first_line
+        # Attach following non-numbered lines until next step
+        # This is heuristic — export formats vary
+        steps.append(
+            ParsedStep(
+                step_id=sid,
+                step_title=first_line[:120],
+                test_data=block,
+                expected_result="",
+            )
+        )
+    if len(steps) >= 2:
+        return steps
+
+    # Fallback: lines like "1,Step title,..." CSV without header
+    for m in re.finditer(r"(?m)^\s*(\d+)\s*,\s*([^,\n]+)(?:\s*,\s*([^\n]*))?", text):
+        sid, t1, t2 = m.group(1), m.group(2).strip(), (m.group(3) or "").strip()
+        steps.append(ParsedStep(step_id=sid, step_title=t1, test_data=t2 or t1, expected_result=""))
+    return steps