trinity-lite 0.2.3__tar.gz → 0.3.1__tar.gz

{trinity_lite-0.2.3 → trinity_lite-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trinity-lite
-Version: 0.2.3
+Version: 0.3.1
 Summary: The bus that lets your AI agents talk to each other.
 Author: Yomiracle
 License-Expression: MIT

{trinity_lite-0.2.3 → trinity_lite-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trinity-lite"
-version = "0.2.3"
+version = "0.3.1"
 description = "The bus that lets your AI agents talk to each other."
 readme = "README.md"
 requires-python = ">=3.10"

{trinity_lite-0.2.3 → trinity_lite-0.3.1}/tests/test_mcp_server.py

@@ -68,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.2")
+        self.assertEqual(resp["result"]["serverInfo"]["version"], "0.3.1")
 
     def test_initialized_returns_none(self):
         resp = self._call(self._msg("initialized"))
@@ -90,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), 10)
+        self.assertEqual(len(tools), 12)
         names = [t["name"] for t in tools]
         self.assertIn("trinity_dispatch", names)
         self.assertIn("trinity_dispatch_auto", names)
@@ -133,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"], 10)
+        self.assertEqual(data["tools"], 12)
         self.assertEqual(data["resources"], 3)
 
     def test_resource_health_degraded(self):

trinity_lite-0.3.1/tests/test_pipeline.py

