# Verify your workspace exists
ls -la /Users/alexarno/materi/domain/

# Check key files are in place
test -f /Users/alexarno/materi/domain.nest.yml && echo "✅ domain.nest.yml found"
test -f /Users/alexarno/materi/domain/sparki/api.sparki.yml && echo "✅ Service definitions found"
test -f /Users/alexarno/materi/domain/sparki/protocol-rules.yml && echo "✅ Protocol rules found"
test -f /Users/alexarno/materi/domain/tests/sparki-test-orchestrator.sh && echo "✅ Test orchestrator found"

✅ domain.nest.yml found
✅ Service definitions found
✅ Protocol rules found
✅ Test orchestrator found

cd /Users/alexarno/materi/domain

# Create workspace structure and clone services
make setup
make assemble ENV=development

# This does:
# ✓ Creates .workspace/ directory with subdirectories
# ✓ Clones API, Relay, Shield services
# ✓ Installs dependencies (go mod, cargo, pip)
# ✓ Initializes databases
# ✓ Generates configuration files

# Using Docker Compose (recommended for quick start)
docker-compose -f docker-compose.unified.yml up -d postgres redis

# Verify they're running
docker ps | grep -E "postgres|redis"

# Expected: Two containers running postgres and redis

cd /Users/alexarno/materi/domain

# Build all services
make build

# Output will show:
# Building manuscript service...
# Building api...
# Building relay...
# Building shield...

# Start all services
make start

# Expected endpoints:
# - API:     http://localhost:8080/health
# - Relay:   http://localhost:8081/health
# - Shield:  http://localhost:8000/health

# Check health endpoints
curl http://localhost:8080/health  # API
curl http://localhost:8081/health  # Relay (may be GET /ready)
curl http://localhost:8000/health  # Shield

# Expected response: {"status":"healthy"} or similar

# Or use the Makefile convenience command
make health

# This will output:
# Service Health Status:
# ├─ API (8080):     ✅ Healthy
# ├─ Relay (8081):   ✅ Healthy
# ├─ Shield (8000):  ✅ Healthy
# └─ Overall:        ✅ All services operational

cd /Users/alexarno/materi/domain

# Run the complete Sparki test orchestrator
./tests/sparki-test-orchestrator.sh all development

# This runs:
# • Unit tests for API, Relay, Shield
# • Integration tests across services
# • Linting and code quality checks
# • Security scanning
# • Complete protocol validation

# Unit tests only (fast, ~5 min)
./tests/sparki-test-orchestrator.sh unit development

# Integration tests only (~10 min)
./tests/sparki-test-orchestrator.sh integration development

# Quality checks (linting, security)
./tests/sparki-test-orchestrator.sh quality development

cd /Users/alexarno/materi/domain

# API service tests (Go)
cd .workspace/api && make test

# Relay service tests (Rust)
cd .workspace/relay && make test

# Shield service tests (Python)
cd .workspace/shield && python manage.py test

# JSON report (machine-readable)
cat test-reports/test-report-*.json | jq .

# Text output (human-readable)
cat test-reports/orchestrator.log

# Quick summary
ls -lh test-reports/

# API metrics (port 9090)
curl http://localhost:9090/metrics | head -20

# Relay metrics (port 9092)
curl http://localhost:9092/metrics | head -20

# Shield metrics (port 9091)
curl http://localhost:9091/metrics | head -20

# Count total HTTP requests across all services
curl -s http://localhost:9090/metrics | grep 'http_requests_total'

# Check database connection pool usage
curl -s http://localhost:9090/metrics | grep 'database_connections'

# Monitor WebSocket connections (Relay)
curl -s http://localhost:9092/metrics | grep 'websocket_connections'

# JWT validation metrics (Shield)
curl -s http://localhost:9091/metrics | grep 'jwt_validations'

# Access Grafana dashboard
open http://localhost:3000

# Default credentials: admin/admin
# Add Prometheus data source: http://localhost:9090
# Import pre-built dashboards or create custom ones

# API Service (Go/Fiber)
cat /Users/alexarno/materi/domain/sparki/api.sparki.yml

# Relay Service (Rust/Axum)
cat /Users/alexarno/materi/domain/sparki/relay.sparki.yml

# Shield Service (Python/Django)
cat /Users/alexarno/materi/domain/sparki/shield.sparki.yml

# Sparki validates that all .sparki.yml files are correct
# Manual validation:

