PyPI - abstractgateway - Versions diffs - 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl - Mend

abstractgateway 0.1.0py3-none-any.whl → 0.1.1py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (40) hide show

abstractgateway/__init__.py +1 -2
abstractgateway/__main__.py +7 -0
abstractgateway/app.py +4 -4
abstractgateway/cli.py +568 -8
abstractgateway/config.py +15 -5
abstractgateway/embeddings_config.py +45 -0
abstractgateway/host_metrics.py +274 -0
abstractgateway/hosts/bundle_host.py +528 -55
abstractgateway/hosts/visualflow_host.py +30 -3
abstractgateway/integrations/__init__.py +2 -0
abstractgateway/integrations/email_bridge.py +782 -0
abstractgateway/integrations/telegram_bridge.py +534 -0
abstractgateway/maintenance/__init__.py +5 -0
abstractgateway/maintenance/action_tokens.py +100 -0
abstractgateway/maintenance/backlog_exec_runner.py +1592 -0
abstractgateway/maintenance/backlog_parser.py +184 -0
abstractgateway/maintenance/draft_generator.py +451 -0
abstractgateway/maintenance/llm_assist.py +212 -0
abstractgateway/maintenance/notifier.py +109 -0
abstractgateway/maintenance/process_manager.py +1064 -0
abstractgateway/maintenance/report_models.py +81 -0
abstractgateway/maintenance/report_parser.py +219 -0
abstractgateway/maintenance/text_similarity.py +123 -0
abstractgateway/maintenance/triage.py +507 -0
abstractgateway/maintenance/triage_queue.py +142 -0
abstractgateway/migrate.py +155 -0
abstractgateway/routes/__init__.py +2 -2
abstractgateway/routes/gateway.py +10817 -179
abstractgateway/routes/triage.py +118 -0
abstractgateway/runner.py +689 -14
abstractgateway/security/gateway_security.py +425 -110
abstractgateway/service.py +213 -6
abstractgateway/stores.py +64 -4
abstractgateway/workflow_deprecations.py +225 -0
abstractgateway-0.1.1.dist-info/METADATA +135 -0
abstractgateway-0.1.1.dist-info/RECORD +40 -0
abstractgateway-0.1.0.dist-info/METADATA +0 -101
abstractgateway-0.1.0.dist-info/RECORD +0 -18
{abstractgateway-0.1.0.dist-info → abstractgateway-0.1.1.dist-info}/WHEEL +0 -0
{abstractgateway-0.1.0.dist-info → abstractgateway-0.1.1.dist-info}/entry_points.txt +0 -0

abstractgateway/maintenance/report_models.py ADDED Viewed

@@ -0,0 +1,81 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional
+ReportType = Literal["bug", "feature"]
+@dataclass(frozen=True)
+class ReportHeader:
+    title: str
+    created_at: str = ""
+    report_id: str = ""
+    session_id: str = ""
+    session_memory_run_id: str = ""
+    active_run_id: str = ""
+    workflow_id: str = ""
+    client: str = ""
+    client_version: str = ""
+    provider: str = ""
+    model: str = ""
+    template: str = ""
+@dataclass(frozen=True)
+class ReportRecord:
+    report_type: ReportType
+    path: Path
+    header: ReportHeader
+    description: str
+    sections: Dict[str, str] = field(default_factory=dict)
+    context: Dict[str, Any] = field(default_factory=dict)
+    def to_similarity_text(self) -> str:
+        bits: List[str] = []
+        if self.header.title:
+            bits.append(self.header.title)
+        if self.description:
+            bits.append(self.description)
+        # Include a small amount of environment context for disambiguation.
+        env_bits: List[str] = []
+        if self.header.client:
+            env_bits.append(f"client={self.header.client}")
+        if self.header.workflow_id:
+            env_bits.append(f"workflow={self.header.workflow_id}")
+        if self.header.template:
+            env_bits.append(f"template={self.header.template}")
+        if env_bits:
+            bits.append(" ".join(env_bits))
+        return "\n\n".join([b for b in bits if b]).strip()
+@dataclass(frozen=True)
+class SimilarityCandidate:
+    kind: Literal["report", "backlog_planned", "backlog_completed"]
+    ref: str
+    score: float
+    title: str = ""
+@dataclass
+class TriageDecision:
+    decision_id: str
+    report_type: ReportType
+    report_relpath: str
+    status: Literal["pending", "approved", "deferred", "rejected"] = "pending"
+    created_at: str = ""
+    updated_at: str = ""
+    defer_until: str = ""
+    missing_fields: List[str] = field(default_factory=list)
+    duplicates: List[SimilarityCandidate] = field(default_factory=list)
+    # When we write a draft file, store its relative path (repo-root relative).
+    draft_relpath: str = ""
+    # Optional LLM suggestions (best-effort; informational only).
+    llm_suggestion: Dict[str, Any] = field(default_factory=dict)

