@misterhuydo/sentinel 1.4.67 → 1.4.69

package/python/scripts/fix_chain_slack.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""Fix the broken slack_alert block in chain_release handler."""
+import ast, py_compile, tempfile, os, sys
+
+TARGET = '/home/sentinel/sentinel/code/sentinel/sentinel_boss.py'
+
+with open(TARGET, 'r', encoding='utf-8') as f:
+    lines = f.readlines()
+
+# Find the broken block: look for doubled slack_alert lines near "Chain release"
+# Strategy: find line with "all_ok = all(r.get" and replace everything up to
+# "logger.info("Boss chain_release"
+
+start_idx = None
+end_idx = None
+for i, line in enumerate(lines):
+    if 'all_ok = all(r.get("status") in ("released", "no_cicd")' in line:
+        start_idx = i
+    if start_idx and 'logger.info("Boss chain_release' in line:
+        end_idx = i
+        break
+
+if start_idx is None or end_idx is None:
+    print(f"Could not find block: start={start_idx}, end={end_idx}")
+    # Print context
+    for i, line in enumerate(lines):
+        if 'chain_release' in line or 'all_ok' in line:
+            print(f"{i+1}: {line}", end='')
+    sys.exit(1)
+
+print(f"Replacing lines {start_idx+1}..{end_idx} (inclusive of logger line)")
+
+# Build the replacement lines (8 spaces indent = inside if name == "chain_release" block)
+replacement = '''\
+        all_ok = all(r.get("status") in ("released", "no_cicd") for r in results)
+        final  = "completed" if all_ok else "partial" if results else "failed"
+        _icon  = ":white_check_mark:" if all_ok else ":warning:"
+        _steps = ", ".join(
+            "`" + r["repo"] + "` " + ("\u2713" if r.get("status") in ("released", "no_cicd") else "\u2717")
+            for r in results
+        )
+        slack_alert(
+            cfg.slack_bot_token, cfg.slack_channel,
+            f"{_icon}: *Chain release {final}* \u2014 {_steps}",
+        )
+'''
+
+# Replace lines start_idx..end_idx-1 (keep the logger line)
+new_lines = lines[:start_idx] + [replacement] + lines[end_idx:]
+
+with open(TARGET, 'w', encoding='utf-8') as f:
+    f.writelines(new_lines)
+
+print("Replacement done.")
+
+# Syntax check
+with open(TARGET, 'r') as f:
+    src = f.read()
+try:
+    ast.parse(src)
+    print("Syntax OK")
+except SyntaxError as e:
+    print(f"SyntaxError line {e.lineno}: {e.msg}")
+    ls = src.splitlines()
+    for i in range(max(0, e.lineno-5), min(len(ls), e.lineno+3)):
+        print(f"{i+1}: {ls[i]}")
+    sys.exit(1)

package/python/scripts/fix_fstring.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Fix Python 3.9 f-string backslash issue in chain_release handler."""
+
+TARGET = '/home/sentinel/sentinel/code/sentinel/sentinel_boss.py'
+
+with open(TARGET, 'r', encoding='utf-8') as f:
+    content = f.read()
+
+# Replace the problematic f-string block
+old = (
+    "            f\":{'white_check_mark' if all_ok else 'warning'}: *Chain release {final}* \\u2014 \"\n"
+    "            + \", \".join(\n"
+    "                f\"`{r['repo']}` {'\\u2713' if r.get('status') in ('released', 'no_cicd') else '\\u2717'}\"\n"
+    "                for r in results\n"
+    "            ),"
+)
+
+new = (
+    "            (\":white_check_mark:\" if all_ok else \":warning:\") + f\": *Chain release {final}* \\u2014 \"\n"
+    "            + \", \".join(\n"
+    "                \"`\" + r[\"repo\"] + \"` \" + (\"\\u2713\" if r.get(\"status\") in (\"released\", \"no_cicd\") else \"\\u2717\")\n"
+    "                for r in results\n"
+    "            ),"
+)
+
+if old not in content:
+    # Try finding it
+    idx = content.find("white_check_mark' if all_ok")
+    if idx >= 0:
+        print("Context around match point:")
+        print(repr(content[idx-10:idx+300]))
+    else:
+        print("Pattern not found at all")
+    import sys; sys.exit(1)
+
+content = content.replace(old, new, 1)
+
+with open(TARGET, 'w', encoding='utf-8') as f:
+    f.write(content)
+
+print("Fixed f-string.")
+
+import ast, py_compile, tempfile, os
+with tempfile.NamedTemporaryFile(suffix='.py', delete=False, mode='w') as tmp:
+    tmp.write(content)
+    tmp_name = tmp.name
+try:
+    py_compile.compile(tmp_name, doraise=True)
+    print("Syntax OK")
+finally:
+    os.unlink(tmp_name)

