@smilintux/skcapstone 0.1.0 → 0.2.3

package/tests/test_context_loader.py

@@ -0,0 +1,310 @@
+"""Tests for the universal agent context loader.
+
+Covers context gathering, all four formatters, and CLI integration.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+import yaml
+
+from skcapstone.context_loader import (
+    FORMATTERS,
+    _gather_consciousness,
+    format_claude_md,
+    format_cursor_rules,
+    format_json,
+    format_text,
+    gather_context,
+)
+from skcapstone.memory_engine import store
+from skcapstone.pillars.identity import generate_identity
+from skcapstone.pillars.memory import initialize_memory
+from skcapstone.pillars.security import initialize_security
+from skcapstone.pillars.sync import initialize_sync
+from skcapstone.pillars.trust import initialize_trust, record_trust_state
+
+
+def _init_agent(home: Path, name: str = "context-test") -> None:
+    """Set up a full agent for testing."""
+    generate_identity(home, name)
+    initialize_memory(home)
+    initialize_trust(home)
+    initialize_security(home)
+    initialize_sync(home)
+
+    manifest = {"name": name, "version": "0.1.0", "created_at": "2026-01-01T00:00:00Z", "connectors": []}
+    (home / "manifest.json").write_text(json.dumps(manifest, indent=2))
+    (home / "config").mkdir(exist_ok=True)
+    (home / "config" / "config.yaml").write_text(yaml.dump({"agent_name": name}))
+
+
+class TestGatherContext:
+    """Tests for gather_context() data collection."""
+
+    def test_gathers_from_initialized_agent(self, tmp_agent_home: Path):
+        """gather_context returns a full context dict for an initialized agent."""
+        _init_agent(tmp_agent_home)
+        store(tmp_agent_home, "Test memory for context", tags=["test"])
+
+        ctx = gather_context(tmp_agent_home)
+
+        assert "agent" in ctx
+        assert "pillars" in ctx
+        assert "board" in ctx
+        assert "memories" in ctx
+        assert "soul" in ctx
+        assert "mcp" in ctx
+        assert "gathered_at" in ctx
+
+    def test_agent_section(self, tmp_agent_home: Path):
+        """Agent section contains name and consciousness state."""
+        _init_agent(tmp_agent_home, "sovereign-ctx")
+        ctx = gather_context(tmp_agent_home)
+
+        assert ctx["agent"]["name"] == "sovereign-ctx"
+        assert "is_conscious" in ctx["agent"]
+        assert "fingerprint" in ctx["agent"]
+
+    def test_pillars_section(self, tmp_agent_home: Path):
+        """Pillars section lists all five pillars."""
+        _init_agent(tmp_agent_home)
+        ctx = gather_context(tmp_agent_home)
+
+        pillars = ctx["pillars"]
+        for name in ("identity", "memory", "trust", "security", "sync"):
+            assert name in pillars
+
+    def test_memories_included(self, tmp_agent_home: Path):
+        """Recent memories appear in the context."""
+        _init_agent(tmp_agent_home)
+        store(tmp_agent_home, "First context memory", tags=["alpha"])
+        store(tmp_agent_home, "Second context memory", tags=["beta"])
+
+        ctx = gather_context(tmp_agent_home, memory_limit=5)
+        assert len(ctx["memories"]) >= 2
+
+    def test_memory_limit_respected(self, tmp_agent_home: Path):
+        """Memory limit caps the number of memories returned."""
+        _init_agent(tmp_agent_home)
+        for i in range(10):
+            store(tmp_agent_home, f"Memory number {i}")
+
+        ctx = gather_context(tmp_agent_home, memory_limit=3)
+        assert len(ctx["memories"]) <= 3
+
+    def test_empty_agent_home(self, tmp_agent_home: Path):
+        """gather_context handles an uninitialized agent gracefully."""
+        ctx = gather_context(tmp_agent_home)
+        assert ctx["agent"].get("name") is not None
+        assert ctx["memories"] == []
+
+    def test_board_section(self, tmp_agent_home: Path):
+        """Board section includes task counts."""
+        _init_agent(tmp_agent_home)
+        from skcapstone.coordination import Board, Task
+
+        board = Board(tmp_agent_home)
+        board.ensure_dirs()
+        board.create_task(Task(title="Test task"))
+
+        ctx = gather_context(tmp_agent_home)
+        assert ctx["board"]["total"] >= 1
+
+    def test_soul_section_base(self, tmp_agent_home: Path):
+        """Soul section reports base when no overlay is active."""
+        _init_agent(tmp_agent_home)
+        ctx = gather_context(tmp_agent_home)
+        assert ctx["soul"]["active"] is None
+
+
+class TestFormatText:
+    """Tests for plain text formatter."""
+
+    def test_contains_agent_name(self, tmp_agent_home: Path):
+        """Text output includes the agent name."""
+        _init_agent(tmp_agent_home, "text-test")
+        ctx = gather_context(tmp_agent_home)
+        output = format_text(ctx)
+
+        assert "text-test" in output
+        assert "SKCapstone Agent Context" in output
+
+    def test_contains_pillars(self, tmp_agent_home: Path):
+        """Text output lists pillar statuses."""
+        _init_agent(tmp_agent_home)
+        ctx = gather_context(tmp_agent_home)
+        output = format_text(ctx)
+
+        assert "Pillars" in output
+        assert "identity" in output
+        assert "memory" in output
+
+    def test_contains_memories(self, tmp_agent_home: Path):
+        """Text output shows recent memories."""
+        _init_agent(tmp_agent_home)
+        store(tmp_agent_home, "Remember this for text test")
+        ctx = gather_context(tmp_agent_home)
+        output = format_text(ctx)
+
+        assert "Recent Memories" in output
+        assert "Remember this" in output
+
+
+class TestFormatJson:
+    """Tests for JSON formatter."""
+
+    def test_valid_json(self, tmp_agent_home: Path):
+        """JSON output is valid parseable JSON."""
+        _init_agent(tmp_agent_home)
+        ctx = gather_context(tmp_agent_home)
+        output = format_json(ctx)
+
+        parsed = json.loads(output)
+        assert "agent" in parsed
+        assert "pillars" in parsed
+
+    def test_roundtrip(self, tmp_agent_home: Path):
+        """JSON output can be parsed back to the original structure."""
+        _init_agent(tmp_agent_home)
+        ctx = gather_context(tmp_agent_home)
+        output = format_json(ctx)
+        parsed = json.loads(output)
+
+        assert parsed["agent"]["name"] == ctx["agent"]["name"]
+
+
+class TestFormatClaudeMd:
+    """Tests for Claude Code CLAUDE.md formatter."""
+
+    def test_markdown_structure(self, tmp_agent_home: Path):
+        """CLAUDE.md has proper markdown headers."""
+        _init_agent(tmp_agent_home, "claude-test")
+        ctx = gather_context(tmp_agent_home)
+        output = format_claude_md(ctx)
+
+        assert "# SKCapstone Agent Context" in output
+        assert "## Agent Identity" in output
+        assert "## Pillar Status" in output
+        assert "## Coordination Board" in output
+
+    def test_contains_cli_reference(self, tmp_agent_home: Path):
+        """CLAUDE.md includes CLI command reference."""
+        _init_agent(tmp_agent_home)
+        ctx = gather_context(tmp_agent_home)
+        output = format_claude_md(ctx)
+
+        assert "## CLI Reference" in output
+        assert "skcapstone status" in output
+        assert "skcapstone memory" in output
+
+    def test_contains_agent_name(self, tmp_agent_home: Path):
+        """CLAUDE.md contains the agent name."""
+        _init_agent(tmp_agent_home, "claude-agent")
+        ctx = gather_context(tmp_agent_home)
+        output = format_claude_md(ctx)
+
+        assert "claude-agent" in output
+
+    def test_pillar_table(self, tmp_agent_home: Path):
+        """CLAUDE.md contains a pillar status table."""
+        _init_agent(tmp_agent_home)
+        ctx = gather_context(tmp_agent_home)
+        output = format_claude_md(ctx)
+
+        assert "| Pillar | Status |" in output
+        assert "identity" in output
+
+
+class TestFormatCursorRules:
+    """Tests for Cursor .mdc rule formatter."""
+
+    def test_mdc_frontmatter(self, tmp_agent_home: Path):
+        """Cursor rules file has proper MDC frontmatter."""
+        _init_agent(tmp_agent_home)
+        ctx = gather_context(tmp_agent_home)
+        output = format_cursor_rules(ctx)
+
+        assert output.startswith("---")
+        assert "description:" in output
+        assert "alwaysApply: true" in output
+
+    def test_contains_agent_info(self, tmp_agent_home: Path):
+        """Cursor rules contain agent identity info."""
+        _init_agent(tmp_agent_home, "cursor-test")
+        ctx = gather_context(tmp_agent_home)
+        output = format_cursor_rules(ctx)
+
+        assert "cursor-test" in output
+
+
+class TestFormattersRegistry:
+    """Tests for the FORMATTERS dict."""
+
+    def test_all_formatters_registered(self):
+        """All four formatters are in the registry."""
+        assert "text" in FORMATTERS
+        assert "json" in FORMATTERS
+        assert "claude-md" in FORMATTERS
+        assert "cursor-rules" in FORMATTERS
+
+    def test_all_formatters_callable(self):
+        """All formatters are callable."""
+        for name, fn in FORMATTERS.items():
+            assert callable(fn), f"Formatter '{name}' is not callable"
+
+
+class TestGatherConsciousness:
+    """Tests for _gather_consciousness() fallback logic."""
+
+    def test_returns_expected_keys(self, tmp_agent_home: Path):
+        """_gather_consciousness returns all required keys."""
+        result = _gather_consciousness(tmp_agent_home)
+
+        for key in ("enabled", "backends_available", "messages_processed",
+                    "active_conversations", "inotify_active"):
+            assert key in result, f"missing key: {key}"
+
+    def test_no_daemon_no_config_returns_disabled(self, tmp_agent_home: Path):
+        """Without daemon or config, enabled is False and lists are empty."""
+        from unittest.mock import patch
+        import urllib.error
+
+        with patch(
+            "urllib.request.urlopen",
+            side_effect=urllib.error.URLError("connection refused"),
+        ):
+            result = _gather_consciousness(tmp_agent_home)
+
+        assert result["enabled"] is False
+        assert result["backends_available"] == []
+        assert result["messages_processed"] == 0
+        assert result["active_conversations"] == 0
+        assert result["inotify_active"] is False
+
+    def test_config_file_triggers_enabled(self, tmp_agent_home: Path):
+        """If consciousness.yaml exists, enabled is True (config fallback)."""
+        config_dir = tmp_agent_home / "config"
+        config_dir.mkdir(exist_ok=True)
+        (config_dir / "consciousness.yaml").write_text("enabled: true\n")
+
+        result = _gather_consciousness(tmp_agent_home)
+
+        assert result["enabled"] is True
+
+    def test_gather_context_includes_consciousness_key(self, tmp_agent_home: Path):
+        """gather_context() output includes the 'consciousness' key."""
+        ctx = gather_context(tmp_agent_home)
+        assert "consciousness" in ctx
+
+    def test_format_text_includes_consciousness_section(self, tmp_agent_home: Path):
+        """format_text() output includes a Consciousness section."""
+        _init_agent(tmp_agent_home)
+        ctx = gather_context(tmp_agent_home)
+        output = format_text(ctx)
+
+        assert "Consciousness" in output
+        assert "Status:" in output

package/tests/test_conversation_api.py

@@ -0,0 +1,306 @@
+"""Tests for the conversation API endpoints in the daemon HTTP server.
+
+Covers:
+  GET  /api/v1/conversations          — list all peers
+  GET  /api/v1/conversations/{peer}   — full history for a peer
+  POST /api/v1/conversations/{peer}/send — send message, write to outbox
+  DELETE /api/v1/conversations/{peer} — clear history
+  Path-traversal sanitization
+"""
+
+from __future__ import annotations
+
+import json
+import socket
+import time
+import threading
+import urllib.error
+import urllib.request
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from skcapstone.daemon import DaemonConfig, DaemonService, _sanitize_peer
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _find_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _api(port: int, path: str, *, method: str = "GET", body: bytes | None = None) -> tuple[int, dict]:
+    url = f"http://127.0.0.1:{port}{path}"
+    req = urllib.request.Request(url, data=body, method=method)
+    if body is not None:
+        req.add_header("Content-Type", "application/json")
+        req.add_header("Content-Length", str(len(body)))
+    try:
+        with urllib.request.urlopen(req, timeout=3) as resp:
+            return resp.status, json.loads(resp.read())
+    except urllib.error.HTTPError as exc:
+        return exc.code, json.loads(exc.read())
+
+
+@pytest.fixture
+def conv_home(tmp_path):
+    """Agent home with conversations directory pre-populated."""
+    home = tmp_path / ".skcapstone"
+    (home / "logs").mkdir(parents=True)
+    conv_dir = home / "conversations"
+    conv_dir.mkdir()
+
+    # Two peers with conversation history
+    alice = [
+        {"role": "user", "content": "hello alice", "timestamp": "2026-01-01T10:00:00+00:00"},
+        {"role": "assistant", "content": "hi there", "timestamp": "2026-01-01T10:00:01+00:00"},
+    ]
+    bob = [
+        {"role": "user", "content": "hey bob", "timestamp": "2026-01-02T12:00:00+00:00"},
+    ]
+    (conv_dir / "alice.json").write_text(json.dumps(alice), encoding="utf-8")
+    (conv_dir / "bob.json").write_text(json.dumps(bob), encoding="utf-8")
+    return home
+
+
+@pytest.fixture
+def live_server(conv_home):
+    """Start the daemon API server, yield (svc, port), then stop."""
+    config = DaemonConfig(
+        home=conv_home,
+        shared_root=conv_home,   # keep test data isolated from real ~/.skcapstone
+        port=_find_free_port(),
+        poll_interval=60,
+    )
+    svc = DaemonService(config)
+    svc.state.running = True
+
+    with patch.object(svc, "_load_components"):
+        svc._write_pid()
+        svc._start_api_server()
+        time.sleep(0.4)
+        yield svc, config.port
+        svc.stop()
+
+
+# ---------------------------------------------------------------------------
+# Unit tests: _sanitize_peer
+# ---------------------------------------------------------------------------
+
+class TestSanitizePeer:
+    def test_normal_name(self):
+        assert _sanitize_peer("alice") == "alice"
+
+    def test_strips_slashes(self):
+        assert "/" not in _sanitize_peer("../etc/passwd")
+        assert "\\" not in _sanitize_peer("..\\windows")
+
+    def test_path_traversal(self):
+        result = _sanitize_peer("../../etc/passwd")
+        assert ".." not in result
+        assert "/" not in result
+
+    def test_empty_string(self):
+        assert _sanitize_peer("") == ""
+
+    def test_none_returns_empty(self):
+        assert _sanitize_peer(None) == ""  # type: ignore[arg-type]
+
+    def test_max_length(self):
+        long = "a" * 100
+        assert len(_sanitize_peer(long)) <= 64
+
+    def test_allowed_chars(self):
+        assert _sanitize_peer("user@domain.io") == "user@domain.io"
+        assert _sanitize_peer("my-peer_01") == "my-peer_01"
+
+    def test_null_bytes_stripped(self):
+        assert "\x00" not in _sanitize_peer("evil\x00peer")
+
+
+# ---------------------------------------------------------------------------
+# Integration tests: GET /api/v1/conversations
+# ---------------------------------------------------------------------------
+
+class TestListConversations:
+    def test_returns_list(self, live_server):
+        svc, port = live_server
+        status, data = _api(port, "/api/v1/conversations")
+        assert status == 200
+        assert "conversations" in data
+        assert isinstance(data["conversations"], list)
+
+    def test_includes_both_peers(self, live_server):
+        svc, port = live_server
+        _, data = _api(port, "/api/v1/conversations")
+        peers = {c["peer"] for c in data["conversations"]}
+        assert "alice" in peers
+        assert "bob" in peers
+
+    def test_message_count(self, live_server):
+        svc, port = live_server
+        _, data = _api(port, "/api/v1/conversations")
+        alice = next(c for c in data["conversations"] if c["peer"] == "alice")
+        assert alice["message_count"] == 2
+
+    def test_last_message_time_present(self, live_server):
+        svc, port = live_server
+        _, data = _api(port, "/api/v1/conversations")
+        alice = next(c for c in data["conversations"] if c["peer"] == "alice")
+        assert "last_message_time" in alice
+        assert alice["last_message_time"] is not None
+
+    def test_last_message_preview_present(self, live_server):
+        svc, port = live_server
+        _, data = _api(port, "/api/v1/conversations")
+        alice = next(c for c in data["conversations"] if c["peer"] == "alice")
+        assert "last_message_preview" in alice
+        assert isinstance(alice["last_message_preview"], str)
+
+    def test_empty_conversations_dir(self, tmp_path):
+        home = tmp_path / ".skcapstone"
+        (home / "logs").mkdir(parents=True)
+        (home / "conversations").mkdir()
+        config = DaemonConfig(
+            home=home,
+            shared_root=home,
+            port=_find_free_port(),
+            poll_interval=60,
+        )
+        svc = DaemonService(config)
+        svc.state.running = True
+        with patch.object(svc, "_load_components"):
+            svc._write_pid()
+            svc._start_api_server()
+            time.sleep(0.4)
+            try:
+                _, data = _api(config.port, "/api/v1/conversations")
+                assert data["conversations"] == []
+            finally:
+                svc.stop()
+
+
+# ---------------------------------------------------------------------------
+# Integration tests: GET /api/v1/conversations/{peer}
+# ---------------------------------------------------------------------------
+
+class TestGetConversation:
+    def test_existing_peer(self, live_server):
+        svc, port = live_server
+        status, data = _api(port, "/api/v1/conversations/alice")
+        assert status == 200
+        assert data["peer"] == "alice"
+        assert len(data["messages"]) == 2
+
+    def test_missing_peer_404(self, live_server):
+        svc, port = live_server
+        status, _ = _api(port, "/api/v1/conversations/nobody")
+        assert status == 404
+
+    def test_path_traversal_rejected(self, live_server):
+        svc, port = live_server
+        # After sanitization "../../etc/passwd" → "etcpasswd" which doesn't exist → 404 or 400
+        status, _ = _api(port, "/api/v1/conversations/../../etc/passwd")
+        assert status in (400, 404)
+
+    def test_get_on_send_returns_405(self, live_server):
+        svc, port = live_server
+        status, data = _api(port, "/api/v1/conversations/alice/send")
+        assert status == 405
+
+
+# ---------------------------------------------------------------------------
+# Integration tests: POST /api/v1/conversations/{peer}/send
+# ---------------------------------------------------------------------------
+
+class TestSendMessage:
+    def test_send_returns_sent(self, live_server):
+        svc, port = live_server
+        body = json.dumps({"content": "hello world"}).encode()
+        status, data = _api(port, "/api/v1/conversations/alice/send", method="POST", body=body)
+        assert status == 200
+        assert data["status"] == "sent"
+        assert "message_id" in data
+
+    def test_send_writes_outbox_file(self, live_server, conv_home):
+        svc, port = live_server
+        body = json.dumps({"content": "test outbox write"}).encode()
+        status, resp = _api(port, "/api/v1/conversations/alice/send", method="POST", body=body)
+        assert status == 200, resp
+        msg_id = resp["message_id"]
+        # shared_root == conv_home in tests
+        outbox = svc.config.shared_root / "sync" / "comms" / "outbox" / f"{msg_id}.skc.json"
+        assert outbox.exists(), f"Outbox file not created: {outbox}"
+        envelope = json.loads(outbox.read_text())
+        assert envelope["recipient"] == "alice"
+        assert envelope["payload"]["content"] == "test outbox write"
+
+    def test_send_missing_content_400(self, live_server):
+        svc, port = live_server
+        body = json.dumps({"content": ""}).encode()
+        status, data = _api(port, "/api/v1/conversations/alice/send", method="POST", body=body)
+        assert status == 400
+        assert "content" in data["error"].lower()
+
+    def test_send_invalid_json_400(self, live_server):
+        svc, port = live_server
+        status, data = _api(
+            port, "/api/v1/conversations/alice/send", method="POST", body=b"not-json"
+        )
+        assert status == 400
+
+    def test_send_path_traversal_rejected(self, live_server):
+        svc, port = live_server
+        body = json.dumps({"content": "hi"}).encode()
+        # URL path traversal: peer sanitizes to empty or benign string
+        status, _ = _api(
+            port, "/api/v1/conversations/../../evil/send", method="POST", body=body
+        )
+        # Either 400 (invalid peer) or 200 (sanitized to "evil" which is fine) — not a server error
+        assert status in (200, 400)
+
+    def test_send_unique_message_ids(self, live_server):
+        svc, port = live_server
+        body = json.dumps({"content": "msg"}).encode()
+        ids = set()
+        for _ in range(5):
+            _, resp = _api(port, "/api/v1/conversations/alice/send", method="POST", body=body)
+            ids.add(resp["message_id"])
+        assert len(ids) == 5, "message_id should be unique per send"
+
+
+# ---------------------------------------------------------------------------
+# Integration tests: DELETE /api/v1/conversations/{peer}
+# ---------------------------------------------------------------------------
+
+class TestDeleteConversation:
+    def test_delete_existing_peer(self, live_server, conv_home):
+        svc, port = live_server
+        assert (conv_home / "conversations" / "bob.json").exists()
+        status, data = _api(port, "/api/v1/conversations/bob", method="DELETE")
+        assert status == 200
+        assert data["status"] == "deleted"
+        assert not (conv_home / "conversations" / "bob.json").exists()
+
+    def test_delete_missing_peer_404(self, live_server):
+        svc, port = live_server
+        status, _ = _api(port, "/api/v1/conversations/nobody", method="DELETE")
+        assert status == 404
+
+    def test_delete_invalid_peer_400(self, live_server):
+        svc, port = live_server
+        status, _ = _api(port, "/api/v1/conversations/", method="DELETE")
+        assert status in (400, 404)
+
+    def test_delete_does_not_affect_other_peers(self, live_server, conv_home):
+        svc, port = live_server
+        _api(port, "/api/v1/conversations/bob", method="DELETE")
+        # alice should still exist
+        assert (conv_home / "conversations" / "alice.json").exists()
+        status, _ = _api(port, "/api/v1/conversations/alice")
+        assert status == 200