igel-qe-core 1.0.3 → 1.0.7

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

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

package/src/config/policy_config.py

@@ -0,0 +1,85 @@
+"""Loads policy_rules.yaml at startup. Singleton via get_policy()."""
+from __future__ import annotations
+import yaml
+from dataclasses import dataclass, field
+from pathlib import Path
+
+_CONFIG_PATH = Path(__file__).parent / "policy_rules.yaml"
+
+@dataclass(frozen=True)
+class ConfidenceDimensions:
+    requirement_clarity: float = 0.25
+    evidence_quality: float = 0.20
+    business_rule_coverage: float = 0.15
+    traceability_coverage: float = 0.15
+    scenario_coverage: float = 0.15
+    structural_quality: float = 0.10
+
+@dataclass(frozen=True)
+class ConfidenceBands:
+    auto_approved: float = 0.80
+    qa_review: float = 0.60
+    sme_required: float = 0.40
+
+@dataclass(frozen=True)
+class PolicyConfig:
+    version: str = "1.0.0"
+    igel_os_version: str = "OS12"
+    max_prompt_chars: int = 30000
+    blocked_patterns: tuple[str, ...] = ()
+    confidence_dimensions: ConfidenceDimensions = field(default_factory=ConfidenceDimensions)
+    confidence_bands: ConfidenceBands = field(default_factory=ConfidenceBands)
+    top_k_chunks: int = 10
+    max_context_tokens: int = 8000
+    test_case_folder: str = "innominds/testcases"
+    automation_folder: str = "tests"
+
+_policy: PolicyConfig | None = None
+
+def get_policy() -> PolicyConfig:
+    global _policy
+    if _policy is None:
+        _policy = _load_policy()
+    return _policy
+
+def _load_policy() -> PolicyConfig:
+    if not _CONFIG_PATH.exists():
+        return PolicyConfig()
+    
+    with open(_CONFIG_PATH) as f:
+        raw = yaml.safe_load(f)
+    
+    prompt_cfg = raw.get("prompt_policy", {})
+    conf_cfg = raw.get("confidence", {})
+    conf_dims = conf_cfg.get("dimensions", {})
+    conf_bands = conf_cfg.get("bands", {})
+    ctx_cfg = raw.get("context_engine", {})
+    folder_cfg = raw.get("folder_standards", {})
+    
+    dims = ConfidenceDimensions(
+        requirement_clarity=conf_dims.get("requirement_clarity", 0.25),
+        evidence_quality=conf_dims.get("evidence_quality", 0.20),
+        business_rule_coverage=conf_dims.get("business_rule_coverage", 0.15),
+        traceability_coverage=conf_dims.get("traceability_coverage", 0.15),
+        scenario_coverage=conf_dims.get("scenario_coverage", 0.15),
+        structural_quality=conf_dims.get("structural_quality", 0.10)
+    )
+    
+    bands = ConfidenceBands(
+        auto_approved=conf_bands.get("auto_approved", 0.80),
+        qa_review=conf_bands.get("qa_review", 0.60),
+        sme_required=conf_bands.get("sme_required", 0.40)
+    )
+    
+    return PolicyConfig(
+        version=raw.get("version", "1.0.0"),
+        igel_os_version=raw.get("platform", {}).get("igel_os_version", "OS12"),
+        max_prompt_chars=prompt_cfg.get("max_prompt_chars", 30000),
+        blocked_patterns=tuple(prompt_cfg.get("blocked_patterns", [])),
+        confidence_dimensions=dims,
+        confidence_bands=bands,
+        top_k_chunks=ctx_cfg.get("top_k_chunks", 10),
+        max_context_tokens=ctx_cfg.get("max_context_tokens", 8000),
+        test_case_folder=folder_cfg.get("test_cases", "innominds/testcases"),
+        automation_folder=folder_cfg.get("automation_scripts", "tests")
+    )

package/src/config/policy_rules.yaml