package/python/scripts/fix_knowledge_cache.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+Add a knowledge_cache table + methods to state_store.py and a cache layer
+to ask_codebase in sentinel_boss.py.
+
+Concept:
+- When ask_codebase answers a question, save the answer to knowledge_cache
+  keyed by (repo_name, normalised_question), TTL 24h
+- On the next identical/similar question, answer from cache instantly
+- Cache is auto-invalidated when a Sentinel fix is applied to that repo
+- New Boss tool: refresh_knowledge — clear cached answers for a repo or all
+- System prompt updated to describe the knowledge cache
+"""
+import ast, hashlib, sys
+
+STORE = '/home/sentinel/sentinel/code/sentinel/state_store.py'
+BOSS  = '/home/sentinel/sentinel/code/sentinel/sentinel_boss.py'
+
+# ── 1. Add knowledge_cache to state_store ────────────────────────────────────
+
+with open(STORE, 'r', encoding='utf-8') as f:
+    store_src = f.read()
+
+OLD_MIGRATE_LIST = '''            ("create_pull_requests",'''
+
+if OLD_MIGRATE_LIST not in store_src:
+    print("ERROR: migrations anchor not found in state_store")
+    sys.exit(1)
+
+KNOWLEDGE_MIGRATION = '''            ("create_knowledge_cache",
+             """CREATE TABLE IF NOT EXISTS knowledge_cache (
+                    cache_key    TEXT    PRIMARY KEY,
+                    repo_name    TEXT    NOT NULL,
+                    question     TEXT    NOT NULL,
+                    answer       TEXT    NOT NULL,
+                    source_tool  TEXT    DEFAULT 'ask_codebase',
+                    cached_at    TEXT    NOT NULL,
+                    expires_at   TEXT    NOT NULL,
+                    hit_count    INTEGER DEFAULT 0
+                )"""),
+            ("create_pull_requests",'''
+
+store_src = store_src.replace(OLD_MIGRATE_LIST, KNOWLEDGE_MIGRATION, 1)
+print("Step 1a OK: knowledge_cache migration entry added")
+
+# Insert methods before get_all_errors
+KNOWLEDGE_METHODS = '''    # ── Knowledge cache (stable project Q&A) ────────────────────────────────
+
+    @staticmethod
+    def _knowledge_key(repo_name: str, question: str) -> str:
+        """Stable hash key for a (repo, question) pair."""
+        import re as _re
+        normalised = _re.sub(r"[^a-z0-9 ]", " ", question.lower().strip())
+        normalised = " ".join(normalised.split())[:200]
+        raw = f"{repo_name.lower()}::{normalised}"
+        return hashlib.sha256(raw.encode()).hexdigest()[:32]
+
+    def get_knowledge(self, repo_name: str, question: str) -> str | None:
+        """Return a cached answer if it exists and has not expired."""
+        key = self._knowledge_key(repo_name, question)
+        now = _now()
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT answer, expires_at, hit_count FROM knowledge_cache "
+                "WHERE cache_key=? AND expires_at > ?",
+                (key, now),
+            ).fetchone()
+            if row:
+                conn.execute(
+                    "UPDATE knowledge_cache SET hit_count=? WHERE cache_key=?",
+                    (row["hit_count"] + 1, key),
+                )
+                return row["answer"]
+        return None
+
+    def save_knowledge(self, repo_name: str, question: str, answer: str,
+                       ttl_hours: int = 24, source_tool: str = "ask_codebase") -> None:
+        """Cache an answer. Overwrites any existing entry for this key."""
+        from datetime import timedelta
+        key       = self._knowledge_key(repo_name, question)
+        now       = _now()
+        expires   = (datetime.now(timezone.utc) + timedelta(hours=ttl_hours)).isoformat()
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO knowledge_cache "
+                "(cache_key, repo_name, question, answer, source_tool, cached_at, expires_at, hit_count) "
+                "VALUES (?,?,?,?,?,?,?,0)",
+                (key, repo_name, question, answer, source_tool, now, expires),
+            )
+
+    def invalidate_knowledge(self, repo_name: str = "") -> int:
+        """Invalidate cached knowledge. Pass repo_name to clear one repo, or '' to clear all."""
+        with self._conn() as conn:
+            if repo_name:
+                cur = conn.execute(
+                    "DELETE FROM knowledge_cache WHERE repo_name LIKE ?",
+                    (f"%{repo_name}%",),
+                )
+            else:
+                cur = conn.execute("DELETE FROM knowledge_cache")
+        return cur.rowcount
+
+    def list_knowledge(self, repo_name: str = "") -> list[dict]:
+        """List cached knowledge entries (for admin inspection)."""
+        with self._conn() as conn:
+            if repo_name:
+                rows = conn.execute(
+                    "SELECT repo_name, question, cached_at, expires_at, hit_count, source_tool "
+                    "FROM knowledge_cache WHERE repo_name LIKE ? ORDER BY hit_count DESC",
+                    (f"%{repo_name}%",),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    "SELECT repo_name, question, cached_at, expires_at, hit_count, source_tool "
+                    "FROM knowledge_cache ORDER BY hit_count DESC LIMIT 100"
+                ).fetchall()
+        return [dict(r) for r in rows]
+
+'''
+
+STORE_ANCHOR = '''    def get_all_errors(self, hours: int = 0) -> list[dict]:'''
+if STORE_ANCHOR not in store_src:
+    print("ERROR: get_all_errors anchor not found in state_store")
+    sys.exit(1)
+
+# Also need to import hashlib at the top of state_store.py
+if 'import hashlib' not in store_src:
+    store_src = store_src.replace(
+        'import sqlite3\n',
+        'import hashlib\nimport sqlite3\n',
+        1
+    )
+    print("Step 1b OK: hashlib import added")
+
+store_src = store_src.replace(STORE_ANCHOR, KNOWLEDGE_METHODS + STORE_ANCHOR, 1)
+print("Step 1c OK: knowledge_cache methods added to state_store")
+
+with open(STORE, 'w', encoding='utf-8') as f:
+    f.write(store_src)
+
+try:
+    ast.parse(store_src)
+    print("state_store.py Syntax OK")
+except SyntaxError as e:
+    lines = store_src.splitlines()
+    print(f"SyntaxError at line {e.lineno}: {e.msg}")
+    for i in range(max(0, e.lineno-4), min(len(lines), e.lineno+3)):
+        print(f"  {i+1}: {lines[i]}")
+    sys.exit(1)
+
+# ── 2. Update ask_codebase handler in sentinel_boss.py ───────────────────────
+
+with open(BOSS, 'r', encoding='utf-8') as f:
+    boss = f.read()
+
+# Wrap _ask_one call with cache check/store
+OLD_ASK_ONE_CALL = '''        if len(matched) == 1:
+            result = _ask_one(*matched[0])
+            # Unwrap single-repo result for cleaner response
+            return json.dumps(result)
+
+        # Multiple repos — query each and combine
+        results = [_ask_one(rn, r) for rn, r in matched]
+        return json.dumps({"project": target, "repos_queried": len(results), "results": results})'''
+
+NEW_ASK_ONE_CALL = '''        def _ask_cached(repo_name, repo_cfg) -> dict:
+            # Check knowledge cache first (skip for issues mode — always fresh)
+            if mode != "issues":
+                cached = store.get_knowledge(repo_name, question)
+                if cached:
+                    logger.info("Boss ask_codebase %s: cache hit", repo_name)
+                    return {"repo": repo_name, "answer": cached, "cached": True}
+            result = _ask_one(repo_name, repo_cfg)
+            # Save to cache if we got a useful answer
+            if result.get("answer") and len(result["answer"]) > 50 and mode != "issues":
+                store.save_knowledge(repo_name, question, result["answer"], ttl_hours=24)
+            return result
+
+        if len(matched) == 1:
+            result = _ask_cached(*matched[0])
+            return json.dumps(result)
+
+        # Multiple repos — query each and combine
+        results = [_ask_cached(rn, r) for rn, r in matched]
+        return json.dumps({"project": target, "repos_queried": len(results), "results": results})'''
+
+if OLD_ASK_ONE_CALL not in boss:
+    print("ERROR: ask_codebase call block not found in boss")
+    sys.exit(1)
+boss = boss.replace(OLD_ASK_ONE_CALL, NEW_ASK_ONE_CALL, 1)
+print("Step 2 OK: ask_codebase now uses knowledge cache")
+
+# ── 3. Invalidate knowledge cache when a fix is applied ──────────────────────
+# Find where record_fix is called after a successful fix application
+
+OLD_RECORD_FIX = '''            if merge_resp.status_code == 200:
+                # Success
+                sha = merge_resp.json().get("sha", "")[:8]
+                store.record_fix(fp, "applied", branch=branch, pr_url=pr_url,
+                                 repo_name=repo_name, commit_hash=sha)
+                try:
+                    store.record_pr_decision(repo_name, int(pr_number), "merged", user_id)
+                except Exception:
+                    pass  # PR may not be in tracking table yet — non-fatal'''
+
+NEW_RECORD_FIX = '''            if merge_resp.status_code == 200:
+                # Success
+                sha = merge_resp.json().get("sha", "")[:8]
+                store.record_fix(fp, "applied", branch=branch, pr_url=pr_url,
+                                 repo_name=repo_name, commit_hash=sha)
+                try:
+                    store.record_pr_decision(repo_name, int(pr_number), "merged", user_id)
+                except Exception:
+                    pass  # PR may not be in tracking table yet — non-fatal
+                # Invalidate knowledge cache so next ask_codebase reflects the fix
+                try:
+                    store.invalidate_knowledge(repo_name)
+                except Exception:
+                    pass'''
+
+if OLD_RECORD_FIX not in boss:
+    print("WARNING: merge_pr Path B success block not found — cache invalidation on merge skipped")
+else:
+    boss = boss.replace(OLD_RECORD_FIX, NEW_RECORD_FIX, 1)
+    print("Step 3 OK: knowledge cache invalidated on merge")
+
+# ── 4. Add refresh_knowledge tool definition ──────────────────────────────────
+
+OLD_BEFORE_MERGE_DEF_2 = '''    {
+        "name": "list_prs",'''
+
+NEW_BEFORE_MERGE_DEF_2 = '''    {
+        "name": "refresh_knowledge",
+        "description": (
+            "Clear the knowledge cache so the next ask_codebase question fetches a fresh answer "
+            "instead of using the cached one. Use when the codebase has changed and you want "
+            "up-to-date answers. "
+            "e.g. 'refresh knowledge for TypeLib', 'clear codebase cache', "
+            "'force fresh answer for Java-SDK', 'list what is cached'"
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "repo": {
+                    "type": "string",
+                    "description": "Repo or project name to clear cache for. Omit to clear all cached knowledge.",
+                },
+                "list_only": {
+                    "type": "boolean",
+                    "description": "If true, just list what is cached without deleting anything.",
+                },
+            },
+        },
+    },
+    {
+        "name": "list_prs",'''
+
+if OLD_BEFORE_MERGE_DEF_2 not in boss:
+    print("ERROR: anchor before list_prs not found")
+    sys.exit(1)
+boss = boss.replace(OLD_BEFORE_MERGE_DEF_2, NEW_BEFORE_MERGE_DEF_2, 1)
+print("Step 4 OK: refresh_knowledge tool definition added")
+
+# ── 5. Add refresh_knowledge handler ──────────────────────────────────────────
+
+OLD_LIST_PRS_HANDLER = '''        if name == "list_prs":
+            if not is_admin:
+                return json.dumps({"error": "list_prs is admin-only. Ask a Sentinel admin (SLACK_ADMIN_USERS) to run this for you."})'''
+
+NEW_LIST_PRS_HANDLER = '''        if name == "refresh_knowledge":
+            repo_filter = inputs.get("repo", "").strip()
+            list_only   = bool(inputs.get("list_only", False))
+            if list_only:
+                entries = store.list_knowledge(repo_name=repo_filter)
+                if not entries:
+                    return json.dumps({"message": "Knowledge cache is empty.", "entries": []})
+                return json.dumps({
+                    "total": len(entries),
+                    "entries": [
+                        {
+                            "repo":       e["repo_name"],
+                            "question":   e["question"][:80],
+                            "cached_at":  e["cached_at"][:16],
+                            "expires_at": e["expires_at"][:16],
+                            "hits":       e["hit_count"],
+                            "tool":       e["source_tool"],
+                        }
+                        for e in entries
+                    ],
+                })
+            deleted = store.invalidate_knowledge(repo_name=repo_filter)
+            scope   = f"repo '{repo_filter}'" if repo_filter else "all repos"
+            logger.info("Boss refresh_knowledge: cleared %d entries for %s by %s", deleted, scope, user_id)
+            return json.dumps({
+                "status":  "cleared",
+                "deleted": deleted,
+                "scope":   scope,
+                "note":    "Next ask_codebase call will fetch a fresh answer from Claude.",
+            })
+
+        if name == "list_prs":
+            if not is_admin:
+                return json.dumps({"error": "list_prs is admin-only. Ask a Sentinel admin (SLACK_ADMIN_USERS) to run this for you."})'''
+
+if OLD_LIST_PRS_HANDLER not in boss:
+    print("ERROR: list_prs handler anchor not found")
+    sys.exit(1)
+boss = boss.replace(OLD_LIST_PRS_HANDLER, NEW_LIST_PRS_HANDLER, 1)
+print("Step 5 OK: refresh_knowledge handler added")
+
+with open(BOSS, 'w', encoding='utf-8') as f:
+    f.write(boss)
+print("Written OK")
+
+try:
+    ast.parse(boss)
+    print("sentinel_boss.py Syntax OK")
+except SyntaxError as e:
+    lines = boss.splitlines()
+    print(f"SyntaxError at line {e.lineno}: {e.msg}")
+    for i in range(max(0, e.lineno-5), min(len(lines), e.lineno+3)):
+        print(f"  {i+1}: {lines[i]}")
+    sys.exit(1)