# Check YAML syntax
yamllint /Users/alexarno/materi/domain/sparki/*.sparki.yml

# Verify all required fields present
cd /Users/alexarno/materi && python -c "
import yaml
for service in ['api', 'relay', 'shield']:
    with open(f'domain/sparki/{service}.sparki.yml') as f:
        config = yaml.safe_load(f)
        print(f'{service}: ports={list(config[\"service\"][\"ports\"].keys())}, health={config[\"service\"].get(\"health_check\")}')"

# View all protocol rules
cat /Users/alexarno/materi/domain/sparki/protocol-rules.yml

cd /Users/alexarno/materi/domain

# Run protocol validation tests
./tests/sparki-test-orchestrator.sh quality development

# This validates:
# ✓ HTTP status codes match spec
# ✓ JWT tokens use correct algorithm
# ✓ WebSocket connections work correctly
# ✓ Redis event publishing works
# ✓ Rate limiting is enforced

cd /Users/alexarno/materi/domain

# Trigger the staging deployment pipeline
# (This would be done via GitHub Actions in production)

# Or manually:
make build
make test-full  # Comprehensive testing
# Then push changes to trigger CI/CD pipeline
git push origin main

# 1. Check service health
make health

# 2. View service logs
make logs-api    # API logs
make logs-relay  # Relay logs
make logs-shield # Shield logs

# 3. Check metrics for anomalies
curl http://localhost:9090/metrics | grep error

# 4. Inspect database state
make db-shell    # Connect to PostgreSQL

# 5. Monitor Redis events
make redis-shell
> XREAD STREAMS materi:events:documents $ BLOCK 5000

cd /Users/alexarno/materi/domain

# Run comprehensive CI pipeline
make ci

# This runs (in order):
# 1. Build all services
# 2. Run all tests
# 3. Run linting checks
# 4. Run security scanning
# 5. Generate reports

# View results
cat test-reports/ci-report.json

# 1. Check if ports are already in use
lsof -i :8080  # API port
lsof -i :8081  # Relay port
lsof -i :8000  # Shield port

# 2. If ports are in use, either:
#    a) Kill the process: kill -9 <PID>
#    b) Change ports in .sparki.yml files

# 3. Check if PostgreSQL/Redis are running
docker ps | grep -E "postgres|redis"

# 4. If not running:
docker-compose -f docker-compose.unified.yml up -d postgres redis

# 1. Check service health first
make health

# 2. View detailed test logs
cat test-reports/orchestrator.log | tail -100

# 3. Run single service tests for debugging
cd .workspace/api && make test-verbose

# 4. Check environment variables
env | grep -E "DATABASE_URL|REDIS_URL|JWT_SECRET"

# 5. Reset database and retry
make db-reset
make assemble
make test

# 1. Verify services are running
make health

# 2. Check metrics endpoints directly
curl -v http://localhost:9090/metrics

# 3. If curl fails, service might not be ready
# Wait 5 seconds and retry

# 4. Check service logs for errors
make logs-api | grep -i "metric\|prometheus"

# 1. Verify JWT_SECRET is set
echo $JWT_SECRET

# 2. If not set:
export JWT_SECRET=$(openssl rand -base64 32)

# 3. Regenerate tokens in Shield
cd .workspace/shield && python manage.py generate_test_token

# 4. Restart services
make restart

# View current configuration
cat /Users/alexarno/materi/domain/sparki/api.sparki.yml | grep -A 10 "performance:"

# Common tunings:
# - Max connections: Increase for high load
# - Request timeout: Increase for slow operations
# - Cache TTL: Balance between memory and freshness

# WebSocket connection limits
cat /Users/alexarno/materi/domain/sparki/relay.sparki.yml | grep -A 5 "websocket:"

# For high-concurrency scenarios:
# - Increase max_connections_per_client
# - Increase total_max_connections
# - Tune message_buffer_size

# Authentication performance
cat /Users/alexarno/materi/domain/sparki/shield.sparki.yml | grep -A 10 "performance:"

# For high auth load:
# - Increase token cache TTL
# - Increase cache size
# - Tune database connection pool

# 1. API service receives request
curl -X POST http://localhost:8080/api/v1/documents \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"title":"New Doc","content":"..."}'

# 2. API validates JWT with Shield
# (Shield runs on :8000)

# 3. API publishes event to Redis Streams
# (Redis runs via docker-compose)

# 4. Relay consumes event and broadcasts to WebSocket clients
# (Relay runs on :8081)

# 5. All services export metrics
# (Metrics on :9090, :9091, :9092)

# 6. Metrics sent to Storm via Folio adapter
# (Folio adapter configured in monitoring/folio-sparki.yml)

cd /Users/alexarno/materi/domain
make health  # Verify services
make test    # Run tests
make logs    # Monitor operations