abstractgateway/maintenance/report_parser.py ADDED Viewed

@@ -0,0 +1,219 @@
+from __future__ import annotations
+import json
+import re
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+from .report_models import ReportHeader, ReportRecord, ReportType
+_TITLE_RE = re.compile(r"^#\s+(?P<kind>Bug|Feature)\s*:\s*(?P<title>.+?)\s*$", re.IGNORECASE)
+_BLOCKQUOTE_KV_RE = re.compile(r"^\s*>\s*(?P<key>[^:]+?)\s*:\s*(?P<value>.*?)\s*$")
+_H2_RE = re.compile(r"^##\s+(?P<name>.+?)\s*$")
+_FENCE_JSON_RE = re.compile(r"```json\s*(?P<body>.*?)\s*```", re.IGNORECASE | re.DOTALL)
+def _infer_report_type_from_path(path: Path) -> Optional[ReportType]:
+    parts = {p.lower() for p in path.parts}
+    if "bug_reports" in parts:
+        return "bug"
+    if "feature_requests" in parts:
+        return "feature"
+    return None
+def _parse_title_and_type(text: str, *, path: Path) -> Tuple[ReportType, str]:
+    for raw in text.splitlines():
+        line = raw.strip()
+        if not line.startswith("#"):
+            continue
+        m = _TITLE_RE.match(line)
+        if m:
+            kind = (m.group("kind") or "").strip().lower()
+            title = (m.group("title") or "").strip()
+            if len(title) > 120:
+                title = title[:120].rstrip()
+            return ("bug" if kind == "bug" else "feature", title)
+        break
+    inferred = _infer_report_type_from_path(path) or "bug"
+    # Best-effort: use first non-empty line as title.
+    for raw in text.splitlines():
+        s = raw.strip().lstrip("#").strip()
+        if s:
+            return inferred, s[:120]
+    return inferred, "Report"
+def _parse_blockquote_headers(text: str) -> Dict[str, str]:
+    out: Dict[str, str] = {}
+    for raw in text.splitlines():
+        m = _BLOCKQUOTE_KV_RE.match(raw)
+        if not m:
+            continue
+        key = str(m.group("key") or "").strip().lower()
+        val = str(m.group("value") or "").strip()
+        if key:
+            out[key] = val
+    return out
+def _parse_sections(text: str) -> Dict[str, str]:
+    sections: Dict[str, list[str]] = {}
+    current: Optional[str] = None
+    for raw in text.splitlines():
+        m = _H2_RE.match(raw.strip())
+        if m:
+            current = str(m.group("name") or "").strip()
+            if current:
+                sections.setdefault(current, [])
+            continue
+        if current:
+            sections[current].append(raw.rstrip("\n"))
+    # Preserve leading whitespace (many templates store user-provided fields as
+    # Markdown literals via indentation). Only strip surrounding newlines.
+    return {k: "\n".join(v).strip("\n") for k, v in sections.items()}
+def _extract_context_json(text: str) -> Dict[str, Any]:
+    m = _FENCE_JSON_RE.search(text)
+    if not m:
+        return {}
+    body = str(m.group("body") or "").strip()
+    if not body:
+        return {}
+    try:
+        obj = json.loads(body)
+    except Exception:
+        return {}
+    return obj if isinstance(obj, dict) else {}
+def _first_nonempty_section(sections: Dict[str, str], *names: str) -> str:
+    for name in names:
+        content = sections.get(name)
+        if isinstance(content, str) and content.strip():
+            # Preserve indentation (see `_parse_sections`).
+            return content.strip("\n")
+    return ""
+def _dedent_markdown_literal(text: str) -> str:
+    """Remove a single Markdown-literal indentation level (4 spaces).
+    Gateway report templates store user-provided descriptions as indented code
+    blocks to avoid accidental Markdown/HTML rendering. Downstream consumers
+    (triage + proposed backlog drafts) want the raw user text.
+    """
+    s = str(text or "").replace("\r\n", "\n").replace("\r", "\n")
+    if not s:
+        return ""
+    lines = s.split("\n")
+    out: list[str] = []
+    for ln in lines:
+        if ln.startswith("    "):
+            out.append(ln[4:])
+        elif ln.startswith("\t"):
+            out.append(ln[1:])
+        else:
+            out.append(ln)
+    return "\n".join(out).rstrip("\n")
+def parse_report_file(path: Path) -> ReportRecord:
+    text = path.read_text(encoding="utf-8", errors="replace")
+    report_type, title = _parse_title_and_type(text, path=path)
+    headers = _parse_blockquote_headers(text)
+    def _h(*keys: str) -> str:
+        for k in keys:
+            v = headers.get(k.lower())
+            if isinstance(v, str) and v.strip():
+                return v.strip()
+        return ""
+    created_at = _h("created")
+    report_id = _h("bug id", "feature id", "report id")
+    session_id = _h("session id")
+    session_memory_run_id = _h("session memory run id", "session_memory_run_id")
+    active_run_id = _h("relevant run id", "active run id", "run id")
+    workflow_id = _h("workflow id")
+    sections = _parse_sections(text)
+    description = _first_nonempty_section(
+        sections,
+        "User Description",
+        "User Request",
+        "Description",
+    )
+    description = _dedent_markdown_literal(description)
+    # Environment info (best-effort; present in templates but may be missing/edited).
+    env_section = sections.get("Environment") or ""
+    client = ""
+    client_version = ""
+    provider = ""
+    model = ""
+    template = ""
+    if env_section:
+        # Parse "- Key: value" bullets.
+        for raw in env_section.splitlines():
+            line = raw.strip()
+            if not line.startswith("-"):
+                continue
+            kv = line.lstrip("-").strip()
+            if ":" not in kv:
+                continue
+            k, v = kv.split(":", 1)
+            key = k.strip().lower()
+            val = v.strip()
+            if not val:
+                continue
+            if key == "client":
+                client = val
+            elif key == "client version":
+                client_version = val
+            elif key in {"provider/model", "provider"}:
+                provider = val
+            elif key == "model":
+                model = val
+            elif key in {"agent template", "template"}:
+                template = val
+            elif key == "provider/model":
+                # "Provider/model: provider / model"
+                if "/" in val:
+                    pass
+        # Special-case provider/model format: "- Provider/model: X / Y"
+        m = re.search(r"^\s*-\s*Provider/model\s*:\s*(.+?)\s*/\s*(.+?)\s*$", env_section, re.IGNORECASE | re.MULTILINE)
+        if m:
+            provider = (m.group(1) or "").strip()
+            model = (m.group(2) or "").strip()
+    header = ReportHeader(
+        title=title,
+        created_at=created_at,
+        report_id=report_id,
+        session_id=session_id,
+        session_memory_run_id=session_memory_run_id,
+        active_run_id=active_run_id,
+        workflow_id=workflow_id,
+        client=client,
+        client_version=client_version,
+        provider=provider,
+        model=model,
+        template=template,
+    )
+    context = _extract_context_json(text)
+    return ReportRecord(
+        report_type=report_type,
+        path=path,
+        header=header,
+        description=description,
+        sections=sections,
+        context=context,
+    )