@@ -0,0 +1,185 @@
+"""Tests for pipeline orchestration."""
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from trinity_lite.bus import TrinityBus
+from trinity_lite.pipeline import (
+    load_pipeline,
+    resolve_step_prompt,
+    run_pipeline,
+)
+
+
+class PipelineTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory(dir=str(Path.home()))
+        self.root = Path(self.tmp.name)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def _write_yaml(self, name, content):
+        path = self.root / name
+        path.write_text(content, encoding="utf-8")
+        return str(path)
+
+    def test_load_valid_pipeline(self):
+        yaml_text = "name: test-pipeline\nsteps:\n  - id: step1\n    agent: codex\n    task_type: implementation\n    prompt_template: 'Implement: {task}'\n"
+        yaml_path = self._write_yaml("test.yaml", yaml_text)
+        p = load_pipeline(yaml_path)
+        self.assertEqual(p["name"], "test-pipeline")
+        self.assertEqual(len(p["steps"]), 1)
+        self.assertEqual(p["steps"][0]["id"], "step1")
+
+    def test_load_invalid_yaml_raises(self):
+        json_path = self._write_yaml("bad.json", "not valid json{{{")
+        with self.assertRaises(ValueError):
+            load_pipeline(json_path)
+
+    def test_missing_required_field_raises(self):
+        yaml_text = "name: bad\nsteps:\n  - id: step1\n    task_type: implementation\n    prompt_template: 'ok'\n"
+        yaml_path = self._write_yaml("bad.yaml", yaml_text)
+        with self.assertRaises(ValueError):
+            load_pipeline(yaml_path)
+
+    def test_empty_steps_raises(self):
+        yaml_path = self._write_yaml("empty.yaml", "name: empty\nsteps: []")
+        with self.assertRaises(ValueError):
+            load_pipeline(yaml_path)
+
+    def test_duplicate_step_ids_raises(self):
+        yaml_text = "name: dup\nsteps:\n  - id: step1\n    agent: codex\n    task_type: implementation\n    prompt_template: 'ok'\n  - id: step1\n    agent: codex\n    task_type: implementation\n    prompt_template: 'ok'\n"
+        yaml_path = self._write_yaml("dup.yaml", yaml_text)
+        with self.assertRaises(ValueError):
+            load_pipeline(yaml_path)
+
+    def test_unknown_step_reference_raises(self):
+        yaml_text = "name: badref\nsteps:\n  - id: step1\n    agent: codex\n    task_type: implementation\n    prompt_template: 'Result: {steps.nonexistent.result}'\n"
+        yaml_path = self._write_yaml("badref.yaml", yaml_text)
+        with self.assertRaises(ValueError):
+            load_pipeline(yaml_path)
+
+    def test_prompt_template_rendering_task_only(self):
+        step = {"prompt_template": "Do: {task}"}
+        result = resolve_step_prompt(step, "write tests", {})
+        self.assertEqual(result, "Do: write tests")
+
+    def test_prompt_template_rendering_with_step_result(self):
+        step = {"prompt_template": "Result was: {steps.step1.result}"}
+        step_results = {"step1": {"result": "all done", "status": "completed"}}
+        result = resolve_step_prompt(step, "task", step_results)
+        self.assertEqual(result, "Result was: all done")
+
+    def test_prompt_template_rendering_with_missing_step(self):
+        step = {"prompt_template": "Got: {steps.missing.result}"}
+        result = resolve_step_prompt(step, "task", {})
+        self.assertEqual(result, "Got: ")
+
+    def test_prompt_template_rendering_with_error(self):
+        step = {"prompt_template": "Error: {steps.step1.result}"}
+        step_results = {"step1": {"error": "failed hard", "status": "failed"}}
+        result = resolve_step_prompt(step, "task", step_results)
+        self.assertEqual(result, "Error: failed hard")
+
+    def test_run_single_step_pipeline(self):
+        bus = TrinityBus(self.root / "bus.db", allowed_roots=[self.root])
+        pipeline = {
+            "name": "test-single",
+            "steps": [
+                {"id": "implement", "agent": "codex", "task_type": "implementation",
+                 "prompt_template": "Implement: {task}"}
+            ],
+        }
+        result = run_pipeline(pipeline, "hello world", bus, cwd=str(self.root))
+        self.assertEqual(result["pipeline_name"], "test-single")
+        self.assertEqual(result["overall_status"], "completed")
+        self.assertEqual(len(result["steps"]), 1)
+        self.assertEqual(result["steps"][0]["status"], "completed")
+
+    def test_run_two_step_pipeline(self):
+        bus = TrinityBus(self.root / "bus.db", allowed_roots=[self.root])
+        pipeline = {
+            "name": "test-two",
+            "steps": [
+                {"id": "implement", "agent": "codex", "task_type": "implementation",
+                 "prompt_template": "Implement: {task}"},
+                {"id": "review", "agent": "claude_code", "task_type": "code_review",
+                 "prompt_template": "Review: {task}\nResult: {steps.implement.result}"},
+            ],
+        }
+        result = run_pipeline(pipeline, "hello", bus, cwd=str(self.root))
+        self.assertEqual(result["overall_status"], "completed")
+        self.assertEqual(len(result["steps"]), 2)
+        self.assertEqual(result["steps"][0]["status"], "completed")
+        self.assertEqual(result["steps"][1]["status"], "completed")
+
+    def test_pipeline_step_results_accessible(self):
+        bus = TrinityBus(self.root / "bus.db", allowed_roots=[self.root])
+        pipeline = {
+            "name": "test-ref",
+            "steps": [
+                {"id": "step1", "agent": "codex", "task_type": "implementation",
+                 "prompt_template": "Task: {task}"},
+                {"id": "step2", "agent": "claude_code", "task_type": "code_review",
+                 "prompt_template": "Previous result was: {steps.step1.result}"},
+            ],
+        }
+        result = run_pipeline(pipeline, "check refs", bus, cwd=str(self.root))
+        self.assertEqual(result["overall_status"], "completed")
+        step2 = bus.get_task(result["steps"][1]["task_id"])
+        self.assertIn("Previous result was:", step2["prompt"])
+
+    def test_pipeline_no_run_workers(self):
+        bus = TrinityBus(self.root / "bus.db", allowed_roots=[self.root])
+        pipeline = {
+            "name": "test-no-run",
+            "steps": [
+                {"id": "step1", "agent": "codex", "task_type": "implementation",
+                 "prompt_template": "{task}"}
+            ],
+        }
+        result = run_pipeline(pipeline, "stuff", bus, cwd=str(self.root), run_workers=False)
+        self.assertEqual(result["overall_status"], "queued")
+
+    def test_pipeline_fail_fast(self):
+        bus = TrinityBus(self.root / "bus.db", allowed_roots=[self.root])
+        pipeline = {
+            "name": "test-fail",
+            "steps": [
+                {"id": "step1", "agent": "no_such_agent", "task_type": "implementation",
+                 "prompt_template": "{task}"},
+                {"id": "step2", "agent": "codex", "task_type": "implementation",
+                 "prompt_template": "{task}"},
+            ],
+        }
+        result = run_pipeline(pipeline, "stuff", bus, cwd=str(self.root))
+        self.assertEqual(result["overall_status"], "failed")
+        self.assertEqual(len(result["steps"]), 1)
+
+    def test_cli_orchestrate_with_pipeline_flag(self):
+        import io as _io
+        import json as _json
+        from contextlib import redirect_stdout as _redirect_stdout
+        from trinity_lite.cli import main
+        yaml_text = "name: cli-pipe\nsteps:\n  - id: step1\n    agent: codex\n    task_type: implementation\n    prompt_template: 'ok'\n"
+        pipeline_path = self._write_yaml("cli_test.yaml", yaml_text)
+        output = _io.StringIO()
+        with _redirect_stdout(output):
+            code = main([
+                "orchestrate",
+                "test task",
+                "--pipeline", pipeline_path,
+                "--db", str(self.root / "cli_bus.db"),
+                "--cwd", str(self.root),
+            ])
+        self.assertEqual(code, 0)
+        data = _json.loads(output.getvalue())
+        self.assertEqual(data["pipeline_name"], "cli-pipe")
+        self.assertEqual(data["overall_status"], "completed")
+
+
+if __name__ == "__main__":
+    unittest.main()

trinity_lite-0.3.1/tests/test_worker.py

