@smilintux/skcapstone 0.1.0 → 0.2.3

package/tests/test_capabilities.py

@@ -0,0 +1,257 @@
+"""Tests for agent capability advertisement.
+
+Covers:
+- AgentConfig defaults
+- HeartbeatBeacon reading capabilities from config
+- HeartbeatBeacon falling back to defaults when config absent
+- Heartbeat pulse includes config capabilities
+- CLI capabilities command (list, add, remove)
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+import yaml
+from click.testing import CliRunner
+
+from skcapstone.heartbeat import AgentCapability, HeartbeatBeacon
+from skcapstone.models import AgentConfig
+
+
+# ---------------------------------------------------------------------------
+# AgentConfig defaults
+# ---------------------------------------------------------------------------
+
+
+class TestAgentConfigCapabilities:
+    """AgentConfig capabilities field."""
+
+    def test_default_capabilities(self) -> None:
+        """AgentConfig has the four default capabilities."""
+        cfg = AgentConfig()
+        assert cfg.capabilities == ["consciousness", "code", "chat", "memory"]
+
+    def test_custom_capabilities(self) -> None:
+        """AgentConfig accepts custom capabilities."""
+        cfg = AgentConfig(capabilities=["vector-search", "reasoning"])
+        assert cfg.capabilities == ["vector-search", "reasoning"]
+
+    def test_capabilities_preserved_in_yaml_roundtrip(self, tmp_path: Path) -> None:
+        """Capabilities survive a YAML serialise/deserialise round-trip."""
+        cfg = AgentConfig(capabilities=["consciousness", "code"])
+        config_path = tmp_path / "config.yaml"
+        config_path.write_text(
+            yaml.dump({"capabilities": cfg.capabilities}, default_flow_style=False),
+            encoding="utf-8",
+        )
+        loaded = yaml.safe_load(config_path.read_text(encoding="utf-8"))
+        restored = AgentConfig(**loaded)
+        assert restored.capabilities == ["consciousness", "code"]
+
+
+# ---------------------------------------------------------------------------
+# HeartbeatBeacon — capability loading
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def home(tmp_path: Path) -> Path:
+    """Minimal agent home."""
+    (tmp_path / "identity").mkdir()
+    (tmp_path / "identity" / "identity.json").write_text(
+        json.dumps({"name": "opus", "fingerprint": "ABCD1234567890AB"}),
+        encoding="utf-8",
+    )
+    return tmp_path
+
+
+@pytest.fixture
+def beacon(home: Path) -> HeartbeatBeacon:
+    b = HeartbeatBeacon(home, agent_name="opus")
+    b.initialize()
+    return b
+
+
+class TestHeartbeatCapabilityLoading:
+    """HeartbeatBeacon reads capabilities from config."""
+
+    def test_defaults_when_no_config(self, beacon: HeartbeatBeacon) -> None:
+        """Falls back to AgentConfig defaults when config.yaml is absent."""
+        caps = beacon._load_config_capabilities()
+        assert caps == ["consciousness", "code", "chat", "memory"]
+
+    def test_reads_capabilities_from_config(self, beacon: HeartbeatBeacon, home: Path) -> None:
+        """Reads custom capabilities list from config.yaml."""
+        config_dir = home / "config"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        (config_dir / "config.yaml").write_text(
+            yaml.dump({"capabilities": ["consciousness", "code", "vector-search"]}),
+            encoding="utf-8",
+        )
+        caps = beacon._load_config_capabilities()
+        assert caps == ["consciousness", "code", "vector-search"]
+
+    def test_detect_capabilities_includes_config_caps(
+        self, beacon: HeartbeatBeacon, home: Path
+    ) -> None:
+        """_detect_capabilities() includes all config-listed capabilities."""
+        config_dir = home / "config"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        (config_dir / "config.yaml").write_text(
+            yaml.dump({"capabilities": ["consciousness", "code", "chat", "memory"]}),
+            encoding="utf-8",
+        )
+        caps = beacon._detect_capabilities()
+        names = [c.name for c in caps]
+        assert "consciousness" in names
+        assert "code" in names
+        assert "chat" in names
+        assert "memory" in names
+
+    def test_detect_capabilities_no_duplicates_from_packages(
+        self, beacon: HeartbeatBeacon, home: Path
+    ) -> None:
+        """Packages already in config list are not duplicated."""
+        config_dir = home / "config"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        (config_dir / "config.yaml").write_text(
+            yaml.dump({"capabilities": ["skcapstone"]}),
+            encoding="utf-8",
+        )
+        caps = beacon._detect_capabilities()
+        names = [c.name for c in caps]
+        assert names.count("skcapstone") == 1
+
+    def test_pulse_heartbeat_has_config_capabilities(
+        self, beacon: HeartbeatBeacon, home: Path
+    ) -> None:
+        """Pulse embeds config capabilities in the published heartbeat."""
+        config_dir = home / "config"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        (config_dir / "config.yaml").write_text(
+            yaml.dump({"capabilities": ["consciousness", "code", "chat", "memory"]}),
+            encoding="utf-8",
+        )
+        hb = beacon.pulse()
+        cap_names = [c.name for c in hb.capabilities]
+        assert "consciousness" in cap_names
+        assert "code" in cap_names
+        assert "chat" in cap_names
+        assert "memory" in cap_names
+
+    def test_pulse_heartbeat_persisted_capabilities(
+        self, beacon: HeartbeatBeacon, home: Path
+    ) -> None:
+        """Capabilities written to disk match what was pulsed."""
+        config_dir = home / "config"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        (config_dir / "config.yaml").write_text(
+            yaml.dump({"capabilities": ["consciousness", "chat"]}),
+            encoding="utf-8",
+        )
+        beacon.pulse()
+        hb_file = home / "heartbeats" / "opus.json"
+        data = json.loads(hb_file.read_text(encoding="utf-8"))
+        persisted_names = [c["name"] for c in data["capabilities"]]
+        assert "consciousness" in persisted_names
+        assert "chat" in persisted_names
+
+
+# ---------------------------------------------------------------------------
+# CLI capabilities command
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def runner() -> CliRunner:
+    return CliRunner()
+
+
+class TestCapabilitiesCLI:
+    """CLI: skcapstone capabilities."""
+
+    def test_capabilities_list_defaults(self, runner: CliRunner, tmp_path: Path) -> None:
+        """capabilities list shows defaults when no config present."""
+        from skcapstone.cli import main
+
+        result = runner.invoke(main, ["capabilities", "list", "--home", str(tmp_path)])
+        assert result.exit_code == 0
+        assert "consciousness" in result.output
+        assert "code" in result.output
+        assert "chat" in result.output
+        assert "memory" in result.output
+
+    def test_capabilities_list_json(self, runner: CliRunner, tmp_path: Path) -> None:
+        """capabilities list --json returns a JSON array."""
+        from skcapstone.cli import main
+
+        result = runner.invoke(
+            main, ["capabilities", "list", "--json", "--home", str(tmp_path)]
+        )
+        assert result.exit_code == 0
+        caps = json.loads(result.output)
+        assert isinstance(caps, list)
+        assert "consciousness" in caps
+
+    def test_capabilities_add(self, runner: CliRunner, tmp_path: Path) -> None:
+        """capabilities add appends a new capability to config."""
+        from skcapstone.cli import main
+
+        result = runner.invoke(
+            main, ["capabilities", "add", "vector-search", "--home", str(tmp_path)]
+        )
+        assert result.exit_code == 0
+        assert "vector-search" in result.output
+
+        # Verify it persisted
+        config_path = tmp_path / "config" / "config.yaml"
+        data = yaml.safe_load(config_path.read_text(encoding="utf-8"))
+        assert "vector-search" in data["capabilities"]
+
+    def test_capabilities_add_no_duplicate(self, runner: CliRunner, tmp_path: Path) -> None:
+        """capabilities add skips silently when capability already present."""
+        from skcapstone.cli import main
+
+        # Add a new capability first (ensures config file is created)
+        runner.invoke(main, ["capabilities", "add", "vector-search", "--home", str(tmp_path)])
+        config_path = tmp_path / "config" / "config.yaml"
+        data1 = yaml.safe_load(config_path.read_text(encoding="utf-8"))
+        count_before = data1["capabilities"].count("vector-search")
+
+        # Add the same capability again — should NOT duplicate
+        result = runner.invoke(
+            main, ["capabilities", "add", "vector-search", "--home", str(tmp_path)]
+        )
+        assert result.exit_code == 0
+        data2 = yaml.safe_load(config_path.read_text(encoding="utf-8"))
+        assert data2["capabilities"].count("vector-search") == count_before
+
+    def test_capabilities_remove(self, runner: CliRunner, tmp_path: Path) -> None:
+        """capabilities remove drops a capability from config."""
+        from skcapstone.cli import main
+
+        # First add so it's persisted
+        runner.invoke(main, ["capabilities", "add", "chat", "--home", str(tmp_path)])
+
+        result = runner.invoke(
+            main, ["capabilities", "remove", "chat", "--home", str(tmp_path)]
+        )
+        assert result.exit_code == 0
+        assert "chat" in result.output
+
+        config_path = tmp_path / "config" / "config.yaml"
+        data = yaml.safe_load(config_path.read_text(encoding="utf-8"))
+        assert "chat" not in data["capabilities"]
+
+    def test_capabilities_root_command_shows_table(
+        self, runner: CliRunner, tmp_path: Path
+    ) -> None:
+        """skcapstone capabilities (no subcommand) prints capability table."""
+        from skcapstone.cli import main
+
+        result = runner.invoke(main, ["capabilities", "--home", str(tmp_path)])
+        assert result.exit_code == 0
+        assert "consciousness" in result.output

package/tests/test_changelog.py

@@ -0,0 +1,254 @@
+"""Tests for the Changelog Generator."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from skcapstone.changelog import (
+    TAG_CATEGORIES,
+    _categorize,
+    _parse_date,
+    generate_changelog,
+    write_changelog,
+)
+
+
+# ---------------------------------------------------------------------------
+# Categorization
+# ---------------------------------------------------------------------------
+
+
+class TestCategorize:
+    """Tests for tag-based categorization."""
+
+    def test_feature_tags(self) -> None:
+        """Feature tags categorize correctly."""
+        assert _categorize(["skcapstone", "memory"]) == "feature"
+
+    def test_security_tags(self) -> None:
+        """Security tags categorize correctly."""
+        assert _categorize(["encryption", "security"]) == "security"
+
+    def test_infrastructure_tags(self) -> None:
+        """Infrastructure tags categorize correctly."""
+        assert _categorize(["docker", "ci"]) == "infrastructure"
+
+    def test_documentation_tags(self) -> None:
+        """Documentation tags categorize correctly."""
+        assert _categorize(["docs", "readme"]) == "documentation"
+
+    def test_empty_tags(self) -> None:
+        """Empty tags return 'other'."""
+        assert _categorize([]) == "other"
+
+    def test_unknown_tags(self) -> None:
+        """Unrecognized tags return 'other'."""
+        assert _categorize(["random", "unknown"]) == "other"
+
+    def test_best_match_wins(self) -> None:
+        """When multiple categories match, the one with most matches wins."""
+        result = _categorize(["skcapstone", "skchat", "security"])
+        assert result == "feature"  # 2 feature matches vs 1 security
+
+    def test_case_insensitive(self) -> None:
+        """Tags are case-insensitive."""
+        assert _categorize(["SKCAPSTONE"]) == "feature"
+
+    def test_emotional_tags(self) -> None:
+        """Emotional/soul tags categorize correctly."""
+        assert _categorize(["cloud9", "soul", "trust"]) == "emotional"
+
+
+# ---------------------------------------------------------------------------
+# Date parsing
+# ---------------------------------------------------------------------------
+
+
+class TestParseDate:
+    """Tests for ISO date extraction."""
+
+    def test_iso_datetime(self) -> None:
+        """Parses full ISO datetime."""
+        assert _parse_date("2026-02-24T12:00:00+00:00") == "2026-02-24"
+
+    def test_date_only(self) -> None:
+        """Parses date-only string."""
+        assert _parse_date("2026-01-15") == "2026-01-15"
+
+    def test_invalid_string(self) -> None:
+        """Invalid string returns today's date."""
+        result = _parse_date("not-a-date")
+        # Should be YYYY-MM-DD format
+        assert len(result) == 10
+        assert result[4] == "-"
+
+    def test_none_input(self) -> None:
+        """None input returns today's date."""
+        result = _parse_date(None)
+        assert len(result) == 10
+
+
+# ---------------------------------------------------------------------------
+# Changelog generation
+# ---------------------------------------------------------------------------
+
+
+def _setup_board(home: Path, tasks: list[dict]) -> None:
+    """Create a minimal coordination board with tasks and agent files.
+
+    Status is derived from agent files, not the task JSON.  Tasks whose
+    ``status`` field is ``"done"`` are added to a test agent's
+    ``completed_tasks`` list so the Board marks them as done.
+    """
+    coord_dir = home / "coordination" / "tasks"
+    coord_dir.mkdir(parents=True)
+    agents_dir = home / "coordination" / "agents"
+    agents_dir.mkdir(parents=True)
+
+    completed_ids: list[str] = []
+    for task in tasks:
+        # Strip the non-schema "status" key before writing the task file.
+        task_data = {k: v for k, v in task.items() if k != "status"}
+        task_file = coord_dir / f"{task['id']}-test.json"
+        task_file.write_text(json.dumps(task_data), encoding="utf-8")
+
+        if task.get("status") == "done":
+            completed_ids.append(task["id"])
+
+    # Create an agent file so the Board can derive "done" status.
+    if completed_ids:
+        agent_file = agents_dir / "test-agent.json"
+        agent_file.write_text(
+            json.dumps({
+                "agent": "test-agent",
+                "completed_tasks": completed_ids,
+                "claimed_tasks": completed_ids,
+            }),
+            encoding="utf-8",
+        )
+
+
+class TestGenerateChangelog:
+    """Tests for changelog generation."""
+
+    def test_empty_board(self, tmp_path: Path) -> None:
+        """Empty board generates minimal changelog."""
+        (tmp_path / "coordination" / "tasks").mkdir(parents=True)
+        (tmp_path / "coordination" / "agents").mkdir(parents=True)
+
+        result = generate_changelog(tmp_path)
+        assert "# SKCapstone Changelog" in result
+        assert "Total completed: 0" in result
+
+    def test_completed_tasks_appear(self, tmp_path: Path) -> None:
+        """Completed tasks appear in the changelog."""
+        _setup_board(tmp_path, [
+            {
+                "id": "abc123",
+                "title": "Add encrypted messaging",
+                "status": "done",
+                "priority": "high",
+                "tags": ["skchat", "encryption"],
+                "created_at": "2026-02-24T12:00:00+00:00",
+            },
+        ])
+        result = generate_changelog(tmp_path)
+        assert "Add encrypted messaging" in result
+
+    def test_open_tasks_excluded(self, tmp_path: Path) -> None:
+        """Open tasks do not appear in the changelog."""
+        _setup_board(tmp_path, [
+            {
+                "id": "abc123",
+                "title": "Pending feature",
+                "status": "open",
+                "priority": "medium",
+                "tags": ["skcapstone"],
+                "created_at": "2026-02-24T12:00:00+00:00",
+            },
+        ])
+        result = generate_changelog(tmp_path)
+        assert "Pending feature" not in result
+
+    def test_grouped_by_date(self, tmp_path: Path) -> None:
+        """Tasks are grouped by date."""
+        _setup_board(tmp_path, [
+            {
+                "id": "t1",
+                "title": "Task One",
+                "status": "done",
+                "priority": "medium",
+                "tags": ["skcapstone"],
+                "created_at": "2026-02-24T12:00:00+00:00",
+            },
+            {
+                "id": "t2",
+                "title": "Task Two",
+                "status": "done",
+                "priority": "medium",
+                "tags": ["skcapstone"],
+                "created_at": "2026-02-25T12:00:00+00:00",
+            },
+        ])
+        result = generate_changelog(tmp_path)
+        assert "## 2026-02-24" in result
+        assert "## 2026-02-25" in result
+
+    def test_custom_title(self, tmp_path: Path) -> None:
+        """Custom title is used."""
+        (tmp_path / "coordination" / "tasks").mkdir(parents=True)
+        (tmp_path / "coordination" / "agents").mkdir(parents=True)
+
+        result = generate_changelog(tmp_path, title="My Custom Changelog")
+        assert "# My Custom Changelog" in result
+
+    def test_without_agents(self, tmp_path: Path) -> None:
+        """Agent attribution can be disabled."""
+        _setup_board(tmp_path, [
+            {
+                "id": "t1",
+                "title": "Some Task",
+                "status": "done",
+                "priority": "medium",
+                "tags": ["skcapstone"],
+                "created_at": "2026-02-24T12:00:00+00:00",
+            },
+        ])
+        result = generate_changelog(tmp_path, include_agents=False)
+        assert "Some Task" in result
+        assert "(@" not in result.split("Some Task")[1].split("\n")[0]
+
+
+# ---------------------------------------------------------------------------
+# Write changelog
+# ---------------------------------------------------------------------------
+
+
+class TestWriteChangelog:
+    """Tests for writing changelog to file."""
+
+    def test_writes_to_default_path(self, tmp_path: Path, monkeypatch) -> None:
+        """write_changelog creates CHANGELOG.md."""
+        (tmp_path / "coordination" / "tasks").mkdir(parents=True)
+        (tmp_path / "coordination" / "agents").mkdir(parents=True)
+
+        output = tmp_path / "CHANGELOG.md"
+        result = write_changelog(tmp_path, output=output)
+        assert result == output
+        assert output.exists()
+        content = output.read_text(encoding="utf-8")
+        assert "SKCapstone Changelog" in content
+
+    def test_writes_to_custom_path(self, tmp_path: Path) -> None:
+        """write_changelog respects custom output path."""
+        (tmp_path / "coordination" / "tasks").mkdir(parents=True)
+        (tmp_path / "coordination" / "agents").mkdir(parents=True)
+
+        output = tmp_path / "custom" / "changes.md"
+        output.parent.mkdir(parents=True)
+        result = write_changelog(tmp_path, output=output)
+        assert result == output
+        assert output.exists()