igel-qe-core 1.0.0

package/knowledge_base/cli/generate_qcapps134.py

@@ -0,0 +1,391 @@
+"""
+QCAPPS-134 Comprehensive Test Case Generator
+=============================================
+Expands the 4-step QCAPPS-134 "Chromium | Hardware-dependent" test case into
+4 separate, detailed test case documents with positive, negative, and edge case
+coverage — using the IGEL Knowledge Base (PostgreSQL + pgvector RAG).
+
+Outputs: Markdown (.md) + Python pytest (.py) + JSON (.json) per sub-topic.
+
+Usage:
+    python -m knowledge_base.cli.generate_qcapps134
+"""
+from __future__ import annotations
+
+import json
+import sys
+import time
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from knowledge_base.db.client import init_pool, test_connection, close_pool
+from knowledge_base.generation.test_generator import (
+    generate_test_cases,
+    GeneratedTestCase,
+)
+
+console = Console()
+
+GENERATED_DIR = Path(__file__).resolve().parents[1] / "tests" / "Generated"
+JSON_DIR = Path(__file__).resolve().parents[1] / "output" / "qcapps_134"
+
+ORIGINAL_DESCRIPTION = """\
+This test case contains all hardware-dependent features of Chromium on IGEL OS 12.
+
+Additional Information:
+- by default chrome://* is blocked; set "URLBlocklist" to ";" to unblock all urls
+- wait a bit (1-2 seconds) until setup parameters take effect after hitting 'Apply'
+- Preferences: /userhome/.config/chromium/Default/Preferences
+- Policies: /etc/chromium-browser/policies/managed/policies.json
+- if preferences are changed chromium needs a restart
+- Attention! On AMD devices, the chrome://media-internals information might be misleading. Always check the cpu consumption!
+
+TC Setup option to change Screenlock/Screensaver timer:
+- TC Setup > User Interface > Screenlock/Screensaver > Start automatically = true
+- TC Setup > User Interface > Screenlock/Screensaver > Timeout = 1
+- TC Setup > User Interface > Screenlock/Screensaver > Different screenlock timeout = true
+- TC Setup > User Interface > Screenlock/Screensaver > Screenlock timeout = 2
+"""
+
+SUB_TOPICS = [
+    {
+        "id": "hw_accel",
+        "topic": (
+            "QCAPPS-134 Chromium Hardware Video Acceleration on IGEL OS 12 — "
+            "comprehensive test with positive, negative, and edge case scenarios. "
+            "Cover: enabling/disabling Hardware Acceleration toggle "
+            "(TC Setup: Apps > Chromium Browser > Global Settings > Hardware Acceleration = true/false), "
+            "H264 video playback on YouTube, tagesschau.de, and W3C HTML5 video page, "
+            "h264ify extension auto-installation verification via chrome://extensions, "
+            "CPU consumption comparison with and without HW acceleration using 'atop 1' command, "
+            "chrome://gpu and chrome://media-internals verification. "
+            "Negative: HW acceleration disabled but expecting smooth playback, "
+            "missing GPU driver, chrome://gpu showing software rendering. "
+            "Edge cases: AMD GPU with misleading chrome://media-internals (always check CPU), "
+            "dual GPU systems, chromium restart required after settings change."
+        ),
+        "json_key": "QCAPPS-134-HW-ACCEL",
+        "json_summary": "Chromium | Hardware Video Acceleration",
+        "original_step": (
+            "Step 1: Check Hardware Video Acceleration and Play videos (HTML5 video)\n"
+            "Test Data:\n"
+            "- Enable HW video acceleration in Chromium Global settings:\n"
+            "  TC Setup: Apps > Chromium Browser > Global Settings > Hardware Acceleration = true/false\n"
+            "- Check hardware video acceleration and H264 Support:\n"
+            "  https://www.youtube.com/\n"
+            "  https://www.tagesschau.de/\n"
+            "  https://www.w3.org/2010/05/video/mediaevents.html\n"
+            "- Check if H264 Extension is automatically installed:\n"
+            "  Open chrome://extensions and check for 'h264ify' extension\n"
+            "- Check Hardware Consumption with and without Hardware Acceleration:\n"
+            "  Run 'atop 1' in terminal and compare cpu usage for chromium process\n"
+            "Expected Result:\n"
+            "- Videos should play smoothly and UI should work as expected\n"
+            "- h264ify extension is installed automatically\n"
+            "- Hardware Acceleration can be positively identified via the cpu consumption"
+        ),
+    },
+    {
+        "id": "gpu_libva",
+        "topic": (
+            "QCAPPS-134 Chromium GPU Process and libva Library Verification on IGEL OS 12 — "
+            "comprehensive test with positive, negative, and edge case scenarios. "
+            "Cover: verifying Chromium GPU process is running via 'ps ax | grep chromium | grep gpu-process', "
+            "checking libva library paths loaded by GPU process via 'cat /proc/<pid>/maps | grep libva', "
+            "verifying VA-API hardware acceleration is properly initialized. "
+            "Negative: GPU process not running, missing libva libraries, "
+            "libva not loaded when HW acceleration is disabled. "
+            "Edge cases: multiple Chromium instances, process restart after crash, "
+            "different libva versions on different hardware platforms."
+        ),
+        "json_key": "QCAPPS-134-GPU-LIBVA",
+        "json_summary": "Chromium | GPU Process and libva Libraries",
+        "original_step": (
+            "Step 2: Check Chromium process and libraries\n"
+            "Test Data:\n"
+            "- Open local shell and find Chromium gpu process by running:\n"
+            "  ps ax | grep chromium | grep gpu-process\n"
+            "- Run the following command:\n"
+            "  cat /proc/<pid of gpu-process>/maps | grep libva\n"
+            "Expected Result:\n"
+            "- You should see the Chromium gpu process running\n"
+            "- You should see a list of libva library paths"
+        ),
+    },
+    {
+        "id": "openh264",
+        "topic": (
+            "QCAPPS-134 OpenH264 Service Verification for Chromium on IGEL OS 12 — "
+            "comprehensive test with positive, negative, and edge case scenarios. "
+            "Cover: checking OpenH264 service status via "
+            "'systemctl status igel-openh264-installer@chromium.service', "
+            "verifying service is active and running, checking H264 codec availability "
+            "for Chromium browser, H264 video playback validation. "
+            "Negative: service stopped/failed, service not found (missing package), "
+            "service active but H264 codec not loaded in Chromium. "
+            "Edge cases: service restart behavior, service status after device reboot, "
+            "interaction with HW acceleration setting, multiple browser sessions."
+        ),
+        "json_key": "QCAPPS-134-OPENH264",
+        "json_summary": "Chromium | OpenH264 Service Verification",
+        "original_step": (
+            "Step 3: Check if OpenH264 works\n"
+            "Test Data:\n"
+            "- Check if H264 Service is running\n"
+            "- Run as root in terminal:\n"
+            "  systemctl status igel-openh264-installer@chromium.service\n"
+            "Expected Result:\n"
+            "- Specified H264 service is active"
+        ),
+    },
+    {
+        "id": "ms_teams",
+        "topic": (
+            "QCAPPS-134 MS Teams in Chromium Browser on IGEL OS 12 — "
+            "comprehensive test with positive, negative, and edge case scenarios. "
+            "Cover: launching MS Teams in Chromium (https://teams.microsoft.com/), "
+            "verifying connected external audio/video devices are correctly identified, "
+            "performing a test call with Windows and iOS MS Teams native users, "
+            "screen sharing functionality test, "
+            "long-term call (>10 minutes) with screenlock/screensaver interaction test "
+            "(TC Setup > User Interface > Screenlock/Screensaver > Start automatically = true, Timeout = 1, "
+            "Different screenlock timeout = true, Screenlock timeout = 2). "
+            "Negative: no audio device connected, camera not detected, "
+            "network interruption during call, Teams login failure. "
+            "Edge cases: screensaver activating during active call, "
+            "multiple audio devices connected (USB headset + built-in), "
+            "screen sharing with multiple monitors, call quality degradation over time."
+        ),
+        "json_key": "QCAPPS-134-MS-TEAMS",
+        "json_summary": "Chromium | MS Teams in Browser",
+        "original_step": (
+            "Step 4: Test MS Teams in Browser\n"
+            "Test Data:\n"
+            "- Start MS Teams in Chromium Browser (https://teams.microsoft.com/)\n"
+            "- Check if all connected external audio/video devices are correctly identified\n"
+            "- Perform a Test Call with someone who uses Windows and someone who uses iOS\n"
+            "  (both using MS Teams native on those devices)\n"
+            "- Perform Screen Sharing\n"
+            "- Perform a long term call (x > 10min) and check if IGEL OS screenlock/screensaver\n"
+            "  interrupts the call\n"
+            "Expected Result:\n"
+            "- All audio/video devices are correctly identified\n"
+            "- Test Call against MS Teams running natively on Windows or iOS does work\n"
+            "- Audio/Video Quality is as expected and does not degrade over time\n"
+            "- Screen Sharing is possible\n"
+            "- IGEL OS screensaver/screenlock does not interrupt the call"
+        ),
+    },
+]
+
+
+def _extract_json_from_markdown(md_content: str, meta: dict) -> dict:
+    """Parse generated markdown into structured JSON matching the project's output format."""
+    import re
+
+    result = {
+        "issue_key": meta["json_key"],
+        "summary": meta["json_summary"],
+        "original_qcapps_step": meta["original_step"],
+        "preconditions": "",
+        "steps": [],
+    }
+
+    prec_match = re.search(
+        r"##\s*Preconditions?\s*\n(.*?)(?=\n##|\Z)",
+        md_content, re.DOTALL | re.IGNORECASE,
+    )
+    if prec_match:
+        result["preconditions"] = prec_match.group(1).strip()
+
+    table_match = re.search(
+        r"\|\s*#\s*\|\s*STEP\s*\|.*?\n\|[-|\s]+\n(.*?)(?=\n##|\n\n---|\Z)",
+        md_content, re.DOTALL | re.IGNORECASE,
+    )
+    if table_match:
+        table_body = table_match.group(1).strip()
+        for row in table_body.split("\n"):
+            row = row.strip()
+            if not row or row.startswith("|---"):
+                continue
+            cells = [c.strip() for c in row.split("|")]
+            cells = [c for c in cells if c]
+            if len(cells) >= 4:
+                try:
+                    step_no = int(cells[0])
+                except ValueError:
+                    continue
+                result["steps"].append({
+                    "step_no": step_no,
+                    "step": cells[1].replace("<br>", "\n").replace("**", ""),
+                    "test_data": cells[2].replace("<br>", "\n"),
+                    "expected_result": cells[3].replace("<br>", "\n"),
+                })
+
+    if not result["steps"]:
+        step_sections = re.findall(
+            r"(?:###?\s*(?:Step|Test Step)\s*(\d+)[^\n]*)\n(.*?)(?=(?:###?\s*(?:Step|Test Step)\s*\d+)|\n##|\Z)",
+            md_content, re.DOTALL | re.IGNORECASE,
+        )
+        for num, body in step_sections:
+            result["steps"].append({
+                "step_no": int(num),
+                "step": f"Step {num}",
+                "test_data": body.strip()[:2000],
+                "expected_result": "",
+            })
+
+    return result
+
+
+def run_generation(sub: dict, test_id: str) -> GeneratedTestCase:
+    """Generate a single sub-topic test case."""
+    console.print(f"\n[bold cyan]--- Generating: {sub['json_summary']} ---[/bold cyan]")
+    console.print(f"  Test ID: {test_id}")
+    console.print(f"  Topic: {sub['topic'][:100]}...")
+
+    full_topic = (
+        f"{sub['topic']}\n\n"
+        "Generate a COMPREHENSIVE test case document covering:\n"
+        "1. POSITIVE SCENARIOS: All happy-path validations for the feature\n"
+        "2. NEGATIVE SCENARIOS: What happens when settings are wrong, services are down, "
+        "devices are missing, or configurations are invalid\n"
+        "3. EDGE CASES: Boundary conditions, unusual hardware configurations, timing issues, "
+        "platform-specific behaviors\n\n"
+        "Important IGEL context for this test:\n"
+        "- by default chrome://* is blocked; set URLBlocklist to ; to unblock all urls\n"
+        "- wait 1-2 seconds until setup parameters take effect after hitting Apply\n"
+        "- Preferences: /userhome/.config/chromium/Default/Preferences\n"
+        "- Policies: /etc/chromium-browser/policies/managed/policies.json\n"
+        "- if preferences are changed chromium needs a restart\n"
+        "- On AMD devices, chrome://media-internals information might be misleading. "
+        "Always check the cpu consumption!\n"
+        "- Screenlock/Screensaver config: TC Setup > User Interface > Screenlock/Screensaver\n\n"
+        "The test case must be written so that a person with NO IGEL knowledge can understand "
+        "and execute every step. Include exact navigation paths, exact commands, and specific "
+        "observable outcomes."
+    )
+
+    result = generate_test_cases(
+        topic=full_topic,
+        output_format="both",
+        product="IGEL OS",
+        test_id=test_id,
+        feature_area="Chromium Hardware Validation",
+        top_k=10,
+        output_dir=GENERATED_DIR,
+        debug_retrieval=False,
+        source_tc=None,
+        detail_level="detailed",
+    )
+
+    if result.markdown_path:
+        md_content = result.markdown_path.read_text(encoding="utf-8")
+        json_data = _extract_json_from_markdown(md_content, sub)
+        json_path = JSON_DIR / f"{sub['json_key']}.json"
+        json_path.write_text(
+            json.dumps(json_data, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+        console.print(f"  [green]JSON[/green]: {json_path}")
+
+    return result
+
+
+def main() -> None:
+    console.rule("[bold blue]QCAPPS-134 Comprehensive Test Case Generator[/bold blue]")
+    console.print("  Source         : QCAPPS-134 (Chromium | Hardware-dependent)")
+    console.print("  Sub-topics     : 4 (HW Accel, GPU/libva, OpenH264, MS Teams)")
+    console.print(f"  MD+Py Output   : {GENERATED_DIR}")
+    console.print(f"  JSON Output    : {JSON_DIR}")
+    console.print("  Detail Level   : detailed (beginner-friendly)")
+    console.print()
+
+    GENERATED_DIR.mkdir(parents=True, exist_ok=True)
+    JSON_DIR.mkdir(parents=True, exist_ok=True)
+
+    console.print("[bold]Connecting to PostgreSQL Knowledge Base...[/bold]")
+    init_pool()
+    if not test_connection():
+        console.print("[red]DB connection failed. Check knowledge_base/.env[/red]")
+        sys.exit(1)
+    console.print("[green]Connected.[/green]\n")
+
+    results: list[tuple[dict, GeneratedTestCase]] = []
+    t_global = time.time()
+
+    for i, sub in enumerate(SUB_TOPICS):
+        test_id = f"TC{20 + i:03d}"
+        try:
+            r = run_generation(sub, test_id)
+            results.append((sub, r))
+            _print_single_result(r)
+        except Exception as e:
+            console.print(f"  [red]FAILED: {e}[/red]")
+            import traceback
+            traceback.print_exc()
+
+    close_pool()
+    elapsed = round(time.time() - t_global, 1)
+
+    console.print()
+    console.rule("[bold green]Generation Complete[/bold green]")
+    summary = Table(title=f"QCAPPS-134 Expansion Results ({elapsed}s total)")
+    summary.add_column("Test ID")
+    summary.add_column("Sub-Topic", max_width=40)
+    summary.add_column("Chunks", justify="right")
+    summary.add_column("Steps(orig)", justify="center")
+    summary.add_column("Syntax")
+    summary.add_column("Time(s)", justify="right")
+    summary.add_column("Status")
+
+    for sub, r in results:
+        status = "[green]OK[/green]" if r.kb_sources else "[red]FAIL[/red]"
+        if r.warnings:
+            status = "[yellow]WARN[/yellow]"
+        summary.add_row(
+            r.test_id,
+            sub["json_summary"],
+            str(r.kb_chunk_count),
+            "1",
+            "[green]Y[/green]" if r.syntax_valid else "[red]N[/red]",
+            str(r.generation_time_sec),
+            status,
+        )
+    console.print(summary)
+
+    console.print("\n[bold]Output Files:[/bold]")
+    for sub, r in results:
+        console.print(f"  {sub['json_summary']}:")
+        if r.markdown_path:
+            console.print(f"    MD  : {r.markdown_path}")
+        if r.python_path:
+            console.print(f"    PY  : {r.python_path}")
+        json_path = JSON_DIR / f"{sub['json_key']}.json"
+        if json_path.exists():
+            console.print(f"    JSON: {json_path}")
+
+
+def _print_single_result(r: GeneratedTestCase) -> None:
+    console.print(f"  KB Chunks    : {r.kb_chunk_count}")
+    console.print(f"  Tokens       : ~{r.tokens_used:,}")
+    console.print(f"  Time         : {r.generation_time_sec}s")
+    console.print(f"  Syntax Valid : {'Yes' if r.syntax_valid else 'No'}")
+    if r.markdown_path:
+        console.print(f"  [green]MD[/green]  : {r.markdown_path}")
+    if r.python_path:
+        console.print(f"  [green]PY[/green]  : {r.python_path}")
+    if r.kb_sources:
+        console.print(f"  KB Sources ({len(r.kb_sources)}):")
+        for src in r.kb_sources[:5]:
+            console.print(f"    {src[:120]}")
+    if r.warnings:
+        for w in r.warnings[:3]:
+            console.print(f"  [yellow]WARN[/yellow]: {w[:120]}")
+
+
+if __name__ == "__main__":
+    main()

package/knowledge_base/config/.env

@@ -0,0 +1,100 @@
+# ── PostgreSQL ───────────────────────────────────────────
+DB_HOST=192.168.204.65
+DB_PORT=5432
+DB_NAME=IGEL
+DB_USER=igle
+DB_PASSWORD=12345
+ 
+# Server auth (not parsed by dotenv — for human reference only)
+# SERVER_URL=https://192.168.204.65:5432/
+# SERVER_USER=root
+# SERVER_PASS=FRIDEbAsec
+ 
+# ── Azure OpenAI (LLM) ───────────────────────────────────
+AZURE_API_KEY=8vhk6TdJxBz1dN5RKJHpN9R4IWVU81wc5PmFHtx793pNegMpxXx7JQQJ99BLACYeBjFXJ3w3AAAAACOG3FtZ
+AZURE_ENDPOINT=https://qe-genai.cognitiveservices.azure.com/
+AZURE_DEPLOYMENT=gpt-4.1
+AZURE_API_VERSION=2024-12-01-preview
+ 
+# ── Azure OpenAI (Embeddings) ────────────────────────────
+AZURE_EMBEDDING_DEPLOYMENT=text-embedding-3-large
+AZURE_EMBEDDINGS_API_VERSION=2024-02-01
+EMBEDDING_DIM=3072
+ 
+# # ── Ingestion Settings ───────────────────────────────────
+# KB_DIR=C:\Users\parav\Workspace\IGEL\IGEL Automation_Suit_AI\innominds\Knowledge Base
+# MARKDOWN_OUTPUT_DIR=C:\Users\parav\Workspace\IGEL\IGEL Automation_Suit_AI\innominds\Knowledge Base\markdown_output
+# BATCH_SIZE=32
+# MAX_RETRIES=3
+# LOG_LEVEL=INFO
+ 
+# ── V3 GraphRAG / rerank / context (CPU-optimized) ──
+RERANKER_BACKEND=local
+RERANKER_DEVICE=cpu
+RERANKER_CPU_PROFILE=true
+RERANKER_MODEL=cross-encoder/ms-marco-MiniLM-L-6-v2
+RERANKER_TOP_N=16
+RERANKER_BATCH_SIZE=8
+RERANKER_MAX_LENGTH=256
+RERANKER_PASSAGE_CHARS=2000
+RERANKER_PARENT_CHARS=1200
+RERANKER_TORCH_THREADS=4
+RERANKER_SCORE_THRESHOLD=0.2
+# Multilingual OSS (slower on CPU): RERANKER_MODEL=BAAI/bge-reranker-base
+# COHERE_API_KEY=
+# COHERE_RERANK_MODEL=rerank-multilingual-v3.0
+
+# ── Chunking strategy ──
+CHUNK_PARENT_MAX_TOKENS=1024
+CHUNK_CHILD_MAX_TOKENS=220
+CHUNK_OVERLAP_TOKENS=64
+CHUNK_CONTEXT_HEADERS=true
+
+# ── Live web retrieval (confidence-gated Stage 2 search) ──
+WEB_RETRIEVAL_ENABLED=true
+CONFIDENCE_THRESHOLD=0.75
+WEB_SEARCH_BACKENDS=firecrawl,ddgs,searxng
+WEB_MAX_PAGES=5
+WEB_MIN_SCORE=0.15
+WEB_BUDGET_RATIO=0.12
+WEB_CACHE_TTL_SECONDS=3600
+FIRECRAWL_BASE_URL=http://127.0.0.1:3002
+FIRECRAWL_API_KEY=
+CRAWL4AI_ENABLED=true
+CRAWL4AI_TIMEOUT=30
+DDGS_BACKEND=auto
+DDGS_REGION=wt-wt
+SEARXNG_BASE_URL=
+STRIP_PROMOTED_PATTERNS=ad,sponsored,promo,advertisement
+WEB_SEARCH_INCLUDE_DOMAINS=
+WEB_SEARCH_EXCLUDE_DOMAINS=
+KB_IGEL_BASE_URL=https://kb.igel.com
+COMMUNITY_BASE_URL=https://community.igel.com
+KB_IGEL_ENABLED=true
+COMMUNITY_ENABLED=true
+KG_ENABLED=true
+KG_MAX_HOPS=2
+CONTEXT_TOKEN_BUDGET=8000
+CONTEXT_RESERVE_PROMPT=800
+CONTEXT_MIN_SCORE=0.10
+CONTEXT_MAX_CHUNKS=10
+CONTEXT_KG_BUDGET_RATIO=0.22
+CONTEXT_IMAGE_BUDGET_RATIO=0.08
+CONTEXT_INCLUDE_IMAGES=true
+RETRIEVAL_CANDIDATE_MULTIPLIER=6
+RETRIEVAL_EXCLUDE_SOURCES=Jira,Defects
+
+# ── Unified query (EKG + Web + MCP connectors) ──
+QUERY_EXTERNAL_ENABLED=true
+QUERY_MCP_SOURCES=jira,confluence
+
+# ── Enterprise hardening ──
+API_KEY_REQUIRED=true
+RATE_LIMIT_ENABLED=true
+JSON_LOGS=true
+FTS_LANGUAGE=english
+QUERY_TIMEOUT_SECONDS=60
+RETRIEVAL_TRACE_SAMPLE_RATE=0.1
+DB_SSLMODE=prefer
+DEFAULT_GENERATION_MODE=pipeline
+ 

package/knowledge_base/config/.env.example

@@ -0,0 +1,75 @@
+# IGEL EKG Knowledge Base — environment template
+# Copy to knowledge_base/config/.env and fill in values
+
+# PostgreSQL
+DB_HOST=192.168.204.65
+DB_PORT=5432
+DB_NAME=genai
+DB_USER=genai
+DB_PASSWORD=CHANGE_ME
+DB_SSLMODE=prefer
+
+# Azure OpenAI
+AZURE_API_KEY=CHANGE_ME
+AZURE_ENDPOINT=https://your-endpoint.cognitiveservices.azure.com/
+AZURE_DEPLOYMENT=gpt-4.1
+AZURE_EMBEDDING_DEPLOYMENT=text-embedding-3-large
+EMBEDDING_DIM=3072
+
+# API Security (Phase C)
+API_KEY_REQUIRED=true
+API_KEY=CHANGE_ME_ADMIN_KEY
+API_KEYS=read_key:read,write_key:write,admin_key:admin
+RATE_LIMIT_ENABLED=true
+JSON_LOGS=true
+
+# Retrieval (Phase D)
+FTS_LANGUAGE=english
+REDIS_URL=redis://localhost:6379/0
+EMBED_CACHE_TTL=3600
+RETRIEVAL_CACHE_TTL=300
+QUERY_TIMEOUT_SECONDS=60
+QUERY_GENERATION_TIMEOUT_SECONDS=90
+ASYNC_THREAD_LIMIT=16
+QUERY_EXTERNAL_ENABLED=true
+QUERY_MCP_SOURCES=jira,confluence
+WEB_RETRIEVAL_ENABLED=true
+CONFIDENCE_THRESHOLD=0.75
+WEB_SEARCH_BACKENDS=firecrawl,ddgs,searxng
+WEB_MAX_PAGES=5
+WEB_ALLOW_PRIVATE_HOSTS=false
+FIRECRAWL_BASE_URL=http://127.0.0.1:3002
+FIRECRAWL_API_KEY=
+CRAWL4AI_ENABLED=true
+CRAWL4AI_TIMEOUT=30
+DDGS_BACKEND=auto
+DDGS_REGION=wt-wt
+SEARXNG_BASE_URL=
+STRIP_PROMOTED_PATTERNS=ad,sponsored,promo,advertisement
+WEB_SEARCH_INCLUDE_DOMAINS=
+WEB_SEARCH_EXCLUDE_DOMAINS=
+
+# Connectors (Phase F)
+JIRA_ENABLED=false
+JIRA_URL=
+JIRA_USERNAME=
+JIRA_API_TOKEN=
+CONFLUENCE_ENABLED=false
+CONFLUENCE_URL=
+CONFLUENCE_USERNAME=
+CONFLUENCE_API_TOKEN=
+
+# Agentic pipeline
+AGENTIC_ENABLED=true
+EVAL_ENABLED=true
+CONFIDENCE_REJECT_THRESHOLD=0.4
+CONFIDENCE_WARN_THRESHOLD=0.6
+
+# Generation A/B (Phase I)
+DEFAULT_GENERATION_MODE=pipeline
+
+# Reranker (CPU)
+RERANKER_BACKEND=local
+RERANKER_DEVICE=cpu
+RERANKER_MODEL=cross-encoder/ms-marco-MiniLM-L-6-v2
+CHUNK_CHILD_MAX_TOKENS=220

package/knowledge_base/config/__init__.py

@@ -0,0 +1,5 @@
+"""Application configuration."""
+
+from knowledge_base.config.settings import Config, cfg
+
+__all__ = ["Config", "cfg"]