@almadar/cli 1.0.6 → 1.0.7

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

@@ -1,168 +0,0 @@
-"""
-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

@@ -1,260 +0,0 @@
-"""
-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

@@ -1,30 +0,0 @@
-# ===========================================
-# 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

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

package/shells/typescript-shell/.prettierrc

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

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

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

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

@@ -1,45 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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