@misterhuydo/sentinel 1.4.86 → 1.4.88

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-03-27T05:09:05.068Z",
-  "checkpoint_at": "2026-03-27T05:09:05.069Z",
+  "message": "Auto-checkpoint at 2026-03-27T05:16:34.970Z",
+  "checkpoint_at": "2026-03-27T05:16:34.971Z",
   "active_files": [],
   "notes": [],
   "mtime_snapshot": {}

package/package.json

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

package/python/sentinel/fix_engine.py

@@ -191,32 +191,118 @@ def _claude_cmd(bin_path: str, prompt: str) -> list[str]:
     return [bin_path, "--bare", "--print", prompt]
 
 
+# ── Claude output → human-readable progress ───────────────────────────────────
+
+# Tool-use lines emitted by Claude Code look like: "⏺ ToolName(args...)"
+_TOOL_USE_RE = re.compile(r'^[⏺⎆●✦]\s*(\w+)\s*\((.{0,120})', re.UNICODE)
+
+
+def _progress_from_line(line: str) -> str | None:
+    """
+    Convert a raw Claude Code output line into a brief Slack progress message.
+    Returns None for lines that are too noisy to show.
+    """
+    stripped = line.strip()
+    m = _TOOL_USE_RE.match(stripped)
+    if not m:
+        return None
+
+    tool = m.group(1)
+    args = m.group(2).rstrip(')')
+
+    if tool == "Bash":
+        cmd = args.strip()
+        if re.search(r'\bmvn\b.*\btest\b|\bgradle\b.*\btest\b', cmd):
+            return ":test_tube: Running tests..."
+        if re.search(r'\byarn\b.*\btest\b|\bnpm\b.*\btest\b', cmd):
+            return ":test_tube: Running tests..."
+        if re.search(r'\byarn\b.*\binstall\b|\bnpm\b.*\binstall\b', cmd):
+            return ":package: Installing dependencies..."
+        if re.search(r'\byarn\b\s*$|\byarn\b\s+build', cmd):
+            return ":package: Running yarn build..."
+        if re.search(r'\bmvn\b', cmd):
+            return ":hammer: Running Maven..."
+        if re.search(r'\bgradle\b|gradlew', cmd):
+            return ":hammer: Running Gradle..."
+        if re.search(r'\bgit\b.*\bcommit\b', cmd):
+            return ":floppy_disk: Committing changes..."
+        if re.search(r'\bgit\b.*\bpush\b', cmd):
+            return ":arrow_up: Pushing to remote..."
+        if re.search(r'\bnpm\b\s+install\b|\bnpm\b\s+ci\b', cmd):
+            return ":package: Installing npm packages..."
+        return None  # other bash — skip
+
+    if tool in ("Edit", "MultiEdit"):
+        fname = args.split(",")[0].strip().split("/")[-1]
+        if fname:
+            return f":pencil2: Patching `{fname}`"
+        return ":pencil2: Editing files..."
+
+    if tool == "Write":
+        fname = args.split(",")[0].strip().split("/")[-1]
+        if fname:
+            return f":pencil2: Writing `{fname}`"
+        return None
+
+    # Read, Glob, Grep, Agent, WebFetch → suppress
+    return None
+
+
 def _run_claude_attempt(
     bin_path: str,
     prompt: str,
     env: dict,
     cwd: str | None = None,
     claude_log_path: Path | None = None,
+    on_progress=None,
 ) -> tuple[str, bool]:
     """
     Run claude CLI with the given env. Returns (output, timed_out).
     Raises FileNotFoundError if binary is missing.
-    If claude_log_path is given, writes the full prompt + raw output there.
+    If on_progress is given, calls on_progress(msg) for meaningful output lines
+    (deduped — same message not repeated consecutively).
     """
