@smilintux/skcapstone 0.4.6 → 0.5.0

package/src/skcapstone/cli/itil.py

@@ -0,0 +1,434 @@
+"""ITIL service management CLI commands."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+
+import click
+
+from ._common import AGENT_HOME, SHARED_ROOT, console
+
+
+def register_itil_commands(main: click.Group) -> None:
+    """Register the itil command group."""
+
+    @main.group()
+    def itil():
+        """ITIL service management — incidents, problems, changes."""
+
+    # ── itil status ───────────────────────────────────────────────────
+
+    @itil.command("status")
+    def itil_status():
+        """Show ITIL dashboard: open incidents, active problems, pending changes."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        status = mgr.get_status()
+
+        inc = status["incidents"]
+        prb = status["problems"]
+        chg = status["changes"]
+        kedb = status["kedb"]
+
+        console.print(f"\n[bold]ITIL Dashboard[/bold]")
+        console.print(f"  Incidents:  [red]{inc['open']}[/red] open / {inc['total']} total")
+        for sev, count in inc.get("by_severity", {}).items():
+            if count:
+                console.print(f"    {sev}: {count}")
+        console.print(f"  Problems:   [yellow]{prb['active']}[/yellow] active / {prb['total']} total")
+        console.print(f"  Changes:    [blue]{chg['pending']}[/blue] pending / {chg['total']} total")
+        console.print(f"  KEDB:       {kedb['total']} entries")
+
+        if inc["open_list"]:
+            console.print(f"\n[bold red]Open Incidents:[/bold red]")
+            for i in inc["open_list"]:
+                console.print(
+                    f"  [{i['id']}] {i['severity'].upper()} {i['title']} "
+                    f"({i['status']}) @{i['managed_by']}"
+                )
+
+        if chg["pending_list"]:
+            console.print(f"\n[bold blue]Pending Changes:[/bold blue]")
+            for c in chg["pending_list"]:
+                console.print(
+                    f"  [{c['id']}] {c['title']} ({c['status']}, "
+                    f"{c['change_type']}) @{c['managed_by']}"
+                )
+
+        console.print()
+
+    # ── itil incident ─────────────────────────────────────────────────
+
+    @itil.group()
+    def incident():
+        """Incident management."""
+
+    @incident.command("create")
+    @click.option("--title", "-t", required=True, help="Incident title")
+    @click.option(
+        "--severity", "-s", default="sev3",
+        type=click.Choice(["sev1", "sev2", "sev3", "sev4"]),
+        help="Severity level",
+    )
+    @click.option("--service", multiple=True, help="Affected service(s)")
+    @click.option("--impact", default="", help="Business impact")
+    @click.option("--by", "managed_by", default="human", help="Managing agent")
+    @click.option("--tag", multiple=True, help="Tags")
+    def incident_create(title, severity, service, impact, managed_by, tag):
+        """Create a new incident."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        inc = mgr.create_incident(
+            title=title,
+            severity=severity,
+            affected_services=list(service),
+            impact=impact,
+            managed_by=managed_by,
+            created_by=managed_by,
+            tags=list(tag),
+        )
+        console.print(
+            f"\n  [green]Created:[/green] {inc.id} — {inc.title} "
+            f"({inc.severity.value}, {inc.status.value})"
+        )
+        if inc.gtd_item_ids:
+            console.print(f"  [dim]GTD item(s): {', '.join(inc.gtd_item_ids)}[/dim]")
+        console.print()
+
+    @incident.command("list")
+    @click.option(
+        "--status", type=click.Choice([
+            "detected", "acknowledged", "investigating",
+            "escalated", "resolved", "closed",
+        ]),
+        help="Filter by status",
+    )
+    @click.option(
+        "--severity",
+        type=click.Choice(["sev1", "sev2", "sev3", "sev4"]),
+        help="Filter by severity",
+    )
+    @click.option("--service", help="Filter by affected service")
+    def incident_list(status, severity, service):
+        """List incidents."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        incidents = mgr.list_incidents(status=status, severity=severity, service=service)
+
+        if not incidents:
+            console.print("\n  [dim]No incidents found[/dim]\n")
+            return
+
+        console.print(f"\n[bold]Incidents ({len(incidents)}):[/bold]")
+        for i in incidents:
+            sev = i.severity.value.upper()
+            console.print(
+                f"  [{i.id}] {sev} {i.title} ({i.status.value}) @{i.managed_by}"
+            )
+        console.print()
+
+    @incident.command("update")
+    @click.argument("incident_id")
+    @click.option("--agent", default="human", help="Agent making the update")
+    @click.option(
+        "--status", "new_status",
+        type=click.Choice([
+            "acknowledged", "investigating", "escalated", "resolved", "closed",
+        ]),
+        help="New status",
+    )
+    @click.option(
+        "--severity",
+        type=click.Choice(["sev1", "sev2", "sev3", "sev4"]),
+        help="New severity",
+    )
+    @click.option("--note", default="", help="Timeline note")
+    @click.option("--resolution", default=None, help="Resolution summary")
+    def incident_update(incident_id, agent, new_status, severity, note, resolution):
+        """Update an incident status or metadata."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        try:
+            inc = mgr.update_incident(
+                incident_id=incident_id,
+                agent=agent,
+                new_status=new_status,
+                severity=severity,
+                note=note,
+                resolution_summary=resolution,
+            )
+            console.print(
+                f"\n  [green]Updated:[/green] {inc.id} -> {inc.status.value} "
+                f"({inc.severity.value})\n"
+            )
+        except ValueError as exc:
+            console.print(f"\n  [red]Error:[/red] {exc}\n")
+
+    # ── itil problem ──────────────────────────────────────────────────
+
+    @itil.group()
+    def problem():
+        """Problem management."""
+
+    @problem.command("create")
+    @click.option("--title", "-t", required=True, help="Problem title")
+    @click.option("--by", "managed_by", default="human", help="Managing agent")
+    @click.option("--incident", "incident_ids", multiple=True, help="Related incident ID(s)")
+    @click.option("--workaround", default="", help="Known workaround")
+    @click.option("--tag", multiple=True, help="Tags")
+    def problem_create(title, managed_by, incident_ids, workaround, tag):
+        """Create a new problem record."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        prb = mgr.create_problem(
+            title=title,
+            managed_by=managed_by,
+            created_by=managed_by,
+            related_incident_ids=list(incident_ids),
+            workaround=workaround,
+            tags=list(tag),
+        )
+        console.print(
+            f"\n  [green]Created:[/green] {prb.id} — {prb.title} ({prb.status.value})\n"
+        )
+
+    @problem.command("list")
+    @click.option(
+        "--status",
+        type=click.Choice(["identified", "analyzing", "known_error", "resolved"]),
+        help="Filter by status",
+    )
+    def problem_list(status):
+        """List problems."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        problems = mgr.list_problems(status=status)
+
+        if not problems:
+            console.print("\n  [dim]No problems found[/dim]\n")
+            return
+
+        console.print(f"\n[bold]Problems ({len(problems)}):[/bold]")
+        for p in problems:
+            console.print(
+                f"  [{p.id}] {p.title} ({p.status.value}) @{p.managed_by}"
+            )
+        console.print()
+
+    @problem.command("update")
+    @click.argument("problem_id")
+    @click.option("--agent", default="human", help="Agent making the update")
+    @click.option(
+        "--status", "new_status",
+        type=click.Choice(["analyzing", "known_error", "resolved"]),
+        help="New status",
+    )
+    @click.option("--root-cause", default=None, help="Root cause description")
+    @click.option("--workaround", default=None, help="Workaround")
+    @click.option("--note", default="", help="Timeline note")
+    @click.option("--create-kedb", is_flag=True, help="Create KEDB entry")
+    def problem_update(problem_id, agent, new_status, root_cause, workaround, note, create_kedb):
+        """Update a problem record."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        try:
+            prb = mgr.update_problem(
+                problem_id=problem_id,
+                agent=agent,
+                new_status=new_status,
+                root_cause=root_cause,
+                workaround=workaround,
+                note=note,
+                create_kedb=create_kedb,
+            )
+            console.print(
+                f"\n  [green]Updated:[/green] {prb.id} -> {prb.status.value}\n"
+            )
+            if prb.kedb_id:
+                console.print(f"  [dim]KEDB entry: {prb.kedb_id}[/dim]\n")
+        except ValueError as exc:
+            console.print(f"\n  [red]Error:[/red] {exc}\n")
+
+    # ── itil change ───────────────────────────────────────────────────
+
+    @itil.group()
+    def change():
+        """Change management (RFC)."""
+
+    @change.command("propose")
+    @click.option("--title", "-t", required=True, help="Change title")
+    @click.option(
+        "--type", "change_type", default="normal",
+        type=click.Choice(["standard", "normal", "emergency"]),
+        help="Change type",
+    )
+    @click.option(
+        "--risk", default="medium",
+        type=click.Choice(["low", "medium", "high"]),
+        help="Risk level",
+    )
+    @click.option("--rollback", default="", help="Rollback plan")
+    @click.option("--test-plan", default="", help="Test plan")
+    @click.option("--by", "managed_by", default="human", help="Managing agent")
+    @click.option("--implementer", default=None, help="Implementing agent")
+    @click.option("--problem", "related_problem_id", default=None, help="Related problem ID")
+    @click.option("--tag", multiple=True, help="Tags")
+    def change_propose(title, change_type, risk, rollback, test_plan,
+                       managed_by, implementer, related_problem_id, tag):
+        """Propose a new change (RFC)."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        chg = mgr.propose_change(
+            title=title,
+            change_type=change_type,
+            risk=risk,
+            rollback_plan=rollback,
+            test_plan=test_plan,
+            managed_by=managed_by,
+            created_by=managed_by,
+            implementer=implementer,
+            related_problem_id=related_problem_id,
+            tags=list(tag),
+        )
+        console.print(
+            f"\n  [green]Proposed:[/green] {chg.id} — {chg.title} "
+            f"({chg.change_type.value}, {chg.status.value})\n"
+        )
+
+    @change.command("list")
+    @click.option(
+        "--status",
+        type=click.Choice([
+            "proposed", "reviewing", "approved", "rejected",
+            "implementing", "deployed", "verified", "failed", "closed",
+        ]),
+        help="Filter by status",
+    )
+    def change_list(status):
+        """List changes."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        changes = mgr.list_changes(status=status)
+
+        if not changes:
+            console.print("\n  [dim]No changes found[/dim]\n")
+            return
+
+        console.print(f"\n[bold]Changes ({len(changes)}):[/bold]")
+        for c in changes:
+            console.print(
+                f"  [{c.id}] {c.title} ({c.status.value}, "
+                f"{c.change_type.value}) @{c.managed_by}"
+            )
+        console.print()
+
+    @change.command("update")
+    @click.argument("change_id")
+    @click.option("--agent", default="human", help="Agent making the update")
+    @click.option(
+        "--status", "new_status",
+        type=click.Choice([
+            "reviewing", "approved", "rejected", "implementing",
+            "deployed", "verified", "failed", "closed",
+        ]),
+        help="New status",
+    )
+    @click.option("--note", default="", help="Timeline note")
+    def change_update(change_id, agent, new_status, note):
+        """Update a change status."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        try:
+            chg = mgr.update_change(
+                change_id=change_id,
+                agent=agent,
+                new_status=new_status,
+                note=note,
+            )
+            console.print(
+                f"\n  [green]Updated:[/green] {chg.id} -> {chg.status.value}\n"
+            )
+        except ValueError as exc:
+            console.print(f"\n  [red]Error:[/red] {exc}\n")
+
+    # ── itil cab ──────────────────────────────────────────────────────
+
+    @itil.group()
+    def cab():
+        """Change Advisory Board voting."""
+
+    @cab.command("vote")
+    @click.argument("change_id")
+    @click.option("--agent", default="human", help="Voting agent")
+    @click.option(
+        "--decision", default="approved",
+        type=click.Choice(["approved", "rejected", "abstain"]),
+        help="Vote decision",
+    )
+    @click.option("--conditions", default="", help="Approval conditions")
+    def cab_vote(change_id, agent, decision, conditions):
+        """Submit a CAB vote for a change."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        vote = mgr.submit_cab_vote(
+            change_id=change_id,
+            agent=agent,
+            decision=decision,
+            conditions=conditions,
+        )
+        console.print(
+            f"\n  [green]Voted:[/green] {vote.agent} -> {vote.decision.value} "
+            f"on {vote.change_id}\n"
+        )
+
+    # ── itil kedb ─────────────────────────────────────────────────────
+
+    @itil.group()
+    def kedb():
+        """Known Error Database."""
+
+    @kedb.command("search")
+    @click.argument("query")
+    def kedb_search(query):
+        """Search the Known Error Database."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        results = mgr.search_kedb(query)
+
+        if not results:
+            console.print(f"\n  [dim]No KEDB entries matching '{query}'[/dim]\n")
+            return
+
+        console.print(f"\n[bold]KEDB Results ({len(results)}):[/bold]")
+        for e in results:
+            console.print(f"  [{e.id}] {e.title}")
+            if e.workaround:
+                console.print(f"    [dim]Workaround: {e.workaround[:100]}[/dim]")
+            if e.root_cause:
+                console.print(f"    [dim]Root cause: {e.root_cause[:100]}[/dim]")
+        console.print()
+
+    # ── itil board ────────────────────────────────────────────────────
+
+    @itil.command("board")
+    def itil_board():
+        """Generate ITIL-BOARD.md overview."""
+        from ..itil import ITILManager
+
+        mgr = ITILManager(Path(SHARED_ROOT).expanduser())
+        path = mgr.write_board_md()
+        console.print(f"\n  [green]Generated:[/green] {path}\n")

package/src/skcapstone/cli/memory.py

@@ -463,8 +463,8 @@ def register_memory_commands(main: click.Group) -> None:
             try:
                 from ..memory_adapter import get_unified, entry_to_memory
                 unified = get_unified()
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.warning("Memory adapter unavailable, falling back to file-only mode: %s", exc)
 
             for layer in MemoryLayer:
                 layer_dir = mem_dir / layer.value
@@ -481,8 +481,8 @@ def register_memory_commands(main: click.Group) -> None:
                                 if existing:
                                     skipped += 1
                                     continue
-                            except Exception:
-                                pass
+                            except Exception as exc:
+                                logger.debug("Failed to check existing memory %s: %s", mem_id, exc)
 
                         if unified:
                             from ..models import MemoryEntry

package/src/skcapstone/cli/skills_cmd.py

@@ -114,8 +114,8 @@ def register_skills_commands(main: click.Group) -> None:
                 try:
                     skill_entries = client.search(query) if query else client.list_skills()
                     source = "remote"
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("Registry client query failed, falling back: %s", exc)
 
         # 2. Try GitHub raw catalog (always fresh, no server needed)
         if skill_entries is None and not offline:

package/src/skcapstone/cli/soul.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import shutil
 import sys
 from datetime import datetime, timezone
@@ -18,6 +19,8 @@ from .. import SKCAPSTONE_AGENT
 from rich.panel import Panel
 from rich.table import Table
 
+logger = logging.getLogger(__name__)
+
 # Path to the soul-blueprints repository (community blueprints)
 _BLUEPRINTS_REPO = Path.home() / "clawd" / "soul-blueprints" / "blueprints"
 
@@ -332,8 +335,8 @@ def register_soul_commands(main: click.Group) -> None:
                 import json
                 base_data = json.loads(base_path.read_text(encoding="utf-8"))
                 vibe = base_data.get("vibe", "")
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.warning("Failed to read vibe from soul base.json: %s", exc)
 
         lines = [
             f"Agent: [bold magenta]{agent}[/]",

package/src/skcapstone/cli/status.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import os
 import shutil
 import sys
@@ -19,6 +20,8 @@ from ..runtime import get_runtime
 from rich.panel import Panel
 from rich.table import Table
 
+logger = logging.getLogger(__name__)
+
 
 def _probe_llm_backends() -> dict[str, bool]:
     """Probe LLM backend availability.
