socrates-ai 0.2.0__py3-none-any.whl

app/__init__.py

@@ -0,0 +1,6 @@
+"""
+Socrates2 Application Package
+Phase 1: Infrastructure Foundation
+"""
+
+__version__ = "0.1.0"

app/main.py

@@ -0,0 +1,292 @@
+"""
+Main FastAPI application.
+
+Socrates2 - AI-Powered Specification Assistant
+Phase 7.0+: Pluggifiable Domain Architecture (COMPLETE)
+Phase 7.2: Domain API Integration (IN PROGRESS)
+"""
+import logging
+from contextlib import asynccontextmanager
+from typing import Callable, Optional
+
+from fastapi import FastAPI
+from fastapi.exceptions import RequestValidationError
+from fastapi.middleware.cors import CORSMiddleware
+from starlette.exceptions import HTTPException
+
+from .api import (
+    admin,
+    analytics,
+    auth,
+    billing,
+    code_generation,
+    collaboration,
+    conflicts,
+    documents,
+    domains,
+    export,
+    export_endpoints,
+    github_endpoints,
+    insights,
+    jobs,
+    llm_endpoints,
+    notifications,
+    projects,
+    quality,
+    resources,
+    search,
+    sessions,
+    teams,
+    templates,
+    workflows,
+)
+from .api.error_handlers import (
+    general_exception_handler,
+    http_exception_handler,
+    validation_error_handler,
+)
+from .core.action_logger import initialize_action_logger
+from .core.config import settings
+from .core.database import close_db_connections
+from .core.sentry_config import init_sentry
+
+# Configure logging
+logging.basicConfig(
+    level=getattr(logging, settings.LOG_LEVEL),
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def _register_default_agents():
+    """
+    Register all agents with the orchestrator.
+    This is the default startup behavior.
+    """
+    from .agents.orchestrator import initialize_default_agents
+    initialize_default_agents()
+    logger.info("AgentOrchestrator initialized with default agents")
+
+
+def _initialize_job_scheduler():
+    """
+    Initialize the background job scheduler.
+    Registers all scheduled tasks.
+    """
+    from .jobs import aggregate_daily_analytics, cleanup_old_sessions
+    from .services.job_scheduler import get_scheduler
+
+    scheduler = get_scheduler()
+    scheduler.start()
+
+    # Register jobs
+    # Daily analytics aggregation at 2 AM UTC
+    scheduler.add_job(
+        aggregate_daily_analytics,
+        trigger="cron",
+        job_id="daily_analytics_aggregation",
+        name="Daily Analytics Aggregation",
+        hour=2,
+        minute=0,
+        timezone="UTC"
+    )
+
+    # Session cleanup at 3 AM UTC
+    scheduler.add_job(
+        cleanup_old_sessions,
+        trigger="cron",
+        job_id="cleanup_old_sessions",
+        name="Clean Up Old Sessions",
+        hour=3,
+        minute=0,
+        timezone="UTC"
+    )
+
+    logger.info("Background job scheduler initialized with registered jobs")
+
+
+def create_app(register_agents_fn: Optional[Callable] = None) -> FastAPI:
+    """
+    Create FastAPI application with configurable agent registration.
+
+    This allows tests to inject custom agent registration logic without
+    modifying the main app or using mocks/patches.
+
+    Args:
+        register_agents_fn: Optional custom function to register agents.
+                           If None, uses default agent registration.
+
+    Returns:
+        Configured FastAPI application
+    """
+    # Initialize Sentry error tracking before creating the app
+    init_sentry()
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        """
+        Application lifespan context manager.
+        Handles startup and shutdown events.
+        """
+        # Startup
+        logger.info("Starting Socrates2 API...")
+        logger.info(f"Environment: {settings.ENVIRONMENT}")
+        logger.info(f"Debug mode: {settings.DEBUG}")
+
+        # Initialize action logging with configuration
+        initialize_action_logger(
+            enabled=settings.ACTION_LOGGING_ENABLED,
+            log_level=settings.ACTION_LOG_LEVEL
+        )
+        logger.info(f"Action logging: {'ENABLED' if settings.ACTION_LOGGING_ENABLED else 'DISABLED'}")
+
+        # Initialize background job scheduler
+        _initialize_job_scheduler()
+
+        # Initialize orchestrator and register agents
+        if register_agents_fn:
+            # Use injected agent registration function
+            register_agents_fn()
+        else:
+            # Use default agent registration
+            _register_default_agents()
+
+        yield
+
+        # Shutdown
+        logger.info("Shutting down Socrates2 API...")
+
+        # Shutdown job scheduler
+        from .services.job_scheduler import get_scheduler
+        scheduler = get_scheduler()
+        if scheduler.is_running:
+            scheduler.stop()
+            logger.info("Job scheduler stopped")
+
+        close_db_connections()
+        logger.info("Database connections closed")
+
+    # Create FastAPI application
+    app = FastAPI(
+        title="Socrates2 API",
+        description="AI-Powered Specification Assistant",
+        version="0.1.0",
+        lifespan=lifespan,
+        debug=settings.DEBUG
+    )
+
+    # Configure CORS
+    app.add_middleware(
+        CORSMiddleware,  # type: ignore[arg-type]  # Standard FastAPI middleware pattern, type checker limitation
+        allow_origins=settings.cors_origins_list,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include routers
+    app.include_router(auth.router)
+    app.include_router(admin.router)
+    app.include_router(projects.router)
+    app.include_router(sessions.router)
+    app.include_router(conflicts.router)
+    app.include_router(code_generation.router)
+    app.include_router(quality.router)
+    app.include_router(teams.router)
+    app.include_router(export_endpoints.router)
+    app.include_router(llm_endpoints.router)
+    app.include_router(github_endpoints.router)
+    app.include_router(search.router)
+    app.include_router(insights.router)
+    app.include_router(templates.router)
+    app.include_router(resources.router)
+    app.include_router(jobs.router)
+    app.include_router(billing.router)
+    app.include_router(documents.router)
+    app.include_router(notifications.router)
+    app.include_router(export.router)
+    app.include_router(collaboration.router)
+    app.include_router(domains.router)
+    app.include_router(workflows.router)
+    app.include_router(analytics.router)
+
+    # Register exception handlers for error tracking and proper response formatting
+    app.add_exception_handler(HTTPException, http_exception_handler)
+    app.add_exception_handler(RequestValidationError, validation_error_handler)
+    app.add_exception_handler(Exception, general_exception_handler)
+
+    return app
+
+
+# Create default app instance (used by uvicorn in production)
+app = create_app()
+
+
+@app.get("/")
+def root():
+    """
+    Root endpoint.
+
+    Returns:
+        Welcome message with API info
+    """
+    return {
+        "message": "Socrates2 API",
+        "version": "0.1.0",
+        "phase": "Phase 7.4 - Advanced Analytics System",
+        "domains_infrastructure": "Phase 7.0 (Complete - 197 tests passing)",
+        "domains_api": "Phase 7.2 (Complete)",
+        "workflows": "Phase 7.3 (Complete - 29 tests passing)",
+        "analytics": "Phase 7.4 (In Development)",
+        "docs": "/docs",
+        "domains_endpoint": "/api/v1/domains",
+        "workflows_endpoint": "/api/v1/workflows",
+        "analytics_endpoint": "/api/v1/analytics",
+        "health": "/api/v1/admin/health"
+    }
+
+
+@app.get("/api/v1/info")
+def api_info():
+    """
+    API information endpoint.
+
+    Returns:
+        Detailed API information
+    """
+    from .agents.orchestrator import get_orchestrator
+
+    orchestrator = get_orchestrator()
+    agent_info = orchestrator.get_all_agents()
+
+    return {
+        "api": {
+            "title": "Socrates2 API",
+            "version": "0.1.0",
+            "environment": settings.ENVIRONMENT,
+            "phase": "Phase 7.4 - Advanced Analytics System",
+            "domains": {
+                "infrastructure": "Phase 7.0 (COMPLETE - 197 tests)",
+                "api_integration": "Phase 7.2 (COMPLETE)",
+                "workflows": "Phase 7.3 (COMPLETE - 29 tests)",
+                "analytics": "Phase 7.4 (IN PROGRESS)",
+                "total_tests": "226 passing"
+            }
+        },
+        "agents": {
+            "total": len(agent_info),
+            "registered": [agent['agent_id'] for agent in agent_info]
+        }
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(
+        "app.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=settings.DEBUG,
+        log_level=settings.LOG_LEVEL.lower()
+    )

socrates_ai-0.2.0.dist-info/METADATA

@@ -0,0 +1,605 @@
+Metadata-Version: 2.4
+Name: socrates-ai
+Version: 0.2.0
+Summary: AI-Powered Specification Assistant using Socratic Method
+Author-email: Socrates2 Team <info@socrates2.io>
+License: MIT
+Project-URL: Homepage, https://github.com/socrates2/socrates2
+Project-URL: Documentation, https://github.com/socrates2/socrates2/blob/main/backend/README.md
+Project-URL: Repository, https://github.com/socrates2/socrates2
+Project-URL: Issues, https://github.com/socrates2/socrates2/issues
+Project-URL: Changelog, https://github.com/socrates2/socrates2/blob/main/backend/CHANGELOG.md
+Keywords: ai,specifications,assistant,socratic-method,multi-domain,workflows,analytics
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Office/Business
+Classifier: Framework :: FastAPI
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi==0.121.0
+Requires-Dist: uvicorn[standard]==0.34.0
+Requires-Dist: sqlalchemy==2.0.44
+Requires-Dist: alembic==1.14.0
+Requires-Dist: psycopg2-binary==2.9.10
+Requires-Dist: pydantic==2.12.3
+Requires-Dist: pydantic-settings==2.7.0
+Requires-Dist: python-dotenv==1.0.1
+Requires-Dist: passlib[bcrypt]==1.7.4
+Requires-Dist: python-jose[cryptography]==3.3.0
+Requires-Dist: python-multipart==0.0.20
+Requires-Dist: anthropic==0.43.0
+Requires-Dist: click==8.1.7
+Requires-Dist: httpx==0.28.1
+Provides-Extra: dev
+Requires-Dist: pytest==8.3.4; extra == "dev"
+Requires-Dist: pytest-asyncio==0.25.0; extra == "dev"
+Requires-Dist: pytest-cov==6.0.0; extra == "dev"
+Requires-Dist: pytest-mock==3.14.0; extra == "dev"
+Requires-Dist: black==24.10.0; extra == "dev"
+Requires-Dist: ruff==0.8.4; extra == "dev"
+Requires-Dist: mypy==1.13.0; extra == "dev"
+Requires-Dist: faker==33.1.0; extra == "dev"
+Requires-Dist: factory-boy==3.3.1; extra == "dev"
+
+# Socrates2 Backend
+
+AI-Powered Specification Assistant using Socratic Method
+
+**Current Version:** 0.1.0
+**Status:** Phase 7.4 - Advanced Analytics & Multi-Domain Workflows
+**Build Status:** 274 tests passing ✅
+
+## Overview
+
+Socrates2 is a comprehensive AI system for building and validating specifications across multiple knowledge domains using the Socratic method. It provides:
+
+- **Multi-Domain System:** 7 pre-configured domains (Programming, Data Engineering, Architecture, Testing, Business, Security, DevOps)
+- **Workflow Management:** Orchestrate specifications across multiple domains with unified validation
+- **Analytics Engine:** Track domain usage, workflow quality, and system health
+- **REST API:** Complete API for programmatic access to all features
+- **CLI Interface:** Command-line tools for domain and workflow management
+- **Template Engine:** Customizable question, export, rule, and analyzer engines
+
+## Quick Start
+
+### Installation
+
+```bash
+cd backend
+
+# Install in editable mode (recommended for development)
+pip install -e ".[dev]"
+
+# Or production installation
+pip install -e .
+```
+
+### Configuration
+
+```bash
+# Copy environment template
+cp .env.example .env
+
+# Edit with your settings
+export ANTHROPIC_API_KEY="your-key-here"
+export SECRET_KEY=$(python -c "import secrets; print(secrets.token_urlsafe(32))")
+```
+
+### Setup Database
+
+```bash
+# Run migrations
+alembic upgrade head
+
+# Verify setup
+pytest tests/ -v --tb=short
+```
+
+### Run Server
+
+```bash
+# Development server with auto-reload
+python -m uvicorn app.main:app --reload
+
+# Access API docs: http://localhost:8000/docs
+# Access ReDoc: http://localhost:8000/redoc
+```
+
+## Key Features
+
+### 1. Multi-Domain System
+
+Seven pre-configured domains with complete question sets, exporters, conflict rules, and quality analyzers:
+
+- **Programming** - Language design, patterns, frameworks
+- **Data Engineering** - Data pipelines, databases, ETL
+- **Architecture** - System design, scalability, performance
+- **Testing** - Test strategy, coverage, automation
+- **Business** - Market analysis, GTM, financials
+- **Security** - Compliance, encryption, threats
+- **DevOps** - Infrastructure, automation, monitoring
+
+```bash
+# List all available domains
+socrates domains list
+
+# Get details about a domain
+socrates domains info programming
+
+# Get all questions in a domain
+socrates domains questions data_engineering
+
+# Get exporters for a domain
+socrates domains exporters architecture
+```
+
+### 2. REST API
+
+Complete API with 40+ endpoints organized by resource:
+
+#### Domains
+```bash
+# List all domains
+curl http://localhost:8000/api/v1/domains
+
+# Get domain details
+curl http://localhost:8000/api/v1/domains/programming
+
+# Get domain questions
+curl http://localhost:8000/api/v1/domains/programming/questions
+
+# Get export formats
+curl http://localhost:8000/api/v1/domains/programming/exporters
+
+# Get validation rules
+curl http://localhost:8000/api/v1/domains/programming/rules
+
+# Validate specification
+curl -X POST http://localhost:8000/api/v1/domains/programming/validate-specification \
+  -H "Content-Type: application/json" \
+  -d '{"field1": "value1", "field2": "value2"}'
+```
+
+#### Workflows
+```bash
+# Create workflow combining multiple domains
+curl -X POST http://localhost:8000/api/v1/workflows?workflow_id=my_project
+
+# Add domain to workflow
+curl -X POST http://localhost:8000/api/v1/workflows/my_project/add-domain \
+  -d '{"domain_id": "programming"}'
+
+# Validate workflow specifications
+curl http://localhost:8000/api/v1/workflows/my_project/validate
+
+# Get cross-domain conflicts
+curl http://localhost:8000/api/v1/workflows/my_project/conflicts
+
+# Export workflow
+curl -X POST http://localhost:8000/api/v1/workflows/my_project/export \
+  -d '{"format_id": "json"}'
+```
+
+#### Analytics
+```bash
+# Get overall analytics report
+curl http://localhost:8000/api/v1/analytics
+
+# Get domain-specific analytics
+curl http://localhost:8000/api/v1/analytics/domains/programming
+
+# Get workflow quality metrics
+curl http://localhost:8000/api/v1/analytics/quality-summary
+
+# Get most used domains
+curl http://localhost:8000/api/v1/analytics/domains/top/10
+
+# Export analytics data
+curl -X POST http://localhost:8000/api/v1/analytics/export?format_id=json
+```
+
+### 3. CLI Interface
+
+Command-line tools for all features:
+
+```bash
+# Domain commands
+socrates domains list                           # List all domains
+socrates domains info <domain_id>              # Domain details
+socrates domains questions <domain_id>         # Get questions
+socrates domains exporters <domain_id>         # Get exporters
+
+# Workflow commands
+socrates workflows create <workflow_id>        # Create workflow
+socrates workflows list                        # List workflows
+socrates workflows show <workflow_id>          # Workflow details
+socrates workflows add <workflow_id> <domain>  # Add domain
+socrates workflows validate <workflow_id>      # Validate specs
+socrates workflows export <workflow_id>        # Export workflow
+socrates workflows delete <workflow_id>        # Delete workflow
+
+# Analytics commands
+socrates analytics report                      # Overall report
+socrates analytics quality                     # Quality summary
+socrates analytics domains                     # Domain ranking
+socrates analytics export <format>             # Export data
+
+# Auth commands
+socrates auth login                            # User login
+socrates auth logout                           # User logout
+socrates auth token --generate                 # Generate API token
+```
+
+## Project Structure
+
+```
+backend/
+├── app/                          # Main application package
+│   ├── api/                      # FastAPI endpoints (40+ routes)
+│   │   ├── domains.py           # Domain management (11 endpoints)
+│   │   ├── workflows.py         # Workflow management (11 endpoints)
+│   │   ├── analytics.py         # Analytics reporting (8 endpoints)
+│   │   ├── auth.py              # Authentication
+│   │   ├── admin.py             # Admin endpoints
+│   │   └── ...                  # Other endpoints
+│   │
+│   ├── domains/                  # Multi-domain system
+│   │   ├── base.py              # BaseDomain abstract class
+│   │   ├── registry.py          # DomainRegistry singleton
+│   │   ├── programming/         # Programming domain (14 Q's, 8 exports)
+│   │   ├── data_engineering/    # Data Engineering domain
+│   │   ├── architecture/        # Architecture domain
+│   │   ├── testing/             # Testing domain
+│   │   ├── business/            # Business domain
+│   │   ├── security/            # Security domain
+│   │   ├── devops/              # DevOps domain
+│   │   ├── questions.py         # Question template engine
+│   │   ├── exporters.py         # Export format engine
+│   │   ├── rules.py             # Conflict rule engine
+│   │   ├── analyzers.py         # Quality analyzer engine
+│   │   ├── workflows.py         # Multi-domain workflow orchestration
+│   │   ├── analytics.py         # Domain analytics tracking
+│   │   └── tests/               # Domain tests (80+ tests)
+│   │
+│   ├── cli/                      # CLI interface
+│   │   ├── main.py              # CLI entry point
+│   │   ├── commands/
+│   │   │   ├── domains.py       # Domain commands
+│   │   │   ├── workflows.py     # Workflow commands
+│   │   │   ├── analytics.py     # Analytics commands
+│   │   │   └── auth.py          # Auth commands
+│   │   └── tests.py             # CLI tests (21 tests)
+│   │
+│   ├── core/                     # Core functionality
+│   │   ├── database.py          # SQLAlchemy setup (2 databases)
+│   │   ├── config.py            # Settings management
+│   │   ├── security.py          # JWT auth
+│   │   ├── dependencies.py      # Dependency injection
+│   │   └── ...                  # Other utilities
+│   │
+│   ├── models/                   # SQLAlchemy models
+│   │   ├── base.py              # BaseModel with UUID, timestamps
+│   │   ├── user.py              # User model
+│   │   ├── project.py           # Project model
+│   │   ├── specification.py     # Specification model
+│   │   └── ...                  # Other models
+│   │
+│   ├── agents/                   # Agent system
+│   │   ├── base.py              # BaseAgent abstract class
+│   │   ├── orchestrator.py      # AgentOrchestrator
+│   │   └── ...                  # Specialized agents
+│   │
+│   ├── services/                 # Business logic services
+│   │   └── ...
+│   │
+│   └── main.py                   # FastAPI application factory
+│
+├── tests/                        # Test suite (274+ tests)
+│   ├── test_domains/            # Domain tests
+│   ├── test_workflows.py        # Workflow tests (29 tests)
+│   ├── test_analytics.py        # Analytics tests (27 tests)
+│   ├── test_cli.py              # CLI tests (21 tests)
+│   └── ...                       # Other test files
+│
+├── alembic/                      # Database migrations
+│   └── versions/                 # Migration scripts
+│
+├── pyproject.toml               # Package configuration
+├── requirements.txt             # Production dependencies
+├── requirements-dev.txt         # Development dependencies
+└── README.md                    # This file
+```
+
+## Testing
+
+### Run All Tests
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run all tests with verbose output
+pytest tests/ -v
+
+# Run with coverage report
+pytest tests/ -v --cov=app --cov-report=html
+
+# Run specific test module
+pytest tests/test_workflows.py -v
+
+# Run tests matching pattern
+pytest tests/ -k "workflow" -v
+```
+
+### Test Coverage
+
+- **Domain System:** 80+ tests
+  - 14 domain tests (per-domain functionality)
+  - Question engine tests
+  - Export engine tests
+  - Rule engine tests
+  - Analyzer engine tests
+
+- **Workflows:** 29 tests
+  - Multi-domain workflow creation and validation
+  - Cross-domain conflict detection
+  - Specification export
+
+- **Analytics:** 27 tests
+  - Metrics tracking
+  - Domain analytics
+  - Workflow analytics
+  - Quality summary
+
+- **CLI:** 21 tests
+  - Domain commands
+  - Workflow commands
+  - Analytics commands
+  - Help text
+
+- **Infrastructure:** 100+ tests
+  - Database persistence
+  - Authentication
+  - API endpoints
+  - Agent system
+  - Service integration
+
+**Total: 274+ tests, all passing ✅**
+
+## Development
+
+### Code Quality
+
+```bash
+# Format code with black (100 char line length)
+black app/ tests/
+
+# Lint with ruff
+ruff check app/ tests/
+
+# Type check with mypy
+mypy app/ --explicit-package-bases
+
+# Run all checks
+black app/ && ruff check app/ && mypy app/
+```
+
+### Common Development Tasks
+
+```bash
+# Start development server with auto-reload
+python -m uvicorn app.main:app --reload --port 8000
+
+# Run tests continuously while editing
+pytest-watch tests/
+
+# Create new database migration
+alembic revision --autogenerate -m "description"
+
+# Apply migrations
+alembic upgrade head
+
+# Rollback migration
+alembic downgrade -1
+```
+
+## Configuration
+
+### Environment Variables
+
+Create `.env` file with:
+
+```env
+# Database URLs (PostgreSQL)
+DATABASE_URL_AUTH=postgresql://postgres:password@localhost:5432/socrates_auth
+DATABASE_URL_SPECS=postgresql://postgres:password@localhost:5432/socrates_specs
+
+# Security
+SECRET_KEY=your-secret-key-here
+ALGORITHM=HS256
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+
+# LLM API
+ANTHROPIC_API_KEY=your-api-key-here
+
+# Application
+DEBUG=True
+ENVIRONMENT=development
+LOG_LEVEL=DEBUG
+
+# CORS
+CORS_ORIGINS=http://localhost:3000,http://localhost:5173
+```
+
+### Generate Secret Key
+
+```bash
+python -c "import secrets; print(secrets.token_urlsafe(32))"
+```
+
+## API Documentation
+
+Once the server is running:
+
+- **Swagger UI:** http://localhost:8000/docs
+- **ReDoc:** http://localhost:8000/redoc
+- **OpenAPI JSON:** http://localhost:8000/openapi.json
+
+All endpoints are documented with:
+- Request/response examples
+- Parameter descriptions
+- Error codes and messages
+- Authentication requirements
+
+## Architecture
+
+### Multi-Database Design
+
+**socrates_auth database:**
+- Users table (authentication)
+- Refresh tokens table (JWT management)
+
+**socrates_specs database:**
+- Projects table (specification metadata)
+- Sessions table (conversation history)
+- And future: specifications, questions, conflicts, metrics
+
+### Domain System Architecture
+
+```
+DomainRegistry (singleton)
+    ├── ProgrammingDomain
+    ├── DataEngineeringDomain
+    ├── ArchitectureDomain
+    ├── TestingDomain
+    ├── BusinessDomain
+    ├── SecurityDomain
+    └── DevOpsDomain
+
+Each Domain contains:
+    ├── Questions (via QuestionTemplateEngine)
+    ├── Export Formats (via ExportTemplateEngine)
+    ├── Conflict Rules (via ConflictRuleEngine)
+    └── Quality Analyzers (via QualityAnalyzerEngine)
+```
+
+### Workflow System
+
+```
+WorkflowManager (singleton)
+    └── MultiDomainWorkflow
+        ├── DomainSpec (per domain)
+        ├── CrossDomainConflict detection
+        │   ├── Architecture ↔ Testing
+        │   ├── Performance ↔ Testing
+        │   └── Data ↔ Architecture
+        └── Unified validation & export
+```
+
+### Analytics System
+
+```
+DomainAnalytics (singleton)
+    ├── Domain access tracking
+    ├── Question answer tracking
+    ├── Export generation tracking
+    ├── Conflict detection tracking
+    ├── Workflow analytics
+    ├── Quality metrics
+    └── Custom reporting
+```
+
+## Troubleshooting
+
+### "ModuleNotFoundError: No module named 'app'"
+
+```bash
+cd backend
+pip install -e .
+```
+
+### "Connection refused" on PostgreSQL
+
+```bash
+# Check if PostgreSQL is running
+sudo systemctl status postgresql  # Linux
+# or Services app on Windows
+
+# Start PostgreSQL if stopped
+sudo systemctl start postgresql   # Linux
+
+# Verify databases exist
+psql -U postgres -l | grep socrates
+```
+
+### API returns 404 for domains
+
+```bash
+# Ensure domains are registered
+python -c "from app.domains import get_domain_registry; r = get_domain_registry(); print([d for d in r.list_domain_ids()])"
+
+# Check that domain JSON files exist
+ls -la app/domains/*/domain.json
+```
+
+### Tests fail with "domain not found"
+
+```bash
+# Domain registration might not have happened
+# Delete any .pyc files and restart
+find . -type d -name __pycache__ -exec rm -r {} + 2>/dev/null || true
+
+# Run tests again
+pytest tests/ -v
+```
+
+## Contributing
+
+1. Install in editable mode: `pip install -e ".[dev]"`
+2. Create feature branch: `git checkout -b feature/your-feature`
+3. Make changes
+4. Run tests: `pytest tests/ -v`
+5. Format code: `black app/ tests/`
+6. Commit with descriptive message
+7. Push and create pull request
+
+## Phase Status
+
+- ✅ **Phase 0:** Documentation - Complete
+- ✅ **Phase 1:** Infrastructure - Complete (user/project/session models)
+- ✅ **Phase 2:** Authentication - Complete (JWT, roles)
+- ✅ **Phase 3:** Agents - Complete (BaseAgent, Orchestrator)
+- ✅ **Phase 4:** Core APIs - Complete (domain/project endpoints)
+- ✅ **Phase 5:** Questions & Exporters - Complete (7 domains, 100+ questions)
+- ✅ **Phase 6:** Specification Validation - Complete (conflict rules, quality analyzers)
+- ✅ **Phase 7:** Advanced Features - Complete
+  - ✅ Phase 7.1: Advanced Domains (Business, Security, DevOps)
+  - ✅ Phase 7.2: Template Engines
+  - ✅ Phase 7.3: Multi-Domain Workflows
+  - ✅ Phase 7.4: Analytics System & CLI
+- ⏳ **Phase 8:** Production Hardening
+
+## License
+
+MIT
+
+## Support
+
+For issues, questions, or contributions:
+1. Check existing documentation in `/docs`
+2. Review test files for usage examples
+3. Check API docs at `/docs` endpoint
+4. Create issue with detailed description
+
+---
+
+**Last Updated:** November 11, 2025
+**Maintained by:** Socrates2 Team

socrates_ai-0.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+app/__init__.py,sha256=ZciT_mF8G9Un0rY26noEwUBAJu3Cpe100MfQrhhvf94,96
+app/main.py,sha256=_gpKegnnp_xczDgE7kDfcKg6Tuh6tpRbi0ms92Vyv9E,8437
+socrates_ai-0.2.0.dist-info/METADATA,sha256=dL_YBW5Y1_A0dRhxZJqTA77LIVnlx6Kt4inUnx5ayG0,18514
+socrates_ai-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+socrates_ai-0.2.0.dist-info/entry_points.txt,sha256=BLb5fpQqDTSt6KT3PjBFv8Hv_HhZ1dzZ1Z6VyycjJ6k,42
+socrates_ai-0.2.0.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+socrates_ai-0.2.0.dist-info/RECORD,,

socrates_ai-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

socrates_ai-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+socrates = app.cli:main

socrates_ai-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+app