+    import threading as _threading
+
+    proc = subprocess.Popen(
+        _claude_cmd(bin_path, prompt),
+        stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+        text=True, env=env, cwd=cwd or None,
+    )
+
+    timed_out_flag = [False]
+    def _kill():
+        timed_out_flag[0] = True
+        try:
+            proc.kill()
+        except Exception:
+            pass
+    timer = _threading.Timer(SUBPROCESS_TIMEOUT, _kill)
+    timer.start()
+
+    lines = []
+    last_progress = [None]
     try:
-        result = subprocess.run(
-            _claude_cmd(bin_path, prompt),
-            capture_output=True, text=True, timeout=SUBPROCESS_TIMEOUT, env=env,
-            cwd=cwd or None,
-        )
-        output = (result.stdout or "") + (result.stderr or "")
-        if claude_log_path:
-            _write_claude_log(claude_log_path, prompt, output, timed_out=False)
-        return output, False
-    except subprocess.TimeoutExpired:
-        if claude_log_path:
-            _write_claude_log(claude_log_path, prompt, "", timed_out=True)
-        return "", True
+        for line in proc.stdout:
+            lines.append(line)
+            if on_progress:
+                msg = _progress_from_line(line)
+                if msg and msg != last_progress[0]:
+                    last_progress[0] = msg
+                    try:
+                        on_progress(msg)
+                    except Exception:
+                        pass
+        proc.wait()
+    except Exception:
+        pass
+    finally:
+        timer.cancel()
+
+    output = "".join(lines)
+    if claude_log_path:
+        _write_claude_log(claude_log_path, prompt, output, timed_out=timed_out_flag[0])
+    return output, timed_out_flag[0]
 
 
 def _write_claude_log(log_path: Path, prompt: str, output: str, timed_out: bool) -> None:
