igel-qe-core 1.0.3 → 1.0.7

package/{knowledge_base → src}/eval/harness.py

@@ -12,7 +12,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any
 
-from knowledge_base.eval.scorers import (
+from src.eval.scorers import (
     DomainScorer,
     EvaluationResult,
     ExecutabilityScorer,
@@ -293,8 +293,8 @@ class EvaluationHarness:
     def _persist_run_to_db(self, run: HarnessRun, query_file: Path | str) -> None:
         """Persist evaluation run to PostgreSQL when EVAL_ENABLED."""
         try:
-            from knowledge_base.config import cfg
-            from knowledge_base.db.feedback_schema import insert_eval_run, insert_eval_results_batch
+            from src.config import cfg
+            from src.db.feedback_schema import insert_eval_run, insert_eval_results_batch
 
             eval_uuid = insert_eval_run(
                 run_id=run.run_id,
@@ -344,14 +344,14 @@ class EvaluationHarness:
         backends: tuple[str, ...] = ("postgres", "neo4j"),
     ) -> dict:
         """Compare KG backend quality across queries (Phase 3)."""
-        from knowledge_base.config import cfg
+        from src.config import cfg
 
         queries = self.load_queries(query_file)
         comparison = {"backends": backends, "results": {}}
 
         original_backend = cfg.KG_BACKEND
         for backend in backends:
-            import knowledge_base.config as config_module
+            import src.config as config_module
             config_module.cfg.KG_BACKEND = backend
             run_id = f"backend_{backend}_{Path(query_file).stem}"
             try:
@@ -363,7 +363,7 @@ class EvaluationHarness:
             except Exception as e:
                 comparison["results"][backend] = {"error": str(e)}
 
-        import knowledge_base.config as config_module
+        import src.config as config_module
         config_module.cfg.KG_BACKEND = original_backend
         return comparison
 

package/{knowledge_base → src}/feedback/__init__.py

@@ -1,6 +1,6 @@
 """Human feedback capture, curation, and application."""
 
-from knowledge_base.feedback.handler import apply_feedback, apply_promotion, capture_feedback, curate_feedback
+from src.feedback.handler import apply_feedback, apply_promotion, capture_feedback, curate_feedback
 
 __all__ = [
     "apply_feedback",

package/{knowledge_base → src}/feedback/analytics.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 from datetime import datetime, timedelta
 
-from knowledge_base.db.client import get_conn
+from src.db.client import get_conn
 
 
 def generate_weekly_report(days: int = 7) -> dict:

package/{knowledge_base → src}/feedback/applier.py

@@ -5,10 +5,10 @@ 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
+from src.db.client import get_conn
+from src.db.feedback_schema import get_feedback_event, list_promotions
+from src.db.schema import ensure_knowledge_graph_tables
+from src.feedback.handler import apply_feedback, apply_promotion
 
 logger = logging.getLogger(__name__)
 

package/{knowledge_base → src}/feedback/curator.py

@@ -3,8 +3,8 @@ 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
+from src.db.feedback_schema import get_feedback_event, list_feedback_events, list_promotions
+from src.feedback.handler import apply_feedback, apply_promotion, curate_feedback
 
 logger = logging.getLogger(__name__)
 

package/{knowledge_base → src}/feedback/handler.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 import logging
 from typing import Any
 
-from knowledge_base.db.feedback_schema import (
+from src.db.feedback_schema import (
     insert_feedback_audit,
     insert_feedback_event,
     insert_feedback_promotion,

package/{knowledge_base → src}/generation/input_classifier.py

@@ -9,7 +9,7 @@ import re
 from dataclasses import dataclass
 from enum import Enum
 
-from knowledge_base.generation.manual_tc_parser import parse_manual_tc, count_parsed_steps
+from src.generation.manual_tc_parser import parse_manual_tc, count_parsed_steps
 
 
 class InputMode(str, Enum):

package/{knowledge_base → src}/generation/prompts.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass
 
-from knowledge_base.config import cfg
+from src.config import cfg
 
 logger = logging.getLogger(__name__)
 

package/{knowledge_base → src}/generation/tc_transformer.py

@@ -10,14 +10,14 @@ import re
 import time
 from dataclasses import dataclass, field
 
-from knowledge_base.generation.input_classifier import (
+from src.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 (
+from src.generation.manual_tc_parser import parse_manual_tc
+from src.generation.prompts import (
     EXPAND_SYSTEM_ADDON,
     TRANSFORM_SYSTEM_ADDON,
     build_expand_markdown_user_prompt,
@@ -30,8 +30,8 @@ from knowledge_base.generation.prompts import (
     kb_trace_lines,
     load_pytest_exemplar,
 )
-from knowledge_base.retrieval.unified_query import unified_query
-from knowledge_base.validators.step_fidelity import (
+from src.retrieval.unified_query import unified_query
+from src.validators.step_fidelity import (
     validate_expand_preservation,
     validate_transform_fidelity,
 )
@@ -61,31 +61,31 @@ def _bundle_kg_entities(bundle) -> dict | None:
 
 
 def _tg_call_gpt(system: str, user: str, **kwargs):
-    from knowledge_base.generation import test_generator as tg
+    from src.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
+    from src.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
+    from src.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
+    from src.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
+    from src.generation import test_generator as tg
 
     return tg._infer_feature_area(topic)
 

package/{knowledge_base → src}/generation/test_generator.py

@@ -19,9 +19,13 @@ from pathlib import Path
 from openai import AzureOpenAI, RateLimitError, APIConnectionError, APITimeoutError
 from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
 
-from knowledge_base.config import cfg
-from knowledge_base.retrieval.unified_query import unified_query
-from knowledge_base.generation.prompts import (
+from src.config import cfg
+from src.core.model_router import ModelRouter
+from src.retrieval.unified_query import unified_query
+
+# Module-level router instance shared across all calls in this process
+_model_router = ModelRouter()
+from src.generation.prompts import (
     PromptContext,
     build_system_prompt,
     build_markdown_user_prompt,
@@ -135,7 +139,7 @@ def generate_test_cases(
     output_dir = output_dir or DEFAULT_OUTPUT_DIR
     output_dir.mkdir(parents=True, exist_ok=True)
 
-    from knowledge_base.generation.input_classifier import DetailLevel, InputMode, classify_input
+    from src.generation.input_classifier import DetailLevel, InputMode, classify_input
 
     try:
         dl = DetailLevel((detail_level or "auto").lower())
@@ -144,7 +148,7 @@ def generate_test_cases(
     cls = classify_input(topic, source_tc, detail_level=dl)
 
     if cls.mode in (InputMode.TRANSFORM, InputMode.EXPAND):
-        from knowledge_base.generation.tc_transformer import run_faithful_generation
+        from src.generation.tc_transformer import run_faithful_generation
 
         resolved_test_id = test_id or _resolve_test_id(output_dir)
         resolved_feature = feature_area or _infer_feature_area(topic)
@@ -209,7 +213,7 @@ def generate_test_cases(
     if not bundle.results:
         raise ValueError(
             f"No KB content found for topic '{topic}'. "
-            "Ensure documents are ingested: python -m knowledge_base.ingestion.ingest"
+            "Ensure documents are ingested: python -m src.ingestion.ingest"
         )
 
     retrieval_debug_json: str | None = bundle.debug.to_json() if debug_retrieval else None
@@ -223,6 +227,9 @@ def generate_test_cases(
 
     tokens_used = bundle.debug.total_tokens_used
 
+    # Step 2b: Load capped feedback for the topic/test_id to inject into context
+    feedback_block = _build_feedback_block(resolved_test_id)
+
     ctx = PromptContext(
         topic=topic,
         test_id=resolved_test_id,
@@ -238,6 +245,9 @@ def generate_test_cases(
     )
 
     system_prompt = build_system_prompt()
+    # Append capped feedback to system prompt if available
+    if feedback_block:
+        system_prompt = system_prompt + "\n\n" + feedback_block
     warnings: list[str] = []
     md_path: Path | None = None
     py_path: Path | None = None
@@ -247,7 +257,18 @@ def generate_test_cases(
     if output_format in ("md", "both"):
         logger.info("Generating markdown for '%s'...", topic)
         markdown_user_prompt = build_markdown_user_prompt(ctx)
-        markdown_content = _call_gpt(system_prompt, markdown_user_prompt, max_tokens=4096, temperature=0.2)
+        # Canary: use model router for testcase_generation; other steps use default
+        _tc_model = _model_router.route(
+            "testcase_generation",
+            context_size=len(markdown_user_prompt),
+        )
+        logger.debug("ModelRouter: testcase_generation → %s", _tc_model.deployment)
+        markdown_content = _call_gpt(
+            system_prompt, markdown_user_prompt,
+            max_tokens=_tc_model.max_tokens,
+            temperature=_tc_model.temperature,
+            deployment=_tc_model.deployment,
+        )
         md_filename = f"{resolved_test_id}_{_slugify(topic)}.md"
         md_path = _safe_write_path(output_dir / md_filename)
         md_ref = format_kb_retrieval_references_markdown(bundle.results)
@@ -404,10 +425,12 @@ def _call_gpt(
     user_prompt: str,
     max_tokens: int = 4096,
     temperature: float = 0.2,
+    deployment: str | None = None,
 ) -> str:
+    """Call Azure OpenAI. deployment overrides cfg.AZURE_DEPLOYMENT when provided."""
     client = _get_llm_client()
     response = client.chat.completions.create(
-        model=cfg.AZURE_DEPLOYMENT,
+        model=deployment or cfg.AZURE_DEPLOYMENT,
         messages=[
             {"role": "system", "content": system_prompt},
             {"role": "user",   "content": user_prompt},
@@ -422,6 +445,29 @@ def _call_gpt(
 
 # ── Post-Processing ───────────────────────────────────────────────────────────
 
+def _build_feedback_block(test_id: str) -> str:
+    """Retrieve capped feedback for test_id and format as a system prompt appendix.
+
+    Returns an empty string if no feedback is found or on any error.
+    Cap: 5 items / 800 chars total (enforced by FeedbackAgent.get_feedback_for_target).
+    """
+    try:
+        from src.agents.feedback_agent import FeedbackAgent
+        items = FeedbackAgent().get_feedback_for_target(test_id, limit=5, max_chars=800)
+        if not items:
+            return ""
+        lines = ["## Historical Feedback (apply these corrections)"]
+        for i, fb in enumerate(items, 1):
+            fb_type = fb.get("type", "correction")
+            comment = fb.get("comment", "").strip()
+            if comment:
+                lines.append(f"{i}. [{fb_type}] {comment}")
+        return "\n".join(lines) if len(lines) > 1 else ""
+    except Exception as e:
+        logger.debug("_build_feedback_block: non-fatal error for %s: %s", test_id, e)
+        return ""
+
+
 def _strip_code_fences(code: str) -> str:
     code = re.sub(r"^```python\s*\n?", "", code, flags=re.MULTILINE)
     code = re.sub(r"^```\s*\n?", "", code, flags=re.MULTILINE)
@@ -499,7 +545,7 @@ def _build_minimal_spec(ctx: PromptContext) -> str:
         f"Product: {ctx.product or 'IGEL OS 12'}\n\n"
         "Generate full executable test steps from the KNOWLEDGE BASE CONTEXT in the same prompt:\n"
         "- Match exact paths, commands, and UI strings from the KB; do not generalize.\n"
-        "- See repository guide: knowledge_base/TEST_GENERATION_GUIDE.md\n"
+        "- See repository guide: src/TEST_GENERATION_GUIDE.md\n"
     )
 
 
@@ -540,7 +586,7 @@ def _score_output(
     """Compute confidence scores when evaluation is enabled."""
     if not cfg.EVAL_ENABLED:
         return None
-    from knowledge_base.core.confidence import flatten_confidence_for_api, score_generation
+    from src.core.confidence import flatten_confidence_for_api, score_generation
 
     raw = score_generation(
         query=topic,

package/{knowledge_base → src}/graph_db/__init__.py

@@ -1,5 +1,5 @@
 """Neo4j graph database layer (Phase 3 shadow deployment)."""
 
-from knowledge_base.graph_db.neo4j_client import Neo4jClient, get_neo4j_client
+from src.graph_db.neo4j_client import Neo4jClient, get_neo4j_client
 
 __all__ = ["Neo4jClient", "get_neo4j_client"]

package/{knowledge_base → src}/graph_db/graphiti_client.py

@@ -5,8 +5,8 @@ import json
 import logging
 from typing import Any
 
-from knowledge_base.config import cfg
-from knowledge_base.db.client import get_conn
+from src.config import cfg
+from src.db.client import get_conn
 
 logger = logging.getLogger(__name__)
 

package/{knowledge_base → src}/graph_db/kg_traversal.py

@@ -5,9 +5,9 @@ import logging
 import re
 from typing import Any
 
-from knowledge_base.config import cfg
-from knowledge_base.graph_db.neo4j_client import get_neo4j_client
-from knowledge_base.retrieval.knowledge_graph import KGContext
+from src.config import cfg
+from src.graph_db.neo4j_client import get_neo4j_client
+from src.retrieval.knowledge_graph import KGContext
 
 logger = logging.getLogger(__name__)
 

package/{knowledge_base → src}/graph_db/migrate_kg.py

@@ -2,16 +2,16 @@
 Migrate PostgreSQL knowledge graph to Neo4j (Phase 3).
 
 Usage:
-    python -m knowledge_base.graph_db.migrate_kg [--dry-run]
+    python -m src.graph_db.migrate_kg [--dry-run]
 """
 from __future__ import annotations
 
 import argparse
 import logging
 
-from knowledge_base.db.client import get_conn, init_pool
-from knowledge_base.graph_db.neo4j_client import get_neo4j_client, should_write_neo4j
-from knowledge_base.graph_db.schema import apply_schema
+from src.db.client import get_conn, init_pool
+from src.graph_db.neo4j_client import get_neo4j_client, should_write_neo4j
+from src.graph_db.schema import apply_schema
 
 logger = logging.getLogger(__name__)
 

package/{knowledge_base → src}/graph_db/neo4j_client.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import logging
 from typing import Any
 
-from knowledge_base.config import cfg
+from src.config import cfg
 
 logger = logging.getLogger(__name__)
 

package/{knowledge_base → src}/graph_db/temporal_ingest.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import logging
 import re
 
-from knowledge_base.graph_db.graphiti_client import get_graphiti_client
+from src.graph_db.graphiti_client import get_graphiti_client
 
 logger = logging.getLogger(__name__)
 

package/{knowledge_base → src}/ingestion/kg_extractor.py

@@ -11,10 +11,10 @@ import argparse
 import logging
 import re
 
-from knowledge_base.config import cfg
-from knowledge_base.db.client import close_pool, get_conn, init_pool
-from knowledge_base.db.kg_introspect import clear_kg_layout_cache
-from knowledge_base.db.schema import ensure_knowledge_graph_tables
+from src.config import cfg
+from src.db.client import close_pool, get_conn, init_pool
+from src.db.kg_introspect import clear_kg_layout_cache
+from src.db.schema import ensure_knowledge_graph_tables
 
 logger = logging.getLogger(__name__)
 
@@ -141,7 +141,7 @@ _CROSS_REF_RE = re.compile(r"(?:see|refer to|documented in|depends on)\s+([^\n.]
 def _llm_extract_entities(content: str, title: str | None) -> dict:
     """LLM-assisted entity extraction for orphan parent chunks."""
     try:
-        from knowledge_base.generation.test_generator import _call_gpt
+        from src.generation.test_generator import _call_gpt
         prompt = f"""Extract structured entities from this IGEL documentation section.
 Return JSON only with keys: registry_keys (list), ui_paths (list), products (list),
 versions (list), error_codes (list), cli_commands (list), related_features (list).
@@ -307,7 +307,7 @@ def _extract_single_parent(cur, pid: str, content: str, title: str | None) -> tu
 def _shadow_write_neo4j(feature_name: str, blob: str) -> None:
     """Dual-write extracted entities to Neo4j when shadow mode is enabled (Phase 3)."""
     try:
-        from knowledge_base.graph_db.neo4j_client import get_neo4j_client, should_write_neo4j
+        from src.graph_db.neo4j_client import get_neo4j_client, should_write_neo4j
 
         if not should_write_neo4j():
             return

package/{knowledge_base → src}/ingestion/web_ingest.py

@@ -5,10 +5,10 @@ from __future__ import annotations
 import hashlib
 import logging
 
-from knowledge_base.chunking.chunker import chunk_sections
-from knowledge_base.config import cfg
-from knowledge_base.db.client import init_pool
-from knowledge_base.db.schema import (
+from src.chunking.chunker import chunk_sections
+from src.config import cfg
+from src.db.client import init_pool
+from src.db.schema import (
     clear_document_chunks,
     document_exists,
     document_has_chunks,
@@ -34,7 +34,7 @@ def ingest_web_items(items: list[dict], *, source_label: str = "web") -> int:
         product = item.get("product", "IGEL")
 
         if not sections and item.get("raw_text"):
-            from knowledge_base.parsers.markdown_parser import Section
+            from src.parsers.markdown_parser import Section
 
             sections = [
                 Section(
@@ -57,7 +57,7 @@ def ingest_web_items(items: list[dict], *, source_label: str = "web") -> int:
         for w in warnings[:5]:
             logger.debug("web_ingest warning: %s", w)
 
-        from knowledge_base.embeddings.azure_embedder import embed_texts, format_for_pgvector
+        from src.embeddings.azure_embedder import embed_texts, format_for_pgvector
 
         _, _, doc_children, _ = ingest_document_atomic(
             file_name=file_name,

package/src/intelligence/diff_analyzer.py

@@ -0,0 +1,109 @@
+"""Diff Analyzer for scope-limited framework analysis.
+
+Purpose:
+- Compute impacted scope from changed files before heavy analysis/indexing.
+- Prevent full-repo processing on pull/merge when only a subset changed.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+from typing import Iterable
+
+
+def _to_repo_relative(path: Path, repo_root: Path) -> Path:
+    try:
+        return path.resolve().relative_to(repo_root.resolve())
+    except Exception:
+        return path
+
+
+def _module_name(py_file: Path, repo_root: Path) -> str:
+    rel = _to_repo_relative(py_file, repo_root)
+    no_suffix = rel.with_suffix("")
+    return ".".join(no_suffix.parts)
+
+
+def _extract_imported_modules(py_file: Path) -> set[str]:
+    try:
+        tree = ast.parse(py_file.read_text(encoding="utf-8"))
+    except Exception:
+        return set()
+
+    modules: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                modules.add(alias.name)
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                modules.add(node.module)
+    return modules
+
+
+def _is_script_path(path: Path) -> bool:
+    p = str(path).lower()
+    return (
+        p.startswith("tests/")
+        or p.startswith("test/")
+        or "script" in p
+        or p.endswith(".feature")
+    )
+
+
+def analyze_diff_scope(repo_root: Path, changed_files: Iterable[Path]) -> dict:
+    """Return impacted scope package for downstream analyzers.
+
+    Args:
+        repo_root: Repository root path.
+        changed_files: Changed paths (relative or absolute).
+
+    Returns:
+        dict containing changed modules/files and impacted dependency hints.
+    """
+    repo_root = repo_root.resolve()
+    normalized: list[Path] = []
+    for p in changed_files:
+        p = Path(p)
+        full = p if p.is_absolute() else (repo_root / p)
+        if full.exists():
+            normalized.append(full.resolve())
+
+    changed_rel = [_to_repo_relative(p, repo_root) for p in normalized]
+    changed_modules = {
+        _module_name(p, repo_root)
+        for p in normalized
+        if p.suffix == ".py"
+    }
+
+    dependent_files: set[Path] = set()
+    dependent_scripts: set[Path] = set()
+
+    # Reverse-import approximation for Python files in repo.
+    for py_file in repo_root.rglob("*.py"):
+        if "/.venv/" in str(py_file) or "/node_modules/" in str(py_file):
+            continue
+        imports = _extract_imported_modules(py_file)
+        if any(any(m == imp or imp.startswith(m + ".") for imp in imports) for m in changed_modules):
+            rel = _to_repo_relative(py_file, repo_root)
+            dependent_files.add(rel)
+            if _is_script_path(rel):
+                dependent_scripts.add(rel)
+
+    impacted_assets = {
+        p for p in changed_rel
+        if str(p).startswith(("core/", "ui/", "bussiness/", "src/"))
+    }
+
+    analysis_targets = sorted({*changed_rel, *dependent_files}, key=lambda x: str(x))
+
+    return {
+        "changed_files": [str(p) for p in sorted(changed_rel, key=lambda x: str(x))],
+        "changed_modules": sorted(changed_modules),
+        "dependent_files": [str(p) for p in sorted(dependent_files, key=lambda x: str(x))],
+        "dependent_scripts": [str(p) for p in sorted(dependent_scripts, key=lambda x: str(x))],
+        "impacted_assets": [str(p) for p in sorted(impacted_assets, key=lambda x: str(x))],
+        # Placeholder until business rule registry links are fully wired.
+        "impacted_business_rules": [],
+        "analysis_targets": [str(p) for p in analysis_targets],
+    }

package/{knowledge_base → src}/intelligence/execution_ingest.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 
 import logging
 
-from knowledge_base.config import cfg
-from knowledge_base.memory.cognee_client import get_cognee_client
-from knowledge_base.memory.memory_types import MemoryType
+from src.config import cfg
+from src.memory.cognee_client import get_cognee_client
+from src.memory.memory_types import MemoryType
 
 logger = logging.getLogger(__name__)