@almadar/cli 0.3.2 → 0.3.3

package/shells/python-shell/tests/test_tensor_contracts.py

@@ -0,0 +1,168 @@
+"""
+Tensor Contracts Tests
+
+Tests for tensor/contracts.py - Input/output validation.
+"""
+
+import pytest
+import torch
+from orbital_app.tensor.contracts import InputContract, OutputContract
+
+
+class TestInputContract:
+    """Tests for InputContract validation."""
+
+    def test_input_contract_valid(self):
+        """Test valid input passes validation."""
+        contract = InputContract(
+            shape=[4],
+            range=[0.0, 1.0],
+            meaning=["x", "y", "z", "w"],
+        )
+
+        tensor = torch.tensor([0.5, 0.3, 0.7, 0.1])
+        violation = contract.validate(tensor)
+
+        assert violation is None
+
+    def test_input_contract_shape_mismatch(self):
+        """Test shape mismatch detection."""
+        contract = InputContract(
+            shape=[4],
+            range=[0.0, 1.0],
+            meaning=["x", "y", "z", "w"],
+        )
+
+        tensor = torch.tensor([0.5, 0.3, 0.7])  # Wrong shape
+        violation = contract.validate(tensor)
+
+        assert violation is not None
+        assert violation["type"] == "shape_mismatch"
+        assert violation["expected"] == [4]
+        assert violation["received"] == [3]
+
+    def test_input_contract_out_of_range(self):
+        """Test range violation detection."""
+        contract = InputContract(
+            shape=[4],
+            range=[0.0, 1.0],
+            meaning=["x", "y", "z", "w"],
+        )
+
+        tensor = torch.tensor([0.5, 1.5, 0.7, -0.5])  # Values out of range
+        violation = contract.validate(tensor)
+
+        assert violation is not None
+        assert violation["type"] == "out_of_range"
+        assert violation["allowed_range"] == [0.0, 1.0]
+        assert 1 in violation["out_of_range_indices"]
+        assert 3 in violation["out_of_range_indices"]
+
+    def test_input_contract_boundary_values(self):
+        """Test boundary values are valid."""
+        contract = InputContract(
+            shape=[2],
+            range=[0.0, 1.0],
+            meaning=["a", "b"],
+        )
+
+        # Exact boundary values should be valid
+        tensor = torch.tensor([0.0, 1.0])
+        violation = contract.validate(tensor)
+
+        assert violation is None
+
+    def test_input_contract_2d_shape(self):
+        """Test 2D shape validation."""
+        contract = InputContract(
+            shape=[2, 3],
+            range=[-1.0, 1.0],
+            meaning=["row1", "row2"],
+        )
+
+        tensor = torch.zeros(2, 3)
+        violation = contract.validate(tensor)
+
+        assert violation is None
+
+
+class TestOutputContract:
+    """Tests for OutputContract clamping and violation detection."""
+
+    @pytest.fixture
+    def output_contract(self):
+        """Create a test output contract."""
+        return OutputContract(
+            shape=[4],
+            ranges={
+                "0": {"min": -1.0, "max": 1.0, "meaning": "velocity_x"},
+                "1": {"min": -1.0, "max": 1.0, "meaning": "velocity_y"},
+                "2": {"min": 0.0, "max": 2.0, "meaning": "speed"},
+                "3": {"min": 0.0, "max": 1.0, "meaning": "confidence"},
+            },
+        )
+
+    def test_output_contract_clamp(self, output_contract):
+        """Test output clamping to ranges."""
+        tensor = torch.tensor([2.0, -2.0, 5.0, 0.5])
+        clamped = output_contract.clamp(tensor)
+
+        assert clamped[0].item() == 1.0  # clamped from 2.0
+        assert clamped[1].item() == -1.0  # clamped from -2.0
+        assert clamped[2].item() == 2.0  # clamped from 5.0
+        assert clamped[3].item() == 0.5  # unchanged
+
+    def test_output_contract_clamp_preserves_valid(self, output_contract):
+        """Test clamping doesn't change valid values."""
+        tensor = torch.tensor([0.5, -0.5, 1.0, 0.8])
+        clamped = output_contract.clamp(tensor)
+
+        assert torch.allclose(tensor, clamped)
+
+    def test_output_contract_violations(self, output_contract):
+        """Test violation reporting."""
+        tensor = torch.tensor([2.0, 0.5, 5.0, 0.5])
+        violations = output_contract.get_violations(tensor)
+
+        assert len(violations) == 2
+
+        # Check first violation
+        v0 = next(v for v in violations if v["dim"] == 0)
+        assert v0["value"] == 2.0
+        assert v0["min"] == -1.0
+        assert v0["max"] == 1.0
+        assert v0["meaning"] == "velocity_x"
+
+        # Check second violation
+        v2 = next(v for v in violations if v["dim"] == 2)
+        assert v2["value"] == 5.0
+        assert v2["meaning"] == "speed"
+
+    def test_output_contract_no_violations(self, output_contract):
+        """Test no violations for valid output."""
+        tensor = torch.tensor([0.5, -0.5, 1.0, 0.8])
+        violations = output_contract.get_violations(tensor)
+
+        assert len(violations) == 0
+
+    def test_output_contract_boundary_violations(self, output_contract):
+        """Test that exact boundary values are not violations."""
+        tensor = torch.tensor([1.0, -1.0, 2.0, 1.0])
+        violations = output_contract.get_violations(tensor)
+
+        assert len(violations) == 0
+
+    def test_output_contract_missing_meaning(self):
+        """Test violation with missing meaning field."""
+        contract = OutputContract(
+            shape=[2],
+            ranges={
+                "0": {"min": 0.0, "max": 1.0},  # No meaning field
+            },
+        )
+
+        tensor = torch.tensor([2.0, 0.5])
+        violations = contract.get_violations(tensor)
+
+        assert len(violations) == 1
+        assert violations[0]["meaning"] == "dim_0"  # Default meaning

