socratic-morality 0.0.2b0__tar.gz

socratic_morality-0.0.2b0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anthropic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

socratic_morality-0.0.2b0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: socratic-morality
+Version: 0.0.2b0
+Summary: Constitutional AI Governance Framework - Grounded in Socratic Philosophy
+Author-email: Anthropic <support@anthropic.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Nireus79/Socratic-morality
+Project-URL: Documentation, https://socratic-morality.readthedocs.io
+Project-URL: Repository, https://github.com/Nireus79/Socratic-morality.git
+Project-URL: Issues, https://github.com/Nireus79/Socratic-morality/issues
+Keywords: constitutional-ai,governance,socratic-philosophy,ethical-ai,multi-agent,llm-safety
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: typing-extensions>=4.0
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: storage-sqlite
+Requires-Dist: aiosqlite>=0.19; extra == "storage-sqlite"
+Provides-Extra: storage-postgres
+Requires-Dist: psycopg2>=2.9; extra == "storage-postgres"
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1; extra == "langchain"
+Provides-Extra: autogen
+Requires-Dist: pyautogen>=0.2; extra == "autogen"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.1; extra == "crewai"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=5.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints>=1.0; extra == "docs"
+Dynamic: license-file
+
+# Socratic Morality
+
+**Constitutional AI Governance Framework** - Building trustworthy, accountable multi-agent systems grounded in Socratic philosophy.
+
+> "It is better to suffer injustice than to commit it." — Plato's Gorgias
+
+## Quick Start
+
+```bash
+pip install socratic-morality
+```
+
+```python
+from socratic_morality import Governor
+
+governor = Governor(constitution="constitution.yaml", llm_provider="anthropic")
+decision = await governor.evaluate(
+    action="Access user's private data",
+    purpose="Personalization",
+    actor="recommendation_agent",
+    context={"user_id": "user_123"}
+)
+```
+
+## Documentation
+
+- [API Reference](docs/)
+- [Philosophy Guide](docs/)
+- [Examples](examples/)
+
+## Status
+
+**Phase 1**: Foundation Library Extraction - In Progress
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for details

socratic_morality-0.0.2b0/README.md

@@ -0,0 +1,37 @@
+# Socratic Morality
+
+**Constitutional AI Governance Framework** - Building trustworthy, accountable multi-agent systems grounded in Socratic philosophy.
+
+> "It is better to suffer injustice than to commit it." — Plato's Gorgias
+
+## Quick Start
+
+```bash
+pip install socratic-morality
+```
+
+```python
+from socratic_morality import Governor
+
+governor = Governor(constitution="constitution.yaml", llm_provider="anthropic")
+decision = await governor.evaluate(
+    action="Access user's private data",
+    purpose="Personalization",
+    actor="recommendation_agent",
+    context={"user_id": "user_123"}
+)
+```
+
+## Documentation
+
+- [API Reference](docs/)
+- [Philosophy Guide](docs/)
+- [Examples](examples/)
+
+## Status
+
+**Phase 1**: Foundation Library Extraction - In Progress
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for details

socratic_morality-0.0.2b0/pyproject.toml

