@smilintux/skcapstone 0.1.0 → 0.2.3

package/src/skcapstone/mcp_tools/comm_tools.py

@@ -0,0 +1,104 @@
+"""SKComm send/receive messaging tools."""
+
+from __future__ import annotations
+
+from mcp.types import TextContent, Tool
+
+from ._helpers import _error_response, _json_response
+
+TOOLS: list[Tool] = [
+    Tool(
+        name="send_message",
+        description=(
+            "Send a message to another agent via SKComm. "
+            "Routes through available transports (Syncthing, file)."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "recipient": {
+                    "type": "string",
+                    "description": "Agent name or PGP fingerprint of the recipient",
+                },
+                "message": {
+                    "type": "string",
+                    "description": "The message content",
+                },
+                "urgency": {
+                    "type": "string",
+                    "enum": ["low", "normal", "high", "critical"],
+                    "description": "Message urgency (default: normal)",
+                },
+            },
+            "required": ["recipient", "message"],
+        },
+    ),
+    Tool(
+        name="check_inbox",
+        description=(
+            "Check for new incoming messages across all SKComm transports. "
+            "Returns any unread message envelopes."
+        ),
+        inputSchema={"type": "object", "properties": {}, "required": []},
+    ),
+]
+
+
+async def _handle_send_message(args: dict) -> list[TextContent]:
+    """Send a message via SKComm."""
+    recipient = args.get("recipient", "")
+    message = args.get("message", "")
+    if not recipient or not message:
+        return _error_response("recipient and message are required")
+
+    try:
+        from skcomm.core import SKComm
+        comm = SKComm.from_config()
+        report = comm.send(recipient, message)
+        return _json_response({
+            "sent": report.success,
+            "recipient": recipient,
+            "attempts": [
+                {
+                    "transport": a.transport_name,
+                    "success": a.success,
+                    "error": a.error,
+                }
+                for a in report.attempts
+            ],
+        })
+    except ImportError:
+        return _error_response("SKComm not installed. Run: pip install skcomm")
+    except Exception as exc:
+        return _error_response(f"Send failed: {exc}")
+
+
+async def _handle_check_inbox(_args: dict) -> list[TextContent]:
+    """Check for incoming messages."""
+    try:
+        from skcomm.core import SKComm
+        comm = SKComm.from_config()
+        envelopes = comm.receive()
+        return _json_response([
+            {
+                "envelope_id": e.envelope_id[:12],
+                "sender": e.sender,
+                "recipient": e.recipient,
+                "content": e.payload.content[:300],
+                "type": e.payload.content_type.value,
+                "urgency": e.metadata.urgency.value,
+                "thread_id": e.metadata.thread_id,
+                "created_at": e.metadata.created_at.isoformat(),
+            }
+            for e in envelopes
+        ])
+    except ImportError:
+        return _error_response("SKComm not installed. Run: pip install skcomm")
+    except Exception as exc:
+        return _error_response(f"Inbox check failed: {exc}")
+
+
+HANDLERS: dict = {
+    "send_message": _handle_send_message,
+    "check_inbox": _handle_check_inbox,
+}

package/src/skcapstone/mcp_tools/consciousness_tools.py