abstractgateway/maintenance/text_similarity.py ADDED Viewed

@@ -0,0 +1,123 @@
+from __future__ import annotations
+import math
+import re
+from typing import Dict, Iterable, List, Set, Tuple
+_TOKEN_RE = re.compile(r"[a-z0-9]+", re.IGNORECASE)
+_STOPWORDS: Set[str] = {
+    "a",
+    "an",
+    "and",
+    "are",
+    "as",
+    "at",
+    "be",
+    "but",
+    "by",
+    "for",
+    "from",
+    "has",
+    "have",
+    "i",
+    "in",
+    "into",
+    "is",
+    "it",
+    "of",
+    "on",
+    "or",
+    "s",
+    "that",
+    "the",
+    "their",
+    "this",
+    "to",
+    "was",
+    "were",
+    "with",
+    "without",
+    "you",
+    "your",
+}
+def tokenize(text: str) -> List[str]:
+    raw = str(text or "").lower()
+    tokens = [t for t in _TOKEN_RE.findall(raw) if len(t) >= 2]
+    return [t for t in tokens if t not in _STOPWORDS]
+def token_set(text: str) -> Set[str]:
+    return set(tokenize(text))
+def jaccard(a: Iterable[str], b: Iterable[str]) -> float:
+    sa = set(a)
+    sb = set(b)
+    if not sa and not sb:
+        return 1.0
+    if not sa or not sb:
+        return 0.0
+    inter = sa.intersection(sb)
+    union = sa.union(sb)
+    return float(len(inter)) / float(len(union)) if union else 0.0
+def cosine_counts(counts_a: Dict[str, int], counts_b: Dict[str, int]) -> float:
+    if not counts_a and not counts_b:
+        return 1.0
+    if not counts_a or not counts_b:
+        return 0.0
+    dot = 0.0
+    na = 0.0
+    nb = 0.0
+    for k, va in counts_a.items():
+        na += float(va) * float(va)
+        vb = counts_b.get(k)
+        if vb:
+            dot += float(va) * float(vb)
+    for vb in counts_b.values():
+        nb += float(vb) * float(vb)
+    denom = math.sqrt(na) * math.sqrt(nb)
+    if denom <= 0:
+        return 0.0
+    return float(dot) / float(denom)
+def token_counts(text: str) -> Dict[str, int]:
+    counts: Dict[str, int] = {}
+    for t in tokenize(text):
+        counts[t] = counts.get(t, 0) + 1
+    return counts
+def similarity(text_a: str, text_b: str) -> float:
+    """Deterministic similarity score in [0,1]."""
+    # Blend set overlap (good for short titles) and cosine counts (good for longer text).
+    sa = token_set(text_a)
+    sb = token_set(text_b)
+    j = jaccard(sa, sb)
+    ca = token_counts(text_a)
+    cb = token_counts(text_b)
+    c = cosine_counts(ca, cb)
+    return 0.55 * j + 0.45 * c
+def top_k_similar(
+    *,
+    query_text: str,
+    candidates: List[Tuple[str, str]],
+    k: int = 5,
+    min_score: float = 0.25,
+) -> List[Tuple[str, float]]:
+    scored: List[Tuple[str, float]] = []
+    for ref, cand_text in candidates:
+        s = similarity(query_text, cand_text)
+        if s >= float(min_score):
+            scored.append((ref, s))
+    scored.sort(key=lambda x: x[1], reverse=True)
+    return scored[: max(0, int(k))]

abstractgateway 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

abstractgateway 0.1.0py3-none-any.whl → 0.1.1py3-none-any.whl