@@ -43,8 +46,8 @@ def _probe_llm_backends() -> dict[str, bool]:
             urllib.request.Request(f"{host}/api/tags"), timeout=2
         ):
             backends["ollama"] = True
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("Ollama probe failed (not available): %s", exc)
     return backends
 
 
@@ -129,8 +132,8 @@ def _read_local_heartbeat(home: Path) -> Optional[dict]:
             hb_path = home / "heartbeats" / f"{agent_name}.json"
         if hb_path.exists():
             return json.loads(hb_path.read_text())
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("Failed to load heartbeat data: %s", exc)
     return None
 
 
@@ -332,8 +335,8 @@ def register_status_commands(main: click.Group) -> None:
                     f"\n  [bold yellow]WARNING:[/] [yellow]Low disk space: "
                     f"{free_gb:.1f} GB free[/]"
                 )
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("Failed to check disk space: %s", exc)
 
         console.print()
         console.print(f"  [dim]Home: {m.home}[/]")
@@ -718,8 +721,8 @@ def register_status_commands(main: click.Group) -> None:
             import webbrowser
             try:
                 webbrowser.open(url)
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.warning("Failed to open browser for dashboard: %s", exc)
 
         server = start_dashboard(home_path, port=port)
         try:

package/src/skcapstone/cli/upgrade_cmd.py