@@ -0,0 +1,114 @@
+"""Consciousness loop MCP tools — status and testing."""
+
+from __future__ import annotations
+
+from mcp.types import TextContent, Tool
+
+from ._helpers import _home, _json_response, _text_response, _error_response
+
+TOOLS: list[Tool] = [
+    Tool(
+        name="consciousness_status",
+        description=(
+            "Get consciousness loop status: enabled state, messages processed, "
+            "responses sent, errors, backend health, inotify state, and "
+            "active conversations."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {},
+            "required": [],
+        },
+    ),
+    Tool(
+        name="consciousness_test",
+        description=(
+            "Test the consciousness pipeline end-to-end with a message. "
+            "Classifies the message, builds the agent system prompt, routes "
+            "to the appropriate LLM, and returns the response."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "description": "The test message to process",
+                },
+            },
+            "required": ["message"],
+        },
+    ),
+]
+
+
+async def _handle_consciousness_status(arguments: dict) -> list[TextContent]:
+    """Handle consciousness_status tool call."""
+    try:
+        import urllib.request
+        import json
+
+        url = "http://127.0.0.1:7777/consciousness"
+        with urllib.request.urlopen(url, timeout=3) as resp:
+            data = json.loads(resp.read())
+            return _json_response(data)
+    except Exception:
+        # Fallback: try to load directly
+        try:
+            from ..consciousness_config import load_consciousness_config
+            from ..consciousness_loop import ConsciousnessConfig, LLMBridge
+
+            home = _home()
+            config = load_consciousness_config(home)
+            bridge = LLMBridge(config)
+
+            return _json_response({
+                "enabled": config.enabled,
+                "backends": bridge.health_check(),
+                "daemon_reachable": False,
+                "note": "Loaded directly (daemon not running)",
+            })
+        except Exception as exc:
+            return _error_response(f"Cannot get consciousness status: {exc}")
+
+
+async def _handle_consciousness_test(arguments: dict) -> list[TextContent]:
+    """Handle consciousness_test tool call."""
+    message = arguments.get("message", "")
+    if not message:
+        return _error_response("message is required")
+
+    try:
+        from ..consciousness_config import load_consciousness_config
+        from ..consciousness_loop import (
+            LLMBridge,
+            SystemPromptBuilder,
+            _classify_message,
+        )
+
+        home = _home()
+        config = load_consciousness_config(home)
+        bridge = LLMBridge(config)
+        builder = SystemPromptBuilder(home, config.max_context_tokens)
+
+        signal = _classify_message(message)
+        system_prompt = builder.build()
+        response = bridge.generate(system_prompt, message, signal)
+
+        return _json_response({
+            "message": message,
+            "signal": {
+                "tags": signal.tags,
+                "estimated_tokens": signal.estimated_tokens,
+            },
+            "system_prompt_length": len(system_prompt),
+            "response": response,
+            "response_length": len(response),
+        })
+    except Exception as exc:
+        return _error_response(f"Consciousness test failed: {exc}")
+
+
+HANDLERS = {
+    "consciousness_status": _handle_consciousness_status,
+    "consciousness_test": _handle_consciousness_test,
+}

package/src/skcapstone/mcp_tools/coord_tools.py

