@smilintux/skcapstone 0.4.6 → 0.4.7

package/scripts/telegram-catchup-all.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+# telegram-catchup-all.sh — Import all configured Telegram groups into SKMemory
+#
+# Reads groups from ~/.skcapstone/agents/lumina/config/telegram.yaml
+# and runs `skcapstone telegram catchup` for each enabled group.
+#
+# Usage:
+#   bash scripts/telegram-catchup-all.sh [--since YYYY-MM-DD] [--limit N] [--group NAME]
+#
+# Examples:
+#   bash scripts/telegram-catchup-all.sh                    # All groups, last 2000 msgs
+#   bash scripts/telegram-catchup-all.sh --since 2026-03-01 # All groups since March 1
+#   bash scripts/telegram-catchup-all.sh --group brother-john  # Just one group
+#
+# Requires:
+#   - TELEGRAM_API_ID and TELEGRAM_API_HASH environment variables
+#   - ~/.skenv/bin/skcapstone on PATH
+#   - Telethon installed in ~/.skenv/
+
+set -uo pipefail  # no -e: individual group failures shouldn't stop the batch
+
+SKENV="${HOME}/.skenv/bin"
+SKCAPSTONE="${SKENV}/skcapstone"
+CONFIG="${HOME}/.skcapstone/agents/lumina/config/telegram.yaml"
+export SKCAPSTONE_AGENT="${SKCAPSTONE_AGENT:-lumina}"
+export PATH="${SKENV}:${PATH}"
+
+# Parse args
+SINCE=""
+LIMIT="2000"
+ONLY_GROUP=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --since) SINCE="$2"; shift 2 ;;
+    --limit) LIMIT="$2"; shift 2 ;;
+    --group) ONLY_GROUP="$2"; shift 2 ;;
+    *) echo "Unknown arg: $1"; exit 1 ;;
+  esac
+done
+
+# Check prerequisites
+if [[ -z "${TELEGRAM_API_ID:-}" || -z "${TELEGRAM_API_HASH:-}" ]]; then
+  echo "ERROR: TELEGRAM_API_ID and TELEGRAM_API_HASH must be set."
+  echo "Get them from https://my.telegram.org"
+  exit 1
+fi
+
+if [[ ! -f "$CONFIG" ]]; then
+  echo "ERROR: Config not found: $CONFIG"
+  exit 1
+fi
+
+# Parse groups from YAML (simple grep — no yq dependency)
+echo "=== Telegram Catch-Up All ==="
+echo "Config: $CONFIG"
+echo "Agent: $SKCAPSTONE_AGENT"
+echo "Limit: $LIMIT"
+[[ -n "$SINCE" ]] && echo "Since: $SINCE"
+[[ -n "$ONLY_GROUP" ]] && echo "Only group: $ONLY_GROUP"
+echo ""
+
+# Extract group entries: name, chat ID, tags, enabled status
+SUCCESS=0
+FAILED=0
+SKIPPED=0
+
+current_name=""
+current_chat=""
+current_tags=""
+current_enabled=""
+
+process_group() {
+  local name="$1" chat="$2" tags="$3" enabled="$4"
+
+  if [[ "$enabled" != "true" ]]; then
+    echo "  SKIP $name (disabled)"
+    SKIPPED=$((SKIPPED + 1))
+    return
+  fi
+
+  if [[ -n "$ONLY_GROUP" && "$name" != *"$ONLY_GROUP"* ]]; then
+    SKIPPED=$((SKIPPED + 1))
+    return
+  fi
+
+  echo -n "  IMPORTING $name (chat: $chat) ... "
+
+  local cmd="$SKCAPSTONE telegram catchup $chat --limit $LIMIT --min-length 20"
+  [[ -n "$SINCE" ]] && cmd="$cmd --since $SINCE"
+  [[ -n "$tags" ]] && cmd="$cmd --tags $tags"
+
+  if eval "$cmd" > /tmp/telegram-catchup-$name.log 2>&1; then
+    echo "OK"
+    SUCCESS=$((SUCCESS + 1))
+  else
+    echo "FAILED (see /tmp/telegram-catchup-$name.log)"
+    FAILED=$((FAILED + 1))
+  fi
+
+  # Rate limit — avoid hitting Telegram flood control
+  sleep 3
+}
+
+# Parse the YAML manually
+while IFS= read -r line; do
+  # Detect new group entry
+  if [[ "$line" =~ ^[[:space:]]*-[[:space:]]*name:[[:space:]]*(.*) ]]; then
+    # Process previous group if we have one
+    if [[ -n "$current_name" ]]; then
+      process_group "$current_name" "$current_chat" "$current_tags" "$current_enabled"
+    fi
+    current_name="${BASH_REMATCH[1]}"
+    current_chat=""
+    current_tags=""
+    current_enabled="true"
+  elif [[ "$line" =~ ^[[:space:]]*chat:[[:space:]]*\"?([0-9]+)\"? ]]; then
+    current_chat="${BASH_REMATCH[1]}"
+  elif [[ "$line" =~ ^[[:space:]]*tags:[[:space:]]*\[(.*)\] ]]; then
+    # Convert YAML list to comma-separated
+    current_tags=$(echo "${BASH_REMATCH[1]}" | sed 's/,/ /g' | tr -s ' ' ',' | sed 's/^,//;s/,$//')
+  elif [[ "$line" =~ ^[[:space:]]*enabled:[[:space:]]*(.*) ]]; then
+    current_enabled="${BASH_REMATCH[1]}"
+  fi
+done < "$CONFIG"
+
+# Process last group
+if [[ -n "$current_name" ]]; then
+  process_group "$current_name" "$current_chat" "$current_tags" "$current_enabled"
+fi
+
+echo ""
+echo "=== Done ==="
+echo "  Success: $SUCCESS"
+echo "  Failed:  $FAILED"
+echo "  Skipped: $SKIPPED"

package/src/skcapstone/__init__.py

@@ -11,7 +11,7 @@ import os
 import platform
 from pathlib import Path
 
-__version__ = "0.4.4"
+__version__ = "0.4.7"
 __author__ = "smilinTux"
 
 

package/src/skcapstone/blueprints/builtins/itil-operations.yaml

@@ -0,0 +1,40 @@
+name: "ITIL Operations"
+slug: "itil-operations"
+version: "1.0.0"
+description: "ITIL service management — incident, problem, and change lifecycle with SLA monitoring and continuous improvement."
+icon: "🔄"
+author: "smilinTux"
+
+agents:
+  deming:
+    role: ops
+    model: reason
+    model_name: "deepseek-r1:32b"
+    description: "ITIL expert — incident triage, problem analysis, change management, SLA monitoring, and blameless postmortems."
+    vm_type: container
+    resources:
+      memory: "4g"
+      cores: 2
+      disk: "20g"
+    soul_blueprint: "souls/deming.yaml"
+    skills: [incident-management, problem-analysis, change-management, kedb, sla-monitoring, root-cause-analysis]
+
+default_provider: local
+estimated_cost: "$0 (local)"
+
+network:
+  mesh_vpn: tailscale
+  discovery: skref_registry
+
+storage:
+  skref_vault: "team-itil-ops"
+  memory_backend: filesystem
+  memory_sync: true
+
+coordination:
+  queen: lumina
+  pattern: supervisor
+  heartbeat: "5m"
+  escalation: chef
+
+tags: [ops, itil, incident-management, problem-analysis, change-management, sla-monitoring, continuous-improvement]

package/src/skcapstone/cli/__init__.py

@@ -86,6 +86,7 @@ from .search_cmd import register_search_commands
 from .mood_cmd import register_mood_commands
 from .register_cmd import register_register_commands
 from .gtd import register_gtd_commands
+from .itil import register_itil_commands
 from .skseed import register_skseed_commands
 from .service_cmd import register_service_commands
 from .telegram import register_telegram_commands
@@ -138,6 +139,7 @@ register_search_commands(main)
 register_mood_commands(main)
 register_register_commands(main)
 register_gtd_commands(main)
+register_itil_commands(main)
 register_skseed_commands(main)
 register_service_commands(main)
 register_telegram_commands(main)

package/src/skcapstone/cli/daemon.py

@@ -270,60 +270,117 @@ def register_daemon_commands(main: click.Group) -> None:
             console.print(f"  [yellow]API unreachable on port {effective_port}[/]\n")
 
     @daemon.command("install")
-    def daemon_install():
-        """Install the daemon as a systemd user service.
+    @click.option("--agent", "agent_name", default=None,
+                  help="Agent name for SKCAPSTONE_AGENT (default: from env or 'sovereign').")
+    @click.option("--start", is_flag=True, help="Start services immediately after installing.")
+    def daemon_install(agent_name: str | None, start: bool):
+        """Install the daemon as a system service.
 
-        Copies unit files to ~/.config/systemd/user/, enables at login,
-        and starts immediately. No root required.
+        On Linux: installs systemd user service units.
+        On macOS: installs launchd plist files to ~/Library/LaunchAgents/.
+
+        The --agent flag sets the SKCAPSTONE_AGENT environment variable
+        in the service definition. If not provided, uses the
+        SKCAPSTONE_AGENT env var or defaults to 'sovereign'.
 
         Examples:
 
             skcapstone daemon install
+
+            skcapstone daemon install --agent myagent --start
         """
-        from ..systemd import install_service, systemd_available
+        import platform
 
-        if not systemd_available():
-            console.print("[red]systemd user session not available.[/]")
-            console.print("[dim]This command requires a Linux system with systemd.[/]")
-            raise SystemExit(1)
+        effective_agent = agent_name or os.environ.get("SKCAPSTONE_AGENT", "sovereign")
 
-        console.print("\n[cyan]Installing skcapstone systemd service...[/]")
-        result = install_service()
+        if platform.system() == "Darwin":
+            from ..launchd import install_service as launchd_install
 
-        if result["installed"]:
-            console.print("[green]  Unit files installed.[/]")
-        if result["enabled"]:
-            console.print("[green]  Service enabled at login.[/]")
-        if result["started"]:
-            console.print("[green]  Service started.[/]")
-        console.print()
+            console.print(f"\n[cyan]Installing launchd services for agent '{effective_agent}'...[/]")
+            result = launchd_install(agent_name=effective_agent, start=start)
+
+            if result["installed"]:
+                for svc in result.get("services", []):
+                    status = "[green]loaded[/]" if svc.get("loaded") else "[green]installed[/]"
+                    console.print(f"  [green]✓[/] {svc['label']} — {status}")
+                console.print()
+                console.print("[dim]  Manage: launchctl list | grep skcapstone[/]")
+                if not start:
+                    console.print("[dim]  Start:  launchctl start com.skcapstone.daemon[/]")
+                    console.print("[dim]  Or re-run with --start to load immediately.[/]")
+            else:
+                console.print("[red]Installation failed. Check logs.[/]")
+                raise SystemExit(1)
+            console.print()
 
-        if not result["installed"]:
-            console.print("[red]Installation failed. Check logs.[/]")
+        elif platform.system() == "Linux":
+            from ..systemd import install_service, systemd_available
+
+            if not systemd_available():
+                console.print("[red]systemd user session not available.[/]")
+                console.print("[dim]This command requires a Linux system with systemd.[/]")
+                raise SystemExit(1)
+
+            console.print("\n[cyan]Installing skcapstone systemd service...[/]")
+            result = install_service(start=start)
+
+            if result["installed"]:
+                console.print("[green]  Unit files installed.[/]")
+            if result["enabled"]:
+                console.print("[green]  Service enabled at login.[/]")
+            if result.get("started"):
+                console.print("[green]  Service started.[/]")
+            console.print()
+
+            if not result["installed"]:
+                console.print("[red]Installation failed. Check logs.[/]")
+                raise SystemExit(1)
+        else:
+            console.print(f"[red]Auto-start not supported on {platform.system()}.[/]")
             raise SystemExit(1)
 
     @daemon.command("uninstall")
     def daemon_uninstall():
-        """Uninstall the systemd user service.
+        """Uninstall the system service.
 
-        Stops, disables, and removes the unit files.
+        On Linux: stops, disables, and removes systemd unit files.
+        On macOS: unloads and removes launchd plist files.
 
         Examples:
 
             skcapstone daemon uninstall
         """
-        from ..systemd import uninstall_service
+        import platform
 
-        console.print("\n[cyan]Uninstalling skcapstone systemd service...[/]")
-        result = uninstall_service()
+        if platform.system() == "Darwin":
+            from ..launchd import uninstall_service as launchd_uninstall
 
-        if result["stopped"]:
-            console.print("[green]  Service stopped.[/]")
-        if result["disabled"]:
-            console.print("[green]  Service disabled.[/]")
-        if result["removed"]:
-            console.print("[green]  Unit files removed.[/]")
-        console.print()
+            console.print("\n[cyan]Uninstalling skcapstone launchd services...[/]")
+            result = launchd_uninstall()
+
+            if result["stopped"]:
+                console.print("[green]  Services unloaded.[/]")
+            if result["removed"]:
+                for label in result.get("services", []):
+                    console.print(f"  [green]✓[/] Removed {label}")
+            console.print()
+
+        elif platform.system() == "Linux":
+            from ..systemd import uninstall_service
+
+            console.print("\n[cyan]Uninstalling skcapstone systemd service...[/]")
+            result = uninstall_service()
+
+            if result["stopped"]:
+                console.print("[green]  Service stopped.[/]")
+            if result["disabled"]:
+                console.print("[green]  Service disabled.[/]")
+            if result["removed"]:
+                console.print("[green]  Unit files removed.[/]")
+            console.print()
+
+        else:
+            console.print(f"[red]Not supported on {platform.system()}.[/]")
 
     @daemon.command("components")
     @click.option("--agent", default=None, help="Named agent to query.")
@@ -413,7 +470,10 @@ def register_daemon_commands(main: click.Group) -> None:
     @click.option("--lines", "-n", default=50, help="Number of lines (default: 50).")
     @click.option("--follow", "-f", is_flag=True, help="Show the command to follow logs live.")
     def daemon_logs(lines: int, follow: bool):
-        """Show daemon logs from journald.
+        """Show daemon logs.
+
+        On Linux: reads from journald.
+        On macOS: reads from ~/.skcapstone/logs/ files.
 
         Examples:
 
@@ -423,14 +483,29 @@ def register_daemon_commands(main: click.Group) -> None:
 
             skcapstone daemon logs -f
         """
-        from ..systemd import service_logs
+        import platform
 
-        if follow:
-            cmd = service_logs(follow=True)
-            console.print(f"\n  Run: [bold cyan]{cmd}[/]\n")
+        if platform.system() == "Darwin":
+            if follow:
+                log_path = Path.home() / ".skcapstone" / "logs" / "daemon.stdout.log"
+                console.print(f"\n  Run: [bold cyan]tail -f {log_path}[/]\n")
+            else:
+                from ..launchd import service_logs
+                output = service_logs(lines=lines)
+                if output.strip():
+                    click.echo(output)
+                else:
+                    console.print("[dim]No logs found in ~/.skcapstone/logs/[/]")
+                    console.print("[dim]Is the service installed? Run: skcapstone daemon install[/]")
         else:
-            output = service_logs(lines=lines)
-            if output.strip():
-                click.echo(output)
+            from ..systemd import service_logs
+
+            if follow:
+                cmd = service_logs(follow=True)
+                console.print(f"\n  Run: [bold cyan]{cmd}[/]\n")
             else:
-                console.print("[dim]No logs found. Is the service installed?[/]")
+                output = service_logs(lines=lines)
+                if output.strip():
+                    click.echo(output)
+                else:
+                    console.print("[dim]No logs found. Is the service installed?[/]")