@@ -0,0 +1,50 @@
+version: "1.0.0"
+platform:
+  igel_os_version: "OS12"    # OS12 only. Never reference OS11.
+
+prompt_policy:
+  max_prompt_chars: 30000
+  blocked_patterns:
+    - "ignore all previous instructions"
+    - "reveal system prompt"
+    - "BEGIN PRIVATE KEY"
+
+confidence:
+  dimensions:
+    requirement_clarity: 0.25
+    evidence_quality: 0.20
+    business_rule_coverage: 0.15
+    traceability_coverage: 0.15
+    scenario_coverage: 0.15
+    structural_quality: 0.10
+  bands:
+    auto_approved: 0.80       # >= 80% → auto-approved, ready for QA review
+    qa_review: 0.60           # 60–79% → QA review recommended
+    sme_required: 0.40        # 40–59% → SME review required
+    # < 40% → rejected, not persisted
+
+approval:
+  existing_code_requires_user_approval: true
+
+context_engine:
+  top_k_chunks: 10
+  max_context_tokens: 8000
+  source_priority:
+    - jira
+    - xray
+    - confluence
+    - postgres_kb
+    - igel_os12_docs
+    - igel_community_docs
+
+folder_standards:
+  test_cases: "innominds/testcases"
+  automation_scripts: "tests"
+
+security:
+  never_expose:
+    - api_keys
+    - tokens
+    - passwords
+    - credentials
+    - internal_secrets

package/{knowledge_base → src}/config/settings.py

@@ -3,11 +3,6 @@ from __future__ import annotations
 import os
 from pathlib import Path
 
-from dotenv import load_dotenv
-
-_ENV_PATH = Path(__file__).parent / ".env"
-load_dotenv(_ENV_PATH)
-
 
 def _truthy(raw: str | None, default: bool = False) -> bool:
     if raw is None or raw == "":
@@ -226,10 +221,54 @@ class Config:
     CONFLUENCE_USERNAME: str = os.getenv("CONFLUENCE_USERNAME", "")
     CONFLUENCE_API_TOKEN: str = os.getenv("CONFLUENCE_API_TOKEN", "")
 
+    # Jira OAuth2 client credentials (Atlassian OAuth 2.0 app)
+    JIRA_CLIENT_ID: str = os.getenv("JIRA_CLIENT_ID", "")
+    JIRA_CLIENT_SECRET: str = os.getenv("JIRA_CLIENT_SECRET", "")
+    JIRA_OAUTH_TOKEN_URL: str = os.getenv("JIRA_OAUTH_TOKEN_URL", "https://auth.atlassian.com/oauth/token")
+
+    # Confluence OAuth2 client credentials
+    CONFLUENCE_OAUTH_TOKEN: str = os.getenv("CONFLUENCE_OAUTH_TOKEN", "")
+    CONFLUENCE_CLIENT_ID: str = os.getenv("CONFLUENCE_CLIENT_ID", "")
+    CONFLUENCE_CLIENT_SECRET: str = os.getenv("CONFLUENCE_CLIENT_SECRET", "")
+
+    # Bitbucket
     BITBUCKET_ENABLED: bool = _truthy(os.getenv("BITBUCKET_ENABLED"), False)