@@ -0,0 +1,219 @@
+"""Coordination board tools."""
+
+from __future__ import annotations
+
+from mcp.types import TextContent, Tool
+
+from ._helpers import _error_response, _home, _json_response, _shared_root
+
+TOOLS: list[Tool] = [
+    Tool(
+        name="coord_status",
+        description=(
+            "Show the multi-agent coordination board. Lists all tasks "
+            "with status, priority, and assignees. Shows active agents."
+        ),
+        inputSchema={"type": "object", "properties": {}, "required": []},
+    ),
+    Tool(
+        name="coord_claim",
+        description=(
+            "Claim a task on the coordination board for an agent. "
+            "Prevents duplicate work across agents."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "task_id": {
+                    "type": "string",
+                    "description": "The task ID to claim",
+                },
+                "agent_name": {
+                    "type": "string",
+                    "description": "Agent name claiming the task",
+                },
+            },
+            "required": ["task_id", "agent_name"],
+        },
+    ),
+    Tool(
+        name="coord_complete",
+        description=(
+            "Mark a task as completed on the coordination board."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "task_id": {
+                    "type": "string",
+                    "description": "The task ID to complete",
+                },
+                "agent_name": {
+                    "type": "string",
+                    "description": "Agent name completing the task",
+                },
+            },
+            "required": ["task_id", "agent_name"],
+        },
+    ),
+    Tool(
+        name="coord_create",
+        description=(
+            "Create a new task on the coordination board."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "title": {
+                    "type": "string",
+                    "description": "Task title",
+                },
+                "description": {
+                    "type": "string",
+                    "description": "Task description",
+                },
+                "priority": {
+                    "type": "string",
+                    "enum": ["critical", "high", "medium", "low"],
+                    "description": "Task priority (default: medium)",
+                },
+                "tags": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Task tags",
+                },
+                "created_by": {
+                    "type": "string",
+                    "description": "Creator agent name",
+                },
+            },
+            "required": ["title"],
+        },
+    ),
+]
+
+
+async def _handle_coord_status(_args: dict) -> list[TextContent]:
+    """Return coordination board status."""
+    from ..coordination import Board
+
+    board = Board(_shared_root())
+    views = board.get_task_views()
+    agents = board.load_agents()
+
+    return _json_response({
+        "tasks": [
+            {
+                "id": v.task.id,
+                "title": v.task.title,
+                "priority": v.task.priority.value,
+                "status": v.status.value,
+                "claimed_by": v.claimed_by,
+                "tags": v.task.tags,
+                "description": v.task.description[:150] if v.task.description else "",
+            }
+            for v in views
+        ],
+        "agents": [
+            {
+                "name": a.agent,
+                "state": a.state.value,
+                "current_task": a.current_task,
+                "claimed": a.claimed_tasks,
+                "completed_count": len(a.completed_tasks),
+            }
+            for a in agents
+        ],
+        "summary": {
+            "total": len(views),
+            "open": sum(1 for v in views if v.status.value == "open"),
+            "claimed": sum(1 for v in views if v.status.value == "claimed"),
+            "in_progress": sum(1 for v in views if v.status.value == "in_progress"),
+            "done": sum(1 for v in views if v.status.value == "done"),
+        },
+    })
+
+
+async def _handle_coord_claim(args: dict) -> list[TextContent]:
+    """Claim a task on the board."""
+    from ..coordination import Board
+
+    task_id = args.get("task_id", "")
+    agent_name = args.get("agent_name", "")
+    if not task_id or not agent_name:
+        return _error_response("task_id and agent_name are required")
+
+    board = Board(_shared_root())
+    try:
+        agent = board.claim_task(agent_name, task_id)
+        try:
+            from .. import activity
+            activity.push("task.claimed", {"task_id": task_id, "agent": agent_name})
+        except Exception:
+            pass
+        return _json_response({
+            "claimed": True,
+            "task_id": task_id,
+            "agent": agent.agent,
+            "current_task": agent.current_task,
+        })
+    except ValueError as exc:
+        return _error_response(str(exc))
+
+
+async def _handle_coord_complete(args: dict) -> list[TextContent]:
+    """Complete a task on the board."""
+    from ..coordination import Board
+
+    task_id = args.get("task_id", "")
+    agent_name = args.get("agent_name", "")
+    if not task_id or not agent_name:
+        return _error_response("task_id and agent_name are required")
+
+    board = Board(_shared_root())
+    agent = board.complete_task(agent_name, task_id)
+    try:
+        from .. import activity
+        activity.push("task.completed", {"task_id": task_id, "agent": agent_name})
+    except Exception:
+        pass
+    return _json_response({
+        "completed": True,
+        "task_id": task_id,
+        "agent": agent.agent,
+        "completed_tasks": agent.completed_tasks,
+    })
+
+
+async def _handle_coord_create(args: dict) -> list[TextContent]:
+    """Create a new task on the board."""
+    from ..coordination import Board, Task, TaskPriority
+
+    title = args.get("title", "")
+    if not title:
+        return _error_response("title is required")
+
+    board = Board(_shared_root())
+    task = Task(
+        title=title,
+        description=args.get("description", ""),
+        priority=TaskPriority(args.get("priority", "medium")),
+        tags=args.get("tags", []),
+        created_by=args.get("created_by", "mcp"),
+    )
+    path = board.create_task(task)
+    return _json_response({
+        "created": True,
+        "task_id": task.id,
+        "title": task.title,
+        "priority": task.priority.value,
+        "path": str(path),
+    })
+
+
+HANDLERS: dict = {
+    "coord_status": _handle_coord_status,
+    "coord_claim": _handle_coord_claim,
+    "coord_complete": _handle_coord_complete,
+    "coord_create": _handle_coord_create,
+}

package/src/skcapstone/mcp_tools/deploy_tools.py