package/shells/python-shell/tests/test_tensor_ops.py

@@ -0,0 +1,260 @@
+"""
+Tensor Operations Tests
+
+Tests for tensor/ops.py - All 28 tensor operators.
+"""
+
+import pytest
+import torch
+from orbital_app.tensor.ops import (
+    # Creation
+    tensor_from,
+    tensor_zeros,
+    tensor_ones,
+    tensor_rand,
+    tensor_randn,
+    # Shape/Indexing
+    tensor_shape,
+    tensor_get,
+    tensor_slice,
+    tensor_reshape,
+    tensor_flatten,
+    # Math
+    tensor_add,
+    tensor_sub,
+    tensor_mul,
+    tensor_div,
+    tensor_matmul,
+    tensor_dot,
+    # Reductions
+    tensor_sum,
+    tensor_mean,
+    tensor_max,
+    tensor_min,
+    tensor_argmax,
+    tensor_norm,
+    # Range
+    tensor_all_in_range,
+    tensor_clamp,
+    tensor_clamp_per_dim,
+    tensor_out_of_range_dims,
+    # Conversion
+    tensor_to_list,
+)
+
+
+class TestTensorCreation:
+    """Tests for tensor creation operations."""
+
+    def test_tensor_from(self):
+        """Test creating tensor from list."""
+        t = tensor_from([1.0, 2.0, 3.0])
+        assert t.shape == (3,)
+        assert t.dtype == torch.float32
+        assert torch.allclose(t, torch.tensor([1.0, 2.0, 3.0]))
+
+    def test_tensor_zeros(self):
+        """Test creating tensor of zeros."""
+        t = tensor_zeros([3, 4])
+        assert t.shape == (3, 4)
+        assert t.sum().item() == 0.0
+
+    def test_tensor_ones(self):
+        """Test creating tensor of ones."""
+        t = tensor_ones([2, 3])
+        assert t.shape == (2, 3)
+        assert t.sum().item() == 6.0
+
+    def test_tensor_rand(self):
+        """Test creating random tensor [0, 1)."""
+        t = tensor_rand([10])
+        assert t.shape == (10,)
+        assert t.min().item() >= 0.0
+        assert t.max().item() < 1.0
+
+    def test_tensor_randn(self):
+        """Test creating random normal tensor."""
+        t = tensor_randn([100])
+        assert t.shape == (100,)
+        # Mean should be approximately 0 for normal distribution
+        assert abs(t.mean().item()) < 0.5
+
+
+class TestTensorShapeIndexing:
+    """Tests for shape and indexing operations."""
+
+    def test_tensor_shape(self):
+        """Test getting tensor shape."""
+        t = tensor_zeros([2, 3, 4])
+        shape = tensor_shape(t)
+        assert shape == [2, 3, 4]
+
+    def test_tensor_get(self):
+        """Test getting element at index."""
+        t = tensor_from([1.0, 2.0, 3.0])
+        assert tensor_get(t, 0) == 1.0
+        assert tensor_get(t, 1) == 2.0
+        assert tensor_get(t, 2) == 3.0
+
+    def test_tensor_slice(self):
+        """Test slicing tensor."""
+        t = tensor_from([1.0, 2.0, 3.0, 4.0, 5.0])
+        sliced = tensor_slice(t, 1, 4)
+        assert sliced.shape == (3,)
+        assert torch.allclose(sliced, torch.tensor([2.0, 3.0, 4.0]))
+
+    def test_tensor_reshape(self):
+        """Test reshaping tensor."""
+        t = tensor_zeros([6])
+        reshaped = tensor_reshape(t, [2, 3])
+        assert reshaped.shape == (2, 3)
+
+    def test_tensor_flatten(self):
+        """Test flattening tensor."""
+        t = tensor_zeros([2, 3, 4])
+        flat = tensor_flatten(t)
+        assert flat.shape == (24,)
+
+
+class TestTensorMath:
+    """Tests for math operations."""
+
+    def test_tensor_add(self):
+        """Test element-wise addition."""
+        a = tensor_from([1.0, 2.0, 3.0])
+        b = tensor_from([4.0, 5.0, 6.0])
+        result = tensor_add(a, b)
+        assert torch.allclose(result, torch.tensor([5.0, 7.0, 9.0]))
+
+    def test_tensor_sub(self):
+        """Test element-wise subtraction."""
+        a = tensor_from([5.0, 5.0, 5.0])
+        b = tensor_from([1.0, 2.0, 3.0])
+        result = tensor_sub(a, b)
+        assert torch.allclose(result, torch.tensor([4.0, 3.0, 2.0]))
+
+    def test_tensor_mul(self):
+        """Test element-wise multiplication."""
+        a = tensor_from([2.0, 3.0, 4.0])
+        b = tensor_from([2.0, 2.0, 2.0])
+        result = tensor_mul(a, b)
+        assert torch.allclose(result, torch.tensor([4.0, 6.0, 8.0]))
+
+    def test_tensor_div(self):
+        """Test element-wise division."""
+        a = tensor_from([4.0, 6.0, 8.0])
+        b = tensor_from([2.0, 2.0, 2.0])
+        result = tensor_div(a, b)
+        assert torch.allclose(result, torch.tensor([2.0, 3.0, 4.0]))
+
+    def test_tensor_matmul(self):
+        """Test matrix multiplication."""
+        a = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
+        b = torch.tensor([[5.0, 6.0], [7.0, 8.0]])
+        result = tensor_matmul(a, b)
+        expected = torch.tensor([[19.0, 22.0], [43.0, 50.0]])
+        assert torch.allclose(result, expected)
+
+    def test_tensor_dot(self):
+        """Test dot product."""
+        a = tensor_from([1.0, 2.0, 3.0])
+        b = tensor_from([4.0, 5.0, 6.0])
+        result = tensor_dot(a, b)
+        assert result == 32.0  # 1*4 + 2*5 + 3*6
+
+
+class TestTensorReductions:
+    """Tests for reduction operations."""
+
+    def test_tensor_sum(self):
+        """Test sum of all elements."""
+        t = tensor_from([1.0, 2.0, 3.0, 4.0])
+        assert tensor_sum(t) == 10.0
+
+    def test_tensor_mean(self):
+        """Test mean of all elements."""
+        t = tensor_from([1.0, 2.0, 3.0, 4.0])
+        assert tensor_mean(t) == 2.5
+
+    def test_tensor_max(self):
+        """Test max element."""
+        t = tensor_from([1.0, 5.0, 3.0, 2.0])
+        assert tensor_max(t) == 5.0
+
+    def test_tensor_min(self):
+        """Test min element."""
+        t = tensor_from([1.0, 5.0, 3.0, 2.0])
+        assert tensor_min(t) == 1.0
+
+    def test_tensor_argmax(self):
+        """Test index of max element."""
+        t = tensor_from([1.0, 5.0, 3.0, 2.0])
+        assert tensor_argmax(t) == 1
+
+    def test_tensor_norm(self):
+        """Test L2 norm."""
+        t = tensor_from([3.0, 4.0])
+        assert tensor_norm(t) == 5.0  # sqrt(9 + 16)
+
+
+class TestTensorRangeValidation:
+    """Tests for range validation operations."""
+
+    def test_tensor_all_in_range_true(self):
+        """Test all elements in range."""
+        t = tensor_from([0.5, 0.6, 0.7])
+        assert tensor_all_in_range(t, [0.0, 1.0]) is True
+
+    def test_tensor_all_in_range_false(self):
+        """Test not all elements in range."""
+        t = tensor_from([0.5, 1.5, 0.7])
+        assert tensor_all_in_range(t, [0.0, 1.0]) is False
+
+    def test_tensor_clamp(self):
+        """Test clamping all elements."""
+        t = tensor_from([-1.0, 0.5, 2.0])
+        result = tensor_clamp(t, 0.0, 1.0)
+        assert torch.allclose(result, torch.tensor([0.0, 0.5, 1.0]))
+
+    def test_tensor_clamp_per_dim(self):
+        """Test per-dimension clamping."""
+        t = tensor_from([2.0, -1.0, 0.5])
+        ranges = {
+            "0": {"min": 0.0, "max": 1.0},
+            "1": {"min": 0.0, "max": 1.0},
+        }
+        result = tensor_clamp_per_dim(t, ranges)
+        assert result[0].item() == 1.0  # clamped from 2.0
+        assert result[1].item() == 0.0  # clamped from -1.0
+        assert result[2].item() == 0.5  # unchanged
+
+    def test_tensor_out_of_range_dims(self):
+        """Test detecting out of range dimensions."""
+        t = tensor_from([2.0, 0.5, -1.0])
+        ranges = {
+            "0": {"min": 0.0, "max": 1.0},
+            "1": {"min": 0.0, "max": 1.0},
+            "2": {"min": 0.0, "max": 1.0},
+        }
+        violations = tensor_out_of_range_dims(t, ranges)
+        assert len(violations) == 2
+        assert violations[0]["dim"] == 0
+        assert violations[0]["value"] == 2.0
+        assert violations[1]["dim"] == 2
+        assert violations[1]["value"] == -1.0
+
+
+class TestTensorConversion:
+    """Tests for conversion operations."""
+
+    def test_tensor_to_list(self):
+        """Test converting tensor to Python list."""
+        t = tensor_from([1.0, 2.0, 3.0])
+        result = tensor_to_list(t)
+        assert result == [1.0, 2.0, 3.0]
+
+    def test_tensor_to_list_2d(self):
+        """Test converting 2D tensor to nested list."""
+        t = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
+        result = tensor_to_list(t)
+        assert result == [[1.0, 2.0], [3.0, 4.0]]