+    BITBUCKET_URL: str = os.getenv("BITBUCKET_URL", "https://bitbucket.org")
+    BITBUCKET_WORKSPACE: str = os.getenv("BITBUCKET_WORKSPACE", "")
+    BITBUCKET_REPO_SLUG: str = os.getenv("BITBUCKET_REPO_SLUG", "")
+    BITBUCKET_USERNAME: str = os.getenv("BITBUCKET_USERNAME", "")
+    BITBUCKET_APP_PASSWORD: str = os.getenv("BITBUCKET_APP_PASSWORD", "")
+    BITBUCKET_ACCESS_TOKEN: str = os.getenv("BITBUCKET_ACCESS_TOKEN", "")
+    BITBUCKET_CLIENT_ID: str = os.getenv("BITBUCKET_CLIENT_ID", "")
+    BITBUCKET_CLIENT_SECRET: str = os.getenv("BITBUCKET_CLIENT_SECRET", "")
+    BITBUCKET_WEBHOOK_SECRET: str = os.getenv("BITBUCKET_WEBHOOK_SECRET", "")
+    BITBUCKET_REPO_PATH: str = os.getenv("BITBUCKET_REPO_PATH", ".")
+
+    # Xray (Cloud: client_id/secret; Server/DC: api_token)
+    XRAY_ENABLED: bool = _truthy(os.getenv("XRAY_ENABLED"), False)
+    XRAY_CLIENT_ID: str = os.getenv("XRAY_CLIENT_ID", "")
+    XRAY_CLIENT_SECRET: str = os.getenv("XRAY_CLIENT_SECRET", "")
+    XRAY_API_TOKEN: str = os.getenv("XRAY_API_TOKEN", "")
+    XRAY_CLOUD_AUTH_URL: str = os.getenv(
+        "XRAY_CLOUD_AUTH_URL", "https://xray.cloud.getxray.app/api/v2/authenticate"
+    )
+    XRAY_CLOUD_BASE_URL: str = os.getenv(
+        "XRAY_CLOUD_BASE_URL", "https://xray.cloud.getxray.app/api/v2"
+    )
+
     TEAMCITY_ENABLED: bool = _truthy(os.getenv("TEAMCITY_ENABLED"), False)
+    TEAMCITY_URL: str = os.getenv("TEAMCITY_URL", "")
+    TEAMCITY_TOKEN: str = os.getenv("TEAMCITY_TOKEN", "")
+
     TESTRAIL_ENABLED: bool = _truthy(os.getenv("TESTRAIL_ENABLED"), False)
+    TESTRAIL_URL: str = os.getenv("TESTRAIL_URL", "")
+    TESTRAIL_USERNAME: str = os.getenv("TESTRAIL_USERNAME", "")
+    TESTRAIL_API_KEY: str = os.getenv("TESTRAIL_API_KEY", "")
+
     SERVICENOW_ENABLED: bool = _truthy(os.getenv("SERVICENOW_ENABLED"), False)
+    SERVICENOW_URL: str = os.getenv("SERVICENOW_URL", "")
+    SERVICENOW_USERNAME: str = os.getenv("SERVICENOW_USERNAME", "")
+    SERVICENOW_PASSWORD: str = os.getenv("SERVICENOW_PASSWORD", "")
 
     # ── Operational memory (Phase 4) ─────────────────────────────────────────
     COGNEE_ENABLED: bool = _truthy(os.getenv("COGNEE_ENABLED"), True)
@@ -262,9 +301,15 @@ class Config:
     # ── Generation modes (Phase I) ───────────────────────────────────────────
     DEFAULT_GENERATION_MODE: str = os.getenv("DEFAULT_GENERATION_MODE", "pipeline")
 
+    # ── V2 Orchestrator and governance flags ─────────────────────────────────
+    V2_ORCHESTRATOR_ENABLED: bool = _truthy(os.getenv("V2_ORCHESTRATOR_ENABLED"), False)
+    V2_GOVERNANCE_ENFORCED: bool = _truthy(os.getenv("V2_GOVERNANCE_ENFORCED"), False)
+    V2_QUESTION_ENGINE_ENABLED: bool = _truthy(os.getenv("V2_QUESTION_ENGINE_ENABLED"), False)
+    V2_APPROVAL_MANAGER_ENABLED: bool = _truthy(os.getenv("V2_APPROVAL_MANAGER_ENABLED"), False)
+
     @property
     def api_key_map(self) -> dict[str, str]:
-        from knowledge_base.core.request_context import parse_api_keys
+        from src.core.request_context import parse_api_keys
         keys = parse_api_keys(self.API_KEYS)
         if self.API_KEY and self.API_KEY not in keys:
             keys[self.API_KEY] = "admin"

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

@@ -1,5 +1,5 @@
 """Connector package — Phase 8 (stubbed, config-driven)."""
 
-from knowledge_base.connectors.base import BaseConnector
+from src.connectors.base import BaseConnector
 
 __all__ = ["BaseConnector"]