@@ -0,0 +1,91 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "socratic-morality"
+version = "0.0.2-beta"
+description = "Constitutional AI Governance Framework - Grounded in Socratic Philosophy"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "Anthropic", email = "support@anthropic.com"}
+]
+keywords = [
+    "constitutional-ai",
+    "governance",
+    "socratic-philosophy",
+    "ethical-ai",
+    "multi-agent",
+    "llm-safety"
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+dependencies = [
+    "pydantic>=2.0",
+    "pyyaml>=6.0",
+    "typing-extensions>=4.0",
+]
+
+[project.optional-dependencies]
+anthropic = ["anthropic>=0.40"]
+openai = ["openai>=1.0"]
+storage-sqlite = ["aiosqlite>=0.19"]
+storage-postgres = ["psycopg2>=2.9"]
+langchain = ["langchain>=0.1"]
+autogen = ["pyautogen>=0.2"]
+crewai = ["crewai>=0.1"]
+
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+    "pytest-cov>=4.0",
+    "black>=23.0",
+    "ruff>=0.1.0",
+    "mypy>=1.0",
+    "pre-commit>=3.0",
+]
+
+docs = [
+    "sphinx>=5.0",
+    "sphinx-rtd-theme>=1.0",
+    "sphinx-autodoc-typehints>=1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Nireus79/Socratic-morality"
+Documentation = "https://socratic-morality.readthedocs.io"
+Repository = "https://github.com/Nireus79/Socratic-morality.git"
+Issues = "https://github.com/Nireus79/Socratic-morality/issues"
+
+[tool.setuptools]
+packages = ["socratic_morality"]
+package-dir = {"" = "src"}
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+addopts = "-v --cov=socratic_morality --cov-report=html --cov-report=term-missing"
+asyncio_mode = "auto"
+
+[tool.coverage.run]
+source = ["src/socratic_morality"]
+
+[tool.black]
+line-length = 100
+target-version = ['py310', 'py311', 'py312']
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"

socratic_morality-0.0.2b0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

socratic_morality-0.0.2b0/src/socratic_morality/__init__.py

@@ -0,0 +1 @@
+"""Socratic Morality - Constitutional AI Governance Framework"""

socratic_morality-0.0.2b0/src/socratic_morality.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: socratic-morality
+Version: 0.0.2b0
+Summary: Constitutional AI Governance Framework - Grounded in Socratic Philosophy
+Author-email: Anthropic <support@anthropic.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Nireus79/Socratic-morality
+Project-URL: Documentation, https://socratic-morality.readthedocs.io
+Project-URL: Repository, https://github.com/Nireus79/Socratic-morality.git
+Project-URL: Issues, https://github.com/Nireus79/Socratic-morality/issues
+Keywords: constitutional-ai,governance,socratic-philosophy,ethical-ai,multi-agent,llm-safety
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: typing-extensions>=4.0
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: storage-sqlite
+Requires-Dist: aiosqlite>=0.19; extra == "storage-sqlite"
+Provides-Extra: storage-postgres
+Requires-Dist: psycopg2>=2.9; extra == "storage-postgres"
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1; extra == "langchain"
+Provides-Extra: autogen
+Requires-Dist: pyautogen>=0.2; extra == "autogen"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.1; extra == "crewai"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=5.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints>=1.0; extra == "docs"
+Dynamic: license-file
+
+# Socratic Morality
+
+**Constitutional AI Governance Framework** - Building trustworthy, accountable multi-agent systems grounded in Socratic philosophy.
+
+> "It is better to suffer injustice than to commit it." — Plato's Gorgias
+
+## Quick Start
+
+```bash
+pip install socratic-morality
+```
+
+```python
+from socratic_morality import Governor
+
+governor = Governor(constitution="constitution.yaml", llm_provider="anthropic")
+decision = await governor.evaluate(
+    action="Access user's private data",
+    purpose="Personalization",
+    actor="recommendation_agent",
+    context={"user_id": "user_123"}
+)
+```
+
+## Documentation
+
+- [API Reference](docs/)
+- [Philosophy Guide](docs/)
+- [Examples](examples/)
+
+## Status
+
+**Phase 1**: Foundation Library Extraction - In Progress
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for details

socratic_morality-0.0.2b0/src/socratic_morality.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/socratic_morality/__init__.py
+src/socratic_morality.egg-info/PKG-INFO
+src/socratic_morality.egg-info/SOURCES.txt
+src/socratic_morality.egg-info/dependency_links.txt
+src/socratic_morality.egg-info/requires.txt
+src/socratic_morality.egg-info/top_level.txt
+tests/test_adapters.py
+tests/test_constitution.py
+tests/test_deliberation.py
+tests/test_governor.py
+tests/test_precedent.py
+tests/test_storage.py

socratic_morality-0.0.2b0/src/socratic_morality.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

socratic_morality-0.0.2b0/src/socratic_morality.egg-info/requires.txt

@@ -0,0 +1,38 @@
+pydantic>=2.0
+pyyaml>=6.0
+typing-extensions>=4.0
+
+[anthropic]
+anthropic>=0.40
+
+[autogen]
+pyautogen>=0.2
+
+[crewai]
+crewai>=0.1
+
+[dev]
+pytest>=7.0
+pytest-asyncio>=0.21
+pytest-cov>=4.0
+black>=23.0
+ruff>=0.1.0
+mypy>=1.0
+pre-commit>=3.0
+
+[docs]
+sphinx>=5.0
+sphinx-rtd-theme>=1.0
+sphinx-autodoc-typehints>=1.0
+
+[langchain]
+langchain>=0.1
+
+[openai]
+openai>=1.0
+
+[storage-postgres]
+psycopg2>=2.9
+
+[storage-sqlite]
+aiosqlite>=0.19

socratic_morality-0.0.2b0/src/socratic_morality.egg-info/top_level.txt

@@ -0,0 +1 @@
+socratic_morality

socratic_morality-0.0.2b0/tests/test_adapters.py

@@ -0,0 +1,164 @@
+"""Tests for framework adapters."""
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+from socratic_morality.adapters.base import BaseAdapter
+from socratic_morality.adapters.langchain_adapter import LangChainAdapter
+from socratic_morality.adapters.autogen_adapter import AutoGenAdapter
+from socratic_morality.adapters.crewai_adapter import CrewAIAdapter
+from socratic_morality.governor.decision import DecisionType
+
+
+@pytest.fixture
+def mock_governor():
+    """Create a mock Governor."""
+    governor = AsyncMock()
+    governor.evaluate = AsyncMock()
+    return governor
+
+
+@pytest.fixture
+def langchain_adapter(mock_governor):
+    """Create LangChain adapter."""
+    return LangChainAdapter(mock_governor)
+
+
+@pytest.fixture
+def autogen_adapter(mock_governor):
+    """Create AutoGen adapter."""
+    return AutoGenAdapter(mock_governor)
+
+
+@pytest.fixture
+def crewai_adapter(mock_governor):
+    """Create CrewAI adapter."""
+    return CrewAIAdapter(mock_governor)
+
+
+class TestLangChainAdapter:
+    """Tests for LangChain adapter."""
+
+    @pytest.mark.asyncio
+    async def test_langchain_wrap_agent(self, langchain_adapter, mock_governor):
+        """Test wrapping a LangChain agent."""
+        mock_agent = MagicMock()
+        mock_agent.name = "test_agent"
+        mock_agent.invoke = MagicMock(return_value="result")
+
+        mock_decision = MagicMock()
+        mock_decision.allowed = True
+        mock_decision.decision_type = DecisionType.ALLOW
+        mock_decision.reasoning = "Action allowed"
+        mock_decision.violations = []
+        mock_decision.requires_escalation = MagicMock(return_value=False)
+
+        mock_governor.evaluate.return_value = mock_decision
+
+        wrapped_agent = await langchain_adapter.wrap_agent(mock_agent)
+        assert hasattr(wrapped_agent, 'governed_invoke')
+
+    @pytest.mark.asyncio
+    async def test_langchain_intercept_allowed(
+        self, langchain_adapter, mock_governor
+    ):
+        """Test intercepting an allowed action."""
+        mock_decision = MagicMock()
+        mock_decision.allowed = True
+        mock_decision.decision_type = DecisionType.ALLOW
+        mock_decision.reasoning = "Action allowed"
+        mock_decision.violations = []
+        mock_decision.requires_escalation = MagicMock(return_value=False)
+
+        mock_governor.evaluate.return_value = mock_decision
+
+        result = await langchain_adapter.intercept_action(
+            action="test action",
+            agent_name="test_agent"
+        )
+
+        assert result['allowed'] is True
+        assert result['decision_type'] == DecisionType.ALLOW
+
+
+class TestAutoGenAdapter:
+    """Tests for AutoGen adapter."""
+
+    @pytest.mark.asyncio
+    async def test_autogen_wrap_agent(self, autogen_adapter, mock_governor):
+        """Test wrapping an AutoGen agent."""
+        mock_agent = MagicMock()
+        mock_agent.name = "autogen_test"
+        mock_agent.generate_reply = AsyncMock(return_value="reply")
+
+        mock_decision = MagicMock()
+        mock_decision.allowed = True
+        mock_decision.decision_type = DecisionType.ALLOW
+        mock_decision.reasoning = "Action allowed"
+        mock_decision.violations = []
+        mock_decision.requires_escalation = MagicMock(return_value=False)
+
+        mock_governor.evaluate.return_value = mock_decision
+
+        wrapped_agent = await autogen_adapter.wrap_agent(mock_agent)
+        assert hasattr(wrapped_agent, 'governed_generate_reply')
+
+    @pytest.mark.asyncio
+    async def test_autogen_intercept(self, autogen_adapter, mock_governor):
+        """Test intercepting an AutoGen action."""
+        mock_decision = MagicMock()
+        mock_decision.allowed = True
+        mock_decision.decision_type = DecisionType.ALLOW
+        mock_decision.reasoning = "Action allowed"
+        mock_decision.violations = []
+        mock_decision.requires_escalation = MagicMock(return_value=False)
+
+        mock_governor.evaluate.return_value = mock_decision
+
+        result = await autogen_adapter.intercept_action(
+            action="reply to message",
+            agent_name="autogen_agent"
+        )
+
+        assert result['allowed'] is True
+
+
+class TestCrewAIAdapter:
+    """Tests for CrewAI adapter."""
+
+    @pytest.mark.asyncio
+    async def test_crewai_wrap_agent(self, crewai_adapter, mock_governor):
+        """Test wrapping a CrewAI agent."""
+        mock_agent = MagicMock()
+        mock_agent.role = "researcher"
+        mock_agent.goal = "Find information"
+        mock_agent.execute_task = AsyncMock(return_value="task result")
+
+        mock_decision = MagicMock()
+        mock_decision.allowed = True
+        mock_decision.decision_type = DecisionType.ALLOW
+        mock_decision.reasoning = "Action allowed"
+        mock_decision.violations = []
+        mock_decision.requires_escalation = MagicMock(return_value=False)
+
+        mock_governor.evaluate.return_value = mock_decision
+
+        wrapped_agent = await crewai_adapter.wrap_agent(mock_agent)
+        assert hasattr(wrapped_agent, 'governed_execute_task')
+
+    @pytest.mark.asyncio
+    async def test_crewai_intercept(self, crewai_adapter, mock_governor):
+        """Test intercepting a CrewAI action."""
+        mock_decision = MagicMock()
+        mock_decision.allowed = True
+        mock_decision.decision_type = DecisionType.ALLOW
+        mock_decision.reasoning = "Action allowed"
+        mock_decision.violations = []
+        mock_decision.requires_escalation = MagicMock(return_value=False)
+
+        mock_governor.evaluate.return_value = mock_decision
+
+        result = await crewai_adapter.intercept_action(
+            action="execute research task",
+            agent_name="researcher"
+        )
+
+        assert result['allowed'] is True

socratic_morality-0.0.2b0/tests/test_constitution.py

@@ -0,0 +1,55 @@
+"""Tests for Constitution framework."""
+from socratic_morality.constitution.models import Constitution, Principle, Rule
+
+def test_constitution_from_dict():
+    """Test creating Constitution from dictionary."""
+    data = {
+        'metadata': {'name': 'Test'},
+        'supreme_principle': 'Never do evil',
+        'principles': {
+            'honesty': {
+                'category': 'virtue',
+                'severity': 'critical',
+                'description': 'Always be truthful'
+            }
+        },
+        'rules': [
+            {
+                'name': 'No Lying',
+                'principle': 'honesty',
+                'condition': 'agent tells falsehood',
+                'action': 'block'
+            }
+        ]
+    }
+    
+    constitution = Constitution.from_dict(data)
+    
+    assert constitution.supreme_principle == 'Never do evil'
+    assert 'honesty' in constitution.principles
+    assert len(constitution.rules) == 1
+    assert constitution.rules[0].name == 'No Lying'
+
+def test_principle_creation():
+    """Test Principle dataclass."""
+    principle = Principle(
+        name="honesty",
+        category="virtue",
+        severity="critical",
+        description="Be truthful"
+    )
+    
+    assert principle.name == "honesty"
+    assert principle.severity == "critical"
+
+def test_rule_creation():
+    """Test Rule dataclass."""
+    rule = Rule(
+        name="No Deception",
+        principle="honesty",
+        condition="agent deceives",
+        action="block"
+    )
+    
+    assert rule.name == "No Deception"
+    assert rule.action == "block"

socratic_morality-0.0.2b0/tests/test_deliberation.py

@@ -0,0 +1,91 @@
+"""Comprehensive tests for ethical deliberation engine."""
+import pytest
+from socratic_morality.ethics.deliberation import EthicalDeliberationEngine
+
+
+@pytest.fixture
+def deliberation_engine():
+    """Create ethical deliberation engine."""
+    return EthicalDeliberationEngine(llm_provider="anthropic")
+
+
+class TestKantianAnalysis:
+    """Tests for Kantian ethical analysis."""
+
+    @pytest.mark.asyncio
+    async def test_kantian_allows_honest_action(self, deliberation_engine):
+        """Test that Kantian analysis allows honest actions."""
+        result = await deliberation_engine.analyze(
+            action="provide truthful information",
+            purpose="help user make decision",
+            actor="assistant",
+            context={}
+        )
+        assert result["frameworks"]["kantian"]["allowed"] is True
+
+    @pytest.mark.asyncio
+    async def test_kantian_denies_manipulation(self, deliberation_engine):
+        """Test that Kantian analysis denies manipulation."""
+        result = await deliberation_engine.analyze(
+            action="manipulate user",
+            purpose="achieve goal",
+            actor="assistant",
+            context={}
+        )
+        assert result["frameworks"]["kantian"]["allowed"] is False
+
+
+class TestRightsBasedAnalysis:
+    """Tests for rights-based ethical analysis."""
+
+    @pytest.mark.asyncio
+    async def test_rights_denies_without_consent(self, deliberation_engine):
+        """Test rights-based analysis denies actions without consent."""
+        result = await deliberation_engine.analyze(
+            action="access data without consent",
+            purpose="improve system",
+            actor="assistant",
+            context={}
+        )
+        assert result["frameworks"]["rights_based"]["allowed"] is False
+
+
+class TestSynthesizedAnalysis:
+    """Tests for synthesized multi-framework analysis."""
+
+    @pytest.mark.asyncio
+    async def test_all_frameworks_included(self, deliberation_engine):
+        """Test that all frameworks are analyzed."""
+        result = await deliberation_engine.analyze(
+            action="provide helpful information",
+            purpose="assist user",
+            actor="assistant",
+            context={"user_id": "user123"}
+        )
+
+        assert "kantian" in result["frameworks"]
+        assert "utilitarian" in result["frameworks"]
+        assert "virtue_ethics" in result["frameworks"]
+        assert "rights_based" in result["frameworks"]
+
+    @pytest.mark.asyncio
+    async def test_overall_denied_when_any_denies(self, deliberation_engine):
+        """Test overall decision is denied when any framework denies."""
+        result = await deliberation_engine.analyze(
+            action="manipulate user without consent",
+            purpose="achieve goal",
+            actor="assistant",
+            context={}
+        )
+        assert result["allowed"] is False
+
+    @pytest.mark.asyncio
+    async def test_confidence_property(self, deliberation_engine):
+        """Test confidence is calculated across frameworks."""
+        result = await deliberation_engine.analyze(
+            action="process data",
+            purpose="assist",
+            actor="assistant",
+            context={}
+        )
+        assert 0 <= result["confidence"] <= 1.0

socratic_morality-0.0.2b0/tests/test_governor.py

@@ -0,0 +1,51 @@
+"""Tests for Governor class."""
+import pytest
+from socratic_morality.governor.core import Governor
+from socratic_morality.constitution.models import Constitution
+
+@pytest.mark.asyncio
+async def test_governor_creation():
+    """Test Governor can be created with a dict constitution."""
+    constitution = {
+        'metadata': {'name': 'Test Constitution'},
+        'supreme_principle': 'Test principle',
+        'principles': {},
+        'rules': []
+    }
+    gov = Governor(constitution=constitution)
+    assert gov.llm_provider == "anthropic"
+    assert gov.constitution is not None
+
+@pytest.mark.asyncio
+async def test_governor_evaluate():
+    """Test Governor.evaluate() returns a decision."""
+    constitution = {
+        'metadata': {'name': 'Test'},
+        'principles': {},
+        'rules': []
+    }
+    gov = Governor(constitution=constitution)
+    
+    decision = await gov.evaluate(
+        action="Test action",
+        purpose="Testing",
+        actor="test_agent",
+        context={'user_id': 'user_123'}
+    )
+    
+    assert decision is not None
+    assert decision.action == "Test action"
+    assert decision.allowed == True
+    assert decision.decision_id.startswith("decision_")
+
+@pytest.mark.asyncio
+async def test_governor_tracking():
+    """Test Governor tracks decisions."""
+    constitution = {'metadata': {}, 'principles': {}, 'rules': []}
+    gov = Governor(constitution=constitution)
+    
+    decision1 = await gov.evaluate(action="Action 1")
+    decision2 = await gov.evaluate(action="Action 2")
+    
+    assert decision1.decision_id == "decision_1"
+    assert decision2.decision_id == "decision_2"

socratic_morality-0.0.2b0/tests/test_precedent.py

@@ -0,0 +1,197 @@
+"""Comprehensive tests for moral precedent engine."""
+import pytest
+from socratic_morality.precedent.engine import MoralPrecedentEngine
+
+
+@pytest.fixture
+async def precedent_engine():
+    """Create moral precedent engine."""
+    return MoralPrecedentEngine(storage_type="memory")
+
+
+class TestPrecedentStorage:
+    """Tests for precedent case storage."""
+
+    @pytest.mark.asyncio
+    async def test_store_case(self, precedent_engine):
+        """Test storing a precedent case."""
+        case_id = await precedent_engine.store_case(
+            action="allow user access",
+            decision=type('Decision', (), {
+                'decision_type': 'ALLOW',
+                'allowed': True,
+                'context': {'user_id': 'user1'},
+                'high_impact': False,
+                'actor': 'system'
+            })(),
+            reasoning="User authenticated and authorized",
+            principles_cited=["transparency", "autonomy"],
+            stakeholders_affected=["user"]
+        )
+
+        assert case_id is not None
+        assert case_id.startswith("case_")
+
+    @pytest.mark.asyncio
+    async def test_retrieve_case(self, precedent_engine):
+        """Test retrieving a stored case."""
+        case_id = await precedent_engine.store_case(
+            action="test action",
+            decision=type('Decision', (), {
+                'decision_type': 'ALLOW',
+                'allowed': True,
+                'context': {},
+                'high_impact': False,
+                'actor': 'test_actor'
+            })(),
+            reasoning="test reasoning",
+            principles_cited=["test_principle"]
+        )
+
+        case = await precedent_engine.get_case(case_id)
+        assert case is not None
+        assert case["action"] == "test action"
+        assert case["reasoning"] == "test reasoning"
+
+    @pytest.mark.asyncio
+    async def test_store_multiple_cases(self, precedent_engine):
+        """Test storing multiple cases."""
+        for i in range(5):
+            await precedent_engine.store_case(
+                action=f"action_{i}",
+                decision=type('Decision', (), {
+                    'decision_type': 'ALLOW' if i % 2 == 0 else 'DENY',
+                    'allowed': i % 2 == 0,
+                    'context': {},
+                    'high_impact': False,
+                    'actor': f'actor_{i}'
+                })(),
+                reasoning=f"reasoning_{i}"
+            )
+
+        all_cases = await precedent_engine.get_all_cases()
+        assert len(all_cases) == 5
+
+
+class TestSimilaritySearch:
+    """Tests for case similarity search."""
+
+    @pytest.mark.asyncio
+    async def test_find_similar_cases(self, precedent_engine):
+        """Test finding similar cases."""
+        await precedent_engine.store_case(
+            action="read file from disk",
+            decision=type('Decision', (), {
+                'decision_type': 'ALLOW',
+                'allowed': True,
+                'context': {},
+                'high_impact': False,
+                'actor': 'system'
+            })(),
+            reasoning="Standard read operation"
+        )
+
+        await precedent_engine.store_case(
+            action="read data from database",
+            decision=type('Decision', (), {
+                'decision_type': 'ALLOW',
+                'allowed': True,
+                'context': {},
+                'high_impact': False,
+                'actor': 'system'
+            })(),
+            reasoning="Database query"
+        )
+
+        similar = await precedent_engine.find_similar_cases("read file")
+        assert len(similar) > 0
+
+    @pytest.mark.asyncio
+    async def test_similarity_scoring(self, precedent_engine):
+        """Test that similarity scores are calculated."""
+        await precedent_engine.store_case(
+            action="user login with password",
+            decision=type('Decision', (), {
+                'decision_type': 'ALLOW',
+                'allowed': True,
+                'context': {},
+                'high_impact': False,
+                'actor': 'auth'
+            })(),
+            reasoning="Authentication"
+        )
+
+        similar = await precedent_engine.find_similar_cases("user login")
+        assert len(similar) > 0
+        assert "similarity_score" in similar[0]
+        assert 0 <= similar[0]["similarity_score"] <= 1.0
+
+
+class TestPrincipleSearch:
+    """Tests for searching by principle."""
+
+    @pytest.mark.asyncio
+    async def test_search_by_principle(self, precedent_engine):
+        """Test searching cases by principle."""
+        await precedent_engine.store_case(
+            action="grant user access",
+            decision=type('Decision', (), {
+                'decision_type': 'ALLOW',
+                'allowed': True,
+                'context': {},
+                'high_impact': False,
+                'actor': 'system'
+            })(),
+            reasoning="User authorized",
+            principles_cited=["autonomy", "transparency"]
+        )
+
+        autonomy_cases = await precedent_engine.search_by_principle("autonomy")
+        assert len(autonomy_cases) >= 1
+
+
+class TestStatistics:
+    """Tests for precedent statistics."""
+
+    @pytest.mark.asyncio
+    async def test_get_statistics(self, precedent_engine):
+        """Test getting case statistics."""
+        for i in range(3):
+            await precedent_engine.store_case(
+                action=f"action_{i}",
+                decision=type('Decision', (), {
+                    'decision_type': 'ALLOW',
+                    'allowed': True,
+                    'context': {},
+                    'high_impact': False,
+                    'actor': 'system'
+                })(),
+                reasoning="allowed"
+            )
+
+        for i in range(2):
+            await precedent_engine.store_case(
+                action=f"denied_action_{i}",
+                decision=type('Decision', (), {
+                    'decision_type': 'DENY',
+                    'allowed': False,
+                    'context': {},
+                    'high_impact': False,
+                    'actor': 'system'
+                })(),
+                reasoning="denied"
+            )
+
+        stats = await precedent_engine.get_statistics()
+        assert stats["total_cases"] == 5
+        assert stats["allowed_decisions"] == 3
+        assert stats["denied_decisions"] == 2
+        assert stats["decision_rate"] == 0.6
+
+    @pytest.mark.asyncio
+    async def test_statistics_empty_engine(self, precedent_engine):
+        """Test statistics on empty engine."""
+        stats = await precedent_engine.get_statistics()
+        assert stats["total_cases"] == 0
+        assert stats["allowed_decisions"] == 0
+        assert stats["denied_decisions"] == 0

socratic_morality-0.0.2b0/tests/test_storage.py

@@ -0,0 +1,104 @@
+"""Tests for storage backends."""
+import pytest
+import asyncio
+from pathlib import Path
+from socratic_morality.storage.base import StorageBackend
+from socratic_morality.storage.sqlite import SQLiteStorage
+
+
+@pytest.fixture
+async def sqlite_storage(tmp_path):
+    """Create SQLite storage for tests."""
+    db_path = str(tmp_path / "test.db")
+    storage = SQLiteStorage(db_path)
+    await storage._ensure_connected()
+    yield storage
+    await storage.close()
+
+
+class TestSQLiteStorage:
+    """Tests for SQLite storage backend."""
+
+    @pytest.mark.asyncio
+    async def test_store_and_retrieve(self, sqlite_storage):
+        """Test storing and retrieving records."""
+        test_data = {"action": "test_action", "allowed": True}
+        
+        record_id = await sqlite_storage.store("test_key", test_data)
+        assert record_id is not None
+        
+        retrieved = await sqlite_storage.retrieve("test_key")
+        assert retrieved is not None
+        assert retrieved["action"] == "test_action"
+        assert retrieved["allowed"] is True
+
+    @pytest.mark.asyncio
+    async def test_search(self, sqlite_storage):
+        """Test searching records."""
+        await sqlite_storage.store("key1", {"action": "read", "allowed": True})
+        await sqlite_storage.store("key2", {"action": "write", "allowed": False})
+        await sqlite_storage.store("key3", {"action": "read", "allowed": True})
+        
+        results = await sqlite_storage.search({"action": "read"})
+        assert len(results) == 2
+
+    @pytest.mark.asyncio
+    async def test_search_multiple_criteria(self, sqlite_storage):
+        """Test searching with multiple criteria."""
+        await sqlite_storage.store("key1", {"action": "read", "allowed": True})
+        await sqlite_storage.store("key2", {"action": "read", "allowed": False})
+        await sqlite_storage.store("key3", {"action": "write", "allowed": True})
+        
+        results = await sqlite_storage.search({"action": "read", "allowed": True})
+        assert len(results) == 1
+        assert results[0]["action"] == "read"
+
+    @pytest.mark.asyncio
+    async def test_delete(self, sqlite_storage):
+        """Test deleting records."""
+        await sqlite_storage.store("test_key", {"action": "test"})
+        
+        deleted = await sqlite_storage.delete("test_key")
+        assert deleted is True
+        
+        retrieved = await sqlite_storage.retrieve("test_key")
+        assert retrieved is None
+
+    @pytest.mark.asyncio
+    async def test_delete_nonexistent(self, sqlite_storage):
+        """Test deleting nonexistent record."""
+        deleted = await sqlite_storage.delete("nonexistent")
+        assert deleted is False
+
+    @pytest.mark.asyncio
+    async def test_list_all(self, sqlite_storage):
+        """Test listing all records."""
+        await sqlite_storage.store("key1", {"action": "action1"})
+        await sqlite_storage.store("key2", {"action": "action2"})
+        await sqlite_storage.store("key3", {"action": "action3"})
+        
+        all_records = await sqlite_storage.list_all()
+        assert len(all_records) == 3
+
+    @pytest.mark.asyncio
+    async def test_list_all_empty(self, sqlite_storage):
+        """Test listing records when storage is empty."""
+        all_records = await sqlite_storage.list_all()
+        assert len(all_records) == 0
+
+    @pytest.mark.asyncio
+    async def test_concurrent_storage(self, sqlite_storage):
+        """Test concurrent storage operations."""
+        async def store_record(key, data):
+            return await sqlite_storage.store(key, data)
+        
+        tasks = [
+            store_record(f"key_{i}", {"action": f"action_{i}"})
+            for i in range(10)
+        ]
+        
+        results = await asyncio.gather(*tasks)
+        assert len(results) == 10
+        
+        all_records = await sqlite_storage.list_all()
+        assert len(all_records) == 10