@smilintux/skcapstone 0.1.0 → 0.2.3

package/tests/test_cli_skills.py

@@ -0,0 +1,223 @@
+"""Tests for skcapstone skills CLI commands."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from skcapstone.cli import main
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_registry_client(skills: list[dict] | None = None) -> MagicMock:
+    """Return a mock RegistryClient pre-populated with skills."""
+    if skills is None:
+        skills = [
+            {
+                "name": "syncthing-setup",
+                "version": "1.0.0",
+                "description": "Syncthing sovereign sync",
+                "tags": ["sync"],
+            },
+            {
+                "name": "pgp-identity",
+                "version": "0.2.0",
+                "description": "PGP key management",
+                "tags": ["identity"],
+            },
+        ]
+
+    client = MagicMock()
+    client.list_skills.return_value = skills
+    client.search.return_value = [skills[0]] if skills else []
+    return client
+
+
+# ---------------------------------------------------------------------------
+# skcapstone skills list
+# ---------------------------------------------------------------------------
+
+
+class TestSkillsList:
+    """Tests for 'skcapstone skills list'."""
+
+    def test_list_all_skills_renders_table(self):
+        """Happy path: list renders a table with skill rows."""
+        runner = CliRunner()
+        client = _make_registry_client()
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
+            result = runner.invoke(main, ["skills", "list"])
+
+        assert result.exit_code == 0
+        assert "syncthing-setup" in result.output
+        assert "pgp-identity" in result.output
+
+    def test_list_with_query_calls_search(self):
+        """--query flag should invoke client.search(), not list_skills()."""
+        runner = CliRunner()
+        client = _make_registry_client()
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
+            result = runner.invoke(main, ["skills", "list", "--query", "syncthing"])
+
+        assert result.exit_code == 0
+        client.search.assert_called_once_with("syncthing")
+        client.list_skills.assert_not_called()
+
+    def test_list_json_output(self):
+        """--json flag should output valid JSON, not a Rich table."""
+        import json
+
+        runner = CliRunner()
+        client = _make_registry_client()
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
+            result = runner.invoke(main, ["skills", "list", "--json"])
+
+        assert result.exit_code == 0
+        parsed = json.loads(result.output)
+        assert isinstance(parsed, list)
+        assert parsed[0]["name"] == "syncthing-setup"
+
+    def test_list_no_skills_empty_message(self):
+        """Empty registry should print a helpful 'no skills' message."""
+        runner = CliRunner()
+        client = _make_registry_client(skills=[])
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
+            result = runner.invoke(main, ["skills", "list"])
+
+        assert result.exit_code == 0
+        assert "No skills found" in result.output
+
+    def test_list_skskills_not_installed(self):
+        """When get_registry_client returns None the command exits 1."""
+        runner = CliRunner()
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=None):
+            result = runner.invoke(main, ["skills", "list"])
+
+        assert result.exit_code == 1
+        assert "skskills not installed" in result.output
+
+    def test_list_registry_error_exits_1(self):
+        """Registry connection error should print an error and exit 1."""
+        runner = CliRunner()
+        client = MagicMock()
+        client.list_skills.side_effect = ConnectionError("offline")
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
+            result = runner.invoke(main, ["skills", "list"])
+
+        assert result.exit_code == 1
+        assert "Registry error" in result.output
+
+
+# ---------------------------------------------------------------------------
+# skcapstone skills install
+# ---------------------------------------------------------------------------
+
+
+class TestSkillsInstall:
+    """Tests for 'skcapstone skills install'."""
+
+    def _install_result(self, name: str = "syncthing-setup") -> dict:
+        return {
+            "name": name,
+            "version": "1.0.0",
+            "agent": "global",
+            "install_path": "/home/user/.skskills/installed/syncthing-setup",
+            "status": "installed",
+        }
+
+    def test_install_happy_path(self):
+        """Successful install prints the skill name, version, and path."""
+        runner = CliRunner()
+        client = MagicMock()
+        client.install.return_value = self._install_result()
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
+            result = runner.invoke(main, ["skills", "install", "syncthing-setup"])
+
+        assert result.exit_code == 0
+        assert "Installed" in result.output
+        assert "syncthing-setup" in result.output
+        client.install.assert_called_once_with(
+            "syncthing-setup", version=None, agent="global", force=False
+        )
+
+    def test_install_with_version_flag(self):
+        """--version should be forwarded to client.install()."""
+        runner = CliRunner()
+        client = MagicMock()
+        client.install.return_value = self._install_result()
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
+            result = runner.invoke(
+                main, ["skills", "install", "syncthing-setup", "--version", "0.9.0"]
+            )
+
+        assert result.exit_code == 0
+        client.install.assert_called_once_with(
+            "syncthing-setup", version="0.9.0", agent="global", force=False
+        )
+
+    def test_install_with_agent_flag(self):
+        """--agent should be forwarded to client.install()."""
+        runner = CliRunner()
+        client = MagicMock()
+        client.install.return_value = self._install_result()
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
+            result = runner.invoke(
+                main, ["skills", "install", "syncthing-setup", "--agent", "opus"]
+            )
+
+        assert result.exit_code == 0
+        client.install.assert_called_once_with(
+            "syncthing-setup", version=None, agent="opus", force=False
+        )
+
+    def test_install_not_found_exits_1(self):
+        """FileNotFoundError from the registry should exit 1 with a helpful message."""
+        runner = CliRunner()
+        client = MagicMock()
+        client.install.side_effect = FileNotFoundError("unknown-skill not in registry")
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
+            result = runner.invoke(main, ["skills", "install", "unknown-skill"])
+
+        assert result.exit_code == 1
+        assert "Not found" in result.output
+
+    def test_install_skskills_not_installed(self):
+        """When get_registry_client returns None the command exits 1."""
+        runner = CliRunner()
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=None):
+            result = runner.invoke(main, ["skills", "install", "syncthing-setup"])
+
+        assert result.exit_code == 1
+        assert "skskills not installed" in result.output
+
+    def test_install_force_flag(self):
+        """--force should be forwarded to client.install()."""
+        runner = CliRunner()
+        client = MagicMock()
+        client.install.return_value = self._install_result()
+
+        with patch("skcapstone.cli.skills_cmd.get_registry_client", return_value=client):
+            result = runner.invoke(
+                main, ["skills", "install", "syncthing-setup", "--force"]
+            )
+
+        assert result.exit_code == 0
+        client.install.assert_called_once_with(
+            "syncthing-setup", version=None, agent="global", force=True
+        )

package/tests/test_cli_status.py

@@ -0,0 +1,395 @@
+"""Tests for the enhanced skcapstone status command and doctor CLI.
+
+Covers:
+- _probe_llm_backends() helper
+- _get_daemon_info() helper
+- _get_last_conversation() helper
+- status --help
+- status CLI output (sections: daemon, backends, disk, conversation)
+- doctor CLI (smoke tests)
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+import yaml
+from click.testing import CliRunner
+
+
+# ---------------------------------------------------------------------------
+# Shared fixture
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def agent_home(tmp_path: Path) -> Path:
+    """Fully initialised agent home with minimal required files."""
+    home = tmp_path / ".skcapstone"
+    for d in [
+        "identity", "memory", "trust", "security", "sync", "config",
+        "memory/short-term", "memory/mid-term", "memory/long-term",
+    ]:
+        (home / d).mkdir(parents=True, exist_ok=True)
+
+    (home / "manifest.json").write_text(json.dumps({
+        "name": "TestAgent", "version": "0.1.0",
+    }))
+    (home / "identity" / "identity.json").write_text(json.dumps({
+        "name": "TestAgent",
+        "fingerprint": "DEADBEEF12345678",
+        "capauth_managed": True,
+    }))
+    (home / "config" / "config.yaml").write_text(
+        yaml.dump({"agent_name": "TestAgent"})
+    )
+    return home
+
+
+# ---------------------------------------------------------------------------
+# Unit tests for helper functions
+# ---------------------------------------------------------------------------
+
+
+class TestProbeLlmBackends:
+    """Tests for _probe_llm_backends()."""
+
+    def test_ollama_available_when_reachable(self):
+        """ollama marked True when HTTP probe succeeds."""
+        from skcapstone.cli.status import _probe_llm_backends
+
+        mock_resp = MagicMock()
+        mock_resp.__enter__ = lambda s: s
+        mock_resp.__exit__ = MagicMock(return_value=False)
+
+        with patch("urllib.request.urlopen", return_value=mock_resp):
+            result = _probe_llm_backends()
+
+        assert result["ollama"] is True
+
+    def test_ollama_unavailable_when_unreachable(self):
+        """ollama marked False when HTTP probe raises."""
+        from skcapstone.cli.status import _probe_llm_backends
+
+        with patch("urllib.request.urlopen", side_effect=OSError("refused")):
+            result = _probe_llm_backends()
+
+        assert result["ollama"] is False
+
+    def test_cloud_backends_via_env(self, monkeypatch):
+        """Cloud backends detected via environment variables."""
+        from skcapstone.cli.status import _probe_llm_backends
+
+        monkeypatch.setenv("ANTHROPIC_API_KEY", "test-key")
+        monkeypatch.setenv("XAI_API_KEY", "test-key")
+        monkeypatch.delenv("MOONSHOT_API_KEY", raising=False)
+        monkeypatch.delenv("NVIDIA_API_KEY", raising=False)
+
+        with patch("urllib.request.urlopen", side_effect=OSError):
+            result = _probe_llm_backends()
+
+        assert result["anthropic"] is True
+        assert result["grok"] is True
+        assert result["kimi"] is False
+        assert result["nvidia"] is False
+
+    def test_returns_all_expected_keys(self):
+        """Result always contains the five expected backend keys."""
+        from skcapstone.cli.status import _probe_llm_backends
+
+        with patch("urllib.request.urlopen", side_effect=OSError):
+            result = _probe_llm_backends()
+
+        assert set(result.keys()) == {"ollama", "anthropic", "grok", "kimi", "nvidia"}
+
+
+class TestGetDaemonInfo:
+    """Tests for _get_daemon_info()."""
+
+    def test_stopped_when_no_pid(self, agent_home: Path):
+        """Returns running=False when no PID file exists."""
+        from skcapstone.cli.status import _get_daemon_info
+
+        with patch("skcapstone.cli.status._get_daemon_info.__module__"):
+            pass  # ensure module is imported
+
+        with patch("skcapstone.daemon.read_pid", return_value=None):
+            result = _get_daemon_info(agent_home)
+
+        assert result["running"] is False
+
+    def test_running_with_pid(self, agent_home: Path):
+        """Returns running=True with PID when daemon is alive."""
+        from skcapstone.cli.status import _get_daemon_info
+
+        with patch("skcapstone.daemon.read_pid", return_value=12345), \
+             patch("skcapstone.daemon.get_daemon_status", return_value=None):
+            result = _get_daemon_info(agent_home)
+
+        assert result["running"] is True
+        assert result["pid"] == 12345
+
+    def test_uptime_formatting_seconds(self, agent_home: Path):
+        """Uptime < 60s shown as Xs."""
+        from skcapstone.cli.status import _get_daemon_info
+
+        with patch("skcapstone.daemon.read_pid", return_value=1), \
+             patch("skcapstone.daemon.get_daemon_status", return_value={"uptime_seconds": 45}):
+            result = _get_daemon_info(agent_home)
+
+        assert result["uptime"] == "45s"
+
+    def test_uptime_formatting_minutes(self, agent_home: Path):
+        """Uptime 60–3599s shown as Xm Ys."""
+        from skcapstone.cli.status import _get_daemon_info
+
+        with patch("skcapstone.daemon.read_pid", return_value=1), \
+             patch("skcapstone.daemon.get_daemon_status", return_value={"uptime_seconds": 125}):
+            result = _get_daemon_info(agent_home)
+
+        assert result["uptime"] == "2m 5s"
+
+    def test_uptime_formatting_hours(self, agent_home: Path):
+        """Uptime >= 3600s shown as Xh Ym."""
+        from skcapstone.cli.status import _get_daemon_info
+
+        with patch("skcapstone.daemon.read_pid", return_value=1), \
+             patch("skcapstone.daemon.get_daemon_status", return_value={"uptime_seconds": 7320}):
+            result = _get_daemon_info(agent_home)
+
+        assert result["uptime"] == "2h 2m"
+
+    def test_message_count_included(self, agent_home: Path):
+        """messages key present when daemon reports > 0 messages."""
+        from skcapstone.cli.status import _get_daemon_info
+
+        with patch("skcapstone.daemon.read_pid", return_value=1), \
+             patch("skcapstone.daemon.get_daemon_status", return_value={
+                 "uptime_seconds": 60, "messages_received": 7,
+             }):
+            result = _get_daemon_info(agent_home)
+
+        assert result["messages"] == 7
+
+
+class TestGetLastConversation:
+    """Tests for _get_last_conversation()."""
+
+    def test_none_when_no_conv_dir(self, agent_home: Path):
+        """Returns None when conversations/ directory does not exist."""
+        from skcapstone.cli.status import _get_last_conversation
+
+        result = _get_last_conversation(agent_home)
+        assert result is None
+
+    def test_none_when_empty_conv_dir(self, agent_home: Path):
+        """Returns None when conversations/ is empty."""
+        from skcapstone.cli.status import _get_last_conversation
+
+        (agent_home / "conversations").mkdir()
+        result = _get_last_conversation(agent_home)
+        assert result is None
+
+    def test_returns_most_recent_peer(self, agent_home: Path):
+        """Returns the peer name of the most-recently-touched file."""
+        from skcapstone.cli.status import _get_last_conversation
+
+        conv_dir = agent_home / "conversations"
+        conv_dir.mkdir()
+        old_file = conv_dir / "alice.json"
+        new_file = conv_dir / "bob.json"
+        old_file.write_text("[]")
+        time.sleep(0.02)  # ensure mtime difference
+        new_file.write_text("[]")
+
+        result = _get_last_conversation(agent_home)
+        assert result is not None
+        assert result["peer"] == "bob"
+        assert "when" in result
+
+    def test_recent_convo_shows_minutes(self, agent_home: Path):
+        """A freshly written file shows time in minutes."""
+        from skcapstone.cli.status import _get_last_conversation
+
+        conv_dir = agent_home / "conversations"
+        conv_dir.mkdir()
+        (conv_dir / "charlie.json").write_text("[]")
+
+        result = _get_last_conversation(agent_home)
+        assert result is not None
+        assert "m ago" in result["when"] or "0m ago" in result["when"]
+
+
+# ---------------------------------------------------------------------------
+# CLI integration tests (via CliRunner)
+# ---------------------------------------------------------------------------
+
+
+class TestStatusCLI:
+    """CLI integration tests for the status command."""
+
+    def test_help(self):
+        """status --help exits 0 and shows description."""
+        from skcapstone.cli import main
+
+        result = CliRunner().invoke(main, ["status", "--help"])
+        assert result.exit_code == 0
+        assert "sovereign" in result.output.lower()
+
+    def test_missing_home_exits_nonzero(self, tmp_path: Path):
+        """status on a nonexistent home exits with code 1."""
+        from skcapstone.cli import main
+
+        result = CliRunner().invoke(main, ["status", "--home", str(tmp_path / "nope")])
+        assert result.exit_code != 0
+
+    def test_daemon_stopped_shown(self, agent_home: Path):
+        """'STOPPED' appears when daemon is not running."""
+        from skcapstone.cli import main
+
+        with patch("skcapstone.cli.status._get_daemon_info", return_value={"running": False}), \
+             patch("skcapstone.cli.status._probe_llm_backends", return_value={
+                 "ollama": False, "anthropic": False, "grok": False,
+                 "kimi": False, "nvidia": False,
+             }), \
+             patch("skcapstone.cli.status._print_consciousness_metrics"), \
+             patch("skcapstone.cli.status._get_last_conversation", return_value=None):
+            result = CliRunner().invoke(main, ["status", "--home", str(agent_home)])
+
+        assert result.exit_code == 0
+        assert "STOPPED" in result.output
+
+    def test_daemon_running_shown(self, agent_home: Path):
+        """'RUNNING' appears with PID when daemon is alive."""
+        from skcapstone.cli import main
+
+        with patch("skcapstone.cli.status._get_daemon_info", return_value={
+                 "running": True, "pid": 42, "uptime": "5m 3s",
+             }), \
+             patch("skcapstone.cli.status._probe_llm_backends", return_value={
+                 "ollama": True, "anthropic": False, "grok": False,
+                 "kimi": False, "nvidia": False,
+             }), \
+             patch("skcapstone.cli.status._print_consciousness_metrics"), \
+             patch("skcapstone.cli.status._get_last_conversation", return_value=None):
+            result = CliRunner().invoke(main, ["status", "--home", str(agent_home)])
+
+        assert result.exit_code == 0
+        assert "RUNNING" in result.output
+        assert "42" in result.output
+
+    def test_backends_section_present(self, agent_home: Path):
+        """'Backends:' line appears in status output."""
+        from skcapstone.cli import main
+
+        with patch("skcapstone.cli.status._get_daemon_info", return_value={"running": False}), \
+             patch("skcapstone.cli.status._probe_llm_backends", return_value={
+                 "ollama": True, "anthropic": False, "grok": False,
+                 "kimi": False, "nvidia": False,
+             }), \
+             patch("skcapstone.cli.status._print_consciousness_metrics"), \
+             patch("skcapstone.cli.status._get_last_conversation", return_value=None):
+            result = CliRunner().invoke(main, ["status", "--home", str(agent_home)])
+
+        assert result.exit_code == 0
+        assert "Backends:" in result.output
+
+    def test_last_conversation_shown(self, agent_home: Path):
+        """Last convo peer and time appear when conversation data exists."""
+        from skcapstone.cli import main
+
+        with patch("skcapstone.cli.status._get_daemon_info", return_value={"running": False}), \
+             patch("skcapstone.cli.status._probe_llm_backends", return_value={
+                 "ollama": False, "anthropic": False, "grok": False,
+                 "kimi": False, "nvidia": False,
+             }), \
+             patch("skcapstone.cli.status._print_consciousness_metrics"), \
+             patch("skcapstone.cli.status._get_last_conversation", return_value={
+                 "peer": "alice", "when": "3m ago",
+             }):
+            result = CliRunner().invoke(main, ["status", "--home", str(agent_home)])
+
+        assert result.exit_code == 0
+        assert "alice" in result.output
+        assert "3m ago" in result.output
+
+    def test_disk_warning_when_low(self, agent_home: Path):
+        """Disk warning printed when free space < 5 GB."""
+        from skcapstone.cli import main
+
+        low_usage = MagicMock()
+        low_usage.free = int(2.5 * 1024 ** 3)  # 2.5 GB
+
+        with patch("skcapstone.cli.status._get_daemon_info", return_value={"running": False}), \
+             patch("skcapstone.cli.status._probe_llm_backends", return_value={
+                 "ollama": False, "anthropic": False, "grok": False,
+                 "kimi": False, "nvidia": False,
+             }), \
+             patch("skcapstone.cli.status._print_consciousness_metrics"), \
+             patch("skcapstone.cli.status._get_last_conversation", return_value=None), \
+             patch("shutil.disk_usage", return_value=low_usage):
+            result = CliRunner().invoke(main, ["status", "--home", str(agent_home)])
+
+        assert result.exit_code == 0
+        assert "WARNING" in result.output
+        assert "2.5" in result.output
+
+    def test_no_disk_warning_when_ample(self, agent_home: Path):
+        """No disk warning when free space >= 5 GB."""
+        from skcapstone.cli import main
+
+        big_usage = MagicMock()
+        big_usage.free = int(50 * 1024 ** 3)  # 50 GB
+
+        with patch("skcapstone.cli.status._get_daemon_info", return_value={"running": False}), \
+             patch("skcapstone.cli.status._probe_llm_backends", return_value={
+                 "ollama": False, "anthropic": False, "grok": False,
+                 "kimi": False, "nvidia": False,
+             }), \
+             patch("skcapstone.cli.status._print_consciousness_metrics"), \
+             patch("skcapstone.cli.status._get_last_conversation", return_value=None), \
+             patch("shutil.disk_usage", return_value=big_usage):
+            result = CliRunner().invoke(main, ["status", "--home", str(agent_home)])
+
+        assert result.exit_code == 0
+        assert "WARNING" not in result.output
+
+
+class TestDoctorCLI:
+    """Smoke tests for the doctor command."""
+
+    def test_doctor_help(self):
+        """doctor --help exits 0."""
+        from skcapstone.cli import main
+
+        result = CliRunner().invoke(main, ["doctor", "--help"])
+        assert result.exit_code == 0
+        assert "Diagnose" in result.output
+
+    def test_doctor_on_agent_home(self, agent_home: Path):
+        """doctor produces output with at least one section heading."""
+        from skcapstone.cli import main
+
+        result = CliRunner().invoke(main, ["doctor", "--home", str(agent_home)])
+        assert result.exit_code == 0
+        # At least one category must be rendered
+        assert any(
+            kw in result.output
+            for kw in ["Python Packages", "Agent Home", "Identity", "Memory"]
+        )
+
+    def test_doctor_json_output(self, agent_home: Path):
+        """doctor --json-out emits valid JSON with expected keys."""
+        from skcapstone.cli import main
+
+        result = CliRunner().invoke(main, ["doctor", "--home", str(agent_home), "--json-out"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert "passed" in data
+        assert "failed" in data
+        assert isinstance(data["checks"], list)