@@ -11,6 +11,7 @@ Commands:
 
 from __future__ import annotations
 
+import logging
 import subprocess
 import sys
 from pathlib import Path
@@ -18,6 +19,8 @@ from typing import Optional
 
 import click
 
+logger = logging.getLogger(__name__)
+
 from ._common import AGENT_HOME, console
 
 # ── Package definitions ───────────────────────────────────────────────────────
@@ -62,8 +65,8 @@ def _get_installed_version(package: str) -> Optional[str]:
         for line in result.stdout.splitlines():
             if line.startswith("Version:"):
                 return line.split(":", 1)[1].strip()
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("Failed to get installed version for %s: %s", package, exc)
     return None
 
 
@@ -91,8 +94,8 @@ def _get_latest_version(package: str) -> Optional[str]:
                     versions = [v.strip() for v in parts[-1].split(",")]
                     if versions:
                         return versions[0]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("Failed to get latest PyPI version for %s: %s", package, exc)
     return None
 
 

package/src/skcapstone/cli/watch_cmd.py

@@ -14,6 +14,7 @@ Usage:
 from __future__ import annotations
 
 import json
+import logging
 import time
 import urllib.request
 from datetime import datetime, timezone
@@ -29,6 +30,8 @@ from rich.text import Text
 
 from ._common import AGENT_HOME, console
 
