@misterhuydo/sentinel 1.5.51 → 1.5.52

package/package.json

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

package/python/sentinel/__init__.py

@@ -1 +1 @@
-__version__ = "1.5.51"
+__version__ = "1.5.52"

package/python/sentinel/sentinel_boss.py

@@ -5192,6 +5192,21 @@ async def _handle_with_api(
     else:
         user_time_hint = ""
     _known_projects = [_read_project_name(d) for d in _find_project_dirs()]
+
+    # Build alias map: repo → [alias, alias, ...] from config + DB
+    _alias_lines: list[str] = []
+    for _rname, _rcfg in cfg_loader.repos.items():
+        _aliases = list(getattr(_rcfg, "service_aliases", []))
+        # also pull DB-stored aliases for this repo
+        _db_aliases = [r["service_name"] for r in (store.get_all_service_aliases() if hasattr(store, "get_all_service_aliases") else []) if r.get("repo_name") == _rname]
+        _all = list(dict.fromkeys(_aliases + _db_aliases))  # dedupe, preserve order
+        if _all:
+            _alias_lines.append(f"  {_rname} = {', '.join(_all)}")
+    _aliases_block = (
+        "\nService alias map (short names → repo):\n" + "\n".join(_alias_lines)
+        if _alias_lines else ""
+    )
+
     system = (
         _resolve_system(
             boss_mode=getattr(cfg_loader.sentinel, "boss_mode", "standard"),
@@ -5207,6 +5222,12 @@ async def _handle_with_api(
         + (f"\n{user_time_hint}" if user_time_hint else "")
         + f"\nSentinel status: {'⏸ PAUSED' if paused else '▶ RUNNING'}"
         + f"\nManaged repos: {', '.join(repos) if repos else '(none configured)'}"
+        + _aliases_block
+        + "\nUNKNOWN SERVICE NAME RULE: If the user mentions a service/repo shorthand that is NOT"
+        + " in 'Managed repos' and NOT in the alias map above, ask EXACTLY: \"What is <name>?\""
+        + " before doing anything else. When the user answers with a repo name, immediately call"
+        + " save_service_alias(service_name=<name>, repo_name=<answer>), then proceed with the"
+        + " original request. Never guess or assume — always ask and save."
         + (f"\nLog sources: {', '.join(log_sources)}" if log_sources else "")
         + (f"\nKnown projects in workspace: {', '.join(known_projects)}" if known_projects else "")
         + f"\nAdmin access for this user: {'YES — admin tools are available' if is_admin else 'NO — admin tools will be refused'}"

package/python/sentinel/slack_bot.py

@@ -181,16 +181,33 @@ import uuid as _uuid
 from pathlib import Path as _Path
 
 
-def _infer_target_repo(text: str, repos: dict, store=None) -> str:
+def _infer_target_repo(text: str, repos: dict, store=None, bot_name: str = "") -> str:
     """
     Try to infer a target repo from bot message content.
-    Checks in order:
-      1. SERVICE_ALIASES declared in repo config files (e.g. SERVICE_ALIASES=STS,SecurityTokenService)
-      2. Saved aliases in DB (learned at runtime via Boss conversation)
-      3. Case-insensitive substring match against repo names
-    Returns the repo name on a unique match, empty string otherwise.
+    Strategy:
+      1. Full-text scan: check every repo's SERVICE_ALIASES as whole-word matches in text.
+         If exactly one repo matches → use it. Avoids needing a specific "Service: <name>" pattern.
+      2. Structured hints (Service:/Class: patterns) → config aliases → DB aliases → substring.
+      3. DB aliases keyed on bot_name (for bots registered via save_service_alias).
+    Returns the repo name on an unambiguous match, empty string otherwise.
     """
     import re as _re
+
+    text_lower = text.lower()
+
+    # 1. Full-text scan of all config-declared SERVICE_ALIASES
+    matched_repos: set[str] = set()
+    for repo_name, repo in repos.items():
+        declared = getattr(repo, "service_aliases", [])
+        for alias in declared:
+            # whole-word match (handles "STS", "SSOLWA", "SecurityTokenService", etc.)
+            if _re.search(r'(?i)\b' + _re.escape(alias) + r'\b', text):
+                matched_repos.add(repo_name)
+                break
+    if len(matched_repos) == 1:
+        return next(iter(matched_repos))
+
+    # 2. Structured hints: "Service: X" or "Class: X" patterns
     hints = _re.findall(r'(?i)service:\s*(\S+)', text)
     hints += _re.findall(r'(?i)class:\s*(\w+)', text)
 
@@ -198,23 +215,29 @@ def _infer_target_repo(text: str, repos: dict, store=None) -> str:
         hint_clean = hint.rstrip(".,:")
         hint_lower = hint_clean.lower()
 
-        # 1. Config-declared SERVICE_ALIASES (authoritative, version-controlled)
+        # Config aliases (already checked above but try exact match here too)
         for repo_name, repo in repos.items():
             declared = getattr(repo, "service_aliases", [])
             if any(hint_lower == a.lower() for a in declared):
                 return repo_name
 
-        # 2. Runtime DB aliases (learned via Boss conversation)
+        # DB aliases
         if store:
             alias = store.get_service_alias(hint_clean)
             if alias and alias in repos:
                 return alias
 
-        # 3. Case-insensitive substring match against repo names
+        # Substring match against repo names
         sub_matches = [r for r in repos if hint_lower in r.lower()]
         if len(sub_matches) == 1:
             return sub_matches[0]
 
+    # 3. DB alias keyed on bot_name (for bots explicitly mapped via save_service_alias)
+    if bot_name and store:
+        alias = store.get_service_alias(bot_name)
+        if alias and alias in repos:
+            return alias
+
     return ""
 
 
@@ -261,35 +284,36 @@ async def _handle_bot_message(event: dict, client, cfg_loader, store) -> None:
     target_repo  = (bot_info or {}).get("target_repo") or ""
 
     # Auto-detect target_repo from message content when not pre-configured
+    bot_name = (bot_info or {}).get("bot_name") or bot_id
     if not target_repo and hasattr(cfg_loader, "repos") and cfg_loader.repos:
-        target_repo = _infer_target_repo(text, cfg_loader.repos, store=store)
+        target_repo = _infer_target_repo(text, cfg_loader.repos, store=store, bot_name=bot_name)
         if not target_repo and len(cfg_loader.repos) > 1:
             # Can't determine — ask in the channel and store as pending routing
-            bot_name = (bot_info or {}).get("bot_name") or bot_id
             service_hint = _extract_service_hint(text)
-            hint_label = f"`{service_hint}`" if service_hint else "this alert"
-            repo_names = ", ".join(f"`{r}`" for r in sorted(cfg_loader.repos))
+            # Use bot_name as the routing key when no service hint found in message
+            routing_key = service_hint or bot_name
+            if service_hint:
+                question = f":mag: Got an alert from *{bot_name}* — what repo is `{service_hint}`?"
+            else:
+                preview = text[:120].replace("\n", " ")
+                question = f":mag: Got an alert from *{bot_name}* — which repo does this belong to?\n_{preview}_"
             try:
-                await client.chat_postMessage(
-                    channel=channel,
-                    text=f":mag: Got an alert from *{bot_name}* — what repo is `{service_hint}`?",
-                )
+                await client.chat_postMessage(channel=channel, text=question)
             except Exception as _e:
                 logger.warning("Bot watcher: could not post routing question: %s", _e)
             # Store as pending so Boss can reprocess when user replies
-            if service_hint:
-                try:
-                    default_issues = str(_Path(cfg_loader.sentinel.workspace_dir).parent / "issues")
-                    store.add_pending_routing(
-                        service_hint=service_hint,
-                        bot_id=bot_id,
-                        channel=channel,
-                        ts=ts,
-                        content=text,
-                        issues_dir=default_issues,
-                    )
-                except Exception as _e:
-                    logger.warning("Bot watcher: could not store pending routing: %s", _e)
+            try:
+                default_issues = str(_Path(cfg_loader.sentinel.workspace_dir).parent / "issues")
+                store.add_pending_routing(
+                    service_hint=routing_key,
+                    bot_id=bot_id,
+                    channel=channel,
+                    ts=ts,
+                    content=text,
+                    issues_dir=default_issues,
+                )
+            except Exception as _e:
+                logger.warning("Bot watcher: could not store pending routing: %s", _e)
             return  # drop this message until routing is resolved
 
     # Resolve the project issues directory