trinity-lite 0.2.0__tar.gz → 0.2.2__tar.gz

{trinity_lite-0.2.0 → trinity_lite-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trinity-lite
-Version: 0.2.0
+Version: 0.2.2
 Summary: A minimal public multi-agent task bus with routing, workers, and safety checks.
 Author: Yomiracle
 License-Expression: MIT
@@ -19,6 +19,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: mcp
 Requires-Dist: mcp>=1.0; extra == "mcp"
+Provides-Extra: agent-skill
+Requires-Dist: agent-skill-system>=1.0.6; extra == "agent-skill"
 Dynamic: license-file
 
 # Trinity Lite

{trinity_lite-0.2.0 → trinity_lite-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trinity-lite"
-version = "0.2.0"
+version = "0.2.2"
 description = "A minimal public multi-agent task bus with routing, workers, and safety checks."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -26,6 +26,7 @@ dependencies = []
 
 [project.optional-dependencies]
 mcp = ["mcp>=1.0"]
+agent-skill = ["agent-skill-system>=1.0.6"]
 
 [project.scripts]
 trinity-lite = "trinity_lite.cli:main"

{trinity_lite-0.2.0 → trinity_lite-0.2.2}/tests/test_mcp_server.py

@@ -1,5 +1,6 @@
 import io
 import json
+import os
 import sys
 import tempfile
 import unittest
@@ -22,6 +23,19 @@ from trinity_lite.mcp_server import (
     _get_known_agents,
 )
 
+try:
+    from engine.bank import SkillBank  # noqa: F401
+
+    HAS_AGENT_SKILL = True
+except ImportError:
+    HAS_AGENT_SKILL = False
+
+# Detect agent-skill-system skills directory
+SKILLS_DIR = os.environ.get(
+    "TRINITY_SKILLS_DIR",
+    os.path.expanduser("~/agent-skill-system/skills"),
+)
+
 
 class McpServerTest(unittest.TestCase):
     def setUp(self):
@@ -54,7 +68,7 @@ class McpServerTest(unittest.TestCase):
         self.assertIn("resources", resp["result"]["capabilities"])
         self.assertIn("serverInfo", resp["result"])
         self.assertEqual(resp["result"]["serverInfo"]["name"], "trinity-lite-mcp")
-        self.assertEqual(resp["result"]["serverInfo"]["version"], "0.2.0")
+        self.assertEqual(resp["result"]["serverInfo"]["version"], "0.2.2")
 
     def test_initialized_returns_none(self):
         resp = self._call(self._msg("initialized"))
@@ -76,7 +90,7 @@ class McpServerTest(unittest.TestCase):
         resp = self._call(self._msg("tools/list", 1))
         tools = resp["result"]["tools"]
         self.assertIsInstance(tools, list)
-        self.assertEqual(len(tools), 8)
+        self.assertEqual(len(tools), 10)
         names = [t["name"] for t in tools]
         self.assertIn("trinity_dispatch", names)
         self.assertIn("trinity_dispatch_auto", names)
@@ -86,6 +100,8 @@ class McpServerTest(unittest.TestCase):
         self.assertIn("trinity_doctor", names)
         self.assertIn("trinity_inbox", names)
         self.assertIn("trinity_send", names)
+        self.assertIn("trinity_skill_search", names)
+        self.assertIn("trinity_skill_load", names)
         # Check schema structure
         for t in tools:
             self.assertIn("name", t)
@@ -117,7 +133,7 @@ class McpServerTest(unittest.TestCase):
         data = json.loads(contents[0]["text"])
         self.assertEqual(data["status"], "ok")
         self.assertEqual(data["bus"], "connected")
-        self.assertEqual(data["tools"], 8)
+        self.assertEqual(data["tools"], 10)
         self.assertEqual(data["resources"], 3)
 
     def test_resource_health_degraded(self):
@@ -451,5 +467,123 @@ class McpServerTest(unittest.TestCase):
         self.assertEqual(compact["id"], "abc123def456")
 
 
+    # ---- Skills: agent-skill-system integration ----
+
+    def test_skill_search_without_agent_skill_system(self):
+        """Graceful error when agent-skill-system not installed."""
+        import trinity_lite.mcp_server as mcp
+        from unittest.mock import patch
+
+        with patch.object(mcp, "_init_skill_engine", return_value=False):
+            params = {
+                "name": "trinity_skill_search",
+                "arguments": {"query": "parse a contract"},
+            }
+            resp = self._call(self._msg("tools/call", 1, params))
+            self.assertIn("result", resp)
+            self.assertIn("error", resp["result"])
+            self.assertEqual(resp["result"]["error"], "agent-skill-system not installed")
+            self.assertIn("hint", resp["result"])
+
+    @unittest.skipUnless(HAS_AGENT_SKILL and Path(SKILLS_DIR).exists(),
+                         "agent-skill-system not installed or skills dir not found")
+    def test_skill_search_returns_matching_skills(self):
+        """Search returns matching skills when engine is available."""
+        import trinity_lite.mcp_server as mcp
+
+        old_available = mcp._SKILL_ENGINE_AVAILABLE
+        old_bank = mcp._SKILL_BANK
+        old_bank_dir = mcp._SKILL_BANK_DIR
+        try:
+            from engine.bank import SkillBank
+            mcp._SKILL_ENGINE_AVAILABLE = True
+            mcp._SKILL_BANK_DIR = SKILLS_DIR
+            mcp._SKILL_BANK = SkillBank(mcp._SKILL_BANK_DIR)
+            mcp._SKILL_BANK.scan_directory()
+
+            params = {
+                "name": "trinity_skill_search",
+                "arguments": {"query": "generate a weekly report", "limit": 3},
+            }
+            resp = self._call(self._msg("tools/call", 1, params))
+            self.assertIn("result", resp)
+            self.assertIn("skills", resp["result"])
+            skills = resp["result"]["skills"]
+            self.assertIsInstance(skills, list)
+            if skills:
+                self.assertIn("name", skills[0])
+                self.assertIn("description", skills[0])
+                self.assertIn("score", skills[0])
+        finally:
+            mcp._SKILL_ENGINE_AVAILABLE = old_available
+            mcp._SKILL_BANK = old_bank
+            mcp._SKILL_BANK_DIR = old_bank_dir
+
+    @unittest.skipUnless(HAS_AGENT_SKILL and Path(SKILLS_DIR).exists(),
+                         "agent-skill-system not installed or skills dir not found")
+    def test_skill_load_returns_content(self):
+        """Load a skill's full content."""
+        import trinity_lite.mcp_server as mcp
+
+        old_available = mcp._SKILL_ENGINE_AVAILABLE
+        old_bank = mcp._SKILL_BANK
+        old_bank_dir = mcp._SKILL_BANK_DIR
+        try:
+            from engine.bank import SkillBank
+            mcp._SKILL_ENGINE_AVAILABLE = True
+            mcp._SKILL_BANK_DIR = SKILLS_DIR
+            mcp._SKILL_BANK = SkillBank(mcp._SKILL_BANK_DIR)
+            mcp._SKILL_BANK.scan_directory()
+
+            # Pick an active skill from the bank
+            active = mcp._SKILL_BANK.list_active()
+            if active:
+                skill_name = active[0].name
+                params = {
+                    "name": "trinity_skill_load",
+                    "arguments": {"skill_name": skill_name},
+                }
+                resp = self._call(self._msg("tools/call", 1, params))
+                self.assertIn("result", resp)
+                result = resp["result"]
+                self.assertIn("name", result)
+                self.assertIn("skill_md", result)
+                self.assertIn("system_prompt", result)
+        finally:
+            mcp._SKILL_ENGINE_AVAILABLE = old_available
+            mcp._SKILL_BANK = old_bank
+            mcp._SKILL_BANK_DIR = old_bank_dir
+
+    @unittest.skipUnless(HAS_AGENT_SKILL and Path(SKILLS_DIR).exists(),
+                         "agent-skill-system not installed or skills dir not found")
+    def test_skill_load_not_found(self):
+        """Graceful error when skill name is not in the bank."""
+        import trinity_lite.mcp_server as mcp
+
+        old_available = mcp._SKILL_ENGINE_AVAILABLE
+        old_bank = mcp._SKILL_BANK
+        old_bank_dir = mcp._SKILL_BANK_DIR
+        try:
+            from engine.bank import SkillBank
+            mcp._SKILL_ENGINE_AVAILABLE = True
+            mcp._SKILL_BANK_DIR = SKILLS_DIR
+            mcp._SKILL_BANK = SkillBank(mcp._SKILL_BANK_DIR)
+            mcp._SKILL_BANK.scan_directory()
+
+            params = {
+                "name": "trinity_skill_load",
+                "arguments": {"skill_name": "nonexistent-skill-xyz"},
+            }
+            resp = self._call(self._msg("tools/call", 1, params))
+            self.assertIn("result", resp)
+            self.assertIn("error", resp["result"])
+            self.assertIn("skill not found", resp["result"]["error"])
+            self.assertIn("available_skills", resp["result"])
+        finally:
+            mcp._SKILL_ENGINE_AVAILABLE = old_available
+            mcp._SKILL_BANK = old_bank
+            mcp._SKILL_BANK_DIR = old_bank_dir
+
+
 if __name__ == "__main__":
     unittest.main()

{trinity_lite-0.2.0 → trinity_lite-0.2.2}/trinity_lite/__init__.py

@@ -1,3 +1,3 @@
 """Trinity Lite: a minimal public multi-agent task bus."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{trinity_lite-0.2.0 → trinity_lite-0.2.2}/trinity_lite/mcp_server.py

@@ -20,10 +20,54 @@ from .guard import GuardError
 from .router import resolve_route
 from .worker import run_once as worker_run_once
 
+# ---------------------------------------------------------------------------
+# agent-skill-system integration (optional, graceful fallback)
+# ---------------------------------------------------------------------------
+
+_SKILL_ENGINE_AVAILABLE = False
+_SKILL_BANK = None
+_SKILL_BANK_DIR = None
+
+
+def _find_skills_dir() -> str:
+    """Locate the agent-skill-system skills/ bank directory."""
+    # Env override
+    env_dir = os.environ.get("TRINITY_SKILLS_DIR", "")
+    if env_dir and Path(env_dir).is_dir():
+        return env_dir
+    # Check ~/.trinity/skills
+    home_skills = Path.home() / ".trinity" / "skills"
+    if home_skills.is_dir():
+        return str(home_skills)
+    # Check ~/agent-skill-system/skills (git-clone default)
+    dev_skills = Path.home() / "agent-skill-system" / "skills"
+    if dev_skills.is_dir():
+        return str(dev_skills)
+    # Default (will be auto-created by SkillBank)
+    return str(home_skills)
+
+
+def _init_skill_engine() -> bool:
+    """Lazy-init the agent-skill-system engine.  Cached after first call."""
+    global _SKILL_ENGINE_AVAILABLE, _SKILL_BANK, _SKILL_BANK_DIR
+    if _SKILL_ENGINE_AVAILABLE:
+        return True
+    try:
+        from engine.bank import SkillBank      # type: ignore[import-untyped]
+        _SKILL_BANK_DIR = _find_skills_dir()
+        _SKILL_BANK = SkillBank(_SKILL_BANK_DIR)
+        _SKILL_BANK.scan_directory()
+        _SKILL_ENGINE_AVAILABLE = True
+        return True
+    except ImportError:
+        _SKILL_ENGINE_AVAILABLE = False
+        return False
+
+
 JSONRPC_VERSION = "2.0"
 PROTOCOL_VERSION = "2024-11-05"
 SERVER_NAME = "trinity-lite-mcp"
-SERVER_VERSION = "0.2.0"
+SERVER_VERSION = "0.2.2"
 
 # ---------------------------------------------------------------------------
 # Tool definitions (MCP schema)
@@ -133,6 +177,23 @@ TOOL_DEFINITIONS = [
         },
         ["target_agent", "message"],
     ),
+    _tool_def(
+        "trinity_skill_search",
+        "Search agent-skill-system for relevant skills matching a task description.",
+        {
+            "query": {"type": "string", "description": "Task description or keyword query"},
+            "limit": {"type": "integer", "description": "Maximum results (default: 5, max: 20)"},
+        },
+        ["query"],
+    ),
+    _tool_def(
+        "trinity_skill_load",
+        "Load the full content (SKILL.md + memory) of a named skill.",
+        {
+            "skill_name": {"type": "string", "description": "Exact name of the skill to load"},
+        },
+        ["skill_name"],
+    ),
 ]
 
 TOOLS_BY_NAME = {t["name"]: t for t in TOOL_DEFINITIONS}
@@ -470,6 +531,96 @@ def _handle_trinity_send(params, bus, agents_path, routes_path):
     return jsonrpc_response(1, msg)
 
 
+def _handle_trinity_skill_search(params, bus, agents_path, routes_path):
+    query = _validate_text(params.get("query", ""), max_len=1000)
+    if not query.strip():
+        return jsonrpc_error(1, -32602, "query must not be empty")
+    limit = _validate_limit(params.get("limit"), default=5, maximum=20)
+
+    if not _init_skill_engine():
+        return jsonrpc_response(1, {
+            "error": "agent-skill-system not installed",
+            "hint": "pip install agent-skill-system",
+            "skills": [],
+        })
+
+    try:
+        from engine.searcher import SkillSearcher  # type: ignore[import-untyped]
+        searcher = SkillSearcher(_SKILL_BANK_DIR)
+        results = searcher.search(query, _SKILL_BANK.index, top_n=limit)
+    except Exception as exc:
+        return jsonrpc_response(1, {
+            "error": "skill search failed: {}".format(exc),
+            "skills": [],
+        })
+
+    skills = []
+    for entry, cfg, score in results:
+        skills.append({
+            "name": entry.name,
+            "description": cfg.description,
+            "version": entry.version,
+            "success_rate": entry.success_rate,
+            "use_count": entry.use_count,
+            "score": score,
+            "tags": cfg.tags,
+            "trigger_keywords": cfg.trigger_keywords[:8],
+        })
+
+    return jsonrpc_response(1, {"skills": skills})
+
+
+def _handle_trinity_skill_load(params, bus, agents_path, routes_path):
+    skill_name = _validate_text(params.get("skill_name", ""), max_len=128)
+    if not skill_name.strip():
+        return jsonrpc_error(1, -32602, "skill_name must not be empty")
+
+    if not _init_skill_engine():
+        return jsonrpc_response(1, {
+            "error": "agent-skill-system not installed",
+            "hint": "pip install agent-skill-system",
+        })
+
+    try:
+        from engine.loader import SkillLoader  # type: ignore[import-untyped]
+        entry = _SKILL_BANK.get(skill_name)
+        if entry is None:
+            return jsonrpc_response(1, {
+                "error": "skill not found: {}".format(skill_name),
+                "available_skills": [s.name for s in _SKILL_BANK.list_active()],
+            })
+        loader = SkillLoader(_SKILL_BANK_DIR)
+        bundle = loader.load(entry)
+        if bundle is None:
+            return jsonrpc_error(1, -32002, "failed to load skill: {}".format(skill_name))
+
+        memory_entries_serialised = []
+        for mem in bundle.memory_entries:
+            memory_entries_serialised.append({
+                "date": mem.date,
+                "type": mem.type.value,
+                "title": mem.title,
+                "scene": mem.scene,
+                "detail": mem.detail,
+            })
+
+        return jsonrpc_response(1, {
+            "name": bundle.config.name,
+            "version": bundle.config.version,
+            "description": bundle.config.description,
+            "skill_md": bundle.skill_md,
+            "memory_md": bundle.memory_md,
+            "memory_entries": memory_entries_serialised,
+            "input_schema": bundle.config.input_schema,
+            "trigger_keywords": bundle.config.trigger_keywords,
+            "system_prompt": loader.build_system_prompt(bundle),
+        })
+    except Exception as exc:
+        return jsonrpc_response(1, {
+            "error": "skill load failed: {}".format(exc),
+        })
+
+
 TOOL_HANDLERS = {
     "trinity_dispatch": _handle_trinity_dispatch,
     "trinity_dispatch_auto": _handle_trinity_dispatch_auto,
@@ -479,6 +630,8 @@ TOOL_HANDLERS = {
     "trinity_doctor": _handle_trinity_doctor,
     "trinity_inbox": _handle_trinity_inbox,
     "trinity_send": _handle_trinity_send,
+    "trinity_skill_search": _handle_trinity_skill_search,
+    "trinity_skill_load": _handle_trinity_skill_load,
 }
 
 

{trinity_lite-0.2.0 → trinity_lite-0.2.2}/trinity_lite.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trinity-lite
-Version: 0.2.0
+Version: 0.2.2
 Summary: A minimal public multi-agent task bus with routing, workers, and safety checks.
 Author: Yomiracle
 License-Expression: MIT
@@ -19,6 +19,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: mcp
 Requires-Dist: mcp>=1.0; extra == "mcp"
+Provides-Extra: agent-skill
+Requires-Dist: agent-skill-system>=1.0.6; extra == "agent-skill"
 Dynamic: license-file
 
 # Trinity Lite

trinity_lite-0.2.2/trinity_lite.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[agent-skill]
+agent-skill-system>=1.0.6
+
+[mcp]
+mcp>=1.0

trinity_lite-0.2.0/trinity_lite.egg-info/requires.txt

@@ -1,3 +0,0 @@
-
-[mcp]
-mcp>=1.0