package/shells/typescript-shell/.env.example

@@ -0,0 +1,30 @@
+# ===========================================
+# Orbital TypeScript Shell - Root Environment Variables
+# ===========================================
+# Copy this file to .env and fill in your values
+
+# ------------------------------------------
+# API Configuration
+# ------------------------------------------
+# URL to the backend API (leave empty to use proxy in development)
+VITE_API_URL=
+
+# ------------------------------------------
+# Firebase Client SDK
+# ------------------------------------------
+# Get these from Firebase Console > Project Settings > General
+# Scroll down to "Your apps" and select your web app
+
+VITE_APP_FIREBASE_API_KEY=your-api-key
+VITE_APP_FIREBASE_AUTH_DOMAIN=your-project-id.firebaseapp.com
+VITE_APP_FIREBASE_PROJECT_ID=your-project-id
+VITE_APP_FIREBASE_STORAGE_BUCKET=your-project-id.firebasestorage.app
+VITE_APP_FIREBASE_MESSAGING_SENDER_ID=your-sender-id
+VITE_APP_FIREBASE_APP_ID=your-app-id
+VITE_APP_FIREBASE_MEASUREMENT_ID=G-XXXXXXXXXX
+
+# ------------------------------------------
+# Optional: Feature Flags
+# ------------------------------------------
+# VITE_ENABLE_AI_FEATURES=true
+# VITE_ENABLE_DEBUG_MODE=false

