@smilintux/skcapstone 0.1.0 → 0.2.3

package/tests/test_security_pillar.py

@@ -0,0 +1,213 @@
+"""Unit tests for the security pillar module."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from skcapstone.models import PillarStatus
+from skcapstone.pillars.security import (
+    AUDIT_LOG_NAME,
+    AuditEntry,
+    audit_event,
+    initialize_security,
+    read_audit_log,
+)
+
+
+class TestInitializeSecurity:
+    """Tests for initialize_security()."""
+
+    def test_creates_security_directory(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        assert (tmp_agent_home / "security").is_dir()
+
+    def test_creates_audit_log(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        assert (tmp_agent_home / "security" / AUDIT_LOG_NAME).exists()
+
+    def test_audit_log_has_init_entry(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        log_path = tmp_agent_home / "security" / AUDIT_LOG_NAME
+        first_line = log_path.read_text(encoding="utf-8").strip().splitlines()[0]
+        entry = json.loads(first_line)
+        assert entry["event_type"] == "INIT"
+
+    def test_audit_log_init_entry_has_timestamp(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        log_path = tmp_agent_home / "security" / AUDIT_LOG_NAME
+        entry = json.loads(log_path.read_text().strip().splitlines()[0])
+        assert "timestamp" in entry and entry["timestamp"]
+
+    def test_audit_log_init_entry_has_host(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        log_path = tmp_agent_home / "security" / AUDIT_LOG_NAME
+        entry = json.loads(log_path.read_text().strip().splitlines()[0])
+        assert "host" in entry and entry["host"]
+
+    def test_returns_security_state(self, tmp_agent_home: Path):
+        state = initialize_security(tmp_agent_home)
+        assert state is not None
+
+    def test_idempotent_does_not_duplicate_init_entry(self, tmp_agent_home: Path):
+        """Calling initialize_security twice must not write a second INIT entry."""
+        initialize_security(tmp_agent_home)
+        initialize_security(tmp_agent_home)
+        log_path = tmp_agent_home / "security" / AUDIT_LOG_NAME
+        lines = [l for l in log_path.read_text().splitlines() if l.strip()]
+        assert len(lines) == 1
+
+
+class TestAuditEvent:
+    """Tests for audit_event()."""
+
+    def test_returns_audit_entry(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        entry = audit_event(tmp_agent_home, "TEST", "a test event")
+        assert isinstance(entry, AuditEntry)
+
+    def test_event_type_stored(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        entry = audit_event(tmp_agent_home, "AUTH", "key verified")
+        assert entry.event_type == "AUTH"
+
+    def test_detail_stored(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        entry = audit_event(tmp_agent_home, "AUTH", "key verified")
+        assert entry.detail == "key verified"
+
+    def test_entry_appended_to_log(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        audit_event(tmp_agent_home, "SYNC_PUSH", "seed pushed")
+        lines = (tmp_agent_home / "security" / AUDIT_LOG_NAME).read_text().splitlines()
+        assert len(lines) == 2
+        second = json.loads(lines[1])
+        assert second["event_type"] == "SYNC_PUSH"
+
+    def test_agent_field_stored(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        entry = audit_event(tmp_agent_home, "BOOT", "agent started", agent="opus")
+        assert entry.agent == "opus"
+        lines = (tmp_agent_home / "security" / AUDIT_LOG_NAME).read_text().splitlines()
+        assert json.loads(lines[-1])["agent"] == "opus"
+
+    def test_metadata_field_stored(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        meta = {"token_id": "tok123", "caps": ["read"]}
+        entry = audit_event(tmp_agent_home, "TOKEN_ISSUE", "token issued", metadata=meta)
+        assert entry.metadata["token_id"] == "tok123"
+        last = json.loads(
+            (tmp_agent_home / "security" / AUDIT_LOG_NAME).read_text().splitlines()[-1]
+        )
+        assert last["metadata"]["token_id"] == "tok123"
+
+    def test_creates_security_dir_if_missing(self, tmp_path: Path):
+        fresh_home = tmp_path / "fresh"
+        fresh_home.mkdir()
+        audit_event(fresh_home, "BOOT", "first event")
+        assert (fresh_home / "security" / AUDIT_LOG_NAME).exists()
+
+    def test_multiple_events_accumulate(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        for i in range(3):
+            audit_event(tmp_agent_home, "EVENT", f"entry {i}")
+        lines = (tmp_agent_home / "security" / AUDIT_LOG_NAME).read_text().splitlines()
+        assert len(lines) == 4  # 1 INIT + 3 events
+
+
+class TestReadAuditLog:
+    """Tests for read_audit_log()."""
+
+    def test_empty_when_log_missing(self, tmp_path: Path):
+        entries = read_audit_log(tmp_path / "no-home")
+        assert entries == []
+
+    def test_returns_list_of_audit_entries(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        entries = read_audit_log(tmp_agent_home)
+        assert isinstance(entries, list)
+        assert all(isinstance(e, AuditEntry) for e in entries)
+
+    def test_parses_init_entry(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        entries = read_audit_log(tmp_agent_home)
+        assert len(entries) >= 1
+        assert entries[0].event_type == "INIT"
+
+    def test_reads_all_events_in_order(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        audit_event(tmp_agent_home, "AUTH", "key check")
+        audit_event(tmp_agent_home, "SYNC_PUSH", "seed sent")
+        entries = read_audit_log(tmp_agent_home)
+        assert len(entries) == 3
+        assert entries[0].event_type == "INIT"
+        assert entries[1].event_type == "AUTH"
+        assert entries[2].event_type == "SYNC_PUSH"
+
+    def test_limit_returns_newest_n(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        for i in range(5):
+            audit_event(tmp_agent_home, "EVENT", f"entry {i}")
+        entries = read_audit_log(tmp_agent_home, limit=2)
+        assert len(entries) == 2
+        assert "entry 3" in entries[0].detail
+        assert "entry 4" in entries[1].detail
+
+    def test_handles_legacy_plaintext_lines(self, tmp_agent_home: Path):
+        security_dir = tmp_agent_home / "security"
+        security_dir.mkdir(parents=True, exist_ok=True)
+        (security_dir / AUDIT_LOG_NAME).write_text(
+            "[2026-01-01T00:00:00] INIT — legacy format\n"
+            "[2026-01-01T00:01:00] AUTH — old auth event\n",
+            encoding="utf-8",
+        )
+        entries = read_audit_log(tmp_agent_home)
+        assert len(entries) == 2
+        assert all(e.event_type == "LEGACY" for e in entries)
+
+    def test_mixed_jsonl_and_legacy(self, tmp_agent_home: Path):
+        """Log may contain a mix of old plain-text and new JSONL entries."""
+        initialize_security(tmp_agent_home)
+        log_path = tmp_agent_home / "security" / AUDIT_LOG_NAME
+        # Append a legacy line after the JSONL INIT entry
+        with log_path.open("a") as f:
+            f.write("[legacy] some old plain text event\n")
+        entries = read_audit_log(tmp_agent_home)
+        assert len(entries) == 2
+        assert entries[0].event_type == "INIT"
+        assert entries[1].event_type == "LEGACY"
+
+    def test_limit_zero_returns_all(self, tmp_agent_home: Path):
+        initialize_security(tmp_agent_home)
+        audit_event(tmp_agent_home, "A", "a")
+        audit_event(tmp_agent_home, "B", "b")
+        entries = read_audit_log(tmp_agent_home, limit=0)
+        assert len(entries) == 3
+
+
+class TestAuditEntryModel:
+    """Tests for the AuditEntry model."""
+
+    def test_default_timestamp_is_set(self):
+        entry = AuditEntry(event_type="TEST", detail="x")
+        assert entry.timestamp
+
+    def test_default_host_is_set(self):
+        entry = AuditEntry(event_type="TEST", detail="x")
+        assert entry.host
+
+    def test_optional_agent_is_none_by_default(self):
+        entry = AuditEntry(event_type="TEST", detail="x")
+        assert entry.agent is None
+
+    def test_optional_metadata_is_none_by_default(self):
+        entry = AuditEntry(event_type="TEST", detail="x")
+        assert entry.metadata is None
+
+    def test_model_dump_json_round_trip(self):
+        entry = AuditEntry(event_type="SYNC", detail="pushed seed", agent="opus")
+        reloaded = AuditEntry.model_validate(json.loads(entry.model_dump_json()))
+        assert reloaded.event_type == "SYNC"
+        assert reloaded.agent == "opus"

package/tests/test_self_healing.py

@@ -0,0 +1,171 @@
+"""Tests for the self-healing doctor."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from skcapstone.self_healing import SelfHealingDoctor
+
+
+class TestHomeDirs:
+    """Home directory auto-fix tests."""
+
+    def test_creates_missing_dirs(self, tmp_path):
+        """Missing home subdirs are auto-created."""
+        home = tmp_path / ".skcapstone"
+        home.mkdir()
+        # Only create 'identity' — rest should be auto-fixed
+        (home / "identity").mkdir()
+
+        doctor = SelfHealingDoctor(home)
+        result = doctor._check_home_dirs()
+
+        assert result["status"] == "fixed"
+        assert (home / "memory").exists()
+        assert (home / "trust").exists()
+        assert (home / "config").exists()
+
+    def test_ok_when_all_present(self, tmp_path):
+        """Returns ok when all dirs exist."""
+        home = tmp_path / ".skcapstone"
+        for subdir in ("identity", "memory", "trust", "security", "sync", "config", "soul", "logs"):
+            (home / subdir).mkdir(parents=True)
+
+        doctor = SelfHealingDoctor(home)
+        result = doctor._check_home_dirs()
+        assert result["status"] == "ok"
+
+
+class TestMemoryIndex:
+    """Memory index rebuild tests."""
+
+    def test_rebuilds_missing_index(self, tmp_path):
+        """Missing index.json is rebuilt from memory files."""
+        home = tmp_path / ".skcapstone"
+        memory_dir = home / "memory" / "short-term"
+        memory_dir.mkdir(parents=True)
+
+        # Write a test memory file
+        memory = {
+            "memory_id": "test-123",
+            "content": "Test memory",
+            "tags": ["test"],
+        }
+        (memory_dir / "test-123.json").write_text(json.dumps(memory))
+
+        doctor = SelfHealingDoctor(home)
+        result = doctor._check_memory_index()
+
+        assert result["status"] == "fixed"
+        index = json.loads((home / "memory" / "index.json").read_text())
+        assert len(index) == 1
+        assert index[0]["memory_id"] == "test-123"
+
+    def test_ok_when_valid(self, tmp_path):
+        """Returns ok when index exists and is valid."""
+        home = tmp_path / ".skcapstone"
+        memory_dir = home / "memory"
+        memory_dir.mkdir(parents=True)
+        (memory_dir / "index.json").write_text("[]")
+
+        doctor = SelfHealingDoctor(home)
+        result = doctor._check_memory_index()
+        assert result["status"] == "ok"
+
+
+class TestSyncManifest:
+    """Sync manifest auto-fix tests."""
+
+    def test_creates_default_manifest(self, tmp_path):
+        """Missing sync-manifest.json is auto-created."""
+        home = tmp_path / ".skcapstone"
+        sync_dir = home / "sync"
+        sync_dir.mkdir(parents=True)
+
+        doctor = SelfHealingDoctor(home)
+        result = doctor._check_sync_manifest()
+
+        assert result["status"] == "fixed"
+        manifest = json.loads((sync_dir / "sync-manifest.json").read_text())
+        assert manifest["version"] == 1
+        assert "syncthing" in manifest["backends"]
+
+    def test_ok_when_present(self, tmp_path):
+        """Returns ok when manifest exists."""
+        home = tmp_path / ".skcapstone"
+        sync_dir = home / "sync"
+        sync_dir.mkdir(parents=True)
+        (sync_dir / "sync-manifest.json").write_text("{}")
+
+        doctor = SelfHealingDoctor(home)
+        result = doctor._check_sync_manifest()
+        assert result["status"] == "ok"
+
+
+class TestConsciousnessHealth:
+    """Consciousness health check tests."""
+
+    def test_ok_when_not_loaded(self, tmp_path):
+        """Returns ok when consciousness is not loaded (disabled)."""
+        home = tmp_path / ".skcapstone"
+        home.mkdir()
+        doctor = SelfHealingDoctor(home, consciousness_loop=None)
+        result = doctor._check_consciousness_health()
+        assert result["status"] == "ok"
+        assert "not loaded" in result["message"]
+
+
+class TestProfileFreshness:
+    """Profile freshness check tests."""
+
+    def test_checks_profile_dates(self, tmp_path):
+        """Profile freshness check doesn't crash."""
+        home = tmp_path / ".skcapstone"
+        home.mkdir()
+        doctor = SelfHealingDoctor(home)
+        result = doctor._check_profile_freshness()
+        assert result["status"] == "ok"
+
+
+class TestDiagnoseAndHeal:
+    """Full diagnose-and-heal pipeline tests."""
+
+    def test_full_pipeline(self, tmp_path):
+        """Full pipeline runs all checks and returns report."""
+        home = tmp_path / ".skcapstone"
+        home.mkdir()
+
+        doctor = SelfHealingDoctor(home)
+        report = doctor.diagnose_and_heal()
+
+        assert "checks_run" in report
+        assert "checks_passed" in report
+        assert "auto_fixed" in report
+        assert "still_broken" in report
+        assert report["checks_run"] > 0
+        assert isinstance(report["details"], list)
+
+    def test_all_ok_when_healthy(self, tmp_path):
+        """Healthy home returns all checks passed."""
+        home = tmp_path / ".skcapstone"
+        for subdir in ("identity", "memory", "trust", "security", "sync", "config", "soul", "logs"):
+            (home / subdir).mkdir(parents=True)
+        (home / "memory" / "index.json").write_text("[]")
+        (home / "sync" / "sync-manifest.json").write_text("{}")
+
+        doctor = SelfHealingDoctor(home)
+        report = doctor.diagnose_and_heal()
+
+        assert report["still_broken"] == 0
+        assert report["checks_passed"] == report["checks_run"]
+
+    def test_last_report_saved(self, tmp_path):
+        """Last report is accessible after running."""
+        home = tmp_path / ".skcapstone"
+        home.mkdir()
+        doctor = SelfHealingDoctor(home)
+        doctor.diagnose_and_heal()
+        assert doctor.last_report["checks_run"] > 0