package/src/connectors/bitbucket_connector.py

@@ -0,0 +1,334 @@
+"""Bitbucket connector — full implementation with OAuth2 client credentials,
+Basic Auth (App Password), and pull/push event webhook processing.
+
+Supports:
+  - Bitbucket Cloud:  OAuth2 consumer (BITBUCKET_CLIENT_ID + BITBUCKET_CLIENT_SECRET)
+  - Bitbucket Server/DC: App Password (BITBUCKET_USERNAME + BITBUCKET_APP_PASSWORD)
+                          or Bearer token (BITBUCKET_ACCESS_TOKEN)
+  - Background pull sync: indexes changed file paths + LOC into DB on every push event
+"""
+from __future__ import annotations
+
+import hashlib
+import hmac
+import logging
+import time
+from datetime import datetime
+from pathlib import Path
+
+import httpx
+
+from src.config import cfg
+from src.connectors.base import BaseConnector
+
+logger = logging.getLogger(__name__)
+
+_BITBUCKET_CLOUD_TOKEN_URL = "https://bitbucket.org/site/oauth2/access_token"
+
+
+class BitbucketConnector(BaseConnector):
+    """Full Bitbucket connector with webhook-driven pull sync → Asset Registry."""
+
+    name = "bitbucket"
+    enabled = cfg.BITBUCKET_ENABLED
+    supports_sync = True
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._token: str | None = None
+        self._token_expiry: float = 0.0
+        self._use_oauth2 = bool(
+            getattr(cfg, "BITBUCKET_CLIENT_ID", "")
+            and getattr(cfg, "BITBUCKET_CLIENT_SECRET", "")
+        )
+        self._use_bearer = bool(getattr(cfg, "BITBUCKET_ACCESS_TOKEN", ""))
+        self._base_url = (getattr(cfg, "BITBUCKET_URL", "https://bitbucket.org") or "https://bitbucket.org").rstrip("/")
+        self._workspace = getattr(cfg, "BITBUCKET_WORKSPACE", "")
+
+    # ── Authentication ─────────────────────────────────────────────────
+
+    def _fetch_oauth2_token(self) -> str | None:
+        """Fetch access token via OAuth2 client credentials (Bitbucket Cloud)."""
+        client_id = getattr(cfg, "BITBUCKET_CLIENT_ID", "")
+        client_secret = getattr(cfg, "BITBUCKET_CLIENT_SECRET", "")
+        try:
+            with httpx.Client(timeout=15.0) as client:
+                resp = client.post(
+                    _BITBUCKET_CLOUD_TOKEN_URL,
+                    data={"grant_type": "client_credentials"},
+                    auth=(client_id, client_secret),
+                )
+                resp.raise_for_status()
+                data = resp.json()
+                self._token = data["access_token"]
+                self._token_expiry = time.time() + int(data.get("expires_in", 7200)) - 60
+                logger.info("Bitbucket OAuth2 token obtained (expires in %ss)", data.get("expires_in"))
+                return self._token
+        except Exception as e:
+            logger.error("Bitbucket OAuth2 token fetch failed: %s", e)
+            return None
+
+    def _get_auth(self) -> dict:
+        """Return httpx kwargs for the current auth mode."""
+        if self._use_oauth2:
+            if not self._token or time.time() >= self._token_expiry:
+                self._fetch_oauth2_token()
+            if self._token:
+                return {"headers": {"Authorization": f"Bearer {self._token}"}}
+        if self._use_bearer:
+            return {"headers": {"Authorization": f"Bearer {getattr(cfg, 'BITBUCKET_ACCESS_TOKEN', '')}"}}
+        username = getattr(cfg, "BITBUCKET_USERNAME", "")
+        password = getattr(cfg, "BITBUCKET_APP_PASSWORD", "")
+        if username and password:
+            return {"auth": (username, password)}
+        return {}
+
+    def connect(self) -> bool:
+        if not self.enabled:
+            return False
+        if not self._use_oauth2 and not self._use_bearer:
+            if not (getattr(cfg, "BITBUCKET_USERNAME", "") and getattr(cfg, "BITBUCKET_APP_PASSWORD", "")):
+                logger.warning("Bitbucket: no credentials configured")
+                return False
+        return True
+
+    # ── Webhook Signature Validation ───────────────────────────────────
+
+    def validate_webhook_signature(self, body: bytes, signature_header: str) -> bool:
+        """Validate Bitbucket webhook HMAC-SHA256 signature.
+
+        Header format: "sha256=<hex_digest>"
+        Set BITBUCKET_WEBHOOK_SECRET in your environment.
+        """
+        secret = getattr(cfg, "BITBUCKET_WEBHOOK_SECRET", "")
+        if not secret:
+            logger.warning("BITBUCKET_WEBHOOK_SECRET not set; skipping signature validation")
+            return True
+        try:
+            expected = hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
+            received = signature_header.replace("sha256=", "")
+            return hmac.compare_digest(expected, received)
+        except Exception as e:
+            logger.error("Webhook signature validation error: %s", e)
+            return False
+
+    # ── Pull / Push Event Processing (Background Sync) ─────────────────
+
+    def sync_pull_event(self, payload: dict) -> dict:
+        """Process a Bitbucket push/PR-merge webhook payload.
+
+        Background process triggered when users pull/push to Bitbucket:
+          1. Extracts changed file paths from the push payload
+          2. Stores file_path + LOC metadata in igel_bitbucket_file_locs
+          3. Runs CodeIntelligenceAgent delta-sync on changed Python files
+          4. Runs RegressionAgent impact analysis
+          5. Returns a summary dict
+
+        Bitbucket Cloud push event payload shape:
+          { "repository": {"slug": "...", "workspace": {"slug": "..."}},
+            "push": {"changes": [{"commits": [{"hash": "...", "date": "...",
+                                               "author": {"raw": "..."}}]}]} }
+        """
+        if not self.enabled:
+            return {"status": "disabled", "files_indexed": 0}
+
+        repo_info = payload.get("repository") or {}
+        repo_slug = repo_info.get("slug", "")
+        workspace_info = repo_info.get("workspace", {})
+        workspace = (workspace_info.get("slug") if isinstance(workspace_info, dict) else workspace_info) or self._workspace
+
+        changed_files_info: list[dict] = []
+        changes = (payload.get("push") or {}).get("changes") or []
+        for change in changes:
+            for commit in (change.get("commits") or []):
+                commit_hash = commit.get("hash", "")
+                if not commit_hash:
+                    continue
+                files = self._fetch_commit_diff_files(workspace, repo_slug, commit_hash)
+                for f in files:
+                    f["commit"] = commit_hash
+                    f["author"] = (commit.get("author") or {}).get("raw", "")
+                    f["commit_date"] = commit.get("date", "")
+                changed_files_info.extend(files)
+
+        # Deduplicate by path (keep latest)
+        seen: dict[str, dict] = {}
+        for f in changed_files_info:
+            seen[f["file_path"]] = f
+        unique_files = list(seen.values())
+
+        # Persist file LOC data
+        self._store_file_locs(unique_files, repo_slug, workspace)
+
+        # Delta-sync automation assets (Python files only)
+        from src.agents.regression_agent import BitbucketSyncAgent, RegressionAgent
+        repo_path = Path(getattr(cfg, "BITBUCKET_REPO_PATH", "."))
+
+        files_indexed = 0
+        try:
+            sync_agent = BitbucketSyncAgent(repo_path)
+            local_changed = [repo_path / f["file_path"] for f in unique_files if (repo_path / f["file_path"]).exists()]
+            files_indexed = sync_agent.sync_changed_files(local_changed)
+        except Exception as e:
+            logger.error("BitbucketSyncAgent failed: %s", e)
+
+        # Impact analysis
+        impact: dict = {}
+        try:
+            changed_paths = [Path(f["file_path"]) for f in unique_files]
+            reg_agent = RegressionAgent()
+            impact = reg_agent.analyze_impact(changed_paths, repo_path)
+        except Exception as e:
+            logger.error("RegressionAgent failed: %s", e)
+
+        return {
+            "status": "complete",
+            "repo": f"{workspace}/{repo_slug}",
+            "files_changed": len(unique_files),
+            "files_indexed": files_indexed,
+            "affected_requirements": impact.get("affected_requirements", []),
+            "affected_scripts": impact.get("affected_scripts", []),
+            "affected_assets": impact.get("affected_assets", []),
+        }
+
+    def _fetch_commit_diff_files(self, workspace: str, repo_slug: str, commit_hash: str) -> list[dict]:
+        """Fetch file diffs for a commit via Bitbucket diffstat API."""
+        if not workspace or not repo_slug or not commit_hash:
+            return []
+        auth = self._get_auth()
+        results: list[dict] = []
+        try:
+            with httpx.Client(timeout=20.0, **auth) as client:
+                url = f"{self._base_url}/2.0/repositories/{workspace}/{repo_slug}/diffstat/{commit_hash}"
+                while url:
+                    resp = client.get(url, params={"pagelen": 50})
+                    resp.raise_for_status()
+                    data = resp.json()
+                    for item in data.get("values") or []:
+                        status = item.get("status", "modified")
+                        new_path = (item.get("new") or {}).get("path") or ""
+                        old_path = (item.get("old") or {}).get("path") or ""
+                        file_path = new_path or old_path
+                        if file_path:
+                            results.append({
+                                "file_path": file_path,
+                                "status": status,
+                                "lines_added": item.get("lines_added", 0),
+                                "lines_removed": item.get("lines_removed", 0),
+                            })
+                    url = data.get("next")
+        except Exception as e:
+            logger.warning("Failed to fetch diffstat for %s@%s: %s", repo_slug, commit_hash[:8], e)
+        return results
+
+    def _store_file_locs(self, files: list[dict], repo_slug: str, workspace: str) -> None:
+        """Persist file path + LOC data to igel_bitbucket_file_locs table."""
+        if not files:
+            return
+        try:
+            from src.db.client import get_conn
+            with get_conn() as conn:
+                with conn.cursor() as cur:
+                    cur.execute("""
+                        CREATE TABLE IF NOT EXISTS igel_bitbucket_file_locs (
+                            id              BIGSERIAL PRIMARY KEY,
+                            workspace       TEXT NOT NULL,
+                            repo_slug       TEXT NOT NULL,
+                            file_path       TEXT NOT NULL,
+                            status          TEXT,
+                            lines_added     INT DEFAULT 0,
+                            lines_removed   INT DEFAULT 0,
+                            commit_hash     TEXT,
+                            author          TEXT,
+                            commit_date     TIMESTAMPTZ,
+                            recorded_at     TIMESTAMPTZ DEFAULT NOW(),
+                            UNIQUE (workspace, repo_slug, file_path, commit_hash)
+                        )
+                    """)
+                    cur.execute("""
+                        CREATE INDEX IF NOT EXISTS bb_file_locs_repo_idx
+                            ON igel_bitbucket_file_locs(workspace, repo_slug)
+                    """)
+                    cur.execute("""
+                        CREATE INDEX IF NOT EXISTS bb_file_locs_path_idx
+                            ON igel_bitbucket_file_locs(file_path)
+                    """)
+                    for f in files:
+                        commit_date = None
+                        raw_date = f.get("commit_date")
+                        if raw_date:
+                            try:
+                                from dateutil import parser as dateparser
+                                commit_date = dateparser.parse(raw_date)
+                            except Exception:
+                                pass
+                        cur.execute("""
+                            INSERT INTO igel_bitbucket_file_locs
+                                (workspace, repo_slug, file_path, status, lines_added,
+                                 lines_removed, commit_hash, author, commit_date)
+                            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
+                            ON CONFLICT (workspace, repo_slug, file_path, commit_hash)
+                            DO UPDATE SET
+                                lines_added   = EXCLUDED.lines_added,
+                                lines_removed = EXCLUDED.lines_removed,
+                                status        = EXCLUDED.status,
+                                recorded_at   = NOW()
+                        """, (
+                            workspace, repo_slug,
+                            f["file_path"], f.get("status", "modified"),
+                            f.get("lines_added", 0), f.get("lines_removed", 0),
+                            f.get("commit", ""), f.get("author", ""), commit_date,
+                        ))
+                conn.commit()
+            logger.info("Stored LOC data for %d files in igel_bitbucket_file_locs", len(files))
+        except Exception as e:
+            logger.error("Failed to store file LOC data: %s", e)
+
+    # ── File LOC Retrieval ─────────────────────────────────────────────
+
+    def fetch_file_locs(self, repo_slug: str, commit: str, workspace: str = "") -> list[dict]:
+        """Fetch file LOC data for a specific commit via Bitbucket API."""
+        ws = workspace or self._workspace
+        return self._fetch_commit_diff_files(ws, repo_slug, commit)
+
+    def get_stored_file_locs(self, repo_slug: str, workspace: str = "", limit: int = 100) -> list[dict]:
+        """Query DB for recently recorded file LOC data."""
+        ws = workspace or self._workspace
+        try:
+            from src.db.client import get_conn
+            with get_conn() as conn:
+                with conn.cursor() as cur:
+                    cur.execute("""
+                        SELECT file_path, status, lines_added, lines_removed,
+                               commit_hash, author, commit_date, recorded_at
+                        FROM igel_bitbucket_file_locs
+                        WHERE workspace = %s AND repo_slug = %s
+                        ORDER BY recorded_at DESC
+                        LIMIT %s
+                    """, (ws, repo_slug, limit))
+                    cols = ["file_path", "status", "lines_added", "lines_removed",
+                            "commit_hash", "author", "commit_date", "recorded_at"]
+                    return [dict(zip(cols, row)) for row in cur.fetchall()]
+        except Exception as e:
+            logger.error("Failed to query file LOC data: %s", e)
+            return []
+
+    # ── BaseConnector interface ────────────────────────────────────────
+
+    def sync(self, since: datetime | None = None) -> list[dict]:
+        """Returns recently stored file LOC records for configured repo."""
+        if not self.enabled or not self._workspace:
+            return []
+        repo_slug = getattr(cfg, "BITBUCKET_REPO_SLUG", "")
+        if not repo_slug:
+            return []
+        return self.get_stored_file_locs(repo_slug, self._workspace)
+
+    def ingest_to_kg(self, items: list[dict]) -> int:
+        return 0
+
+    def ingest_to_rag(self, items: list[dict]) -> int:
+        return 0
+
+    def search(self, query: str, limit: int = 5, timeout: float | None = None) -> list[str]:
+        return []