package/shells/typescript-shell/.firebaserc.template

@@ -0,0 +1,14 @@
+{
+  "projects": {
+    "default": "theme-kitchen-sink-project"
+  },
+  "targets": {
+    "theme-kitchen-sink-project": {
+      "hosting": {
+        "theme-kitchen-sink": [
+          "theme-kitchen-sink"
+        ]
+      }
+    }
+  }
+}

package/shells/typescript-shell/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "printWidth": 100
+}

package/shells/typescript-shell/firestore.indexes.json

@@ -0,0 +1,4 @@
+{
+  "indexes": [],
+  "fieldOverrides": []
+}

package/shells/typescript-shell/infra/docker/docker-compose.prod.yml

@@ -0,0 +1,45 @@
+version: '3.8'
+
+# Production Docker Compose
+# Usage: docker-compose -f docker-compose.prod.yml up -d
+# Requires: REGISTRY, TAG, DATABASE_URL, CORS_ORIGIN environment variables
+
+services:
+  client:
+    image: ${REGISTRY}/Theme Kitchen Sink-client:${TAG:-latest}
+    restart: unless-stopped
+    ports:
+      - "80:80"
+    depends_on:
+      - server
+    healthcheck:
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    deploy:
+      resources:
+        limits:
+          cpus: '0.5'
+          memory: 256M
+
+  server:
+    image: ${REGISTRY}/Theme Kitchen Sink-server:${TAG:-latest}
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+      - DATABASE_URL=${DATABASE_URL}
+      - CORS_ORIGIN=${CORS_ORIGIN}
+    healthcheck:
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    deploy:
+      resources:
+        limits:
+          cpus: '1'
+          memory: 512M

package/shells/typescript-shell/infra/docker/docker-compose.yml

@@ -0,0 +1,57 @@
+version: '3.8'
+
+services:
+  client:
+    build:
+      context: ../..
+      dockerfile: infra/docker/Dockerfile.client
+    ports:
+      - "5173:80"
+    depends_on:
+      - server
+    networks:
+      - app-network
+    restart: unless-stopped
+
+  server:
+    build:
+      context: ../..
+      dockerfile: infra/docker/Dockerfile.server
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=development
+      - PORT=3000
+      - DATABASE_URL=postgresql://postgres:postgres@db:5432/Theme Kitchen Sink?schema=public
+      - CORS_ORIGIN=http://localhost:5173
+    depends_on:
+      db:
+        condition: service_healthy
+    networks:
+      - app-network
+    restart: unless-stopped
+
+  db:
+    image: postgres:16-alpine
+    ports:
+      - "5432:5432"
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=Theme Kitchen Sink
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    networks:
+      - app-network
+
+volumes:
+  postgres-data:
+
+networks:
+  app-network:
+    driver: bridge