@@ -0,0 +1,161 @@
+import os, signal, tempfile, time, unittest, json
+from pathlib import Path
+from unittest.mock import patch
+
+from trinity_lite.bus import TrinityBus
+from trinity_lite.worker import (
+    run_once, run_loop, _acquire_pid_file, _cleanup_pid_file,
+    _check_existing_pid, _read_pid_file, _stop_flag,
+    _install_signal_handlers, _default_pid_path,
+)
+
+
+class WorkerTest(unittest.TestCase):
+    def test_mock_worker_completes_task(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            task = bus.submit_task("user", "codex", "implement hello", cwd=root)
+            done = run_once("codex", bus)
+            self.assertEqual(done["id"], task["id"])
+            self.assertEqual(done["status"], "completed")
+            self.assertIn("[mock:codex]", done["result"])
+
+    def test_missing_configured_agent_fails_task(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            task = bus.submit_task("user", "unknown", "work", cwd=root)
+            done = run_once("unknown", bus)
+            self.assertEqual(done["id"], task["id"])
+            self.assertEqual(done["status"], "failed")
+            self.assertIn("agent not configured", done["error"])
+
+    def test_command_adapter_failure_is_recorded(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            agents_path = root / "agents.json"
+            agents_path.write_text(json.dumps({
+                "agents": {
+                    "codex": {
+                        "mode": "command",
+                        "command": ["definitely-not-a-real-trinity-lite-command"]
+                    }
+                }
+            }), encoding="utf-8")
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            task = bus.submit_task("user", "codex", "work", cwd=root)
+            done = run_once("codex", bus, str(agents_path))
+            self.assertEqual(done["id"], task["id"])
+            self.assertEqual(done["status"], "failed")
+            self.assertIn("executable not found", done["error"])
+
+    def test_memory_error_is_not_swallowed(self):
+        class OomAdapter:
+            def run(self, task):
+                raise MemoryError("oom")
+
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            task = bus.submit_task("user", "codex", "work", cwd=root)
+            with patch("trinity_lite.worker.build_adapter", return_value=OomAdapter()):
+                with self.assertRaises(MemoryError):
+                    run_once("codex", bus)
+            self.assertEqual(bus.get_task(task["id"])["status"], "running")
+
+    # ── New daemon tests ──
+
+    def test_run_loop_stop_flag(self):
+        """Start loop, set stop_flag, verify exits cleanly."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            _stop_flag.clear()
+            # Set stop flag after a short delay in a separate thread
+            import threading
+            def set_stop():
+                time.sleep(0.15)
+                _stop_flag.set()
+            t = threading.Thread(target=set_stop)
+            t.start()
+            exit_code = run_loop("codex", bus, poll_seconds=0.05)
+            t.join()
+            self.assertEqual(exit_code, 0)
+
+    def test_pid_file_creation(self):
+        """Verify PID file created with correct contents."""
+        with tempfile.TemporaryDirectory() as tmp:
+            pid_path = Path(tmp) / "test.pid"
+            _acquire_pid_file(pid_path)
+            self.assertTrue(pid_path.exists())
+            pid = int(pid_path.read_text().strip())
+            self.assertEqual(pid, os.getpid())
+            _cleanup_pid_file(pid_path)
+
+    def test_pid_file_cleanup_on_exit(self):
+        """Verify PID file created during daemon loop and cleanup works."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            pid_path = Path(tmp) / "cleanup_test.pid"
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            _stop_flag.clear()
+            import threading
+            def set_stop():
+                time.sleep(0.15)
+                _stop_flag.set()
+            t = threading.Thread(target=set_stop)
+            t.start()
+            exit_code = run_loop("codex", bus, poll_seconds=0.05, pid_file=pid_path)
+            t.join()
+            self.assertEqual(exit_code, 0)
+            # PID file was created
+            self.assertTrue(pid_path.exists())
+            # Manually verify cleanup works (atexit fires at process exit)
+            _cleanup_pid_file(pid_path)
+            self.assertFalse(pid_path.exists())
+
+    def test_duplicate_daemon_prevented(self):
+        """Verify second attempt to acquire PID raises error."""
+        with tempfile.TemporaryDirectory() as tmp:
+            pid_path = Path(tmp) / "dup.pid"
+            # Write our own PID first
+            _acquire_pid_file(pid_path)
+            self.assertTrue(pid_path.exists())
+            # Second attempt should raise
+            with self.assertRaises(RuntimeError):
+                _check_existing_pid(pid_path)
+            _cleanup_pid_file(pid_path)
+
+    def test_stale_pid_cleanup(self):
+        """Write fake PID, verify it's treated as stale and can be re-acquired."""
+        with tempfile.TemporaryDirectory() as tmp:
+            pid_path = Path(tmp) / "stale.pid"
+            # Write a PID that doesn't exist
+            pid_path.write_text("99999")
+            # Should be treated as stale (None returned)
+            result = _check_existing_pid(pid_path)
+            self.assertIsNone(result)
+
+    def test_read_pid_file(self):
+        """Test _read_pid_file returns correct PID."""
+        with tempfile.TemporaryDirectory() as tmp:
+            pid_path = Path(tmp) / "read.pid"
+            pid_path.write_text("42")
+            self.assertEqual(_read_pid_file(pid_path), 42)
+            # Corrupt file
+            pid_path.write_text("not_a_pid")
+            self.assertIsNone(_read_pid_file(pid_path))
+            # Missing file
+            self.assertIsNone(_read_pid_file(Path(tmp) / "nonexistent.pid"))
+
+    def test_default_pid_path(self):
+        """Test default PID path resolution."""
+        path = _default_pid_path("codex")
+        self.assertIn(".trinity", str(path))
+        self.assertIn("workers", str(path))
+        self.assertTrue(str(path).endswith("codex.pid"))
+
+
+if __name__ == "__main__":
+    unittest.main()

{trinity_lite-0.2.3 → trinity_lite-0.3.1}/trinity_lite/__init__.py

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

{trinity_lite-0.2.3 → trinity_lite-0.3.1}/trinity_lite/cli.py

@@ -12,8 +12,9 @@ from typing import Any
 from .bus import TrinityBus
 from .doctor import run_doctor
 from .orchestrator import run_review_flow
+from .pipeline import load_pipeline, run_pipeline
 from .router import resolve_route
-from .worker import run_loop, run_once
+from .worker import _default_pid_path, run_loop, run_once
 
 
 def print_json(data: Any) -> None:
@@ -77,6 +78,7 @@ def build_parser() -> argparse.ArgumentParser:
 
     orchestrate = sub.add_parser("orchestrate", parents=[common], help="dispatch and run a primary task with optional review")
     orchestrate.add_argument("task")
+    orchestrate.add_argument("--pipeline", default=None, help="path to pipeline YAML (uses pipeline orchestration instead of review flow)")
     orchestrate.add_argument("--source", default="user")
     orchestrate.add_argument("--type", dest="task_type")
     orchestrate.add_argument("--previous-agent")
@@ -94,8 +96,10 @@ def build_parser() -> argparse.ArgumentParser:
 
     worker = sub.add_parser("worker", parents=[common], help="run a worker for one agent")
     worker.add_argument("agent")
-    worker.add_argument("--once", action="store_true")
-    worker.add_argument("--poll", type=float, default=2.0)
+    worker.add_argument("--once", action="store_true", help="run a single worker cycle and exit")
+    worker.add_argument("--poll", type=float, default=2.0, help="poll interval in seconds (default: 2.0)")
+    worker.add_argument("--daemon", action="store_true", help="run in continuous daemon mode with signal handling and PID locking")
+    worker.add_argument("--pid-file", default=None, help="custom PID file path (default: ~/.trinity/workers/<agent>.pid)")
 
     send = sub.add_parser("send", parents=[common], help="send a durable message")
     send.add_argument("target_agent")
@@ -198,17 +202,30 @@ def run_command(args: argparse.Namespace) -> int:
         print_json(task)
         return 0
     if args.command == "orchestrate":
-        result = run_review_flow(
-            args.task,
-            bus,
-            args.routes,
-            args.agents,
-            args.source,
-            args.task_type,
-            args.previous_agent,
-            args.cwd,
-            run_workers=not args.no_run and not getattr(args, "wait", False),
-        )
+        if args.pipeline:
+            pipeline = load_pipeline(args.pipeline)
+            result = run_pipeline(
+                pipeline,
+                args.task,
+                bus,
+                args.routes,
+                args.agents,
+                args.source,
+                cwd=args.cwd,
+                run_workers=not args.no_run and not getattr(args, "wait", False),
+            )
+        else:
+            result = run_review_flow(
+                args.task,
+                bus,
+                args.routes,
+                args.agents,
+                args.source,
+                args.task_type,
+                args.previous_agent,
+                args.cwd,
+                run_workers=not args.no_run and not getattr(args, "wait", False),
+            )
         if getattr(args, "wait", False):
             result = _wait_for_flow(bus, result, args.agents, args.routes, args.wait_timeout)
         print_json(result)
@@ -223,6 +240,10 @@ def run_command(args: argparse.Namespace) -> int:
         if args.once:
             print_json(run_once(args.agent, bus, args.agents))
             return 0
+        if args.daemon:
+            pid_file = args.pid_file or str(_default_pid_path(args.agent))
+            return run_loop(args.agent, bus, args.agents, args.poll, pid_file=pid_file)
+        # Default: loop without daemon features (backwards compatible)
         run_loop(args.agent, bus, args.agents, args.poll)
         return 0
     if args.command == "send":

{trinity_lite-0.2.3 → trinity_lite-0.3.1}/trinity_lite/mcp_server.py

@@ -17,8 +17,9 @@ from typing import Any
 from .bus import TERMINAL_STATUSES, TrinityBus
 from .doctor import run_doctor
 from .guard import GuardError
+from .pipeline import load_pipeline, run_pipeline
 from .router import resolve_route
-from .worker import run_once as worker_run_once
+from .worker import _default_pid_path, _read_pid_file, run_once as worker_run_once
 
 # ---------------------------------------------------------------------------
 # agent-skill-system integration (optional, graceful fallback)
@@ -67,7 +68,7 @@ def _init_skill_engine() -> bool:
 JSONRPC_VERSION = "2.0"
 PROTOCOL_VERSION = "2024-11-05"
 SERVER_NAME = "trinity-lite-mcp"
-SERVER_VERSION = "0.2.2"
+SERVER_VERSION = "0.3.1"
 
 # ---------------------------------------------------------------------------
 # Tool definitions (MCP schema)
@@ -115,6 +116,21 @@ TOOL_DEFINITIONS = [
         },
         ["task"],
     ),
+    _tool_def(
+        "trinity_orchestrate",
+        "Orchestrate a multi-step pipeline from a YAML file or run the default review flow.",
+        {
+            "task": {"type": "string", "description": "Task prompt"},
+            "source_agent": {"type": "string", "description": "Originating agent id (default: mcp)"},
+            "cwd": {"type": "string", "description": "Working directory (default: $HOME)"},
+            "task_type": {"type": "string", "description": "Task type hint"},
+            "previous_agent": {"type": "string", "description": "Previous agent for avoidance"},
+            "pipeline": {"type": "string", "description": "Path to pipeline YAML file"},
+            "wait": {"type": "boolean", "description": "Block until task completes"},
+            "wait_timeout": {"type": "number", "description": "Timeout in seconds for wait"},
+        },
+        ["task"],
+    ),
     _tool_def(
         "trinity_status",
         "Get the current state and result of a task.",
@@ -141,6 +157,15 @@ TOOL_DEFINITIONS = [
         },
         ["agent"],
     ),
+    _tool_def(
+        "trinity_worker_daemon",
+        "Start, stop, or check status of a daemon worker.",
+        {
+            "agent": {"type": "string", "description": "Agent name"},
+            "action": {"type": "string", "enum": ["start", "stop", "status"], "description": "Action to perform"},
+        },
+        ["agent", "action"],
+    ),
     _tool_def(
         "trinity_doctor",
         "Run health and diagnostic checks.",
@@ -621,17 +646,150 @@ def _handle_trinity_skill_load(params, bus, agents_path, routes_path):
         })
 
 
+
+def _handle_trinity_orchestrate(params, bus, agents_path, routes_path):
+    """Handle trinity_orchestrate: orchestrate pipeline or review flow."""
+    prompt = _validate_text(params["task"])
+    source = params.get("source_agent", "mcp")
+    source = _validate_text(source, 128)
+    cwd = params.get("cwd", os.environ.get("HOME", str(Path.home())))
+    task_type = params.get("task_type") or None
+    previous_agent = params.get("previous_agent") or None
+    pipeline_path = params.get("pipeline") or None
+    wait = params.get("wait", False)
+    wait_timeout = _validate_timeout(params.get("wait_timeout"))
+
+    known = _get_known_agents(bus, agents_path)
+    _validate_agent_id(source, known)
+
+    if pipeline_path:
+        pipeline = load_pipeline(pipeline_path)
+        result = run_pipeline(
+            pipeline,
+            prompt,
+            bus,
+            routes_path=routes_path,
+            agents_path=agents_path,
+            source_agent=source,
+            cwd=cwd,
+            run_workers=True,
+        )
+        return jsonrpc_response(1, result)
+    else:
+        from .orchestrator import run_review_flow
+        result = run_review_flow(
+            prompt,
+            bus,
+            routes_path=routes_path,
+            agents_path=agents_path,
+            source_agent=source,
+            task_type=task_type,
+            previous_agent=previous_agent,
+            cwd=cwd,
+            run_workers=True,
+        )
+        return jsonrpc_response(1, result)
+def _handle_trinity_worker_daemon(params, bus, agents_path, routes_path):
+    """Handle trinity_worker_daemon: start/stop/status a daemon worker."""
+    import subprocess as _sp
+    import time as _time
+
+    agent = _validate_text(params["agent"], 128)
+    action = params.get("action", "status")
+
+    if action not in ("start", "stop", "status"):
+        return jsonrpc_error(1, -32602, "action must be one of: start, stop, status")
+
+    pid_path = _default_pid_path(agent)
+
+    if action == "status":
+        pid = _read_pid_file(pid_path)
+        if pid is not None:
+            try:
+                os.kill(pid, 0)
+                return jsonrpc_response(1, {"running": True, "pid": pid, "pid_file": str(pid_path)})
+            except OSError:
+                pass
+        return jsonrpc_response(1, {"running": False, "pid_file": str(pid_path)})
+
+    if action == "stop":
+        pid = _read_pid_file(pid_path)
+        if pid is None:
+            # Clean up stale pid file if exists
+            try:
+                pid_path.unlink(missing_ok=True)
+            except OSError:
+                pass
+            return jsonrpc_response(1, {"stopped": True, "message": "no running daemon found"})
+        try:
+            os.kill(pid, signal.SIGTERM)
+        except OSError:
+            pid_path.unlink(missing_ok=True)
+            return jsonrpc_response(1, {"stopped": True, "message": "stale PID cleaned up"})
+
+        # Wait up to 5s for graceful shutdown
+        deadline = _time.monotonic() + 5
+        while _time.monotonic() < deadline:
+            try:
+                os.kill(pid, 0)
+            except OSError:
+                break
+            _time.sleep(0.1)
+        else:
+            # Force kill
+            try:
+                os.kill(pid, signal.SIGKILL)
+            except OSError:
+                pass
+
+        # Clean PID file
+        try:
+            pid_path.unlink(missing_ok=True)
+        except OSError:
+            pass
+
+        return jsonrpc_response(1, {"stopped": True, "pid": pid})
+
+    if action == "start":
+        # Check if already running
+        pid = _read_pid_file(pid_path)
+        if pid is not None:
+            try:
+                os.kill(pid, 0)
+                return jsonrpc_error(1, -32000,
+                    "worker daemon for '{}' is already running (PID {})".format(agent, pid))
+            except OSError:
+                pid_path.unlink(missing_ok=True)
+
+        # Spawn daemon via subprocess (non-blocking)
+        try:
+            cmd = [sys.executable, "-m", "trinity_lite", "worker", agent, "--daemon"]
+            proc = _sp.Popen(cmd, stdin=_sp.DEVNULL, stdout=_sp.DEVNULL, stderr=_sp.DEVNULL)
+            # Give it a moment to acquire PID lock
+            _time.sleep(0.3)
+            pid = _read_pid_file(pid_path)
+            return jsonrpc_response(1, {
+                "started": True,
+                "pid": pid or proc.pid,
+                "pid_file": str(pid_path),
+            })
+        except Exception as exc:
+            return jsonrpc_error(1, -32603, "failed to start daemon: {}".format(exc))
+
+
 TOOL_HANDLERS = {
     "trinity_dispatch": _handle_trinity_dispatch,
     "trinity_dispatch_auto": _handle_trinity_dispatch_auto,
     "trinity_status": _handle_trinity_status,
     "trinity_tasks": _handle_trinity_tasks,
     "trinity_worker": _handle_trinity_worker,
+    "trinity_worker_daemon": _handle_trinity_worker_daemon,
     "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_orchestrate": _handle_trinity_orchestrate,
 }
 
 

{trinity_lite-0.2.3 → trinity_lite-0.3.1}/trinity_lite/orchestrator.py

@@ -10,6 +10,17 @@ from .router import resolve_route
 from .worker import run_once
 
 
+BUILTIN_REVIEW_PIPELINE = {
+    "name": "review",
+    "description": "Built-in implement-then-review pipeline",
+    "steps": [
+        {"id": "implement", "agent": "", "task_type": "", "prompt_template": "{task}"},
+        {"id": "review_step", "agent": "", "task_type": "code_review",
+         "prompt_template": "Review: {task}\n\nResult:\n{steps.implement.result}"},
+    ],
+}
+
+
 def run_review_flow(
     task: str,
     bus: TrinityBus,

trinity_lite-0.3.1/trinity_lite/pipeline.py

@@ -0,0 +1,158 @@
+"""YAML pipeline orchestration for Trinity Lite.
+
+Defines load/validate/execute for N-step sequential pipelines.
+"""
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+from .bus import TrinityBus
+from .router import resolve_route
+from .worker import run_once
+
+
+def _load_yaml(path: str) -> dict[str, Any]:
+    """Load a YAML file, falling back gracefully."""
+    try:
+        import yaml
+
+        with open(path, "r", encoding="utf-8") as fh:
+            return yaml.safe_load(fh)
+    except ImportError:
+        pass
+
+    import json
+
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            return json.load(fh)
+    except (json.JSONDecodeError, ValueError):
+        raise ValueError(
+            f"Cannot parse pipeline file {path}: yaml module not available and file is not valid JSON"
+        )
+
+
+_RE_STEP_REF = re.compile(
+    r"\{steps\.([a-zA-Z_][a-zA-Z0-9_]*)\.result\}"
+)
+
+REQUIRED_STEP_FIELDS = ("id", "agent", "task_type", "prompt_template")
+
+def _validate_pipeline(pipeline: dict[str, Any]) -> None:
+    """Validate a loaded pipeline dictionary."""
+    if not isinstance(pipeline, dict):
+        raise ValueError("pipeline must be a dictionary")
+
+    name = pipeline.get("name")
+    if not name or not isinstance(name, str):
+        raise ValueError("pipeline must have non-empty name")
+
+    steps = pipeline.get("steps")
+    if not steps or not isinstance(steps, list):
+        raise ValueError("pipeline must have non-empty steps list")
+
+    step_ids: set[str] = set()
+
+    for i, step in enumerate(steps):
+        if not isinstance(step, dict):
+            raise ValueError(f"step[{i}] must be dict, got {type(step).__name__}")
+
+        for field in REQUIRED_STEP_FIELDS:
+            val = step.get(field)
+            if not val or not isinstance(val, str):
+                raise ValueError(f"step[{i}] missing field {field}: {val!r}")
+
+        sid = step["id"]
+        if sid in step_ids:
+            raise ValueError(f"duplicate step id: {sid!r}")
+        step_ids.add(sid)
+
+    for step in steps:
+        refs = _RE_STEP_REF.findall(step["prompt_template"])
+        for ref in refs:
+            if ref not in step_ids:
+                raise ValueError(f"step references unknown step: {ref}")
+
+def load_pipeline(path: str) -> dict[str, Any]:
+    """Load and validate a pipeline YAML (or JSON) file."""
+    pipeline = _load_yaml(path)
+    _validate_pipeline(pipeline)
+    return pipeline
+
+def resolve_step_prompt(step: dict[str, Any], task: str, step_results: dict[str, Any]) -> str:
+    """Render prompt_template with {task} and step references."""
+    template = step["prompt_template"]
+
+    def _replace_step_ref(m):
+        sid = m.group(1)
+        info = step_results.get(sid, {})
+        return str(info.get("result") or info.get("error") or "")
+
+    rendered = _RE_STEP_REF.sub(_replace_step_ref, template)
+    rendered = rendered.replace("{task}", task)
+    return rendered
+
+def run_pipeline(
+    pipeline: dict[str, Any],
+    task: str,
+    bus: TrinityBus,
+    routes_path: str | None = None,
+    agents_path: str | None = None,
+    source_agent: str = "user",
+    cwd: str | None = None,
+    run_workers: bool = True,
+) -> dict[str, Any]:
+    """Execute pipeline steps sequentially."""
+    workdir = cwd or os.getcwd()
+    step_results: dict[str, Any] = {}
+    step_summaries: list[dict[str, Any]] = []
+
+    for step in pipeline["steps"]:
+        sid = step["id"]
+        rendered_prompt = resolve_step_prompt(step, task, step_results)
+        target_agent = step["agent"]
+
+        submitted = bus.submit_task(
+            source_agent=source_agent,
+            target_agent=target_agent,
+            prompt=rendered_prompt,
+            task_type=step.get("task_type"),
+            cwd=workdir,
+        )
+
+        if run_workers:
+            result = run_once(target_agent, bus, agents_path, task_id=submitted["id"])
+            if result is None:
+                result = bus.get_task(submitted["id"])
+        else:
+            result = submitted
+
+        step_results[sid] = result
+        summary = {
+            "id": sid,
+            "task_id": result["id"] if result else submitted["id"],
+            "status": result.get("status", "unknown") if result else "unknown",
+            "result": result.get("result") if result else None,
+        }
+        step_summaries.append(summary)
+
+        if result and result.get("status") == "failed":
+            break
+
+    all_done = all(s["status"] == "completed" for s in step_summaries)
+    any_fail = any(s["status"] == "failed" for s in step_summaries)
+    if any_fail:
+        overall = "failed"
+    elif all_done:
+        overall = "completed"
+    else:
+        overall = "queued"
+
+    return {
+        "pipeline_name": pipeline["name"],
+        "steps": step_summaries,
+        "overall_status": overall,
+    }

trinity_lite-0.3.1/trinity_lite/worker.py

@@ -0,0 +1,206 @@
+"""Worker loop for Trinity Lite."""
+
+from __future__ import annotations
+
+import atexit
+import errno
+import os
+import signal
+import sys
+import threading
+import time
+import traceback
+from pathlib import Path
+from typing import Any
+
+from .adapters import AdapterError, build_adapter, load_specs
+from .bus import TrinityBus
+
+# ---------------------------------------------------------------------------
+# Stop-flag pattern (Huey standard) — signal handlers ONLY set flags
+# ---------------------------------------------------------------------------
+
+_stop_flag: threading.Event = threading.Event()
+"""Set by SIGTERM (immediate) or SIGINT (graceful — finish current task)."""
+
+
+def _signal_handler(signum: int, frame: Any) -> None:  # pragma: no cover — signal integration
+    reason = signal.Signals(signum).name
+    if signum == signal.SIGTERM:
+        print(f"[worker] received {reason} — shutting down", file=sys.stderr, flush=True)
+        _stop_flag.set()
+    elif signum == signal.SIGINT:
+        print(f"[worker] received {reason} — finishing current task then exiting", file=sys.stderr, flush=True)
+        _stop_flag.set()
+
+
+def _install_signal_handlers() -> None:
+    """Install POSIX signal handlers.  Idempotent — safe to call multiple times."""
+    signal.signal(signal.SIGTERM, _signal_handler)
+    signal.signal(signal.SIGINT, _signal_handler)
+
+
+# ---------------------------------------------------------------------------
+# PID file management
+# ---------------------------------------------------------------------------
+
+_PID_DIR = Path.home() / ".trinity" / "workers"
+
+
+def _default_pid_path(agent: str) -> Path:
+    """Return the default PID file path for a given agent."""
+    return _PID_DIR / f"{agent}.pid"
+
+
+def _acquire_pid_file(pid_path: Path) -> None:
+    """Atomically create + lock a PID file.
+
+    Raises RuntimeError if another daemon is already running for this agent.
+    Cleans up stale PID files (process no longer exists).
+    """
+    # Ensure parent directory exists
+    pid_path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        fd = os.open(str(pid_path), os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o644)
+    except OSError as exc:
+        if exc.errno != errno.EEXIST:
+            raise
+        # PID file exists — check if process is still alive
+        fd = _check_existing_pid(pid_path)
+        if fd is None:
+            # Stale — recreate after removing
+            pid_path.unlink(missing_ok=True)
+            fd = os.open(str(pid_path), os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o644)
+
+    with os.fdopen(fd, "w") as f:
+        f.write(str(os.getpid()))
+
+    # Register cleanup
+    atexit.register(_cleanup_pid_file, pid_path)
+
+
+def _check_existing_pid(pid_path: Path) -> int | None:
+    """Check whether the PID stored in *pid_path* corresponds to a live process.
+
+    Returns None if the PID file is stale (process gone), otherwise raises
+    RuntimeError for a live duplicate daemon.
+    """
+    try:
+        raw = pid_path.read_text().strip()
+    except OSError:
+        return None
+
+    if not raw:
+        return None
+
+    try:
+        pid = int(raw)
+    except ValueError:
+        return None
+
+    try:
+        os.kill(pid, 0)
+    except OSError as exc:
+        if exc.errno == errno.ESRCH:
+            return None
+        if exc.errno == errno.EPERM:
+            raise RuntimeError(
+                f"Worker daemon for agent is already running (PID {pid} exists). "
+                f"PID file: {pid_path}"
+            ) from None
+        raise
+    else:
+        raise RuntimeError(
+            f"Worker daemon for agent is already running (PID {pid}). "
+            f"Remove {pid_path} if this is stale."
+        )
+
+
+def _cleanup_pid_file(pid_path: Path) -> None:
+    """Remove the PID file on exit (registered via atexit)."""
+    try:
+        pid_path.unlink(missing_ok=True)
+    except OSError:
+        pass
+
+
+def _read_pid_file(pid_path: Path) -> int | None:
+    """Read the PID from a PID file, returning None if unreadable/corrupt."""
+    try:
+        raw = pid_path.read_text().strip()
+    except OSError:
+        return None
+    if not raw:
+        return None
+    try:
+        return int(raw)
+    except ValueError:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Core worker functions
+# ---------------------------------------------------------------------------
+
+
+def run_once(
+    agent: str,
+    bus: TrinityBus,
+    agents_path: str | None = None,
+    task_id: str | None = None,
+) -> dict[str, Any] | None:
+    task = bus.task_for_worker(agent, task_id=task_id)
+    if task is None:
+        return None
+    specs = load_specs(agents_path)
+    spec = specs.get(agent)
+    if spec is None:
+        return bus.finish_worker(task["id"], error=f"agent not configured: {agent}")
+    try:
+        result = build_adapter(spec).run(task)
+        return bus.finish_worker(task["id"], result=result)
+    except (KeyboardInterrupt, SystemExit, MemoryError):
+        raise
+    except Exception as exc:
+        tb = traceback.format_exc()
+        return bus.finish_worker(task["id"], error=f"{exc}\n{tb}")
+
+
+def run_loop(
+    agent: str,
+    bus: TrinityBus,
+    agents_path: str | None = None,
+    poll_seconds: float = 2.0,
+    pid_file: str | Path | None = None,
+) -> int:
+    """Run the worker loop continuously until a stop signal is received.
+
+    Args:
+        agent: The agent id to process tasks for.
+        bus: The TrinityBus instance.
+        agents_path: Path to agents configuration JSON.
+        poll_seconds: Sleep duration between polls when no task is available.
+        pid_file: Optional path to the PID lock file.  When provided, the PID
+            file is acquired before entering the loop and cleaned up on exit.
+
+    Returns:
+        Exit code: 0 on clean shutdown, 1 if pid lock acquisition fails.
+    """
+    if pid_file is not None:
+        pid_path = Path(pid_file)
+        try:
+            _acquire_pid_file(pid_path)
+        except RuntimeError as exc:
+            print(f"[worker] {exc}", file=sys.stderr, flush=True)
+            return 1
+
+    _install_signal_handlers()
+
+    while not _stop_flag.is_set():
+        handled = run_once(agent, bus, agents_path)
+        if handled is None and not _stop_flag.is_set():
+            time.sleep(poll_seconds)
+
+    print("[worker] daemon stopped", file=sys.stderr, flush=True)
+    return 0

{trinity_lite-0.2.3 → trinity_lite-0.3.1}/trinity_lite.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trinity-lite
-Version: 0.2.3
+Version: 0.3.1
 Summary: The bus that lets your AI agents talk to each other.
 Author: Yomiracle
 License-Expression: MIT

{trinity_lite-0.2.3 → trinity_lite-0.3.1}/trinity_lite.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ tests/test_doctor.py
 tests/test_guard.py
 tests/test_mcp_server.py
 tests/test_orchestrator.py
+tests/test_pipeline.py
 tests/test_router.py
 tests/test_worker.py
 trinity_lite/__init__.py
@@ -20,6 +21,7 @@ trinity_lite/guard.py
 trinity_lite/mcp_server.py
 trinity_lite/orchestrator.py
 trinity_lite/paths.py
+trinity_lite/pipeline.py
 trinity_lite/py.typed
 trinity_lite/router.py
 trinity_lite/validation.py

trinity_lite-0.2.3/tests/test_worker.py

@@ -1,67 +0,0 @@
-import tempfile
-import unittest
-import json
-from pathlib import Path
-from unittest.mock import patch
-
-from trinity_lite.bus import TrinityBus
-from trinity_lite.worker import run_once
-
-
-class WorkerTest(unittest.TestCase):
-    def test_mock_worker_completes_task(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
-            task = bus.submit_task("user", "codex", "implement hello", cwd=root)
-            done = run_once("codex", bus)
-            self.assertEqual(done["id"], task["id"])
-            self.assertEqual(done["status"], "completed")
-            self.assertIn("[mock:codex]", done["result"])
-
-    def test_missing_configured_agent_fails_task(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
-            task = bus.submit_task("user", "unknown", "work", cwd=root)
-            done = run_once("unknown", bus)
-            self.assertEqual(done["id"], task["id"])
-            self.assertEqual(done["status"], "failed")
-            self.assertIn("agent not configured", done["error"])
-
-    def test_command_adapter_failure_is_recorded(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            agents_path = root / "agents.json"
-            agents_path.write_text(json.dumps({
-                "agents": {
-                    "codex": {
-                        "mode": "command",
-                        "command": ["definitely-not-a-real-trinity-lite-command"]
-                    }
-                }
-            }), encoding="utf-8")
-            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
-            task = bus.submit_task("user", "codex", "work", cwd=root)
-            done = run_once("codex", bus, str(agents_path))
-            self.assertEqual(done["id"], task["id"])
-            self.assertEqual(done["status"], "failed")
-            self.assertIn("executable not found", done["error"])
-
-    def test_memory_error_is_not_swallowed(self):
-        class OomAdapter:
-            def run(self, task):
-                raise MemoryError("oom")
-
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
-            task = bus.submit_task("user", "codex", "work", cwd=root)
-            with patch("trinity_lite.worker.build_adapter", return_value=OomAdapter()):
-                with self.assertRaises(MemoryError):
-                    run_once("codex", bus)
-            self.assertEqual(bus.get_task(task["id"])["status"], "running")
-
-
-if __name__ == "__main__":
-    unittest.main()

trinity_lite-0.2.3/trinity_lite/worker.py

@@ -1,45 +0,0 @@
-"""Worker loop for Trinity Lite."""
-
-from __future__ import annotations
-
-import time
-import traceback
-from typing import Any
-
-from .adapters import AdapterError, build_adapter, load_specs
-from .bus import TrinityBus
-
-
-def run_once(
-    agent: str,
-    bus: TrinityBus,
-    agents_path: str | None = None,
-    task_id: str | None = None,
-) -> dict[str, Any] | None:
-    task = bus.task_for_worker(agent, task_id=task_id)
-    if task is None:
-        return None
-    specs = load_specs(agents_path)
-    spec = specs.get(agent)
-    if spec is None:
-        return bus.finish_worker(task["id"], error=f"agent not configured: {agent}")
-    try:
-        result = build_adapter(spec).run(task)
-        return bus.finish_worker(task["id"], result=result)
-    except (KeyboardInterrupt, SystemExit, MemoryError):
-        raise
-    except Exception as exc:
-        tb = traceback.format_exc()
-        return bus.finish_worker(task["id"], error=f"{exc}\n{tb}")
-
-
-def run_loop(
-    agent: str,
-    bus: TrinityBus,
-    agents_path: str | None = None,
-    poll_seconds: float = 2.0,
-) -> None:
-    while True:
-        handled = run_once(agent, bus, agents_path)
-        if handled is None:
-            time.sleep(poll_seconds)