@@ -0,0 +1,202 @@
+"""Deploy status tool — platform detection, secrets backend, last deploy, ArgoCD sync."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from mcp.types import TextContent, Tool
+
+from ._helpers import _json_response
+
+TOOLS: list[Tool] = [
+    Tool(
+        name="deploy_status",
+        description=(
+            "Report infrastructure deployment status: detected platform "
+            "(swarm/k8s/rke2 from skstacks/v2/ layout), active secrets "
+            "backend (SKSTACKS_SECRET_BACKEND env), last deploy commit "
+            "(git log --oneline -1), and ArgoCD app-of-apps sync/health "
+            "when app-of-apps.yaml is present. Returns structured JSON."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "skstacks_root": {
+                    "type": "string",
+                    "description": (
+                        "Absolute path to skstacks/v2/. "
+                        "Auto-detected from git root or SKSTACKS_V2_ROOT env if omitted."
+                    ),
+                },
+            },
+            "required": [],
+        },
+    ),
+]
+
+
+# ── Internal helpers ──────────────────────────────────────────
+
+
+def _git_root() -> Optional[Path]:
+    """Return the git repository root, or None if not in a repo."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return Path(result.stdout.strip())
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        pass
+    return None
+
+
+def _find_skstacks_v2(override: Optional[str] = None) -> Optional[Path]:
+    """Locate the skstacks/v2/ directory.
+
+    Resolution order:
+    1. *override* argument (caller-supplied path)
+    2. ``SKSTACKS_V2_ROOT`` environment variable
+    3. ``<git-root>/skstacks/v2/``
+    4. ``<cwd>/skstacks/v2/``
+    """
+    if override:
+        p = Path(override).expanduser()
+        return p if p.exists() else None
+
+    env_val = os.environ.get("SKSTACKS_V2_ROOT")
+    if env_val:
+        p = Path(env_val).expanduser()
+        return p if p.exists() else None
+
+    git_root = _git_root()
+    if git_root:
+        candidate = git_root / "skstacks" / "v2"
+        if candidate.exists():
+            return candidate
+
+    cwd_candidate = Path.cwd() / "skstacks" / "v2"
+    if cwd_candidate.exists():
+        return cwd_candidate
+
+    return None
+
+
+def _detect_platforms(v2_root: Path) -> list[str]:
+    """Return detected platforms from skstacks/v2/ structure.
+
+    * ``rke2``  — ``platform/rke2/`` directory present
+    * ``swarm`` — any ``docker-compose*.j2`` file found recursively
+    * ``k8s``   — ``overlays/`` directory present
+    """
+    detected: list[str] = []
+
+    if (v2_root / "platform" / "rke2").exists():
+        detected.append("rke2")
+
+    if list(v2_root.rglob("docker-compose*.j2")):
+        detected.append("swarm")
+
+    if (v2_root / "overlays").exists():
+        detected.append("k8s")
+
+    return detected or ["unknown"]
+
+
+def _active_secrets_backend() -> str:
+    """Read ``SKSTACKS_SECRET_BACKEND`` env var (default: ``vault-file``)."""
+    return os.environ.get("SKSTACKS_SECRET_BACKEND", "vault-file")
+
+
+def _last_deploy_commit(repo_root: Optional[Path] = None) -> str:
+    """Return ``git log --oneline -1`` from *repo_root* (or CWD)."""
+    try:
+        result = subprocess.run(
+            ["git", "log", "--oneline", "-1"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            cwd=str(repo_root) if repo_root else None,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+        return f"error: {result.stderr.strip()}"
+    except (FileNotFoundError, subprocess.TimeoutExpired) as exc:
+        return f"error: {exc}"
+
+
+def _argocd_sync_status(v2_root: Path) -> Optional[dict]:
+    """Return ArgoCD sync/health for app-of-apps if the manifest exists.
+
+    Runs ``kubectl get application app-of-apps -n argocd`` and extracts
+    ``.status.sync.status`` + ``.status.health.status``.  When kubectl is
+    unavailable or the cluster is unreachable the error is returned in the
+    dict rather than raising.
+    """
+    aoa_path = v2_root / "cicd" / "argocd" / "app-of-apps.yaml"
+    if not aoa_path.exists():
+        return None
+
+    base: dict = {"app": "app-of-apps", "manifest": str(aoa_path)}
+    try:
+        result = subprocess.run(
+            [
+                "kubectl", "get", "application", "app-of-apps",
+                "-n", "argocd",
+                "-o", "jsonpath={.status.sync.status} {.status.health.status}",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            parts = result.stdout.strip().split()
+            return {
+                **base,
+                "sync": parts[0] if parts else "Unknown",
+                "health": parts[1] if len(parts) > 1 else "Unknown",
+            }
+        return {**base, "error": result.stderr.strip() or "kubectl returned non-zero"}
+    except (FileNotFoundError, subprocess.TimeoutExpired) as exc:
+        return {**base, "error": str(exc)}
+
+
+# ── Handler ───────────────────────────────────────────────────
+
+
+async def _handle_deploy_status(args: dict) -> list[TextContent]:
+    """Return deployment status: platform, secrets backend, last commit, ArgoCD."""
+    v2_root = _find_skstacks_v2(args.get("skstacks_root"))
+    repo_root = _git_root()
+
+    if v2_root is None:
+        return _json_response({
+            "platforms": ["unknown"],
+            "skstacks_v2": None,
+            "secrets_backend": _active_secrets_backend(),
+            "last_deploy": _last_deploy_commit(repo_root),
+            "argocd": None,
+            "warning": (
+                "skstacks/v2/ not found; "
+                "set SKSTACKS_V2_ROOT or run from repo root"
+            ),
+        })
+
+    return _json_response({
+        "platforms": _detect_platforms(v2_root),
+        "skstacks_v2": str(v2_root),
+        "secrets_backend": _active_secrets_backend(),
+        "last_deploy": _last_deploy_commit(repo_root),
+        "argocd": _argocd_sync_status(v2_root),
+    })
+
+
+HANDLERS: dict = {
+    "deploy_status": _handle_deploy_status,
+}