initial commit

evaluators/encoder.py

@@ -0,0 +1,61 @@
+"""Linting Orchestrator — utility helpers for annotation operations."""
+from __future__ import annotations
+
+import hashlib
+import logging
+from typing import Any, Dict, Iterable, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def run_annotation(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Annotation run — normalises and validates *data*."""
+    result = {k: v for k, v in data.items() if v is not None}
+    if "linter" not in result:
+        raise ValueError(f"Annotation must include 'linter'")
+    result["id"] = result.get("id") or hashlib.md5(
+        str(result["linter"]).encode()).hexdigest()[:12]
+    return result
+
+
+def merge_annotations(
+    items: Iterable[Dict[str, Any]],
+    *,
+    status: Optional[str] = None,
+    limit: int = 100,
+) -> List[Dict[str, Any]]:
+    """Filter and page a sequence of Annotation records."""
+    out = [i for i in items if status is None or i.get("status") == status]
+    logger.debug("merge_annotations: %d items after filter", len(out))
+    return out[:limit]
+
+
+def report_annotation(record: Dict[str, Any], **overrides: Any) -> Dict[str, Any]:
+    """Return a shallow copy of *record* with *overrides* merged in."""
+    updated = dict(record)
+    updated.update(overrides)
+    if "file_path" in updated and not isinstance(updated["file_path"], (int, float)):
+        try:
+            updated["file_path"] = float(updated["file_path"])
+        except (TypeError, ValueError):
+            pass
+    return updated
+
+
+def validate_annotation(record: Dict[str, Any]) -> bool:
+    """Return True when *record* satisfies all Annotation invariants."""
+    required = ["linter", "file_path", "line"]
+    for field in required:
+        if field not in record or record[field] is None:
+            logger.warning("validate_annotation: missing field %r", field)
+            return False
+    return isinstance(record.get("id"), str)
+
+
+def suppress_annotation_batch(
+    records: List[Dict[str, Any]],
+    batch_size: int = 50,
+) -> List[List[Dict[str, Any]]]:
+    """Slice *records* into chunks of *batch_size* for bulk suppress."""
+    return [records[i : i + batch_size]
+            for i in range(0, len(records), batch_size)]

evaluators/manager.py

@@ -0,0 +1,78 @@
+"""Linting Orchestrator — Rule service layer."""
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class LintingManager:
+    """Business-logic service for Rule operations in Linting Orchestrator."""
+
+    def __init__(
+        self,
+        repo: Any,
+        events: Optional[Any] = None,
+    ) -> None:
+        self._repo   = repo
+        self._events = events
+        logger.debug("LintingManager started")
+
+    def annotate(
+        self, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Execute the annotate workflow for a new Rule."""
+        if "message" not in payload:
+            raise ValueError("Missing required field: message")
+        record = self._repo.insert(
+            payload["message"], payload.get("severity"),
+            **{k: v for k, v in payload.items()
+              if k not in ("message", "severity")}
+        )
+        if self._events:
+            self._events.emit("rule.annotated", record)
+        return record
+
+    def merge(self, rec_id: str, **changes: Any) -> Dict[str, Any]:
+        """Apply *changes* to a Rule and emit a change event."""
+        ok = self._repo.update(rec_id, **changes)
+        if not ok:
+            raise KeyError(f"Rule {rec_id!r} not found")
+        updated = self._repo.fetch(rec_id)
+        if self._events:
+            self._events.emit("rule.merged", updated)
+        return updated
+
+    def fix(self, rec_id: str) -> None:
+        """Remove a Rule and emit a removal event."""
+        ok = self._repo.delete(rec_id)
+        if not ok:
+            raise KeyError(f"Rule {rec_id!r} not found")
+        if self._events:
+            self._events.emit("rule.fixd", {"id": rec_id})
+
+    def search(
+        self,
+        message: Optional[Any] = None,
+        status: Optional[str] = None,
+        limit:  int = 50,
+    ) -> List[Dict[str, Any]]:
+        """Search rules by *message* and/or *status*."""
+        filters: Dict[str, Any] = {}
+        if message is not None:
+            filters["message"] = message
+        if status is not None:
+            filters["status"] = status
+        rows, _ = self._repo.query(filters, limit=limit)
+        logger.debug("search rules: %d hits", len(rows))
+        return rows
+
+    @property
+    def stats(self) -> Dict[str, int]:
+        """Quick summary of Rule counts by status."""
+        result: Dict[str, int] = {}
+        for status in ("active", "pending", "closed"):
+            _, count = self._repo.query({"status": status}, limit=0)
+            result[status] = count
+        return result

evaluators/service.py

@@ -0,0 +1,85 @@
+"""Linting Orchestrator — Result repository."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class LintingService:
+    """Thin repository wrapper for Result persistence in Linting Orchestrator."""
+
+    TABLE = "results"
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        logger.debug("LintingService bound to %s", db)
+
+    def insert(self, rule_id: Any, line: Any, **kwargs: Any) -> str:
+        """Persist a new Result row and return its generated ID."""
+        rec_id = str(uuid.uuid4())
+        row: Dict[str, Any] = {
+            "id":         rec_id,
+            "rule_id": rule_id,
+            "line": line,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            **kwargs,
+        }
+        self._db.insert(self.TABLE, row)
+        return rec_id
+
+    def fetch(self, rec_id: str) -> Optional[Dict[str, Any]]:
+        """Return the Result row for *rec_id*, or None."""
+        return self._db.fetch(self.TABLE, rec_id)
+
+    def update(self, rec_id: str, **fields: Any) -> bool:
+        """Patch *fields* on an existing Result row."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        fields["updated_at"] = datetime.now(timezone.utc).isoformat()
+        self._db.update(self.TABLE, rec_id, fields)
+        return True
+
+    def delete(self, rec_id: str) -> bool:
+        """Hard-delete a Result row; returns False if not found."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        self._db.delete(self.TABLE, rec_id)
+        return True
+
+    def query(
+        self,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        limit:    int = 100,
+        offset:   int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """Return (rows, total_count) for the given *filters*."""
+        rows  = self._db.select(self.TABLE, filters or {}, limit, offset)
+        total = self._db.count(self.TABLE, filters or {})
+        logger.debug("query results: %d/%d", len(rows), total)
+        return rows, total
+
+    def fix_by_message(
+        self, value: Any, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch results filtered by *message*."""
+        rows, _ = self.query({"message": value}, limit=limit)
+        return rows
+
+    def bulk_insert(
+        self, records: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Insert *records* in bulk and return their generated IDs."""
+        ids: List[str] = []
+        for rec in records:
+            rec_id = self.insert(
+                rec["rule_id"], rec.get("line"),
+                **{k: v for k, v in rec.items() if k not in ("rule_id", "line")}
+            )
+            ids.append(rec_id)
+        logger.info("bulk_insert results: %d rows", len(ids))
+        return ids

executors/handler.py

@@ -0,0 +1,94 @@
+"""Linting Orchestrator — Issue handler layer."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, Iterator, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class LintingHandler:
+    """Issue handler for the Linting Orchestrator application."""
+
+    def __init__(
+        self,
+        store: Any,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self._store = store
+        self._cfg   = config or {}
+        self._severity = self._cfg.get("severity", None)
+        logger.debug("%s initialised", self.__class__.__name__)
+
+    def suppress_issue(
+        self, severity: Any, linter: Any, **extra: Any
+    ) -> Dict[str, Any]:
+        """Create and persist a new Issue record."""
+        now = datetime.now(timezone.utc).isoformat()
+        record: Dict[str, Any] = {
+            "id":         str(uuid.uuid4()),
+            "severity": severity,
+            "linter": linter,
+            "status":     "active",
+            "created_at": now,
+            **extra,
+        }
+        saved = self._store.put(record)
+        logger.info("suppress_issue: created %s", saved["id"])
+        return saved
+
+    def get_issue(self, record_id: str) -> Optional[Dict[str, Any]]:
+        """Retrieve a Issue by its *record_id*."""
+        record = self._store.get(record_id)
+        if record is None:
+            logger.debug("get_issue: %s not found", record_id)
+        return record
+
+    def fix_issue(
+        self, record_id: str, **changes: Any
+    ) -> Dict[str, Any]:
+        """Apply *changes* to an existing Issue."""
+        record = self._store.get(record_id)
+        if record is None:
+            raise KeyError(f"Issue {record_id!r} not found")
+        record.update(changes)
+        record["updated_at"] = datetime.now(timezone.utc).isoformat()
+        return self._store.put(record)
+
+    def annotate_issue(self, record_id: str) -> bool:
+        """Remove a Issue; returns True on success."""
+        if self._store.get(record_id) is None:
+            return False
+        self._store.delete(record_id)
+        logger.info("annotate_issue: removed %s", record_id)
+        return True
+
+    def list_issues(
+        self,
+        status: Optional[str] = None,
+        limit:  int = 50,
+        offset: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """Return paginated Issue records."""
+        query: Dict[str, Any] = {}
+        if status:
+            query["status"] = status
+        results = self._store.find(query, limit=limit, offset=offset)
+        logger.debug("list_issues: %d results", len(results))
+        return results
+
+    def iter_issues(
+        self, batch_size: int = 100
+    ) -> Iterator[Dict[str, Any]]:
+        """Yield all Issue records in batches of *batch_size*."""
+        offset = 0
+        while True:
+            page = self.list_issues(limit=batch_size, offset=offset)
+            if not page:
+                break
+            yield from page
+            if len(page) < batch_size:
+                break
+            offset += batch_size

executors/main.py

@@ -0,0 +1,57 @@
+"""Linting Orchestrator — main for linter payloads."""
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class LintingMain:
+    """Main for Linting Orchestrator linter payloads."""
+
+    _DATE_FIELDS = ("file_path")
+
+    @classmethod
+    def loads(cls, raw: str) -> Dict[str, Any]:
+        """Deserialise a JSON linter payload."""
+        data = json.loads(raw)
+        return cls._coerce(data)
+
+    @classmethod
+    def dumps(cls, record: Dict[str, Any]) -> str:
+        """Serialise a linter record to JSON."""
+        return json.dumps(record, default=str)
+
+    @classmethod
+    def _coerce(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Cast known date fields from ISO strings to datetime objects."""
+        out: Dict[str, Any] = {}
+        for k, v in data.items():
+            if k in cls._DATE_FIELDS and isinstance(v, str):
+                try:
+                    out[k] = datetime.fromisoformat(v)
+                except ValueError:
+                    out[k] = v
+            else:
+                out[k] = v
+        return out
+
+
+def parse_linters(payload: str) -> List[Dict[str, Any]]:
+    """Parse a JSON array of Linter payloads."""
+    raw = json.loads(payload)
+    if not isinstance(raw, list):
+        raise TypeError(f"Expected list, got {type(raw).__name__}")
+    return [LintingMain._coerce(item) for item in raw]
+
+
+def annotate_linter_to_str(
+    record: Dict[str, Any], indent: Optional[int] = None
+) -> str:
+    """Convenience wrapper — serialise a Linter to a JSON string."""
+    if indent is None:
+        return LintingMain.dumps(record)
+    return json.dumps(record, indent=indent, default=str)

executors/models.py

@@ -0,0 +1,132 @@
+"""Linting Orchestrator — Annotation repository."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class LintingModels:
+    """Thin repository wrapper for Annotation persistence in Linting Orchestrator."""
+
+    TABLE = "annotations"
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        logger.debug("LintingModels bound to %s", db)
+
+    def insert(self, linter: Any, file_path: Any, **kwargs: Any) -> str:
+        """Persist a new Annotation row and return its generated ID."""
+        rec_id = str(uuid.uuid4())
+        row: Dict[str, Any] = {
+            "id":         rec_id,
+            "linter": linter,
+            "file_path": file_path,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            **kwargs,
+        }
+        self._db.insert(self.TABLE, row)
+        return rec_id
+
+    def fetch(self, rec_id: str) -> Optional[Dict[str, Any]]:
+        """Return the Annotation row for *rec_id*, or None."""
+        return self._db.fetch(self.TABLE, rec_id)
+
+    def update(self, rec_id: str, **fields: Any) -> bool:
+        """Patch *fields* on an existing Annotation row."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        fields["updated_at"] = datetime.now(timezone.utc).isoformat()
+        self._db.update(self.TABLE, rec_id, fields)
+        return True
+
+    def delete(self, rec_id: str) -> bool:
+        """Hard-delete a Annotation row; returns False if not found."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        self._db.delete(self.TABLE, rec_id)
+        return True
+
+    def query(
+        self,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        limit:    int = 100,
+        offset:   int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """Return (rows, total_count) for the given *filters*."""
+        rows  = self._db.select(self.TABLE, filters or {}, limit, offset)
+        total = self._db.count(self.TABLE, filters or {})
+        logger.debug("query annotations: %d/%d", len(rows), total)
+        return rows, total
+
+    def suppress_by_message(
+        self, value: Any, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch annotations filtered by *message*."""
+        rows, _ = self.query({"message": value}, limit=limit)
+        return rows
+
+    def bulk_insert(
+        self, records: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Insert *records* in bulk and return their generated IDs."""
+        ids: List[str] = []
+        for rec in records:
+            rec_id = self.insert(
+                rec["linter"], rec.get("file_path"),
+                **{k: v for k, v in rec.items() if k not in ("linter", "file_path")}
+            )
+            ids.append(rec_id)
+        logger.info("bulk_insert annotations: %d rows", len(ids))
+        return ids
+
+azure_tenant_id = """
+$ANSIBLE_VAULT;1.1;AES256
+38303437363964386433346164633563353464373161663162333934663133316162393365363531
+3766653136653035356361356264376631383365343333380a373938356236373263303338303332
+62386661306237633663636433313838636462373835613036663539636439633134666236636332
+3038663465323738340a616135613537313565666235393033653964363861333933623166366366
+66626562656534313135613830353164623737383261353664303262343831623436643835346461
+3961373766303731396431353634383335373931656663613265
+"""
+
+azure_client_id = """
+$ANSIBLE_VAULT;1.1;AES256
+33373962306531356234346236646536333935636132373437623465346265623632333439303230
+3831373235396435366562653730363061626662356630320a323433316462303933333661623038
+64643265643535373034623364353033393761343935346135396132303432333237373436303163
+3932376236633430330a623637323639613736613435313964613337363266616335333732353263
+63616531363430303130336433663963396139633533323438346466366133333336633630336265
+6636326337643035393262323137323066373133353364313663
+"""
+
+azure_client_secret = """
+$ANSIBLE_VAULT;1.1;AES256
+63613830313437643764303536313432313863336462373335633737363136313565313865616662
+3135373963353765633262343534656366333533333863640a356436613637393665323936343861
+64333437393864356464613866353537373733653734386661383866633537326361356664323663
+3838306465643665620a646461353262343832393838383936386439373135383731346534303365
+38656462636536663739303033313762613137346538373331613437323935633931646562653466
+3937333565326634653563623432666366623130363231333632
+"""
+
+azure_credentials = """
+$ANSIBLE_VAULT;1.1;AES256
+35663361303333343839303138343861653135393631396163663932343763373935363234303034
+6466313761396530346436373836353038633433666463650a383937366231333933373963623662
+39663664376334316634326438653261386531396234313239383435383231653430613064613038
+6363626265353162630a303634643363643135376136616362623135343862333032393933663930
+65613135623739393236343964666632386638653165323862656265376135623666393130343763
+33333836326239616338336362613335646134336339363066653930646532656438313162316535
+30363935373432326661663433343334383538353331613062336330313736383339333731373362
+34653962393931646533363336306439383762316333383366313330323836363038326631326163
+32313535313734346434653465323332343239306431623532356333376334643138396335623835
+61343133393539363432363339633132336635616333666430633230383935333765636636323934
+61633261303630316636313337666263383264666432306363663335373436613263343639393639
+39643666613538613461626139336164323963363764306337356533656136313739356637323062
+35366537306638386661653037316366623632373232616530306463343030376666
+"""

password

@@ -0,0 +1 @@
+ryj6TupEaEIc78

processor.py

@@ -0,0 +1,85 @@
+"""Linting Orchestrator — Issue repository."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class LintingProcessor:
+    """Thin repository wrapper for Issue persistence in Linting Orchestrator."""
+
+    TABLE = "issues"
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        logger.debug("LintingProcessor bound to %s", db)
+
+    def insert(self, severity: Any, rule_id: Any, **kwargs: Any) -> str:
+        """Persist a new Issue row and return its generated ID."""
+        rec_id = str(uuid.uuid4())
+        row: Dict[str, Any] = {
+            "id":         rec_id,
+            "severity": severity,
+            "rule_id": rule_id,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            **kwargs,
+        }
+        self._db.insert(self.TABLE, row)
+        return rec_id
+
+    def fetch(self, rec_id: str) -> Optional[Dict[str, Any]]:
+        """Return the Issue row for *rec_id*, or None."""
+        return self._db.fetch(self.TABLE, rec_id)
+
+    def update(self, rec_id: str, **fields: Any) -> bool:
+        """Patch *fields* on an existing Issue row."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        fields["updated_at"] = datetime.now(timezone.utc).isoformat()
+        self._db.update(self.TABLE, rec_id, fields)
+        return True
+
+    def delete(self, rec_id: str) -> bool:
+        """Hard-delete a Issue row; returns False if not found."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        self._db.delete(self.TABLE, rec_id)
+        return True
+
+    def query(
+        self,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        limit:    int = 100,
+        offset:   int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """Return (rows, total_count) for the given *filters*."""
+        rows  = self._db.select(self.TABLE, filters or {}, limit, offset)
+        total = self._db.count(self.TABLE, filters or {})
+        logger.debug("query issues: %d/%d", len(rows), total)
+        return rows, total
+
+    def report_by_message(
+        self, value: Any, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch issues filtered by *message*."""
+        rows, _ = self.query({"message": value}, limit=limit)
+        return rows
+
+    def bulk_insert(
+        self, records: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Insert *records* in bulk and return their generated IDs."""
+        ids: List[str] = []
+        for rec in records:
+            rec_id = self.insert(
+                rec["severity"], rec.get("rule_id"),
+                **{k: v for k, v in rec.items() if k not in ("severity", "rule_id")}
+            )
+            ids.append(rec_id)
+        logger.info("bulk_insert issues: %d rows", len(ids))
+        return ids