@misterhuydo/sentinel 1.5.60 → 1.5.62

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-04-21T08:26:07.121Z",
-  "checkpoint_at": "2026-04-21T08:26:07.122Z",
+  "message": "Auto-checkpoint at 2026-04-21T09:35:34.502Z",
+  "checkpoint_at": "2026-04-21T09:35:34.503Z",
   "active_files": [
     "J:\\Projects\\Sentinel\\cli\\bin\\sentinel.js",
     "J:\\Projects\\Sentinel\\cli\\lib\\test.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misterhuydo/sentinel",
-  "version": "1.5.60",
+  "version": "1.5.62",
   "description": "Sentinel — Autonomous DevOps Agent installer and manager",
   "bin": {
     "sentinel": "./bin/sentinel.js"

package/python/sentinel/__init__.py

@@ -1 +1 @@
-__version__ = "1.5.60"
+__version__ = "1.5.62"

package/python/sentinel/main.py

@@ -1770,6 +1770,44 @@ def _format_monitor_step_output(tool: str, raw: str) -> str | None:
             text += f"\n_…and {len(matches) - 200} more_"
         return f"```\n{text}\n```"
 
+    # ── search_logs ───────────────────────────────────────────────────────────
+    if tool == "search_logs":
+        hits = data.get("results") or data.get("matches") or []
+        if not hits:
+            return None
+        lines = [
+            f"[{h.get('source','?')}] {h.get('line', h)}" if isinstance(h, dict) else str(h)
+            for h in hits[:200]
+        ]
+        text = "\n".join(lines)
+        if len(hits) > 200:
+            text += f"\n_…and {len(hits) - 200} more_"
+        return f"```\n{text}\n```"
+
+    # ── list_pending_prs ──────────────────────────────────────────────────────
+    if tool == "list_pending_prs":
+        prs = data.get("prs") or data.get("results") or []
+        if not prs:
+            return None
+        lines = [
+            f"• [{p.get('repo','?')}] {p.get('title','?')} — {p.get('url') or p.get('pr_url','')}"
+            if isinstance(p, dict) else str(p)
+            for p in prs
+        ]
+        return "\n".join(lines)
+
+    # ── get_repo_status ───────────────────────────────────────────────────────
+    if tool == "get_repo_status":
+        repos = data.get("repos") or (data.get("repo") and [data]) or []
+        if not repos:
+            return raw.strip() or None
+        lines = []
+        for r in repos:
+            name   = r.get("repo") or r.get("name", "?")
+            status = r.get("status") or r.get("summary", "")
+            lines.append(f"• *{name}*: {status}")
+        return "\n".join(lines) or None
+
     # ── get_status / check_health / others — always show ─────────────────────
     if "error" in data:
         return f":warning: `{tool}` error: {data['error']}"
@@ -1846,28 +1884,47 @@ async def _execute_monitor(monitor: dict, cfg_loader: ConfigLoader, store: State
     # Only post if there is something to show
     if formatted_parts:
         combined = "\n".join(formatted_parts)
-        # Slack section blocks are capped at 3000 chars — keep content well under
-        MAX_LEN  = 2900
-        if len(combined) > MAX_LEN:
-            tail = combined[:MAX_LEN]
-            # Close any unclosed code block before the truncation note
-            if tail.count("```") % 2 == 1:
-                tail += "\n```"
-            combined = tail + f"\n_…truncated ({len(combined)} chars total)_"
         header = f":repeat: *Monitor `{mon_id}`* ({mon_name}) — run #{runs_after}"
         if done:
             header += " _(final)_"
-        try:
-            await slack_client.chat_postMessage(
-                channel=channel,
-                text=header,  # plain-text fallback for notifications
-                blocks=[
-                    {"type": "section", "text": {"type": "mrkdwn", "text": header}},
-                    {"type": "section", "text": {"type": "mrkdwn", "text": combined}},
-                ],
-            )
-        except Exception as e:
-            logger.warning("Monitor %s: Slack post failed: %s", mon_id, e)
+
+        # Split into 2900-char chunks (Slack section block limit is 3000).
+        # Chunk on line boundaries where possible; preserve open/close ``` pairs.
+        CHUNK = 2900
+        chunks: list[str] = []
+        remaining = combined
+        while remaining:
+            if len(remaining) <= CHUNK:
+                chunks.append(remaining)
+                break
+            # Find last newline within the limit
+            split_at = remaining.rfind("\n", 0, CHUNK)
+            if split_at == -1:
+                split_at = CHUNK
+            piece = remaining[:split_at]
+            rest  = remaining[split_at:].lstrip("\n")
+            # Close any unclosed code block so each chunk is self-contained,
+            # and reopen it at the start of the next chunk
+            if piece.count("```") % 2 == 1:
+                piece += "\n```"
+                rest   = "```\n" + rest
+            chunks.append(piece)
+            remaining = rest
+
+        for i, chunk in enumerate(chunks):
+            chunk_header = header if i == 0 else f"_{mon_name} continued ({i + 1}/{len(chunks)})_"
+            try:
+                await slack_client.chat_postMessage(
+                    channel=channel,
+                    text=chunk_header,
+                    blocks=[
+                        {"type": "section", "text": {"type": "mrkdwn", "text": chunk_header}},
+                        {"type": "section", "text": {"type": "mrkdwn", "text": chunk}},
+                    ],
+                )
+            except Exception as e:
+                logger.warning("Monitor %s: Slack post chunk %d failed: %s", mon_id, i, e)
+                break
 
     if done:
         try:

package/python/sentinel/sentinel_boss.py

@@ -374,8 +374,18 @@ reply with a grouped summary like this:
     – "every X min for Y hours/days" → calculate stop_at = now + duration
     – "every X min for N times" → set max_runs=N
     – "every X min until <datetime>" → set stop_at
-  Minimum interval: 60 seconds. Allowed tools: fetch_logs, filter_logs, get_status,
-  ask_logs, list_recent_commits, check_health.
+  Minimum interval: 60 seconds.
+  When a user asks what monitors can do or what tools are available for monitors, list all
+  allowed tools with a one-line description of each use case:
+    • fetch_logs — pull fresh logs from SSH servers (with optional filter/grep)
+    • filter_logs — search already-fetched logs by pattern
+    • ask_logs — ask an AI question about fetched log content
+    • get_status — Sentinel's error/fix summary for the last N hours
+    • check_health — health check on a service or repo
+    • list_recent_commits — recent commits across monitored repos
+    • search_logs — search indexed log history for a pattern across all sources
+    • list_pending_prs — show open Sentinel PRs waiting for review
+    • get_repo_status — git status of a repo (behind main, diverged, dirty, etc.)
   Always confirm to the user with the monitor ID and stop condition before creating.
 • `stop_monitor` — delete a monitor by ID (stops it if active); pass "all" to delete all in this channel
 • `list_monitors` — show active monitors plus completed/cancelled ones from the last 24 hours
@@ -1347,14 +1357,16 @@ _TOOLS = [
             "results to this Slack channel. Supports: run indefinitely (until stopped), run for "
             "a fixed duration (stop_at), or run N times (max_runs). "
             "steps is a list of {tool, inputs} objects — most monitors are a single step. "
-            "Allowed tools: fetch_logs, filter_logs, get_status, ask_logs, list_recent_commits, check_health. "
+            "Allowed tools: fetch_logs, filter_logs, get_status, ask_logs, list_recent_commits, "
+            "check_health, search_logs, list_pending_prs, get_repo_status. "
             "Boss calculates stop_at from phrases like 'within 2 hours' / 'for 30 minutes' using "
             "the current UTC time in the system prompt. "
             "IMPORTANT: ALWAYS call list_monitors FIRST to get the live DB state before calling "
             "this tool — never infer active monitors from conversation history, as finished monitors "
             "are deleted and context window state will be stale. "
             "Examples: 'fetch SSOLWA logs filtered by provision/phone every 5 min for 2 hours', "
-            "'check STS health every 10 min until I say stop', 'get status every hour for 3 times'."
+            "'check STS health every 10 min until I say stop', 'search logs for OOM every 10 min', "
+            "'watch for pending PRs every 30 min', 'monitor repo drift every hour'."
         ),
         "input_schema": {
             "type": "object",
@@ -3534,7 +3546,8 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
             return json.dumps({"error": f"interval_seconds must be >= 60 (minimum 1 minute), got {interval_s}"})
 
         _MONITOR_ALLOWED = {"fetch_logs", "filter_logs", "get_status", "ask_logs",
-                            "list_recent_commits", "check_health"}
+                            "list_recent_commits", "check_health",
+                            "search_logs", "list_pending_prs", "get_repo_status"}
         for _step in steps:
             _t = _step.get("tool", "")
             if _t not in _MONITOR_ALLOWED: