igel-qe-core 1.0.3 → 1.0.7

package/{knowledge_base → src}/db/igel_schema.py

@@ -10,8 +10,8 @@ Manages tables for the AI Platform Layer:
 from __future__ import annotations
 
 import logging
-from knowledge_base.db.client import get_conn
-from knowledge_base.config import cfg
+from src.db.client import get_conn
+from src.config import cfg
 
 logger = logging.getLogger(__name__)
 
@@ -122,6 +122,23 @@ CREATE TABLE IF NOT EXISTS igel_asset_mappings (
     created_at      TIMESTAMP DEFAULT NOW()
 );
 
+-- ==========================================
+-- 4b. Context Intelligence Registry
+-- ==========================================
+CREATE TABLE IF NOT EXISTS igel_context_registry (
+    id               UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    context_path     TEXT UNIQUE NOT NULL,
+    folder_path      TEXT NOT NULL,
+    content          TEXT NOT NULL,
+    key_assets       JSONB DEFAULT '[]'::jsonb,
+    dependency_graph JSONB DEFAULT '[]'::jsonb,
+    metadata         JSONB DEFAULT '{{}}'::jsonb,
+    source_hash      TEXT,
+    updated_at       TIMESTAMP DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS igel_context_registry_folder_idx ON igel_context_registry(folder_path);
+
 -- ==========================================
 -- 5. Granular Human Feedback
 -- ==========================================
@@ -138,7 +155,7 @@ CREATE TABLE IF NOT EXISTS igel_granular_feedback (
 """
 
 def ensure_igel_tables():
-    """Create IGEL enterprise tables if they don't exist."""
+    """Create IGEL enterprise tables and run all schema migrations."""
     try:
         with get_conn() as conn:
             with conn.cursor() as cur:
@@ -146,5 +163,13 @@ def ensure_igel_tables():
             conn.commit()
         logger.info("IGEL Enterprise DB schema verified.")
     except Exception as e:
-        logger.error(f"Failed to create IGEL schema: {{e}}")
+        logger.error(f"Failed to create IGEL schema: {e}")
+        raise
+
+    # Run incremental migrations (idempotent, append-only)
+    try:
+        from src.db.migrations import run_all_migrations
+        run_all_migrations()
+    except Exception as e:
+        logger.error(f"Schema migrations failed: {e}")
         raise

package/{knowledge_base → src}/db/kg_introspect.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass
 
-from knowledge_base.db.client import get_conn
+from src.db.client import get_conn
 
 logger = logging.getLogger(__name__)
 

package/src/db/migrations.py

@@ -0,0 +1,237 @@
+"""Idempotent schema migrations for the IGEL QE Agent.
+
+Design rules:
+  - Every statement is safe to run multiple times (IF NOT EXISTS guards).
+  - No destructive operation (DROP COLUMN) runs without an archive step first.
+  - Called from ensure_igel_tables() on every startup via run_all_migrations().
+  - Structured log output only; caller controls verbosity.
+
+Migration list (append-only — never edit existing entries):
+  M001 — Archive igel_automation_scripts.code_content, then drop it; Git is source of truth.
+  M002 — Add version/parent_id/created_by/source lineage columns.
+  M003 — Add script_version + commit_hash to igel_automation_scripts.
+  M004 — Create igel_generation_history table.
+  M005 — Ensure connector_sync_state table exists.
+  M006 — Create first-class business rule registry and linkage tables.
+
+Legacy Alembic helper kept below for repos that still use alembic.ini.
+"""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from src.db.client import get_conn
+
+logger = logging.getLogger(__name__)
+
+
+# ── schema helpers ─────────────────────────────────────────────────────────────
+
+def _column_exists(cur, table: str, column: str) -> bool:
+    cur.execute(
+        "SELECT 1 FROM information_schema.columns WHERE table_name=%s AND column_name=%s",
+        (table, column),
+    )
+    return cur.fetchone() is not None
+
+
+def _table_exists(cur, table: str) -> bool:
+    cur.execute(
+        "SELECT 1 FROM information_schema.tables WHERE table_name=%s",
+        (table,),
+    )
+    return cur.fetchone() is not None
+
+
+def _count(cur, table: str) -> int:
+    cur.execute(f"SELECT COUNT(*) FROM {table}")
+    row = cur.fetchone()
+    return row[0] if row else 0
+
+
+# ── individual migrations ──────────────────────────────────────────────────────
+
+def _m001_archive_and_drop_code_content(cur) -> None:
+    """Archive igel_automation_scripts.code_content before dropping.
+
+    Git/Bitbucket is source of truth for script code going forward.
+    The archive table preserves all pre-migration rows so nothing is silently lost.
+    """
+    if not _table_exists(cur, "igel_automation_scripts"):
+        return
+    if not _table_exists(cur, "igel_automation_scripts_archive"):
+        cur.execute("""
+            CREATE TABLE igel_automation_scripts_archive AS
+            SELECT * FROM igel_automation_scripts
+            WHERE code_content IS NOT NULL
+        """)
+        archived = _count(cur, "igel_automation_scripts_archive")
+        logger.info("M001: Created igel_automation_scripts_archive (%d rows)", archived)
+    if _column_exists(cur, "igel_automation_scripts", "code_content"):
+        cur.execute("ALTER TABLE igel_automation_scripts DROP COLUMN code_content")
+        logger.info("M001: Dropped code_content from igel_automation_scripts")
+
+
+def _m002_lineage_columns(cur) -> None:
+    """Add version / parent_id / created_by / source lineage columns.
+
+    Regeneration contract (enforced at application layer):
+      - Re-generate always inserts a NEW row: version = prev + 1, parent_id = prev.id.
+      - Existing rows are NEVER mutated.
+    """
+    for table in ("igel_requirements", "igel_generated_testcases"):
+        if not _table_exists(cur, table):
+            continue
+        for col, defn in [
+            ("version",    "INT NOT NULL DEFAULT 1"),
+            ("parent_id",  f"UUID REFERENCES {table}(id) ON DELETE SET NULL"),
+            ("created_by", "TEXT"),
+            ("source",     "TEXT DEFAULT 'jira'"),
+        ]:
+            if not _column_exists(cur, table, col):
+                cur.execute(f"ALTER TABLE {table} ADD COLUMN IF NOT EXISTS {col} {defn}")
+                logger.info("M002: Added %s.%s", table, col)
+
+
+def _m003_script_metadata_columns(cur) -> None:
+    """Add script_version + commit_hash to igel_automation_scripts."""
+    if not _table_exists(cur, "igel_automation_scripts"):
+        return
+    for col, defn in [
+        ("script_version", "INT NOT NULL DEFAULT 1"),
+        ("commit_hash",    "TEXT"),
+    ]:
+        if not _column_exists(cur, "igel_automation_scripts", col):
+            cur.execute(f"ALTER TABLE igel_automation_scripts ADD COLUMN IF NOT EXISTS {col} {defn}")
+            logger.info("M003: Added igel_automation_scripts.%s", col)
+
+
+def _m004_generation_history(cur) -> None:
+    """Create igel_generation_history — one row per LLM call with routing metadata."""
+    cur.execute("""
+        CREATE TABLE IF NOT EXISTS igel_generation_history (
+            id            UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+            jira_key      TEXT,
+            action        TEXT NOT NULL,
+            model_used    TEXT NOT NULL,
+            task_type     TEXT,
+            tokens_in     INT,
+            tokens_out    INT,
+            duration_ms   INT,
+            quality_score FLOAT,
+            routed_by     TEXT DEFAULT 'config',
+            created_at    TIMESTAMPTZ DEFAULT NOW()
+        )
+    """)
+    for idx, col in [("gen_history_jira_idx", "jira_key"), ("gen_history_action_idx", "action"), ("gen_history_model_idx", "model_used")]:
+        cur.execute(f"CREATE INDEX IF NOT EXISTS {idx} ON igel_generation_history({col})")
+    logger.info("M004: Ensured igel_generation_history")
+
+
+def _m005_connector_sync_state(cur) -> None:
+    """Ensure connector_sync_state exists (may also be created by connector_sync module)."""
+    cur.execute("""
+        CREATE TABLE IF NOT EXISTS connector_sync_state (
+            source         TEXT PRIMARY KEY,
+            last_synced_at TIMESTAMPTZ,
+            status         TEXT DEFAULT 'never_synced',
+            updated_at     TIMESTAMPTZ DEFAULT NOW()
+        )
+    """)
+    logger.info("M005: Ensured connector_sync_state")
+
+
+def _m006_business_rule_registry(cur) -> None:
+    """Create first-class business rule registry and traceability links."""
+    cur.execute("""
+        CREATE TABLE IF NOT EXISTS igel_business_rule_registry (
+            id                  UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+            rule_key            TEXT UNIQUE,
+            rule_text           TEXT NOT NULL,
+            source_type         TEXT,
+            source_ref          TEXT,
+            confidence          FLOAT,
+            status              TEXT DEFAULT 'active',
+            version             INT NOT NULL DEFAULT 1,
+            created_at          TIMESTAMPTZ DEFAULT NOW(),
+            updated_at          TIMESTAMPTZ DEFAULT NOW()
+        )
+    """)
+
+    cur.execute("""
+        CREATE TABLE IF NOT EXISTS igel_rule_testcase_map (
+            id                  UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+            business_rule_id    UUID NOT NULL REFERENCES igel_business_rule_registry(id) ON DELETE CASCADE,
+            testcase_id         UUID NOT NULL REFERENCES igel_generated_testcases(id) ON DELETE CASCADE,
+            created_at          TIMESTAMPTZ DEFAULT NOW(),
+            UNIQUE(business_rule_id, testcase_id)
+        )
+    """)
+
+    cur.execute("""
+        CREATE TABLE IF NOT EXISTS igel_rule_script_map (
+            id                  UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+            business_rule_id    UUID NOT NULL REFERENCES igel_business_rule_registry(id) ON DELETE CASCADE,
+            script_id           UUID NOT NULL REFERENCES igel_automation_scripts(id) ON DELETE CASCADE,
+            created_at          TIMESTAMPTZ DEFAULT NOW(),
+            UNIQUE(business_rule_id, script_id)
+        )
+    """)
+
+    for idx, table, col in [
+        ("rule_registry_key_idx", "igel_business_rule_registry", "rule_key"),
+        ("rule_registry_source_idx", "igel_business_rule_registry", "source_ref"),
+        ("rule_tc_rule_idx", "igel_rule_testcase_map", "business_rule_id"),
+        ("rule_script_rule_idx", "igel_rule_script_map", "business_rule_id"),
+    ]:
+        cur.execute(f"CREATE INDEX IF NOT EXISTS {idx} ON {table}({col})")
+
+    logger.info("M006: Ensured business rule registry and link maps")
+
+
+# ── public entry point ─────────────────────────────────────────────────────────
+
+def run_all_migrations() -> None:
+    """Run all migrations in sequence. Safe to call on every startup."""
+    steps = [
+        ("M001", _m001_archive_and_drop_code_content),
+        ("M002", _m002_lineage_columns),
+        ("M003", _m003_script_metadata_columns),
+        ("M004", _m004_generation_history),
+        ("M005", _m005_connector_sync_state),
+        ("M006", _m006_business_rule_registry),
+    ]
+    try:
+        with get_conn() as conn:
+            with conn.cursor() as cur:
+                for name, fn in steps:
+                    try:
+                        fn(cur)
+                    except Exception as exc:
+                        logger.error("Migration %s failed: %s", name, exc)
+                        raise
+            conn.commit()
+        logger.info("All migrations complete")
+    except Exception as exc:
+        logger.error("Migration run aborted: %s", exc)
+        raise
+
+
+# ── legacy Alembic helper (kept for repos using alembic.ini) ──────────────────
+
+def run_migrations(revision: str = "head") -> None:
+    """Apply Alembic migrations up to revision (default: head)."""
+    try:
+        from alembic import command
+        from alembic.config import Config
+        alembic_ini = Path(__file__).resolve().parent.parent.parent / "alembic.ini"
+        if not alembic_ini.exists():
+            logger.warning("alembic.ini not found at %s — skipping Alembic migrations", alembic_ini)
+            return
+        alembic_cfg = Config(str(alembic_ini))
+        command.upgrade(alembic_cfg, revision)
+        logger.info("Alembic migrations applied: %s", revision)
+    except ImportError:
+        logger.debug("Alembic not installed — skipping")
+

package/{knowledge_base → src}/db/schema.py

@@ -9,8 +9,8 @@ Tables:
   eval_results     - per-query evaluation results (Phase 0)
 """
 from __future__ import annotations
-from knowledge_base.db.client import get_conn
-from knowledge_base.config import cfg
+from src.db.client import get_conn
+from src.config import cfg
 
 _SCHEMA_SQL = f"""
 -- Enable required extensions
@@ -189,7 +189,7 @@ def ensure_knowledge_graph_tables() -> None:
             )
             cur.execute(_KG_INDEX_SQL)
     try:
-        from knowledge_base.db.kg_introspect import clear_kg_layout_cache
+        from src.db.kg_introspect import clear_kg_layout_cache
         clear_kg_layout_cache()
     except Exception:
         pass
@@ -200,7 +200,7 @@ def ensure_knowledge_graph_tables() -> None:
 def create_schema() -> None:
     """Ensure schema via Alembic migrations, with legacy DDL fallback."""
     try:
-        from knowledge_base.db.migrations import run_migrations
+        from src.db.migrations import run_migrations
         run_migrations("head")
     except Exception as exc:
         import logging
@@ -211,7 +211,7 @@ def create_schema() -> None:
             with conn.cursor() as cur:
                 cur.execute(_SCHEMA_SQL)
         ensure_knowledge_graph_tables()
-        from knowledge_base.db.feedback_schema import ensure_feedback_tables
+        from src.db.feedback_schema import ensure_feedback_tables
         ensure_feedback_tables()
     print("  Schema ready (Alembic + kb_documents, kb_parent_chunks, kb_chunks, knowledge_graph_*)")
 
@@ -416,7 +416,7 @@ def ingest_document_atomic(
     Atomically insert document + parent + child chunks in one transaction.
     Returns (doc_id, parent_count, chunk_count, validation_skipped).
     """
-    from knowledge_base.db.client import get_transaction
+    from src.db.client import get_transaction
 
     validation_skipped = 0
     with get_transaction() as conn:

package/{knowledge_base → src}/deploy/Dockerfile

@@ -5,10 +5,10 @@ WORKDIR /app
 RUN apt-get update && apt-get install -y --no-install-recommends curl \
     && rm -rf /var/lib/apt/lists/*
 
-COPY knowledge_base/ knowledge_base/
+COPY src/ src/
 COPY alembic.ini alembic.ini
 
-COPY knowledge_base/deploy/requirements.txt requirements.txt
+COPY src/deploy/requirements.txt requirements.txt
 RUN pip install --no-cache-dir -r requirements.txt
 
 ENV PYTHONPATH=/app
@@ -20,4 +20,4 @@ EXPOSE 8000
 HEALTHCHECK --interval=30s --timeout=10s --start-period=120s --retries=3 \
   CMD curl -f http://localhost:8000/health || exit 1
 
-CMD ["uvicorn", "knowledge_base.api.server:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "2"]
+CMD ["uvicorn", "src.api.server:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "2"]

package/{knowledge_base → src}/deploy/feedback_automation.sh

@@ -4,9 +4,9 @@ set -euo pipefail
 cd "$(dirname "$0")/../.."
 export PYTHONPATH="${PWD}:${PYTHONPATH:-}"
 /usr/bin/python3.8 - <<'PY'
-from knowledge_base.db.client import init_pool, close_pool
-from knowledge_base.feedback.applier import apply_pending_promotions
-from knowledge_base.memory.ingest_memory import ingest_curated_feedback
+from src.db.client import init_pool, close_pool
+from src.feedback.applier import apply_pending_promotions
+from src.memory.ingest_memory import ingest_curated_feedback
 
 init_pool()
 results = apply_pending_promotions(limit=50)

package/{knowledge_base → src}/deploy/firecrawl-docker.sh

@@ -24,7 +24,7 @@ else
 fi
 
 cd "$INSTALL_DIR"
-cat > .env << EOF
+cat > firecrawl-runtime.conf << EOF
 PORT=${PORT}
 HOST=0.0.0.0
 USE_DB_AUTHENTICATION=false
@@ -32,14 +32,14 @@ BULL_AUTH_KEY=igel-kb-local
 EOF
 
 echo "Building and starting Firecrawl on port ${PORT} ..."
-docker compose build
-docker compose up -d
+docker compose --env-file firecrawl-runtime.conf build
+docker compose --env-file firecrawl-runtime.conf up -d
 
 echo "Waiting for Firecrawl health ..."
 for i in $(seq 1 30); do
   if curl -sf "http://127.0.0.1:${PORT}/" >/dev/null 2>&1; then
     echo "Firecrawl is up at http://127.0.0.1:${PORT}"
-    echo "Set in knowledge_base/config/.env:"
+    echo "Set in your runtime environment:"
     echo "  FIRECRAWL_BASE_URL=http://127.0.0.1:${PORT}"
     exit 0
   fi

package/{knowledge_base → src}/deploy/igel-testgen.service

@@ -15,9 +15,9 @@ Wants=postgresql.service
 Type=simple
 User=root
 WorkingDirectory=/root/IGEL/IGEL_Automation_Claude/IGEL/innominds
-EnvironmentFile=-/root/IGEL/IGEL_Automation_Claude/IGEL/innominds/knowledge_base/config/.env
+EnvironmentFile=-/etc/igel-testgen/runtime.conf
 ExecStartPre=/bin/bash -c 'until pg_isready -h ${DB_HOST:-localhost} -p ${DB_PORT:-5432}; do sleep 2; done'
-ExecStart=/bin/bash knowledge_base/deploy/run_server.sh
+ExecStart=/bin/bash src/deploy/run_server.sh
 Restart=always
 RestartSec=5
 TimeoutStopSec=30

package/{knowledge_base → src}/deploy/install_reranker.sh

@@ -49,7 +49,7 @@ elapsed = perf_counter() - t0
 print(f"OK — MiniLM reranked {len(pairs)} pairs in {elapsed:.2f}s, top score={float(max(scores)):.4f}")
 PYEOF
 
-echo "Done. Set RERANKER_BACKEND=local in config/.env (default)."
+echo "Done. Ensure RERANKER_BACKEND=local is set in your runtime environment (default)."
 
 echo "Installing free web search (DuckDuckGo ddgs)..."
 # shellcheck disable=SC2086

package/{knowledge_base → src}/deploy/requirements.txt

@@ -26,13 +26,12 @@ tiktoken>=0.5.0
 # Config / Utils
 pydantic>=2.7.0
 eval_type_backport>=0.2.0; python_version < "3.10"
-python-dotenv==1.0.1
 tenacity==9.0.0
 rich==13.9.4
 
 # OSS local reranker (CrossEncoder — free, runs on CPU/GPU)
 # Default model: BAAI/bge-reranker-v2-m3 (multilingual, best open-source for IGEL DE/EN)
-# Install: bash knowledge_base/deploy/install_reranker.sh
+# Install: bash src/deploy/install_reranker.sh
 jinja2>=3.1.2,<3.2
 MarkupSafe>=2.1.0,<3
 tokenizers>=0.20,<0.21

package/{knowledge_base → src}/deploy/run_server.sh

@@ -28,7 +28,7 @@ echo "  Python:      $($PYTHON --version 2>&1)"
 echo "  Swagger UI:  http://${HOST}:${PORT}/docs"
 echo ""
 
-exec "$PYTHON" -m uvicorn knowledge_base.api.server:app \
+exec "$PYTHON" -m uvicorn src.api.server:app \
     --host "$HOST" \
     --port "$PORT" \
     --workers "$WORKERS" \

package/{knowledge_base → src}/docs/TEST_GENERATION_GUIDE.md

@@ -1,6 +1,6 @@
 # IGEL test case generation — operator guide
 
-This document is for anyone running the RAG-powered test generator in `knowledge_base/`. The CLI (`python -m knowledge_base.cli.generate`) **always retrieves context from PostgreSQL** (vector + full-text hybrid search + knowledge graph) before calling the LLM. Outputs are only as accurate as the **ingested documentation** in the KB.
+This document is for anyone running the RAG-powered test generator in `src/`. The CLI (`python -m src.cli.generate`) **always retrieves context from PostgreSQL** (vector + full-text hybrid search + knowledge graph) before calling the LLM. Outputs are only as accurate as the **ingested documentation** in the KB.
 
 ## How it works (short)
 
@@ -30,18 +30,18 @@ Step-fidelity checks run after generation; warnings are returned when counts or
 
 ## Prerequisites
 
-- PostgreSQL reachable with the KB populated (`knowledge_base/.env`, see `config.py` / `db/client.py`).
-- Documents ingested (`python -m knowledge_base.ingestion.ingest` — this **also populates the Knowledge Graph automatically**).
+- PostgreSQL reachable with the KB populated (configured via runtime environment variables).
+- Documents ingested (`python -m src.ingestion.ingest` — this **also populates the Knowledge Graph automatically**).
 - Azure OpenAI credentials configured for the LLM and embeddings.
 
 ## Ingestion (single command — RAG + KG in sync)
 
 ```bash
-python -m knowledge_base.ingestion.ingest               # Ingest all new docs + build KG
-python -m knowledge_base.ingestion.ingest --file x.pdf  # Single file (KG extracted for that doc)
-python -m knowledge_base.ingestion.ingest --reset       # Full re-ingest from scratch
-python -m knowledge_base.ingestion.ingest --stats       # Show document, chunk, KG, and image counts
-python -m knowledge_base.ingestion.ingest --skip-kg     # Text + embeddings only (rare; skips KG)
+python -m src.ingestion.ingest               # Ingest all new docs + build KG
+python -m src.ingestion.ingest --file x.pdf  # Single file (KG extracted for that doc)
+python -m src.ingestion.ingest --reset       # Full re-ingest from scratch
+python -m src.ingestion.ingest --stats       # Show document, chunk, KG, and image counts
+python -m src.ingestion.ingest --skip-kg     # Text + embeddings only (rare; skips KG)
 ```
 
 **No separate KG step is needed.** Each ingested document automatically has its registry keys (`app.*`), TC Setup paths, and feature nodes extracted into `knowledge_graph_nodes` / `knowledge_graph_edges`. The `--stats` output shows `kg_nodes`, `kg_edges`, and `kg_orphan_parents` (parents with no KG entity — ideally 0 or low).
@@ -49,7 +49,7 @@ python -m knowledge_base.ingestion.ingest --skip-kg     # Text + embeddings only
 If you ever need a backfill (e.g. after upgrading the KG extractor logic), you can still run the standalone extractor:
 
 ```bash
-python -m knowledge_base.ingestion.kg_extractor
+python -m src.ingestion.kg_extractor
 ```
 
 ## Always-running API service (recommended)
@@ -60,14 +60,14 @@ The server runs on **192.168.204.65:8000** and responds to any user query — no
 
 ```bash
 # Option 1: systemd (starts on boot, restarts on crash)
-sudo cp knowledge_base/igel-testgen.service /etc/systemd/system/
+sudo cp src/igel-testgen.service /etc/systemd/system/
 sudo systemctl daemon-reload
 sudo systemctl enable igel-testgen
 sudo systemctl start igel-testgen
 
 # Option 2: directly
 cd /root/IGEL/IGEL_Automation_Claude/IGEL/innominds
-./knowledge_base/run_server.sh
+./src/run_server.sh
 ```
 
 ### API endpoints
@@ -111,10 +111,10 @@ Response includes `markdown_content`, `python_content`, `traceability_table`, an
 From the `innominds` package root (where `knowledge_base` is importable):
 
 ```bash
-python -m knowledge_base.cli.generate "Entra ID SSO login validation" --format both
-python -m knowledge_base.cli.generate "UMS profile assignment" --product UMS --top-k 10
-python -m knowledge_base.cli.generate "Chromium policies QCAPPS-429" --source-tc-file path/to/jira_export.csv --detail-level detailed
-python -m knowledge_base.cli.generate --interactive
+python -m src.cli.generate "Entra ID SSO login validation" --format both
+python -m src.cli.generate "UMS profile assignment" --product UMS --top-k 10
+python -m src.cli.generate "Chromium policies QCAPPS-429" --source-tc-file path/to/jira_export.csv --detail-level detailed
+python -m src.cli.generate --interactive
 ```
 
 - **`--product`**: narrows search (UMS, IGEL OS, COSMOS, etc.); if nothing matches, retrieval retries without the filter.

package/{knowledge_base → src}/embeddings/azure_embedder.py

@@ -12,7 +12,7 @@ import logging
 from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
 
 from openai import AzureOpenAI, RateLimitError, APIConnectionError, APITimeoutError
-from knowledge_base.config import cfg
+from src.config import cfg
 
 logger = logging.getLogger(__name__)
 
@@ -94,6 +94,15 @@ def embed_single(text: str) -> list[float]:
     return embed_texts([text])[0]
 
 
+def get_embedding(text: str) -> str:
+    """Backward-compatible wrapper returning a pgvector literal string.
+
+    Some legacy indexing paths expect a serialized vector value that can be
+    passed directly to SQL as ``%s::vector``.
+    """
+    return format_for_pgvector(embed_single(text))
+
+
 def format_for_pgvector(embedding: list[float]) -> str:
     """Format embedding as PostgreSQL vector literal string."""
     return "[" + ",".join(f"{v:.8f}" for v in embedding) + "]"

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

@@ -10,7 +10,7 @@ Provides 5-dimensional scoring for test case generation quality:
 """
 from __future__ import annotations
 
-from knowledge_base.eval.scorers import (
+from src.eval.scorers import (
     RetrievalScorer,
     DomainScorer,
     StructuralScorer,
@@ -18,8 +18,8 @@ from knowledge_base.eval.scorers import (
     PublishScorer,
     EvaluationResult,
 )
-from knowledge_base.eval.harness import EvaluationHarness
-from knowledge_base.eval.baseline import BaselineManager
+from src.eval.harness import EvaluationHarness
+from src.eval.baseline import BaselineManager
 
 __all__ = [
     "RetrievalScorer",

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

@@ -2,9 +2,9 @@
 CLI entry point for running evaluations.
 
 Usage:
-    python -m knowledge_base.eval --baseline --queries queries_50.json
-    python -m knowledge_base.eval --run my_run --queries queries_50.json
-    python -m knowledge_base.eval --compare baseline my_run
+    python -m src.eval --baseline --queries queries_50.json
+    python -m src.eval --run my_run --queries queries_50.json
+    python -m src.eval --compare baseline my_run
 """
 import argparse
 import sys
@@ -13,8 +13,8 @@ from pathlib import Path
 # Add parent directory to path to allow imports
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
-from knowledge_base.eval.baseline import BaselineManager
-from knowledge_base.eval.harness import EvaluationHarness
+from src.eval.baseline import BaselineManager
+from src.eval.harness import EvaluationHarness
 
 
 def main():
@@ -48,7 +48,7 @@ def main():
     parser.add_argument(
         "--queries",
         type=str,
-        default="knowledge_base/eval/queries_50.json",
+        default="src/eval/queries_50.json",
         help="Path to query file (default: queries_50.json)",
     )
     parser.add_argument(
@@ -89,7 +89,7 @@ def main():
         current = baseline_mgr.load_baseline(current_name)
         
         # Create mock harness run for comparison
-        from knowledge_base.eval.harness import HarnessRun
+        from src.eval.harness import HarnessRun
         current_run = HarnessRun(
             run_id=current.run_id,
             timestamp=current.timestamp,