package/tests/test_session_capture.py

@@ -0,0 +1,200 @@
+"""Tests for the session auto-capture module."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from skcapstone.memory_engine import search
+from skcapstone.pillars.memory import initialize_memory
+from skcapstone.session_capture import (
+    CapturedMoment,
+    SessionCapture,
+    _text_overlap,
+)
+
+
+@pytest.fixture
+def capture_home(tmp_agent_home: Path) -> Path:
+    """Provide an agent home with memory initialized."""
+    initialize_memory(tmp_agent_home)
+    return tmp_agent_home
+
+
+class TestMomentExtraction:
+    """Tests for extract_moments()."""
+
+    def test_splits_paragraphs(self, capture_home: Path):
+        """Multiple paragraphs become separate moments."""
+        cap = SessionCapture(capture_home)
+        text = (
+            "We decided to use Ed25519 for all agent keys. "
+            "This gives us small keys and fast verification.\n\n"
+            "The deployment pipeline will use GitHub Actions. "
+            "Each package gets its own workflow file."
+        )
+        moments = cap.extract_moments(text)
+        assert len(moments) >= 2
+
+    def test_short_fragments_merged(self, capture_home: Path):
+        """Very short segments get merged with neighbors."""
+        cap = SessionCapture(capture_home)
+        moments = cap.extract_moments("Yes. No. OK. Sure thing. Got it.")
+        # Reason: these are too short individually, should merge
+        assert len(moments) <= 2
+
+    def test_empty_input(self, capture_home: Path):
+        """Empty input produces no moments."""
+        cap = SessionCapture(capture_home)
+        assert cap.extract_moments("") == []
+        assert cap.extract_moments("   ") == []
+
+    def test_single_long_sentence(self, capture_home: Path):
+        """A single long sentence becomes one moment."""
+        cap = SessionCapture(capture_home)
+        text = (
+            "The sovereign agent framework uses CapAuth PGP keys for identity, "
+            "SKMemory for persistent memory across sessions, and Cloud 9 FEB files "
+            "for trust state rehydration after session resets."
+        )
+        moments = cap.extract_moments(text)
+        assert len(moments) >= 1
+
+
+class TestMomentScoring:
+    """Tests for score_moment()."""
+
+    def test_decision_scores_higher(self, capture_home: Path):
+        """Moments with decision keywords score above baseline."""
+        cap = SessionCapture(capture_home)
+        decision = cap.score_moment("We decided to use PostgreSQL instead of MySQL for the database.")
+        generic = cap.score_moment("The sky is blue and the weather is nice today in the park.")
+
+        assert decision.importance > generic.importance
+
+    def test_architecture_tagged(self, capture_home: Path):
+        """Architecture mentions get tagged and boosted."""
+        cap = SessionCapture(capture_home)
+        moment = cap.score_moment("The architecture uses a plugin-based design pattern for transports.")
+        assert moment.importance > 0.3
+        assert "architecture" in moment.reason
+
+    def test_security_boosted(self, capture_home: Path):
+        """Security-related content gets a boost."""
+        cap = SessionCapture(capture_home)
+        moment = cap.score_moment("PGP encryption protects all messages with GPG keys.")
+        assert moment.importance > 0.4
+        assert "pgp" in moment.tags
+
+    def test_package_auto_tagged(self, capture_home: Path):
+        """Package names are auto-detected as tags."""
+        cap = SessionCapture(capture_home)
+        moment = cap.score_moment("The skcapstone MCP server exposes memory tools.")
+        assert "skcapstone" in moment.tags
+        assert "mcp" in moment.tags
+
+    def test_importance_capped_at_one(self, capture_home: Path):
+        """Importance never exceeds 1.0 even with many signals."""
+        cap = SessionCapture(capture_home)
+        text = (
+            "We decided on a critical security architecture pattern for the "
+            "encrypted PGP GPG API endpoint deployment requiring always-on "
+            "convention-based important rules."
+        )
+        moment = cap.score_moment(text)
+        assert moment.importance <= 1.0
+
+    def test_baseline_score(self, capture_home: Path):
+        """Generic text gets the baseline score."""
+        cap = SessionCapture(capture_home)
+        moment = cap.score_moment("Nothing special about this particular sentence at all here.")
+        assert 0.25 <= moment.importance <= 0.5
+
+
+class TestCapture:
+    """Tests for the full capture() pipeline."""
+
+    def test_stores_memories(self, capture_home: Path):
+        """Captured moments are stored as retrievable memories."""
+        cap = SessionCapture(capture_home)
+        entries = cap.capture(
+            "We decided to use Ed25519 for all sovereign agent identity keys. "
+            "This is a critical architectural decision for the CapAuth system."
+        )
+        assert len(entries) >= 1
+        assert all(e.memory_id for e in entries)
+
+        results = search(capture_home, "Ed25519")
+        assert len(results) >= 1
+
+    def test_tags_applied(self, capture_home: Path):
+        """Extra tags are applied to all captured memories."""
+        cap = SessionCapture(capture_home)
+        entries = cap.capture(
+            "The skcapstone architecture uses five sovereign pillars for agent consciousness.",
+            tags=["meeting", "2026-02-24"],
+        )
+        assert len(entries) >= 1
+        for e in entries:
+            assert "session-capture" in e.tags
+            assert "meeting" in e.tags
+
+    def test_min_importance_filters(self, capture_home: Path):
+        """Moments below min_importance are not stored."""
+        cap = SessionCapture(capture_home)
+        entries = cap.capture(
+            "Nothing important here. Just chatting. The weather is nice.",
+            min_importance=0.9,
+        )
+        assert len(entries) == 0
+
+    def test_source_recorded(self, capture_home: Path):
+        """The source field is set correctly."""
+        cap = SessionCapture(capture_home)
+        entries = cap.capture(
+            "We decided to switch from REST to GraphQL for the agent API.",
+            source="claude-code",
+        )
+        assert len(entries) >= 1
+        assert entries[0].source == "claude-code"
+
+    def test_deduplication(self, capture_home: Path):
+        """Identical content is not captured twice."""
+        cap = SessionCapture(capture_home)
+        text = "The sovereign agent framework requires PGP identity for all operations."
+
+        first = cap.capture(text)
+        second = cap.capture(text)
+
+        assert len(first) >= 1
+        assert len(second) == 0
+
+    def test_empty_content_no_crash(self, capture_home: Path):
+        """Empty content produces no memories and doesn't crash."""
+        cap = SessionCapture(capture_home)
+        assert cap.capture("") == []
+        assert cap.capture("   \n\n  ") == []
+
+
+class TestTextOverlap:
+    """Tests for the Jaccard overlap helper."""
+
+    def test_identical_strings(self):
+        """Identical strings have overlap of 1.0."""
+        assert _text_overlap("hello world", "hello world") == 1.0
+
+    def test_no_overlap(self):
+        """Completely different strings have overlap of 0.0."""
+        assert _text_overlap("alpha beta", "gamma delta") == 0.0
+
+    def test_partial_overlap(self):
+        """Partial overlap returns a value between 0 and 1."""
+        overlap = _text_overlap("the quick brown fox", "the slow brown cat")
+        assert 0.0 < overlap < 1.0
+
+    def test_empty_strings(self):
+        """Empty strings return 0.0."""
+        assert _text_overlap("", "") == 0.0
+        assert _text_overlap("hello", "") == 0.0