+logger = logging.getLogger(__name__)
+
 
 def _fetch_consciousness(port: int = 7777) -> dict:
     """Fetch consciousness loop status from the running daemon.
@@ -87,8 +90,8 @@ def _build_renderable(home: Path, daemon_port: int = 7777) -> Group:
         memory_short = m.memory.short_term
         memory_mid = m.memory.mid_term
         memory_long = m.memory.long_term
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("Failed to read runtime manifest for watch display: %s", exc)
 
     # ── Consciousness data ────────────────────────────────────────────────
     cdata = _fetch_consciousness(daemon_port)
@@ -99,8 +102,8 @@ def _build_renderable(home: Path, daemon_port: int = 7777) -> Group:
         from ..memory_engine import list_memories
 
         recent_memories = list_memories(home, limit=5)
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("Failed to load recent memories for watch display: %s", exc)
 
     # ── Coordination board ────────────────────────────────────────────────
     board_tasks: list = []
@@ -118,8 +121,8 @@ def _build_renderable(home: Path, daemon_port: int = 7777) -> Group:
         board_tasks = [
             v for v in views if v.status.value in ("open", "in_progress")
         ][:8]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("Failed to load coordination board for watch display: %s", exc)
 
     # ── Header ────────────────────────────────────────────────────────────
     con_color = {

package/src/skcapstone/config_validator.py

@@ -16,6 +16,7 @@ Usage:
 from __future__ import annotations
 
 import json
+import logging
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -23,6 +24,8 @@ from typing import Any, Optional
 
 import yaml
 
+logger = logging.getLogger(__name__)
+
 
 # ---------------------------------------------------------------------------
 # Result models
@@ -113,8 +116,8 @@ def _yaml_key_line(text: str, key: str) -> Optional[int]:
         for key_node, _ in node.value:
             if isinstance(key_node, yaml.ScalarNode) and key_node.value == key:
                 return key_node.start_mark.line + 1
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("Failed to locate YAML key '%s' for line number: %s", key, exc)
     return None
 
 
@@ -147,8 +150,8 @@ def _yaml_seq_item_line(text: str, seq_key: str, idx: int, subkey: str) -> Optio
                             if kk.value == subkey:
                                 return kk.start_mark.line + 1
                         return item.start_mark.line + 1
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("Failed to locate YAML seq item line for '%s[%d].%s': %s", seq_key, idx, subkey, exc)
     return None