@@ -241,6 +327,7 @@ def generate_fix(
     cfg: SentinelConfig,
     patches_dir: Path,
     store=None,
+    on_progress=None,
 ) -> tuple[str, Path | None, str]:
     """
     Generate a fix for the given error event.
@@ -310,7 +397,8 @@ def generate_fix(
                 continue
             logger.info("fix_engine: trying %s for %s", label, event.fingerprint)
             output, timed_out = _run_claude_attempt(
-                cfg.claude_code_bin, prompt, env, cwd=repo.local_path, claude_log_path=claude_log_path,
+                cfg.claude_code_bin, prompt, env, cwd=repo.local_path,
+                claude_log_path=claude_log_path, on_progress=on_progress,
             )
             if timed_out:
                 logger.error("Claude Code timed out for %s", event.fingerprint)

package/python/sentinel/main.py

@@ -316,8 +316,8 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
         )
         return  # Leave the file so admin can add the header
 
-    # Post "working on" to channel so everyone can see progress.
-    from .notify import slack_alert as _slack_alert
+    # Post "working on" to channel and capture thread_ts for progress replies
+    from .notify import slack_alert as _slack_alert, slack_thread_reply as _slack_reply
     _submitter = getattr(event, "submitter_user_id", "")
     _started_msg = (
         f":hammer: Working on *<@{_submitter}>*'s request — *{repo.repo_name}*\n"
@@ -325,15 +325,21 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
     ) if _submitter else (
         f":hammer: Working on *{repo.repo_name}*\n_{event.message[:120]}_"
     )
-    _slack_alert(sentinel.slack_bot_token, sentinel.slack_channel, _started_msg)
+    _thread_ts = _slack_alert(sentinel.slack_bot_token, sentinel.slack_channel, _started_msg)
+
+    def _progress(msg: str) -> None:
+        """Post a threaded reply under the 'Working on' message."""
+        _slack_reply(sentinel.slack_bot_token, sentinel.slack_channel, _thread_ts, msg)
 
     try:
         patches_dir = Path(sentinel.workspace_dir).resolve() / "patches"
         _loop = asyncio.get_event_loop()
 
-        # Run blocking subprocess work in thread executor so Boss stays responsive
+        # Run blocking subprocess work in thread executor so Boss stays responsive.
+        # _progress is thread-safe (HTTP POST) so pass it as streaming callback.
+        _progress(":brain: Analyzing with Claude Code...")
         status, patch_path, marker = await _loop.run_in_executor(
-            None, generate_fix, event, repo, sentinel, patches_dir, store
+            None, generate_fix, event, repo, sentinel, patches_dir, store, _progress
         )
 
         submitter_uid = getattr(event, "submitter_user_id", "")
@@ -342,6 +348,7 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
             store.record_fix(event.fingerprint, "skipped" if status in ("skip", "needs_human") else "failed",
                              repo_name=repo.repo_name)
             reason_text = marker if status == "needs_human" else f"Claude Code returned {status.upper()}"
+            _progress(f":x: Could not generate a safe fix — {reason_text[:120]}")
             notify_fix_blocked(sentinel, event.source, event.message,
                                reason=reason_text, repo_name=repo.repo_name,
                                submitter_user_id=submitter_uid)
@@ -349,11 +356,13 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
             return {"submitter": submitter_uid, "repo_name": repo.repo_name,
                     "status": "blocked", "summary": reason_text[:120], "pr_url": ""}
 
+        _progress(f":mag: Patch generated — running tests (`{repo.repo_name}`)...")
         commit_status, commit_hash = await _loop.run_in_executor(
             None, apply_and_commit, event, patch_path, repo, sentinel
         )
         if commit_status != "committed":
             store.record_fix(event.fingerprint, "failed", repo_name=repo.repo_name)
+            _progress(":x: Tests failed or patch couldn't apply — needs human review")
             notify_fix_blocked(sentinel, event.source, event.message,
                                reason="Patch was generated but commit/tests failed",
                                repo_name=repo.repo_name,
@@ -362,6 +371,7 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
             return {"submitter": submitter_uid, "repo_name": repo.repo_name,
                     "status": "blocked", "summary": "Commit/tests failed", "pr_url": ""}
 
+        _progress(f":white_check_mark: Tests passed — committed `{commit_hash[:8]}`, pushing to `{repo.branch}`...")
         branch, pr_url = publish(event, repo, sentinel, commit_hash)
         store.record_fix(
             event.fingerprint,
@@ -387,6 +397,8 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
             "auto_publish": repo.auto_publish,
             "files_changed": [],
         })
+        if pr_url:
+            _progress(f":arrow_right: <{pr_url}|PR opened> — awaiting review")
         notify_fix_applied(sentinel, event.source, event.message,
                            repo_name=repo.repo_name, branch=branch, pr_url=pr_url,
                            submitter_user_id=submitter_uid)
@@ -394,6 +406,8 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
 
         if repo.auto_publish:
             ok = cicd_trigger(repo, store, event.fingerprint)
+            if ok:
+                _progress(f":rocket: Release triggered via {repo.cicd_type}")
             if ok and repo.cicd_type.lower() in ("jenkins_release", "jenkins-release"):
                 _run_cascade(repo, sentinel, cfg_loader)
 
@@ -403,15 +417,18 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
     except MissingToolError as e:
         logger.warning("Missing tool for %s: %s", event.source, e)
         submitter_uid = getattr(event, "submitter_user_id", "")
+        _progress(f":wrench: `{e.tool}` not found — auto-installing...")
         installed = await _loop.run_in_executor(
             None, _auto_install_if_safe, e.tool, repo.local_path, sentinel, repo.repo_name, event.source
         )
         if not installed:
+            _progress(f":x: `{e.tool}` is not a known safe tool — manual install required")
             notify_missing_tool(sentinel, e.tool, repo.repo_name, event.source, submitter_uid)
             store.record_fix(event.fingerprint, "failed", repo_name=repo.repo_name)
             mark_done(event.issue_file)
             return {"submitter": submitter_uid, "repo_name": repo.repo_name,
                     "status": "blocked", "summary": f"Missing tool: {e.tool}", "pr_url": ""}
+        _progress(f":white_check_mark: `{e.tool}` installed — retrying tests...")
         # Tool installed — retry apply_and_commit once
         try:
             commit_status, commit_hash = await _loop.run_in_executor(
@@ -419,6 +436,7 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
             )
         except MissingToolError as e2:
             logger.error("Still missing tool after auto-install: %s", e2)
+            _progress(f":x: Still missing `{e2.tool}` after install — manual fix needed")
             notify_missing_tool(sentinel, e2.tool, repo.repo_name, event.source, submitter_uid)
             store.record_fix(event.fingerprint, "failed", repo_name=repo.repo_name)
             mark_done(event.issue_file)
@@ -426,12 +444,14 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
                     "status": "blocked", "summary": f"Missing tool: {e2.tool}", "pr_url": ""}
         if commit_status != "committed":
             store.record_fix(event.fingerprint, "failed", repo_name=repo.repo_name)
+            _progress(":x: Tests still failing after tool install — needs human review")
             notify_fix_blocked(sentinel, event.source, event.message,
                                reason="Patch was generated but commit/tests failed after tool install",
                                repo_name=repo.repo_name, submitter_user_id=submitter_uid)
             mark_done(event.issue_file)
             return {"submitter": submitter_uid, "repo_name": repo.repo_name,
                     "status": "blocked", "summary": "Commit/tests failed after tool install", "pr_url": ""}
+        _progress(f":white_check_mark: Tests passed — committed `{commit_hash[:8]}`, pushing to `{repo.branch}`...")
         branch, pr_url = publish(event, repo, sentinel, commit_hash)
         store.record_fix(
             event.fingerprint,
@@ -447,12 +467,16 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
             "branch": branch, "pr_url": pr_url,
             "auto_publish": repo.auto_publish, "files_changed": [],
         })
+        if pr_url:
+            _progress(f":arrow_right: <{pr_url}|PR opened> — awaiting review")
         notify_fix_applied(sentinel, event.source, event.message,
                            repo_name=repo.repo_name, branch=branch, pr_url=pr_url,
                            submitter_user_id=submitter_uid)
         mark_done(event.issue_file)
         if repo.auto_publish:
             ok = cicd_trigger(repo, store, event.fingerprint)
+            if ok:
+                _progress(f":rocket: Release triggered via {repo.cicd_type}")
             if ok and repo.cicd_type.lower() in ("jenkins_release", "jenkins-release"):
                 _run_cascade(repo, sentinel, cfg_loader)
         return {"submitter": submitter_uid, "repo_name": repo.repo_name,

package/python/sentinel/notify.py

@@ -127,29 +127,43 @@ def rate_limit_message(source: str, raw: str) -> str:
 
 # ── Alert dispatcher ──────────────────────────────────────────────────────────
 
-def slack_alert(bot_token: str, channel: str, text: str) -> None:
+def slack_alert(bot_token: str, channel: str, text: str, thread_ts: str = "") -> str:
     """
     Post a plain-text alert to a Slack channel.
     Best-effort: logs on failure, never raises.
+    Returns the message timestamp (ts) on success, "" on failure.
+    Pass thread_ts to reply inside an existing thread.
     """
     if not bot_token or not channel:
         logger.debug("slack_alert: no token/channel configured — logging only: %s", text[:120])
-        return
+        return ""
     try:
+        payload: dict = {"channel": channel, "text": text}
+        if thread_ts:
+            payload["thread_ts"] = thread_ts
         resp = requests.post(
             "https://slack.com/api/chat.postMessage",
             headers={
                 "Authorization": f"Bearer {bot_token}",
                 "Content-Type": "application/json",
             },
-            json={"channel": channel, "text": text},
+            json=payload,
             timeout=10,
         )
         data = resp.json()
         if not data.get("ok"):
             logger.warning("slack_alert: Slack API error: %s", data.get("error"))
+            return ""
+        return data.get("ts", "")
     except Exception as exc:
         logger.warning("slack_alert: failed to post: %s", exc)
+        return ""
+
+
+def slack_thread_reply(bot_token: str, channel: str, thread_ts: str, text: str) -> None:
+    """Post a reply in an existing Slack thread. No-op if thread_ts is empty."""
+    if thread_ts:
+        slack_alert(bot_token, channel, text, thread_ts=thread_ts)