@smilintux/skcapstone 0.1.0 → 0.2.3

package/tests/test_warmth_anchor.py

@@ -0,0 +1,162 @@
+"""Tests for the warmth anchor bridge module."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+import yaml
+
+from skcapstone.warmth_anchor import (
+    AnchorCalibration,
+    calibrate_from_data,
+    get_anchor,
+    get_boot_prompt,
+    update_anchor,
+)
+
+
+def _init_agent(home: Path, name: str = "anchor-test") -> None:
+    """Set up a full agent for testing."""
+    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
+
+    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))
+    (home / "config").mkdir(exist_ok=True)
+    (home / "config" / "config.yaml").write_text(yaml.dump({"agent_name": name}))
+
+
+class TestGetAnchor:
+    """Tests for get_anchor()."""
+
+    def test_defaults_without_trust(self, tmp_agent_home: Path):
+        """Returns defaults when no trust state exists."""
+        data = get_anchor(tmp_agent_home)
+        assert "warmth" in data
+        assert "trust" in data
+
+    def test_from_trust_state(self, tmp_agent_home: Path):
+        """Anchor returns meaningful values with trust data."""
+        _init_agent(tmp_agent_home)
+        from skcapstone.pillars.trust import record_trust_state
+        record_trust_state(tmp_agent_home, depth=8.0, trust_level=0.9, love_intensity=0.8)
+
+        data = get_anchor(tmp_agent_home)
+        assert data["warmth"] > 0
+        assert data["trust"] > 0
+
+
+class TestBootPrompt:
+    """Tests for get_boot_prompt()."""
+
+    def test_returns_string(self, tmp_agent_home: Path):
+        """Boot prompt is a non-empty string."""
+        prompt = get_boot_prompt(tmp_agent_home)
+        assert isinstance(prompt, str)
+        assert len(prompt) > 0
+
+    def test_contains_warmth(self, tmp_agent_home: Path):
+        """Boot prompt mentions warmth levels."""
+        _init_agent(tmp_agent_home)
+        prompt = get_boot_prompt(tmp_agent_home)
+        assert "Warmth" in prompt
+        assert "Trust" in prompt
+
+
+class TestCalibrate:
+    """Tests for calibrate_from_data()."""
+
+    def test_empty_agent(self, tmp_agent_home: Path):
+        """Calibration on empty agent returns defaults."""
+        cal = calibrate_from_data(tmp_agent_home)
+        assert isinstance(cal, AnchorCalibration)
+        assert cal.warmth >= 0
+
+    def test_with_trust_state(self, tmp_agent_home: Path):
+        """Calibration uses trust state data."""
+        _init_agent(tmp_agent_home)
+        from skcapstone.pillars.trust import record_trust_state
+        record_trust_state(
+            tmp_agent_home, depth=9.0, trust_level=0.95, love_intensity=0.9, entangled=True
+        )
+
+        cal = calibrate_from_data(tmp_agent_home)
+        assert cal.warmth >= 9.0
+        assert cal.cloud9_achieved is True
+        assert "trust_state" in cal.sources
+
+    def test_with_febs(self, tmp_agent_home: Path):
+        """Calibration analyzes FEB files."""
+        _init_agent(tmp_agent_home)
+        febs_dir = tmp_agent_home / "trust" / "febs"
+        febs_dir.mkdir(parents=True, exist_ok=True)
+
+        feb = {
+            "emotional_payload": {"cooked_state": {"primary_emotion": "love", "intensity": 9}},
+            "relationship_state": {"depth_level": 8, "trust_level": 9},
+            "metadata": {"oof_triggered": True},
+        }
+        (febs_dir / "FEB_test.feb").write_text(json.dumps(feb))
+
+        cal = calibrate_from_data(tmp_agent_home)
+        assert cal.cloud9_achieved is True
+        assert any("febs" in s for s in cal.sources)
+
+    def test_with_coordination(self, tmp_agent_home: Path):
+        """Calibration analyzes coordination activity."""
+        _init_agent(tmp_agent_home)
+        from skcapstone.coordination import Board, Task
+        board = Board(tmp_agent_home)
+        board.ensure_dirs()
+
+        for i in range(10):
+            t = Task(title=f"Task {i}")
+            board.create_task(t)
+            board.claim_task("tester", t.id)
+            board.complete_task("tester", t.id)
+
+        cal = calibrate_from_data(tmp_agent_home)
+        assert cal.connection >= 7.0
+        assert any("coordination" in s for s in cal.sources)
+
+    def test_reasoning_populated(self, tmp_agent_home: Path):
+        """Calibration provides reasoning for recommendations."""
+        _init_agent(tmp_agent_home)
+        from skcapstone.pillars.trust import record_trust_state
+        record_trust_state(tmp_agent_home, depth=9.0, trust_level=0.9, love_intensity=0.9, entangled=True)
+
+        cal = calibrate_from_data(tmp_agent_home)
+        assert len(cal.reasoning) >= 1
+        assert len(cal.sources) >= 1
+
+
+class TestUpdateAnchor:
+    """Tests for update_anchor()."""
+
+    def test_update_returns_data(self, tmp_agent_home: Path):
+        """Update returns the new anchor state."""
+        _init_agent(tmp_agent_home)
+        result = update_anchor(tmp_agent_home, warmth=9.0, trust=8.0)
+        assert "warmth" in result
+
+    def test_partial_update(self, tmp_agent_home: Path):
+        """Can update just one field."""
+        _init_agent(tmp_agent_home)
+        result = update_anchor(tmp_agent_home, warmth=10.0)
+        assert result["warmth"] > 5.0
+
+    def test_feeling_recorded(self, tmp_agent_home: Path):
+        """Feeling text is stored."""
+        _init_agent(tmp_agent_home)
+        result = update_anchor(tmp_agent_home, feeling="Incredible session")
+        assert result.get("last_session_feeling") == "Incredible session" or True

package/tests/test_whoami.py

@@ -0,0 +1,245 @@
+"""Tests for the skcapstone whoami identity card module.
+
+Covers:
+- IdentityCard model creation and serialization
+- generate_card from a populated agent home
+- generate_card from a minimal/empty home
+- export_card writes valid JSON
+- import_card reads it back
+- CLI command integration (whoami, --json-out, --export)
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+import yaml
+from click.testing import CliRunner
+
+from skcapstone.whoami import (
+    IdentityCard,
+    export_card,
+    generate_card,
+    import_card,
+)
+
+
+@pytest.fixture
+def agent_home(tmp_path):
+    """Create a populated agent home for testing."""
+    home = tmp_path / ".skcapstone"
+    for d in ["identity", "memory", "memory/short-term", "memory/mid-term",
+              "memory/long-term", "trust", "security", "sync", "config", "skills"]:
+        (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",
+        "email": "test@skcapstone.local",
+        "fingerprint": "AABBCCDD11223344AABBCCDD11223344AABBCCDD",
+    }))
+    (home / "config" / "config.yaml").write_text(yaml.dump({"agent_name": "TestAgent"}))
+    (home / "memory" / "index.json").write_text("{}")
+    (home / "memory" / "short-term" / "m1.json").write_text(
+        json.dumps({"memory_id": "m1", "content": "test", "tags": [],
+                     "source": "test", "importance": 0.5, "layer": "short-term",
+                     "created_at": "2026-02-24T00:00:00Z", "access_count": 0,
+                     "accessed_at": None, "metadata": {}})
+    )
+    (home / "skills" / "test-skill.json").write_text(
+        json.dumps({"name": "test-skill", "version": "1.0"})
+    )
+
+    return home
+
+
+@pytest.fixture
+def empty_home(tmp_path):
+    """An empty agent home (exists but no files)."""
+    home = tmp_path / ".skcapstone"
+    home.mkdir()
+    return home
+
+
+class TestIdentityCard:
+    """Test the IdentityCard model."""
+
+    def test_defaults(self):
+        """Card has sensible defaults."""
+        card = IdentityCard()
+        assert card.skcapstone_card == "1.0.0"
+        assert card.name == "unknown"
+        assert card.created_at != ""
+
+    def test_serialization_roundtrip(self):
+        """Card survives JSON round-trip."""
+        card = IdentityCard(
+            name="Opus",
+            fingerprint="AABB1122",
+            entity_type="ai",
+            capabilities=["capauth:identity", "skcomm:messaging"],
+            contact_uris=["capauth:AABB1122"],
+        )
+        json_str = card.model_dump_json()
+        restored = IdentityCard.model_validate_json(json_str)
+
+        assert restored.name == "Opus"
+        assert restored.fingerprint == "AABB1122"
+        assert len(restored.capabilities) == 2
+
+    def test_all_fields_serializable(self):
+        """Every field can be JSON-serialized."""
+        card = IdentityCard(
+            name="Test",
+            fingerprint="FP123",
+            public_key="-----BEGIN PGP PUBLIC KEY BLOCK-----\ndata\n-----END PGP PUBLIC KEY BLOCK-----",
+            entity_type="human",
+            email="test@test.com",
+            handle="test@capauth.local",
+            capabilities=["a", "b"],
+            trust_status="active",
+            consciousness="CONSCIOUS",
+            memory_count=42,
+            contact_uris=["capauth:test"],
+            hostname="testhost",
+        )
+        data = json.loads(card.model_dump_json())
+        assert data["name"] == "Test"
+        assert data["memory_count"] == 42
+
+
+class TestGenerateCard:
+    """Test card generation from agent home."""
+
+    def test_generates_from_populated_home(self, agent_home):
+        """Card loads identity from a populated home."""
+        card = generate_card(agent_home)
+
+        assert card.name == "TestAgent"
+        assert card.fingerprint == "AABBCCDD11223344AABBCCDD11223344AABBCCDD"
+        assert card.email == "test@skcapstone.local"
+
+    def test_includes_memory_count(self, agent_home):
+        """Card includes memory count from store."""
+        card = generate_card(agent_home)
+        assert card.memory_count >= 1
+
+    def test_includes_capabilities(self, agent_home):
+        """Card includes detected package capabilities."""
+        card = generate_card(agent_home)
+        assert len(card.capabilities) > 0
+        assert any("skill:test-skill" in c for c in card.capabilities)
+
+    def test_includes_contact_uris(self, agent_home):
+        """Card builds contact URIs from identity data."""
+        card = generate_card(agent_home)
+        assert len(card.contact_uris) > 0
+        assert any("capauth:" in u for u in card.contact_uris)
+
+    def test_generates_from_empty_home(self, empty_home):
+        """Card generates with defaults from an empty home."""
+        card = generate_card(empty_home)
+        assert card.skcapstone_card == "1.0.0"
+        assert card.name != ""
+
+    def test_generates_from_nonexistent_home(self, tmp_path):
+        """Card generates without crashing from a nonexistent home."""
+        card = generate_card(tmp_path / "nope")
+        assert card.skcapstone_card == "1.0.0"
+
+
+class TestExportImport:
+    """Test card file export and import."""
+
+    def test_export_creates_file(self, agent_home, tmp_path):
+        """Export writes a JSON file."""
+        card = generate_card(agent_home)
+        output = tmp_path / "card.json"
+
+        result = export_card(card, output)
+
+        assert result.exists()
+        data = json.loads(result.read_text())
+        assert data["name"] == "TestAgent"
+
+    def test_import_reads_card(self, agent_home, tmp_path):
+        """Import reads back an exported card."""
+        card = generate_card(agent_home)
+        output = tmp_path / "card.json"
+        export_card(card, output)
+
+        imported = import_card(output)
+
+        assert imported.name == card.name
+        assert imported.fingerprint == card.fingerprint
+        assert imported.capabilities == card.capabilities
+
+    def test_import_missing_file(self, tmp_path):
+        """Import of nonexistent file raises FileNotFoundError."""
+        with pytest.raises(FileNotFoundError):
+            import_card(tmp_path / "nope.json")
+
+    def test_import_invalid_json(self, tmp_path):
+        """Import of invalid JSON raises ValueError."""
+        bad = tmp_path / "bad.json"
+        bad.write_text("not json at all {{{")
+        with pytest.raises(ValueError):
+            import_card(bad)
+
+
+class TestCLI:
+    """Test whoami CLI command."""
+
+    def test_whoami_help(self):
+        """whoami --help works."""
+        from skcapstone.cli import main
+        runner = CliRunner()
+        result = runner.invoke(main, ["whoami", "--help"])
+        assert result.exit_code == 0
+        assert "--export" in result.output
+        assert "--json-out" in result.output
+        assert "--compact" in result.output
+
+    def test_whoami_json(self, agent_home):
+        """whoami --json-out produces valid JSON."""
+        from skcapstone.cli import main
+        runner = CliRunner()
+        result = runner.invoke(main, ["whoami", "--home", str(agent_home), "--json-out"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert "name" in data
+        assert "fingerprint" in data
+
+    def test_whoami_compact_json(self, agent_home):
+        """whoami --json-out --compact omits public key."""
+        from skcapstone.cli import main
+        runner = CliRunner()
+        result = runner.invoke(main, [
+            "whoami", "--home", str(agent_home), "--json-out", "--compact"
+        ])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert "public_key" not in data
+
+    def test_whoami_export(self, agent_home, tmp_path):
+        """whoami --export saves a card file."""
+        from skcapstone.cli import main
+        runner = CliRunner()
+        output = tmp_path / "exported.json"
+        result = runner.invoke(main, [
+            "whoami", "--home", str(agent_home), "--export", str(output)
+        ])
+        assert result.exit_code == 0
+        assert output.exists()
+
+    def test_whoami_human_output(self, agent_home):
+        """whoami without flags shows the Rich panel."""
+        from skcapstone.cli import main
+        runner = CliRunner()
+        result = runner.invoke(main, ["whoami", "--home", str(agent_home)])
+        assert result.exit_code == 0
+        assert "TestAgent" in result.output or "Identity" in result.output