@smilintux/skcapstone 0.1.0 → 0.2.3

package/src/skcapstone/mcp_tools/skcomm_tools.py

@@ -0,0 +1,122 @@
+"""SKComm notification and status tools.
+
+Exposes two tools:
+    comm_notify — Send a notification via SKComm transports
+    comm_status — Show SKComm subsystem status
+"""
+
+from __future__ import annotations
+
+from mcp.types import TextContent, Tool
+
+from ._helpers import _error_response, _home, _json_response
+
+TOOLS: list[Tool] = [
+    Tool(
+        name="comm_notify",
+        description=(
+            "Send a notification message via SKComm. Routes through "
+            "available transports (Syncthing, file, Tailscale). "
+            "Supports urgency levels for priority routing."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "recipient": {
+                    "type": "string",
+                    "description": "Agent name or PGP fingerprint of the recipient",
+                },
+                "message": {
+                    "type": "string",
+                    "description": "Notification message content",
+                },
+                "urgency": {
+                    "type": "string",
+                    "enum": ["low", "normal", "high", "critical"],
+                    "description": "Notification urgency (default: normal)",
+                },
+                "subject": {
+                    "type": "string",
+                    "description": "Optional notification subject line",
+                },
+            },
+            "required": ["recipient", "message"],
+        },
+    ),
+    Tool(
+        name="comm_status",
+        description=(
+            "Show SKComm subsystem status: installed version, "
+            "available transports, connection state, and recent "
+            "delivery statistics."
+        ),
+        inputSchema={"type": "object", "properties": {}, "required": []},
+    ),
+]
+
+
+async def _handle_comm_notify(args: dict) -> list[TextContent]:
+    """Send a notification 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  # type: ignore[import]
+
+        comm = SKComm.from_config()
+        report = comm.send(recipient, message)
+        return _json_response({
+            "sent": report.success,
+            "recipient": recipient,
+            "urgency": args.get("urgency", "normal"),
+            "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"Notification send failed: {exc}")
+
+
+async def _handle_comm_status(_args: dict) -> list[TextContent]:
+    """Show SKComm subsystem status."""
+    result: dict = {}
+
+    try:
+        import skcomm  # type: ignore[import]
+
+        result["installed"] = True
+        result["version"] = getattr(skcomm, "__version__", "unknown")
+    except ImportError:
+        result["installed"] = False
+        result["version"] = None
+        return _json_response(result)
+
+    try:
+        from skcomm.core import SKComm  # type: ignore[import]
+
+        comm = SKComm.from_config()
+        result["transports"] = [
+            t.name for t in getattr(comm, "transports", [])
+        ]
+        result["connected"] = True
+    except Exception as exc:
+        result["transports"] = []
+        result["connected"] = False
+        result["error"] = str(exc)
+
+    return _json_response(result)
+
+
+HANDLERS: dict = {
+    "comm_notify": _handle_comm_notify,
+    "comm_status": _handle_comm_status,
+}

package/src/skcapstone/mcp_tools/skills_tools.py

@@ -0,0 +1,127 @@
+"""SKSkills list and run tools."""
+
+from __future__ import annotations
+
+import logging
+
+from mcp.types import TextContent, Tool
+
+from ._helpers import _error_response, _get_agent_name, _home, _json_response, _text_response
+
+logger = logging.getLogger("skcapstone.mcp")
+
+TOOLS: list[Tool] = [
+    Tool(
+        name="skskills_list_tools",
+        description=(
+            "List all tools available from installed SKSkills agent skills. "
+            "Returns tool names in 'skill_name.tool_name' format, descriptions, "
+            "and which skills are enabled or disabled. Use this to discover "
+            "what skill capabilities are available before calling skskills_run_tool."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "agent": {
+                    "type": "string",
+                    "description": "Agent namespace to load skills for (default: global)",
+                },
+            },
+            "required": [],
+        },
+    ),
+    Tool(
+        name="skskills_run_tool",
+        description=(
+            "Run a specific skill tool by its qualified name (skill_name.tool_name). "
+            "Use skskills_list_tools first to discover available tools. "
+            "Example: skskills_run_tool with tool='syncthing-setup.check_status'."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "tool": {
+                    "type": "string",
+                    "description": "Fully-qualified tool name, e.g. 'syncthing-setup.check_status'",
+                },
+                "args": {
+                    "type": "object",
+                    "description": "Arguments to pass to the tool (tool-specific)",
+                },
+                "agent": {
+                    "type": "string",
+                    "description": "Agent namespace to load skills for (default: global)",
+                },
+            },
+            "required": ["tool"],
+        },
+    ),
+]
+
+
+async def _handle_skskills_list_tools(args: dict) -> list[TextContent]:
+    """List all tools from installed SKSkills agent skills."""
+    try:
+        from skskills.aggregator import SkillAggregator
+    except ImportError:
+        return _error_response(
+            "skskills is not installed. Run: pip install skskills"
+        )
+
+    agent = args.get("agent") or _get_agent_name(_home())
+    agg = SkillAggregator(agent=agent)
+    count = agg.load_all_skills()
+
+    tools = agg.loader.all_tools()
+    skills = agg.get_loaded_skills()
+
+    return _json_response({
+        "agent": agent,
+        "skills_loaded": count,
+        "skills": skills,
+        "tools": [
+            {
+                "name": t["name"],
+                "description": t["description"],
+                "inputSchema": t["inputSchema"],
+            }
+            for t in tools
+        ],
+    })
+
+
+async def _handle_skskills_run_tool(args: dict) -> list[TextContent]:
+    """Run a specific skill tool by its qualified name."""
+    try:
+        from skskills.aggregator import SkillAggregator
+    except ImportError:
+        return _error_response(
+            "skskills is not installed. Run: pip install skskills"
+        )
+
+    tool_name = args.get("tool", "")
+    if not tool_name:
+        return _error_response("'tool' argument is required (e.g. 'syncthing-setup.check_status')")
+
+    agent = args.get("agent") or _get_agent_name(_home())
+    tool_args = args.get("args") or {}
+
+    agg = SkillAggregator(agent=agent)
+    agg.load_all_skills()
+
+    try:
+        result = await agg.loader.call_tool(tool_name, tool_args)
+        if isinstance(result, str):
+            return _text_response(result)
+        return _json_response(result)
+    except KeyError as exc:
+        return _error_response(str(exc))
+    except Exception as exc:
+        logger.exception("skskills_run_tool '%s' failed", tool_name)
+        return _error_response(f"{tool_name} failed: {exc}")
+
+
+HANDLERS: dict = {
+    "skskills_list_tools": _handle_skskills_list_tools,
+    "skskills_run_tool": _handle_skskills_run_tool,
+}

package/src/skcapstone/mcp_tools/skseed_tools.py

@@ -0,0 +1,255 @@
+"""SKSeed (Logic Kernel) tools."""
+
+from __future__ import annotations
+
+from mcp.types import TextContent, Tool
+
+from ._helpers import _error_response, _json_response
+
+TOOLS: list[Tool] = [
+    Tool(
+        name="skseed_ingest",
+        description=(
+            "Ingest a document (file or URL) into long-term memory. "
+            "Supports PDF, Markdown, TXT, HTML files and HTTP(S) URLs. "
+            "Extracts text, identifies key claims, and stores as a searchable memory."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "File path or URL to ingest",
+                },
+                "title": {
+                    "type": "string",
+                    "description": "Optional title override for the document",
+                },
+                "tags": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Optional tags to attach to the memory",
+                },
+            },
+            "required": ["path"],
+        },
+    ),
+    Tool(
+        name="skseed_collide",
+        description=(
+            "Run a proposition through the 6-stage steel man collider. "
+            "Builds strongest version, strongest counter, smashes them together, "
+            "and extracts invariant truth. Returns coherence score and truth grade."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "proposition": {
+                    "type": "string",
+                    "description": "The claim/argument/idea to analyze",
+                },
+                "context": {
+                    "type": "string",
+                    "description": "Domain context (e.g., security, ethics, identity)",
+                },
+            },
+            "required": ["proposition"],
+        },
+    ),
+    Tool(
+        name="skseed_audit",
+        description=(
+            "Scan memories for logic/truth misalignment. Extracts beliefs from "
+            "memory, clusters by domain, runs through collider, flags contradictions. "
+            "Separates truth misalignments from moral misalignments."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "domain": {
+                    "type": "string",
+                    "description": "Filter by topic domain (optional)",
+                },
+                "triggered_by": {
+                    "type": "string",
+                    "description": "What triggered this audit (default: mcp)",
+                },
+            },
+            "required": [],
+        },
+    ),
+    Tool(
+        name="skseed_philosopher",
+        description=(
+            "Enter philosopher mode for brainstorming. Modes: socratic (challenge "
+            "assumptions), dialectic (thesis/antithesis/synthesis), adversarial "
+            "(max counter-arguments), collaborative (steel-man only, build together)."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "topic": {
+                    "type": "string",
+                    "description": "The subject to explore",
+                },
+                "mode": {
+                    "type": "string",
+                    "description": "Brainstorming mode: socratic, dialectic, adversarial, collaborative (default: dialectic)",
+                    "enum": ["socratic", "dialectic", "adversarial", "collaborative"],
+                },
+            },
+            "required": ["topic"],
+        },
+    ),
+    Tool(
+        name="skseed_truth_check",
+        description=(
+            "Check if a belief is truth-aligned. Runs through the steel man "
+            "collider and records the result. Tracks human beliefs, model beliefs, "
+            "and collider results separately."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "belief": {
+                    "type": "string",
+                    "description": "The belief statement to check",
+                },
+                "source": {
+                    "type": "string",
+                    "description": "Who holds this belief: human or model (default: model)",
+                    "enum": ["human", "model"],
+                },
+                "domain": {
+                    "type": "string",
+                    "description": "Topic domain (default: general)",
+                },
+            },
+            "required": ["belief"],
+        },
+    ),
+    Tool(
+        name="skseed_alignment",
+        description=(
+            "Show truth alignment status across all three belief stores "
+            "(human, model, collider). Lists open misalignment issues, "
+            "coherence trends, and three-way comparison."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "domain": {
+                    "type": "string",
+                    "description": "Filter by domain (optional)",
+                },
+                "action": {
+                    "type": "string",
+                    "description": "Action: status, issues, ledger (default: status)",
+                    "enum": ["status", "issues", "ledger"],
+                },
+            },
+            "required": [],
+        },
+    ),
+]
+
+
+async def _handle_skseed_ingest(args: dict) -> list[TextContent]:
+    """Ingest a document into long-term memory."""
+    from ..cli.skseed import ingest_document
+
+    path = args.get("path", "")
+    if not path:
+        return _error_response("path is required")
+
+    try:
+        result = ingest_document(
+            source=path,
+            title=args.get("title"),
+            tags=args.get("tags"),
+        )
+        return _json_response(result)
+    except FileNotFoundError as e:
+        return _error_response(str(e))
+    except ValueError as e:
+        return _error_response(str(e))
+    except Exception as e:
+        return _error_response(f"Ingestion failed: {e}")
+
+
+async def _handle_skseed_collide(args: dict) -> list[TextContent]:
+    """Run a proposition through the 6-stage steel man collider."""
+    from skseed.skill import collide
+
+    proposition = args.get("proposition", "")
+    if not proposition:
+        return _error_response("proposition is required")
+
+    result = collide(
+        proposition=proposition,
+        context=args.get("context", ""),
+    )
+    return _json_response(result)
+
+
+async def _handle_skseed_audit(args: dict) -> list[TextContent]:
+    """Scan memories for logic/truth misalignment."""
+    from skseed.skill import audit
+
+    result = audit(
+        domain=args.get("domain", ""),
+        triggered_by=args.get("triggered_by", "mcp"),
+    )
+    return _json_response(result)
+
+
+async def _handle_skseed_philosopher(args: dict) -> list[TextContent]:
+    """Enter philosopher mode for brainstorming."""
+    from skseed.skill import philosopher
+
+    topic = args.get("topic", "")
+    if not topic:
+        return _error_response("topic is required")
+
+    result = philosopher(
+        topic=topic,
+        mode=args.get("mode", "dialectic"),
+    )
+    return _json_response(result)
+
+
+async def _handle_skseed_truth_check(args: dict) -> list[TextContent]:
+    """Check if a belief is truth-aligned."""
+    from skseed.skill import truth_check
+
+    belief = args.get("belief", "")
+    if not belief:
+        return _error_response("belief is required")
+
+    result = truth_check(
+        belief=belief,
+        source=args.get("source", "model"),
+        domain=args.get("domain", "general"),
+    )
+    return _json_response(result)
+
+
+async def _handle_skseed_alignment(args: dict) -> list[TextContent]:
+    """Show truth alignment status across belief stores."""
+    from skseed.skill import alignment_report
+
+    result = alignment_report(
+        domain=args.get("domain", ""),
+        action=args.get("action", "status"),
+    )
+    return _json_response(result)
+
+
+HANDLERS: dict = {
+    "skseed_ingest": _handle_skseed_ingest,
+    "skseed_collide": _handle_skseed_collide,
+    "skseed_audit": _handle_skseed_audit,
+    "skseed_philosopher": _handle_skseed_philosopher,
+    "skseed_truth_check": _handle_skseed_truth_check,
+    "skseed_alignment": _handle_skseed_alignment,
+}