package/{knowledge_base → src}/connectors/community_connector.py

@@ -7,10 +7,10 @@ from datetime import datetime
 from typing import Any
 from urllib.parse import quote_plus
 
-from knowledge_base.config import cfg
-from knowledge_base.connectors.base import BaseConnector
-from knowledge_base.connectors.web_fetcher import fetch_url, search_confluence_site
-from knowledge_base.parsers.html_parser import parse_html_page
+from src.config import cfg
+from src.connectors.base import BaseConnector
+from src.connectors.web_fetcher import fetch_url, search_confluence_site
+from src.parsers.html_parser import parse_html_page
 
 logger = logging.getLogger(__name__)
 
@@ -84,7 +84,7 @@ class CommunityConnector(BaseConnector):
     def ingest_to_kg(self, items: list[dict]) -> int:
         if not items:
             return 0
-        from knowledge_base.db.client import get_conn
+        from src.db.client import get_conn
         import json
         count = 0
         with get_conn() as conn:
@@ -107,6 +107,6 @@ class CommunityConnector(BaseConnector):
         return count
 
     def ingest_to_rag(self, items: list[dict]) -> int:
-        from knowledge_base.ingestion.web_ingest import ingest_web_items
+        from src.ingestion.web_ingest import ingest_web_items
 
         return ingest_web_items(items, source_label="community.igel.com")