@smilintux/skcapstone 0.1.0 → 0.2.3

package/scripts/check-updates.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+SKCapstone Bundle Update Checker
+Checks for updates to all SK packages and reports status
+"""
+
+import subprocess
+import sys
+import json
+from datetime import datetime
+from pathlib import Path
+
+# Package configuration
+PACKAGES = {
+    "skcapstone": {
+        "name": "skcapstone",
+        "path": "~/clawd/skcapstone",
+        "pypi_name": "skcapstone",
+    },
+    "skmemory": {
+        "name": "skmemory",
+        "path": "~/clawd/skcapstone-repos/skmemory",
+        "pypi_name": "skmemory",
+    },
+    "sksecurity": {
+        "name": "sksecurity",
+        "path": "~/clawd/skcapstone-repos/sksecurity",
+        "pypi_name": "sksecurity",
+    },
+    "cloud9-protocol": {
+        "name": "cloud9-protocol",
+        "path": "~/clawd/skcapstone-repos/cloud9-python",
+        "pypi_name": "cloud9-protocol",
+    },
+}
+
+
+def get_installed_version(package_name):
+    """Get currently installed version of a package."""
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "show", package_name],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        for line in result.stdout.split("\n"):
+            if line.startswith("Version:"):
+                return line.split(":")[1].strip()
+    except subprocess.CalledProcessError:
+        return None
+    return None
+
+
+def get_latest_version(package_name):
+    """Get latest version from PyPI."""
+    try:
+        import urllib.request
+        import json
+
+        url = f"https://pypi.org/pypi/{package_name}/json"
+        with urllib.request.urlopen(url, timeout=5) as response:
+            data = json.loads(response.read())
+            return data["info"]["version"]
+    except Exception:
+        return None
+
+
+def check_git_updates(package_name, package_path):
+    """Check if local repo has uncommitted changes or is behind remote."""
+    path = Path(package_path).expanduser()
+
+    if not path.exists():
+        return {"error": "Repository not found"}
+
+    try:
+        # Check for uncommitted changes
+        result = subprocess.run(
+            ["git", "-C", str(path), "status", "--porcelain"], capture_output=True, text=True
+        )
+        has_changes = len(result.stdout.strip()) > 0
+
+        # Check if behind remote
+        subprocess.run(["git", "-C", str(path), "fetch", "--quiet"], capture_output=True)
+
+        result = subprocess.run(
+            ["git", "-C", str(path), "rev-list", "HEAD..@{upstream}", "--count"],
+            capture_output=True,
+            text=True,
+        )
+        behind_count = int(result.stdout.strip()) if result.stdout.strip().isdigit() else 0
+
+        # Get current commit
+        result = subprocess.run(
+            ["git", "-C", str(path), "rev-parse", "--short", "HEAD"],
+            capture_output=True,
+            text=True,
+        )
+        current_commit = result.stdout.strip()
+
+        return {
+            "has_changes": has_changes,
+            "behind_count": behind_count,
+            "current_commit": current_commit,
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def check_package(package_key):
+    """Check status of a single package."""
+    config = PACKAGES[package_key]
+
+    status = {
+        "name": config["name"],
+        "installed": None,
+        "latest_pypi": None,
+        "git_status": None,
+    }
+
+    # Check installed version
+    status["installed"] = get_installed_version(config["pypi_name"])
+
+    # Check PyPI version
+    status["latest_pypi"] = get_latest_version(config["pypi_name"])
+
+    # Check git status
+    status["git_status"] = check_git_updates(config["name"], config["path"])
+
+    return status
+
+
+def print_status_report(results):
+    """Print formatted status report."""
+    print("\n" + "=" * 70)
+    print("SKCapstone Bundle Update Checker")
+    print(f"Checked at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("=" * 70)
+
+    updates_available = []
+    git_updates_available = []
+
+    for package_key, status in results.items():
+        print(f"\n📦 {status['name']}")
+        print("-" * 70)
+
+        # Installed version
+        if status["installed"]:
+            print(f"   Installed: {status['installed']}")
+        else:
+            print(f"   Installed: ❌ Not installed")
+
+        # PyPI version
+        if status["latest_pypi"]:
+            print(f"   PyPI:      {status['latest_pypi']}")
+            if status["installed"] and status["installed"] != status["latest_pypi"]:
+                print(f"   ⚠️  Update available on PyPI!")
+                updates_available.append(status["name"])
+        else:
+            print(f"   PyPI:      (unable to check)")
+
+        # Git status
+        git = status["git_status"]
+        if git:
+            if "error" in git:
+                print(f"   Git:       ❌ {git['error']}")
+            else:
+                print(f"   Git commit: {git['current_commit']}")
+                if git["has_changes"]:
+                    print(f"   ⚠️  Uncommitted changes detected")
+                if git["behind_count"] > 0:
+                    print(f"   ⚠️  {git['behind_count']} commit(s) behind remote")
+                    git_updates_available.append(status["name"])
+
+    print("\n" + "=" * 70)
+    print("SUMMARY")
+    print("=" * 70)
+
+    if updates_available:
+        print(f"\n🔄 PyPI updates available: {', '.join(updates_available)}")
+        print("   Run: pip install --upgrade " + " ".join(updates_available))
+    else:
+        print("\n✅ All packages up-to-date on PyPI")
+
+    if git_updates_available:
+        print(f"\n🔄 Git updates available: {', '.join(git_updates_available)}")
+        print("   Run: git pull in respective repositories")
+    else:
+        print("✅ All repositories up-to-date")
+
+    print("\n" + "=" * 70)
+
+
+def save_check_results(results):
+    """Save results to JSON file for programmatic access."""
+    results_dir = Path("~/.skcapstone/logs").expanduser()
+    results_dir.mkdir(parents=True, exist_ok=True)
+
+    results_file = results_dir / f"update-check-{datetime.now().strftime('%Y%m%d-%H%M%S')}.json"
+
+    with open(results_file, "w") as f:
+        json.dump({"timestamp": datetime.now().isoformat(), "results": results}, f, indent=2)
+
+    print(f"\n📄 Detailed results saved to: {results_file}")
+
+
+def main():
+    """Main entry point."""
+    print("Checking for updates to all SK packages...")
+    print("This may take a moment...")
+
+    results = {}
+    for package_key in PACKAGES:
+        results[package_key] = check_package(package_key)
+
+    print_status_report(results)
+    save_check_results(results)
+
+    # Exit with error code if updates available (useful for automation)
+    has_updates = any(
+        r["installed"] != r["latest_pypi"]
+        for r in results.values()
+        if r["installed"] and r["latest_pypi"]
+    )
+
+    return 1 if has_updates else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/convert_blueprints_to_yaml.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""Convert soul blueprint markdown files to structured YAML.
+
+Reads all .md blueprints from the souls-blueprints repo and writes
+corresponding .yaml files using the existing soul.py parser.
+
+Usage:
+    python scripts/convert_blueprints_to_yaml.py [--source DIR] [--dest DIR]
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+import yaml
+
+# Add src to path so we can import soul.py
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
+
+from skcapstone.soul import parse_blueprint, _slugify
+
+
+def _slug_from_filename(path: Path) -> str:
+    """Derive a clean slug from the filename, not the display name."""
+    stem = path.stem.lower()
+    # Remove leading 'the-' or 'the_' for cleaner slugs
+    stem = re.sub(r"[^\w\s-]", "", stem)
+    stem = re.sub(r"[\s_]+", "-", stem)
+    return stem.strip("-")
+
+
+def convert_one(md_path: Path, dest_dir: Path) -> Path:
+    """Convert a single MD blueprint to YAML.
+
+    Args:
+        md_path: Path to the .md blueprint file.
+        dest_dir: Directory to write the .yaml file.
+
+    Returns:
+        Path to the written YAML file.
+    """
+    bp = parse_blueprint(md_path)
+
+    # Use filename-based slug for predictable, short names
+    slug = _slug_from_filename(md_path)
+
+    # Build the YAML structure
+    data = {
+        "name": slug,
+        "display_name": bp.display_name,
+        "category": bp.category,
+        "vibe": bp.vibe or "",
+        "philosophy": bp.philosophy or "",
+        "emoji": bp.emoji,
+        "core_traits": bp.core_traits if bp.core_traits else [],
+        "communication_style": {
+            "patterns": bp.communication_style.patterns,
+            "tone_markers": bp.communication_style.tone_markers,
+            "signature_phrases": bp.communication_style.signature_phrases,
+        },
+        "decision_framework": bp.decision_framework,
+        "emotional_topology": bp.emotional_topology if bp.emotional_topology else {},
+    }
+
+    # Clean up None values in nested dicts
+    if not data["communication_style"]["patterns"]:
+        del data["communication_style"]["patterns"]
+    if not data["communication_style"]["tone_markers"]:
+        del data["communication_style"]["tone_markers"]
+    if not data["communication_style"]["signature_phrases"]:
+        del data["communication_style"]["signature_phrases"]
+    if not data["communication_style"]:
+        data["communication_style"] = {}
+
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    yaml_path = dest_dir / f"{slug}.yaml"
+
+    with open(yaml_path, "w", encoding="utf-8") as f:
+        yaml.dump(
+            data,
+            f,
+            default_flow_style=False,
+            allow_unicode=True,
+            sort_keys=False,
+            width=120,
+        )
+
+    return yaml_path
+
+
+def convert_all(source: Path, dest: Path) -> tuple[int, int]:
+    """Convert all MD blueprints preserving category directories.
+
+    Args:
+        source: Root directory containing category subdirs with .md files.
+        dest: Root directory for YAML output.
+
+    Returns:
+        Tuple of (success_count, failure_count).
+    """
+    successes = 0
+    failures = 0
+
+    for md_path in sorted(source.rglob("*.md")):
+        if md_path.name.startswith(".") or md_path.name.upper() == "README.MD":
+            continue
+
+        # Preserve category directory structure
+        rel = md_path.parent.relative_to(source)
+        dest_dir = dest / rel
+
+        try:
+            yaml_path = convert_one(md_path, dest_dir)
+            print(f"  {md_path.name} -> {yaml_path.relative_to(dest)}")
+            successes += 1
+        except Exception as exc:
+            print(f"  FAIL: {md_path.name}: {exc}", file=sys.stderr)
+            failures += 1
+
+    return successes, failures
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert soul blueprints MD -> YAML")
+    parser.add_argument(
+        "--source",
+        type=Path,
+        default=Path(__file__).resolve().parent.parent.parent
+        / "souls-blueprints"
+        / "blueprints",
+        help="Source directory with MD blueprints",
+    )
+    parser.add_argument(
+        "--dest",
+        type=Path,
+        default=Path(__file__).resolve().parent.parent.parent
+        / "souls-blueprints"
+        / "yaml",
+        help="Destination directory for YAML output",
+    )
+    args = parser.parse_args()
+
+    print(f"Source: {args.source}")
+    print(f"Dest:   {args.dest}")
+    print()
+
+    ok, fail = convert_all(args.source, args.dest)
+    print(f"\nConverted: {ok}, Failed: {fail}")
+
+    return 0 if fail == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/dev-install.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# dev-install.sh — Sovereign Agent Suite Dev Installer
+#
+# Wrapper around install.sh with --dev flag.
+# Installs all SK* packages plus pytest, ruff, black.
+#
+# Usage:
+#   bash scripts/dev-install.sh
+#   bash scripts/dev-install.sh --force   # Recreate venv
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+exec bash "$SCRIPT_DIR/install.sh" --dev "$@"

package/scripts/e2e-test.sh

@@ -0,0 +1,193 @@
+#!/usr/bin/env bash
+# scripts/e2e-test.sh — Automated multi-agent E2E test for the SKCapstone daemon.
+#
+# Usage:
+#   ./scripts/e2e-test.sh [--port PORT] [--timeout SECS] [--peer PEER_NAME]
+#
+# Exit codes:
+#   0  — all checks passed
+#   1  — one or more checks failed
+
+set -euo pipefail
+
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
+PORT="${PORT:-7777}"
+STARTUP_WAIT="${STARTUP_WAIT:-10}"
+POLL_TIMEOUT="${POLL_TIMEOUT:-300}"
+PEER="${PEER:-test-peer}"
+AGENT_HOME="${SKCAPSTONE_ROOT:-${HOME}/.skcapstone}"
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+pass() { echo -e "${GREEN}[PASS]${NC} $*"; }
+fail() { echo -e "${RED}[FAIL]${NC} $*"; FAILURES=$((FAILURES + 1)); }
+info() { echo -e "${YELLOW}[INFO]${NC} $*"; }
+
+FAILURES=0
+DAEMON_PID=""
+
+cleanup() {
+    if [[ -n "${DAEMON_PID}" ]]; then
+        info "Stopping daemon (PID ${DAEMON_PID})…"
+        kill "${DAEMON_PID}" 2>/dev/null || true
+        wait "${DAEMON_PID}" 2>/dev/null || true
+    fi
+}
+trap cleanup EXIT
+
+# ---------------------------------------------------------------------------
+# Step 0: Reinstall package
+# ---------------------------------------------------------------------------
+info "Reinstalling skcapstone…"
+pip install -e . --quiet
+
+# ---------------------------------------------------------------------------
+# Step 1: Start daemon in the background
+# ---------------------------------------------------------------------------
+INBOX_DIR="${AGENT_HOME}/sync/comms/inbox/${PEER}"
+OUTBOX_DIR="${AGENT_HOME}/sync/comms/outbox/${PEER}"
+CONV_FILE="${AGENT_HOME}/conversations/${PEER}.json"
+
+info "Starting daemon on port ${PORT}…"
+skcapstone daemon start --foreground --port "${PORT}" \
+    >"${TMPDIR:-/tmp}/skcapstone-e2e-daemon.log" 2>&1 &
+DAEMON_PID=$!
+
+info "Waiting ${STARTUP_WAIT}s for daemon to initialize…"
+sleep "${STARTUP_WAIT}"
+
+# Verify process is still alive
+if ! kill -0 "${DAEMON_PID}" 2>/dev/null; then
+    fail "Daemon exited prematurely — check ${TMPDIR:-/tmp}/skcapstone-e2e-daemon.log"
+    exit 1
+fi
+
+# ---------------------------------------------------------------------------
+# Step 2: Check /consciousness endpoint
+# ---------------------------------------------------------------------------
+info "Checking /consciousness endpoint…"
+CONSCIOUSNESS_RESP=$(curl -sf "http://127.0.0.1:${PORT}/consciousness" 2>&1) || true
+if echo "${CONSCIOUSNESS_RESP}" | python3 -c "import sys,json; d=json.load(sys.stdin); assert d.get('status') in ('ACTIVE','active','ok','running')" 2>/dev/null; then
+    pass "/consciousness endpoint returned active status"
+elif [[ -n "${CONSCIOUSNESS_RESP}" ]]; then
+    # Accept any valid JSON response — daemon is reachable
+    if echo "${CONSCIOUSNESS_RESP}" | python3 -m json.tool >/dev/null 2>&1; then
+        pass "/consciousness endpoint returned JSON (status field: $(echo "${CONSCIOUSNESS_RESP}" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('status','N/A'))" 2>/dev/null))"
+    else
+        fail "/consciousness endpoint returned non-JSON: ${CONSCIOUSNESS_RESP:0:120}"
+    fi
+else
+    fail "/consciousness endpoint unreachable on port ${PORT}"
+fi
+
+# ---------------------------------------------------------------------------
+# Step 3: Write a test message to the inbox
+# ---------------------------------------------------------------------------
+info "Writing test message to inbox (peer=${PEER})…"
+mkdir -p "${INBOX_DIR}"
+TIMESTAMP=$(date +%s)
+MSG_ID="e2e-${TIMESTAMP}"
+MSG_FILE="${INBOX_DIR}/${MSG_ID}.skc.json"
+
+python3 - <<PYEOF
+import json, time
+msg = {
+    "sender": "${PEER}",
+    "recipient": "Opus",
+    "payload": {
+        "content": "Ping test — automated E2E at $(date -u +%Y-%m-%dT%H:%M:%SZ)",
+        "content_type": "text",
+    },
+    "message_id": "${MSG_ID}",
+    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S+00:00", time.gmtime()),
+}
+with open("${MSG_FILE}", "w") as fh:
+    json.dump(msg, fh)
+print(f"  Wrote {len(json.dumps(msg))} bytes → ${MSG_FILE}")
+PYEOF
+
+pass "Test message written: ${MSG_FILE}"
+
+# ---------------------------------------------------------------------------
+# Step 4: Poll outbox for response (up to POLL_TIMEOUT seconds)
+# ---------------------------------------------------------------------------
+info "Polling outbox for response (timeout=${POLL_TIMEOUT}s)…"
+mkdir -p "${OUTBOX_DIR}"
+
+RESPONSE_FOUND=false
+DEADLINE=$((SECONDS + POLL_TIMEOUT))
+LAST_OUTBOX_COUNT=0
+
+while [[ ${SECONDS} -lt ${DEADLINE} ]]; do
+    OUTBOX_COUNT=$(find "${OUTBOX_DIR}" -name "*.skc.json" 2>/dev/null | wc -l)
+    if [[ "${OUTBOX_COUNT}" -gt "${LAST_OUTBOX_COUNT}" ]]; then
+        RESPONSE_FOUND=true
+        LATEST_RESP=$(find "${OUTBOX_DIR}" -name "*.skc.json" -newer "${MSG_FILE}" 2>/dev/null | sort | tail -1)
+        info "Response file detected: ${LATEST_RESP:-<any .skc.json in outbox>}"
+        break
+    fi
+
+    # Also accept: conversations file updated (passthrough / no-SKComm mode)
+    if [[ -f "${CONV_FILE}" ]] && [[ "${CONV_FILE}" -nt "${MSG_FILE}" ]]; then
+        RESPONSE_FOUND=true
+        info "Conversation file updated (passthrough mode detected)"
+        break
+    fi
+
+    ELAPSED=$((SECONDS - (DEADLINE - POLL_TIMEOUT)))
+    if (( ELAPSED % 30 == 0 )); then
+        info "  Still waiting… ${ELAPSED}s elapsed / ${POLL_TIMEOUT}s timeout"
+    fi
+    sleep 2
+done
+
+if ${RESPONSE_FOUND}; then
+    pass "Response received within $((SECONDS - (DEADLINE - POLL_TIMEOUT)))s"
+else
+    fail "No response within ${POLL_TIMEOUT}s (outbox: ${OUTBOX_DIR}, conv: ${CONV_FILE})"
+fi
+
+# ---------------------------------------------------------------------------
+# Step 5: Check conversations file
+# ---------------------------------------------------------------------------
+info "Checking conversations/${PEER}.json…"
+if [[ -f "${CONV_FILE}" ]]; then
+    CONV_SIZE=$(wc -c < "${CONV_FILE}")
+    if python3 -m json.tool "${CONV_FILE}" >/dev/null 2>&1; then
+        pass "conversations/${PEER}.json exists and is valid JSON (${CONV_SIZE} bytes)"
+    else
+        fail "conversations/${PEER}.json exists but is not valid JSON"
+    fi
+else
+    fail "conversations/${PEER}.json not found at ${CONV_FILE}"
+fi
+
+# ---------------------------------------------------------------------------
+# Step 6: Kill daemon
+# ---------------------------------------------------------------------------
+info "Stopping daemon…"
+kill "${DAEMON_PID}" 2>/dev/null || true
+wait "${DAEMON_PID}" 2>/dev/null || true
+DAEMON_PID=""  # prevent double-kill in trap
+pass "Daemon stopped"
+
+# ---------------------------------------------------------------------------
+# Summary
+# ---------------------------------------------------------------------------
+echo ""
+if [[ ${FAILURES} -eq 0 ]]; then
+    echo -e "${GREEN}E2E TEST PASSED${NC} — all checks passed."
+    exit 0
+else
+    echo -e "${RED}E2E TEST FAILED${NC} — ${FAILURES} check(s) failed."
+    echo "  Daemon log: ${TMPDIR:-/tmp}/skcapstone-e2e-daemon.log"
+    exit 1
+fi