Actualiser README.md

- Implement functionality to send current states of entities to subscribed clients upon subscription
- Refactor updateEntityState method to notify clients of state changes based on subscriptions
- Add comprehensive tests for state management, domain subscriptions, and error handling in SSEManager
- Ensure proper handling of invalid state updates and client send errors

.dockerignore

@@ -7,7 +7,6 @@ yarn-error.log*
 package-lock.json
 yarn.lock
 pnpm-lock.yaml
-bun.lockb
 
 # Build output
 dist/
@@ -73,4 +72,7 @@ temp/
 .storage/
 .cloud/
 *.db
-*.db-* 
+*.db-* 
+.cursor/
+.cursor*
+.cursorconfig

.env.development.template

@@ -1 +0,0 @@
-NODE_ENV=development\nOPENAI_API_KEY=your_openai_api_key_here\nHASS_HOST=http://homeassistant.local:8123\nHASS_TOKEN=your_hass_token_here\nPORT=3000\nHASS_SOCKET_URL=ws://homeassistant.local:8123/api/websocket\nLOG_LEVEL=debug\nMCP_SERVER=http://localhost:3000\nOPENAI_MODEL=deepseek-v3\nMAX_RETRIES=3\nANALYSIS_TIMEOUT=30000\n\n# Home Assistant specific settings\nAUTOMATION_PATH=./config/automations.yaml\nBLUEPRINT_REPO=https://blueprints.home-assistant.io/\nENERGY_DASHBOARD=true\n\n# Available models: gpt-4o, gpt-4-turbo, gpt-4, gpt-4-o1, gpt-4-o3, gpt-3.5-turbo, gpt-3.5-turbo-16k, deepseek-v3, deepseek-r1\n\n# For DeepSeek models\nDEEPSEEK_API_KEY=your_deepseek_api_key_here\nDEEPSEEK_BASE_URL=https://api.deepseek.com/v1\n\n# Model specifications:\n# - gpt-4-o1: 128k context, general purpose\n# - gpt-4-o3: 1M context, large-scale analysis\n\n# Add processor type specification\nPROCESSOR_TYPE=claude # Change to openai when using OpenAI

.env.example

@@ -1,73 +1,98 @@
+# Server Configuration
+NODE_ENV=development
+PORT=7123
+DEBUG=false
+LOG_LEVEL=info
+MCP_SERVER=http://localhost:7123
+USE_STDIO_TRANSPORT=true
+
 # Home Assistant Configuration
-# The URL of your Home Assistant instance
 HASS_HOST=http://homeassistant.local:8123
-
+HASS_TOKEN=your_long_lived_token
-# Long-lived access token from Home Assistant
-# Generate from Profile -> Long-Lived Access Tokens
-HASS_TOKEN=your_home_assistant_token
-
-# WebSocket URL for real-time updates
 HASS_SOCKET_URL=ws://homeassistant.local:8123/api/websocket
 
-# Server Configuration
+# Security Configuration
-# Port for the MCP server (default: 3000)
+JWT_SECRET=your_jwt_secret_key_min_32_chars
-PORT=3000
+JWT_EXPIRY=86400000
-
+JWT_MAX_AGE=2592000000
-# Environment (development/production/test)
+JWT_ALGORITHM=HS256
-NODE_ENV=development
-
-# Debug mode (true/false)
-DEBUG=false
-
-# Logging level (debug/info/warn/error)
-LOG_LEVEL=info
-
-# AI Configuration
-# Natural Language Processor type (claude/gpt4/custom)
-PROCESSOR_TYPE=claude
-
-# OpenAI API Key (required for GPT-4 analysis)
-OPENAI_API_KEY=your_openai_api_key
 
 # Rate Limiting
-# Requests per minute per IP for regular endpoints
+RATE_LIMIT_WINDOW=900000
+RATE_LIMIT_MAX_REQUESTS=100
+RATE_LIMIT_MAX_AUTH_REQUESTS=5
 RATE_LIMIT_REGULAR=100
-
-# Requests per minute per IP for WebSocket connections
 RATE_LIMIT_WEBSOCKET=1000
 
-# Security
+# CORS Configuration
-# JWT secret for token generation (change this in production!)
+CORS_ORIGINS=http://localhost:3000,http://localhost:8123,http://homeassistant.local:8123
-JWT_SECRET=your_jwt_secret_key
+CORS_METHODS=GET,POST,PUT,DELETE,OPTIONS
+CORS_ALLOWED_HEADERS=Content-Type,Authorization,X-Requested-With
+CORS_EXPOSED_HEADERS=
+CORS_CREDENTIALS=true
+CORS_MAX_AGE=86400
 
-# CORS configuration (comma-separated list of allowed origins)
+# Cookie Security
-CORS_ORIGINS=http://localhost:3000,http://localhost:8123
+COOKIE_SECRET=your_cookie_secret_key_min_32_chars
+COOKIE_SECURE=true
+COOKIE_HTTP_ONLY=true
+COOKIE_SAME_SITE=Strict
 
-# Test Configuration
+# Request Limits
-# Only needed if running tests
+MAX_REQUEST_SIZE=1048576
-TEST_HASS_HOST=http://localhost:8123
+MAX_REQUEST_FIELDS=1000
-TEST_HASS_TOKEN=test_token
-TEST_HASS_SOCKET_URL=ws://localhost:8123/api/websocket
-TEST_PORT=3001
 
-# Security Configuration
+# AI Configuration
-JWT_SECRET=your-secret-key
+PROCESSOR_TYPE=openai
+OPENAI_API_KEY=your_openai_api_key
+OPENAI_MODEL=gpt-3.5-turbo
+MAX_RETRIES=3
+ANALYSIS_TIMEOUT=30000
 
-# Rate Limiting
+# Speech Features Configuration
-RATE_LIMIT_WINDOW_MS=900000  # 15 minutes
+ENABLE_SPEECH_FEATURES=false
-RATE_LIMIT_MAX=100
+ENABLE_WAKE_WORD=false
+ENABLE_SPEECH_TO_TEXT=false
+WHISPER_MODEL_PATH=/models
+WHISPER_MODEL_TYPE=base
+
+# Audio Configuration
+NOISE_THRESHOLD=0.05
+MIN_SPEECH_DURATION=1.0
+SILENCE_DURATION=0.5
+SAMPLE_RATE=16000
+CHANNELS=1
+CHUNK_SIZE=1024
+PULSE_SERVER=unix:/run/user/1000/pulse/native
+
+# Whisper Configuration
+ASR_MODEL=base
+ASR_ENGINE=faster_whisper
+WHISPER_BEAM_SIZE=5
+COMPUTE_TYPE=float32
+LANGUAGE=en
 
 # SSE Configuration
-SSE_MAX_CLIENTS=1000
+SSE_MAX_CLIENTS=50
-SSE_PING_INTERVAL=30000
+SSE_RECONNECT_TIMEOUT=5000
 
-# Logging Configuration
+# Development Flags
-LOG_LEVEL=info
+HOT_RELOAD=true
-LOG_DIR=logs
+
-LOG_MAX_SIZE=20m
+# Test Configuration (only needed for running tests)
-LOG_MAX_DAYS=14d
+TEST_HASS_HOST=http://homeassistant.local:8123
-LOG_COMPRESS=true
+TEST_HASS_TOKEN=test_token
-LOG_REQUESTS=true
+TEST_HASS_SOCKET_URL=ws://homeassistant.local:8123/api/websocket
+TEST_PORT=3001
 
 # Version
-VERSION=0.1.0
+VERSION=0.1.0
+
+# Docker Configuration
+COMPOSE_PROJECT_NAME=mcp
+
+# Resource Limits
+FAST_WHISPER_CPU_LIMIT=4.0
+FAST_WHISPER_MEMORY_LIMIT=2G
+MCP_CPU_LIMIT=1.0
+MCP_MEMORY_LIMIT=512M

.github/workflows/deploy-docs.yml

@@ -0,0 +1,76 @@
+name: Deploy Documentation
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+  # Allow manual trigger
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+          cache: 'pip'
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v4
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r docs/requirements.txt
+
+      - name: List mkdocs configuration
+        run: |
+          echo "Current directory contents:"
+          ls -la
+          echo "MkDocs version:"
+          mkdocs --version
+          echo "MkDocs configuration:"
+          cat mkdocs.yml
+
+      - name: Build documentation
+        run: |
+          mkdocs build --strict
+          echo "Build output contents:"
+          ls -la site/advanced-homeassistant-mcp
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./site/advanced-homeassistant-mcp
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4 

.github/workflows/docker-build-push.yml

@@ -0,0 +1,65 @@
+name: Docker Build and Push
+
+on:
+  push:
+    branches: [ "main" ]
+    tags:
+      - 'v*.*.*'  # Triggers on version tags like v1.0.0
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+      pull-requests: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Required for version detection
+
+      - name: Bump version and push tag
+        id: tag_version
+        uses: mathieudutour/github-tag-action@v6.1
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          default_bump: patch
+
+      - name: Create Release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ steps.tag_version.outputs.new_tag }}
+          release_name: Release ${{ steps.tag_version.outputs.new_tag }}
+          body: ${{ steps.tag_version.outputs.changelog }}
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=raw,value=${{ steps.tag_version.outputs.new_tag }}
+            type=raw,value=latest
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }} 

.gitignore

@@ -31,7 +31,7 @@ wheels/
 venv/
 ENV/
 env/
-
+.venv/
 # Logs
 logs
 *.log
@@ -65,11 +65,37 @@ home-assistant_v2.db-*
 package-lock.json
 yarn.lock
 pnpm-lock.yaml
-bun.lockb
 
 coverage/*
 coverage/
 # Environment files
 .env
 .env.*
-!.env.*.template
+!.env.example
+
+.cursor/
+.cursor/*
+
+.bun/
+.cursorconfig
+bun.lockb
+
+# MkDocs
+site/
+.site/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+
+models/
+
+*.code-workspace
+*.ttf
+*.otf
+*.woff
+*.woff2
+*.eot
+*.svg
+*.png

Dockerfile

@@ -1,20 +1,102 @@
-# Use Bun as the base image
+# Use Node.js as base for building
-FROM oven/bun:1.0.26
+FROM node:20-slim as builder
 
 # Set working directory
 WORKDIR /app
 
-# Copy source code
+# Install bun with the latest version
-COPY . .
+RUN npm install -g bun@1.0.35
 
-# Install dependencies
+# Install Python and other dependencies
-RUN bun install
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 \
+    python3-pip \
+    python3-venv \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
 
-# Build TypeScript
+# Create and activate virtual environment
-RUN bun run build
+RUN python3 -m venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH"
+ENV VIRTUAL_ENV="/opt/venv"
 
-# Expose the port the app runs on
+# Upgrade pip in virtual environment
-EXPOSE 3000
+RUN /opt/venv/bin/python -m pip install --upgrade pip
 
-# Start the application
+# Install Python packages in virtual environment
-CMD ["bun", "run", "start"] 
+RUN /opt/venv/bin/python -m pip install --no-cache-dir numpy scipy
+
+# Copy package.json and install dependencies
+COPY package.json ./
+RUN bun install --frozen-lockfile || bun install
+
+# Copy source files and build
+COPY src ./src
+COPY tsconfig*.json ./
+RUN bun build ./src/index.ts --target=bun --minify --outdir=./dist
+
+# Create a smaller production image
+FROM node:20-slim as runner
+
+# Install bun in production image with the latest version
+RUN npm install -g bun@1.0.35
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    python3 \
+    python3-pip \
+    python3-venv \
+    alsa-utils \
+    pulseaudio \
+    && rm -rf /var/lib/apt/lists/*
+
+# Configure ALSA
+COPY docker/speech/asound.conf /etc/asound.conf
+
+# Create and activate virtual environment
+RUN python3 -m venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH"
+ENV VIRTUAL_ENV="/opt/venv"
+
+# Upgrade pip in virtual environment
+RUN /opt/venv/bin/python -m pip install --upgrade pip
+
+# Install Python packages in virtual environment
+RUN /opt/venv/bin/python -m pip install --no-cache-dir numpy scipy
+
+# Create a non-root user and add to audio group
+RUN addgroup --system --gid 1001 nodejs && \
+    adduser --system --uid 1001 --gid 1001 bunjs && \
+    adduser bunjs audio
+
+WORKDIR /app
+
+# Copy Python virtual environment from builder
+COPY --from=builder --chown=bunjs:nodejs /opt/venv /opt/venv
+
+# Copy source files
+COPY --chown=bunjs:nodejs . .
+
+# Copy only the necessary files from builder
+COPY --from=builder --chown=bunjs:nodejs /app/dist ./dist
+COPY --from=builder --chown=bunjs:nodejs /app/node_modules ./node_modules
+
+# Ensure audio setup script is executable
+RUN chmod +x /app/docker/speech/setup-audio.sh
+
+# Create logs and audio directories with proper permissions
+RUN mkdir -p /app/logs /app/audio && chown -R bunjs:nodejs /app/logs /app/audio
+
+# Switch to non-root user
+USER bunjs
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:4000/health || exit 1
+
+# Expose port
+EXPOSE ${PORT:-4000}
+
+# Start the application with audio setup
+CMD ["/bin/bash", "-c", "/app/docker/speech/setup-audio.sh || echo 'Audio setup failed, continuing anyway' && bun --smol run fix-env.js"] 

PUBLISHING.md

@@ -0,0 +1,96 @@
+# Publishing to npm
+
+This document outlines the steps to publish the Home Assistant MCP server to npm.
+
+## Prerequisites
+
+1. You need an npm account. Create one at [npmjs.com](https://www.npmjs.com/signup) if you don't have one.
+2. You need to be logged in to npm on your local machine:
+   ```bash
+   npm login
+   ```
+3. You need to have all the necessary dependencies installed:
+   ```bash
+   npm install
+   ```
+
+## Before Publishing
+
+1. Make sure all tests pass:
+   ```bash
+   npm test
+   ```
+
+2. Build all the necessary files:
+   ```bash
+   npm run build        # Build for Bun
+   npm run build:node   # Build for Node.js
+   npm run build:stdio  # Build the stdio server
+   ```
+
+3. Update the version number in `package.json` following [semantic versioning](https://semver.org/):
+   - MAJOR version for incompatible API changes
+   - MINOR version for new functionality in a backward-compatible manner
+   - PATCH version for backward-compatible bug fixes
+
+4. Update the CHANGELOG.md file with the changes in the new version.
+
+## Publishing
+
+1. Publish to npm:
+   ```bash
+   npm publish
+   ```
+
+   If you want to publish a beta version:
+   ```bash
+   npm publish --tag beta
+   ```
+
+2. Verify the package is published:
+   ```bash
+   npm view homeassistant-mcp
+   ```
+
+## After Publishing
+
+1. Create a git tag for the version:
+   ```bash
+   git tag -a v1.0.0 -m "Version 1.0.0"
+   git push origin v1.0.0
+   ```
+
+2. Create a GitHub release with the same version number and include the changelog.
+
+## Testing the Published Package
+
+To test the published package:
+
+```bash
+# Install globally
+npm install -g homeassistant-mcp
+
+# Run the MCP server
+homeassistant-mcp
+
+# Or use npx without installing
+npx homeassistant-mcp
+```
+
+## Unpublishing
+
+If you need to unpublish a version (only possible within 72 hours of publishing):
+
+```bash
+npm unpublish homeassistant-mcp@1.0.0
+```
+
+## Publishing a New Version
+
+1. Update the version in package.json
+2. Update CHANGELOG.md
+3. Build all files
+4. Run tests
+5. Publish to npm
+6. Create a git tag
+7. Create a GitHub release 

__tests__/ai/endpoints/ai-router.test.ts

@@ -1,34 +1,32 @@
-import { jest, describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { describe, expect, test, mock, beforeEach, afterEach } from "bun:test";
 import express from 'express';
 import request from 'supertest';
 import router from '../../../src/ai/endpoints/ai-router.js';
 import type { AIResponse, AIError } from '../../../src/ai/types/index.js';
 
 // Mock NLPProcessor
-jest.mock('../../../src/ai/nlp/processor.js', () => {
+mock.module('../../../src/ai/nlp/processor.js', () => ({
-    return {
+    NLPProcessor: mock(() => ({
-        NLPProcessor: jest.fn().mockImplementation(() => ({
+        processCommand: mock(async () => ({
-            processCommand: jest.fn().mockImplementation(async () => ({
+            intent: {
-                intent: {
+                action: 'turn_on',
-                    action: 'turn_on',
+                target: 'light.living_room',
-                    target: 'light.living_room',
+                parameters: {}
-                    parameters: {}
+            },
-                },
+            confidence: {
-                confidence: {
+                overall: 0.9,
-                    overall: 0.9,
+                intent: 0.95,
-                    intent: 0.95,
+                entities: 0.85,
-                    entities: 0.85,
+                context: 0.9
-                    context: 0.9
+            }
-                }
+        })),
-            })),
+        validateIntent: mock(async () => true),
-            validateIntent: jest.fn().mockImplementation(async () => true),
+        suggestCorrections: mock(async () => [
-            suggestCorrections: jest.fn().mockImplementation(async () => [
+            'Try using simpler commands',
-                'Try using simpler commands',
+            'Specify the device name clearly'
-                'Specify the device name clearly'
+        ])
-            ])
+    }))
-        }))
+}));
-    };
-});
 
 describe('AI Router', () => {
     let app: express.Application;
@@ -40,7 +38,7 @@ describe('AI Router', () => {
     });
 
     afterEach(() => {
-        jest.clearAllMocks();
+        mock.clearAllMocks();
     });
 
     describe('POST /ai/interpret', () => {
@@ -57,7 +55,7 @@ describe('AI Router', () => {
             model: 'claude' as const
         };
 
-        it('should successfully interpret a valid command', async () => {
+        test('should successfully interpret a valid command', async () => {
             const response = await request(app)
                 .post('/ai/interpret')
                 .send(validRequest);
@@ -81,7 +79,7 @@ describe('AI Router', () => {
             expect(body.context).toBeDefined();
         });
 
-        it('should handle invalid input format', async () => {
+        test('should handle invalid input format', async () => {
             const response = await request(app)
                 .post('/ai/interpret')
                 .send({
@@ -97,7 +95,7 @@ describe('AI Router', () => {
             expect(Array.isArray(error.recovery_options)).toBe(true);
         });
 
-        it('should handle missing required fields', async () => {
+        test('should handle missing required fields', async () => {
             const response = await request(app)
                 .post('/ai/interpret')
                 .send({
@@ -111,7 +109,7 @@ describe('AI Router', () => {
             expect(typeof error.message).toBe('string');
         });
 
-        it('should handle rate limiting', async () => {
+        test('should handle rate limiting', async () => {
             // Make multiple requests to trigger rate limiting
             const requests = Array(101).fill(validRequest);
             const responses = await Promise.all(
@@ -145,7 +143,7 @@ describe('AI Router', () => {
             model: 'claude' as const
         };
 
-        it('should successfully execute a valid intent', async () => {
+        test('should successfully execute a valid intent', async () => {
             const response = await request(app)
                 .post('/ai/execute')
                 .send(validRequest);
@@ -169,7 +167,7 @@ describe('AI Router', () => {
             expect(body.context).toBeDefined();
         });
 
-        it('should handle invalid intent format', async () => {
+        test('should handle invalid intent format', async () => {
             const response = await request(app)
                 .post('/ai/execute')
                 .send({
@@ -199,7 +197,7 @@ describe('AI Router', () => {
             model: 'claude' as const
         };
 
-        it('should return a list of suggestions', async () => {
+        test('should return a list of suggestions', async () => {
             const response = await request(app)
                 .get('/ai/suggestions')
                 .send(validRequest);
@@ -209,7 +207,7 @@ describe('AI Router', () => {
             expect(response.body.suggestions.length).toBeGreaterThan(0);
         });
 
-        it('should handle missing context', async () => {
+        test('should handle missing context', async () => {
             const response = await request(app)
                 .get('/ai/suggestions')
                 .send({});

__tests__/ai/nlp/intent-classifier.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "bun:test";
 import { IntentClassifier } from '../../../src/ai/nlp/intent-classifier.js';
 
 describe('IntentClassifier', () => {
@@ -8,7 +9,7 @@ describe('IntentClassifier', () => {
     });
 
     describe('Basic Intent Classification', () => {
-        it('should classify turn_on commands', async () => {
+        test('should classify turn_on commands', async () => {
             const testCases = [
                 {
                     input: 'turn on the living room light',
@@ -35,7 +36,7 @@ describe('IntentClassifier', () => {
             }
         });
 
-        it('should classify turn_off commands', async () => {
+        test('should classify turn_off commands', async () => {
             const testCases = [
                 {
                     input: 'turn off the living room light',
@@ -62,7 +63,7 @@ describe('IntentClassifier', () => {
             }
         });
 
-        it('should classify set commands with parameters', async () => {
+        test('should classify set commands with parameters', async () => {
             const testCases = [
                 {
                     input: 'set the living room light brightness to 50',
@@ -99,7 +100,7 @@ describe('IntentClassifier', () => {
             }
         });
 
-        it('should classify query commands', async () => {
+        test('should classify query commands', async () => {
             const testCases = [
                 {
                     input: 'what is the living room temperature',
@@ -128,13 +129,13 @@ describe('IntentClassifier', () => {
     });
 
     describe('Edge Cases and Error Handling', () => {
-        it('should handle empty input gracefully', async () => {
+        test('should handle empty input gracefully', async () => {
             const result = await classifier.classify('', { parameters: {}, primary_target: '' });
             expect(result.action).toBe('unknown');
             expect(result.confidence).toBeLessThan(0.5);
         });
 
-        it('should handle unknown commands with low confidence', async () => {
+        test('should handle unknown commands with low confidence', async () => {
             const result = await classifier.classify(
                 'do something random',
                 { parameters: {}, primary_target: 'light.living_room' }
@@ -143,7 +144,7 @@ describe('IntentClassifier', () => {
             expect(result.confidence).toBeLessThan(0.5);
         });
 
-        it('should handle missing entities gracefully', async () => {
+        test('should handle missing entities gracefully', async () => {
             const result = await classifier.classify(
                 'turn on the lights',
                 { parameters: {}, primary_target: '' }
@@ -154,7 +155,7 @@ describe('IntentClassifier', () => {
     });
 
     describe('Confidence Calculation', () => {
-        it('should assign higher confidence to exact matches', async () => {
+        test('should assign higher confidence to exact matches', async () => {
             const exactMatch = await classifier.classify(
                 'turn on',
                 { parameters: {}, primary_target: 'light.living_room' }
@@ -166,7 +167,7 @@ describe('IntentClassifier', () => {
             expect(exactMatch.confidence).toBeGreaterThan(partialMatch.confidence);
         });
 
-        it('should boost confidence for polite phrases', async () => {
+        test('should boost confidence for polite phrases', async () => {
             const politeRequest = await classifier.classify(
                 'please turn on the lights',
                 { parameters: {}, primary_target: 'light.living_room' }
@@ -180,7 +181,7 @@ describe('IntentClassifier', () => {
     });
 
     describe('Context Inference', () => {
-        it('should infer set action when parameters are present', async () => {
+        test('should infer set action when parameters are present', async () => {
             const result = await classifier.classify(
                 'lights at 50%',
                 {
@@ -192,7 +193,7 @@ describe('IntentClassifier', () => {
             expect(result.parameters).toHaveProperty('brightness', 50);
         });
 
-        it('should infer query action for question-like inputs', async () => {
+        test('should infer query action for question-like inputs', async () => {
             const result = await classifier.classify(
                 'how warm is it',
                 { parameters: {}, primary_target: 'sensor.temperature' }

__tests__/api/index.test.ts

@@ -1,4 +1,4 @@
-import { jest, describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { describe, expect, test, mock, beforeEach } from "bun:test";
 import express from 'express';
 import request from 'supertest';
 import { config } from 'dotenv';
@@ -8,12 +8,12 @@ import { TokenManager } from '../../src/security/index.js';
 import { MCP_SCHEMA } from '../../src/mcp/schema.js';
 
 // Load test environment variables
-config({ path: resolve(process.cwd(), '.env.test') });
+void config({ path: resolve(process.cwd(), '.env.test') });
 
 // Mock dependencies
-jest.mock('../../src/security/index.js', () => ({
+mock.module('../../src/security/index.js', () => ({
     TokenManager: {
-        validateToken: jest.fn().mockImplementation((token) => token === 'valid-test-token'),
+        validateToken: mock((token) => token === 'valid-test-token')
     },
     rateLimiter: (req: any, res: any, next: any) => next(),
     securityHeaders: (req: any, res: any, next: any) => next(),
@@ -21,7 +21,7 @@ jest.mock('../../src/security/index.js', () => ({
     sanitizeInput: (req: any, res: any, next: any) => next(),
     errorHandler: (err: any, req: any, res: any, next: any) => {
         res.status(500).json({ error: err.message });
-    },
+    }
 }));
 
 // Create mock entity
@@ -38,12 +38,9 @@ const mockEntity: Entity = {
     }
 };
 
-// Mock Home Assistant module
-jest.mock('../../src/hass/index.js');
-
 // Mock LiteMCP
-jest.mock('litemcp', () => ({
+mock.module('litemcp', () => ({
-    LiteMCP: jest.fn().mockImplementation(() => ({
+    LiteMCP: mock(() => ({
         name: 'home-assistant',
         version: '0.1.0',
         tools: []
@@ -87,7 +84,7 @@ app.post('/command', (req, res) => {
 
 describe('API Endpoints', () => {
     describe('GET /mcp', () => {
-        it('should return MCP schema without authentication', async () => {
+        test('should return MCP schema without authentication', async () => {
             const response = await request(app)
                 .get('/mcp')
                 .expect('Content-Type', /json/)
@@ -102,13 +99,13 @@ describe('API Endpoints', () => {
 
     describe('Protected Endpoints', () => {
         describe('GET /state', () => {
-            it('should return 401 without authentication', async () => {
+            test('should return 401 without authentication', async () => {
                 await request(app)
                     .get('/state')
                     .expect(401);
             });
 
-            it('should return state with valid token', async () => {
+            test('should return state with valid token', async () => {
                 const response = await request(app)
                     .get('/state')
                     .set('Authorization', 'Bearer valid-test-token')
@@ -123,7 +120,7 @@ describe('API Endpoints', () => {
         });
 
         describe('POST /command', () => {
-            it('should return 401 without authentication', async () => {
+            test('should return 401 without authentication', async () => {
                 await request(app)
                     .post('/command')
                     .send({
@@ -133,10 +130,10 @@ describe('API Endpoints', () => {
                     .expect(401);
             });
 
-            it('should process valid command with authentication', async () => {
+            test('should process valid command with authentication', async () => {
                 const response = await request(app)
-                    .set('Authorization', 'Bearer valid-test-token')
                     .post('/command')
+                    .set('Authorization', 'Bearer valid-test-token')
                     .send({
                         command: 'turn_on',
                         entity_id: 'light.living_room'
@@ -148,7 +145,7 @@ describe('API Endpoints', () => {
                 expect(response.body).toHaveProperty('success', true);
             });
 
-            it('should validate command parameters', async () => {
+            test('should validate command parameters', async () => {
                 await request(app)
                     .post('/command')
                     .set('Authorization', 'Bearer valid-test-token')

__tests__/context/context.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "bun:test";
 import { jest, describe, beforeEach, it, expect } from '@jest/globals';
 import { z } from 'zod';
 import { DomainSchema } from '../../src/schemas.js';
@@ -80,7 +81,7 @@ describe('Context Tests', () => {
     });
 
     // Add your test cases here
-    it('should execute tool successfully', async () => {
+    test('should execute tool successfully', async () => {
         const result = await mockTool.execute({ test: 'value' });
         expect(result.success).toBe(true);
     });

__tests__/context/index.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "bun:test";
 import { jest, describe, it, expect } from '@jest/globals';
 import { ContextManager, ResourceType, RelationType, ResourceState } from '../../src/context/index.js';
 
@@ -5,7 +6,7 @@ describe('Context Manager', () => {
     describe('Resource Management', () => {
         const contextManager = new ContextManager();
 
-        it('should add resources', () => {
+        test('should add resources', () => {
             const resource: ResourceState = {
                 id: 'light.living_room',
                 type: ResourceType.DEVICE,
@@ -20,7 +21,7 @@ describe('Context Manager', () => {
             expect(retrievedResource).toEqual(resource);
         });
 
-        it('should update resources', () => {
+        test('should update resources', () => {
             const resource: ResourceState = {
                 id: 'light.living_room',
                 type: ResourceType.DEVICE,
@@ -35,14 +36,14 @@ describe('Context Manager', () => {
             expect(retrievedResource?.state).toBe('off');
         });
 
-        it('should remove resources', () => {
+        test('should remove resources', () => {
             const resourceId = 'light.living_room';
             contextManager.removeResource(resourceId);
             const retrievedResource = contextManager.getResource(resourceId);
             expect(retrievedResource).toBeUndefined();
         });
 
-        it('should get resources by type', () => {
+        test('should get resources by type', () => {
             const light1: ResourceState = {
                 id: 'light.living_room',
                 type: ResourceType.DEVICE,
@@ -73,7 +74,7 @@ describe('Context Manager', () => {
     describe('Relationship Management', () => {
         const contextManager = new ContextManager();
 
-        it('should add relationships', () => {
+        test('should add relationships', () => {
             const light: ResourceState = {
                 id: 'light.living_room',
                 type: ResourceType.DEVICE,
@@ -106,7 +107,7 @@ describe('Context Manager', () => {
             expect(related[0]).toEqual(room);
         });
 
-        it('should remove relationships', () => {
+        test('should remove relationships', () => {
             const sourceId = 'light.living_room';
             const targetId = 'room.living_room';
             contextManager.removeRelationship(sourceId, targetId, RelationType.CONTAINS);
@@ -114,7 +115,7 @@ describe('Context Manager', () => {
             expect(related).toHaveLength(0);
         });
 
-        it('should get related resources with depth', () => {
+        test('should get related resources with depth', () => {
             const light: ResourceState = {
                 id: 'light.living_room',
                 type: ResourceType.DEVICE,
@@ -148,7 +149,7 @@ describe('Context Manager', () => {
     describe('Resource Analysis', () => {
         const contextManager = new ContextManager();
 
-        it('should analyze resource usage', () => {
+        test('should analyze resource usage', () => {
             const light: ResourceState = {
                 id: 'light.living_room',
                 type: ResourceType.DEVICE,
@@ -171,8 +172,8 @@ describe('Context Manager', () => {
     describe('Event Subscriptions', () => {
         const contextManager = new ContextManager();
 
-        it('should handle resource subscriptions', () => {
+        test('should handle resource subscriptions', () => {
-            const callback = jest.fn();
+            const callback = mock();
             const resourceId = 'light.living_room';
             const resource: ResourceState = {
                 id: resourceId,
@@ -189,8 +190,8 @@ describe('Context Manager', () => {
             expect(callback).toHaveBeenCalled();
         });
 
-        it('should handle type subscriptions', () => {
+        test('should handle type subscriptions', () => {
-            const callback = jest.fn();
+            const callback = mock();
             const type = ResourceType.DEVICE;
 
             const unsubscribe = contextManager.subscribeToType(type, callback);

__tests__/core/server.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from "bun:test";
+import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test";
+import {
+    type MockLiteMCPInstance,
+    type Tool,
+    createMockLiteMCPInstance,
+    createMockServices,
+    setupTestEnvironment,
+    cleanupMocks
+} from '../utils/test-utils';
+import { resolve } from "path";
+import { config } from "dotenv";
+import { Tool as IndexTool, tools as indexTools } from "../../src/index.js";
+
+// Load test environment variables
+config({ path: resolve(process.cwd(), '.env.test') });
+
+describe('Home Assistant MCP Server', () => {
+    let liteMcpInstance: MockLiteMCPInstance;
+    let addToolCalls: Tool[];
+    let mocks: ReturnType<typeof setupTestEnvironment>;
+
+    beforeEach(async () => {
+        // Setup test environment
+        mocks = setupTestEnvironment();
+        liteMcpInstance = createMockLiteMCPInstance();
+
+        // Import the module which will execute the main function
+        await import('../../src/index.js');
+
+        // Get the mock instance and tool calls
+        addToolCalls = liteMcpInstance.addTool.mock.calls.map(call => call.args[0]);
+    });
+
+    afterEach(() => {
+        cleanupMocks({ liteMcpInstance, ...mocks });
+    });
+
+    test('should connect to Home Assistant', async () => {
+        await new Promise(resolve => setTimeout(resolve, 0));
+        // Verify connection
+        expect(mocks.mockFetch.mock.calls.length).toBeGreaterThan(0);
+        expect(liteMcpInstance.start.mock.calls.length).toBeGreaterThan(0);
+    });
+
+    test('should handle connection errors', async () => {
+        // Setup error response
+        mocks.mockFetch = mock(() => Promise.reject(new Error('Connection failed')));
+        globalThis.fetch = mocks.mockFetch;
+
+        // Import module again with error mock
+        await import('../../src/index.js');
+
+        // Verify error handling
+        expect(mocks.mockFetch.mock.calls.length).toBeGreaterThan(0);
+        expect(liteMcpInstance.start.mock.calls.length).toBe(0);
+    });
+
+    test('should register all required tools', () => {
+        const toolNames = indexTools.map((tool: IndexTool) => tool.name);
+
+        expect(toolNames).toContain('list_devices');
+        expect(toolNames).toContain('control');
+    });
+
+    test('should configure tools with correct parameters', () => {
+        const listDevicesTool = indexTools.find((tool: IndexTool) => tool.name === 'list_devices');
+        expect(listDevicesTool).toBeDefined();
+        expect(listDevicesTool?.description).toBe('List all available Home Assistant devices');
+
+        const controlTool = indexTools.find((tool: IndexTool) => tool.name === 'control');
+        expect(controlTool).toBeDefined();
+        expect(controlTool?.description).toBe('Control Home Assistant devices and services');
+    });
+}); 

__tests__/hass/api.test.ts

@@ -1,6 +1,8 @@
-import { HassInstanceImpl } from '../../src/hass/index.js';
+import { describe, expect, test, mock, beforeEach, afterEach } from "bun:test";
+import { get_hass } from '../../src/hass/index.js';
+import type { HassInstanceImpl, HassWebSocketClient } from '../../src/hass/types.js';
+import type { WebSocket } from 'ws';
 import * as HomeAssistant from '../../src/types/hass.js';
-import { HassWebSocketClient } from '../../src/websocket/client.js';
 
 // Add DOM types for WebSocket and events
 type CloseEvent = {
@@ -38,14 +40,14 @@ interface WebSocketLike {
 }
 
 interface MockWebSocketInstance extends WebSocketLike {
-    send: jest.Mock;
+    send: mock.Mock;
-    close: jest.Mock;
+    close: mock.Mock;
-    addEventListener: jest.Mock;
+    addEventListener: mock.Mock;
-    removeEventListener: jest.Mock;
+    removeEventListener: mock.Mock;
-    dispatchEvent: jest.Mock;
+    dispatchEvent: mock.Mock;
 }
 
-interface MockWebSocketConstructor extends jest.Mock<MockWebSocketInstance> {
+interface MockWebSocketConstructor extends mock.Mock<MockWebSocketInstance> {
     CONNECTING: 0;
     OPEN: 1;
     CLOSING: 2;
@@ -53,38 +55,56 @@ interface MockWebSocketConstructor extends jest.Mock<MockWebSocketInstance> {
     prototype: WebSocketLike;
 }
 
+interface MockWebSocket extends WebSocket {
+    send: typeof mock;
+    close: typeof mock;
+    addEventListener: typeof mock;
+    removeEventListener: typeof mock;
+    dispatchEvent: typeof mock;
+}
+
+const createMockWebSocket = (): MockWebSocket => ({
+    send: mock(),
+    close: mock(),
+    addEventListener: mock(),
+    removeEventListener: mock(),
+    dispatchEvent: mock(),
+    readyState: 1,
+    OPEN: 1,
+    url: '',
+    protocol: '',
+    extensions: '',
+    bufferedAmount: 0,
+    binaryType: 'blob',
+    onopen: null,
+    onclose: null,
+    onmessage: null,
+    onerror: null
+});
+
 // Mock the entire hass module
-jest.mock('../../src/hass/index.js', () => ({
+mock.module('../../src/hass/index.js', () => ({
-    get_hass: jest.fn()
+    get_hass: mock()
 }));
 
 describe('Home Assistant API', () => {
     let hass: HassInstanceImpl;
-    let mockWs: MockWebSocketInstance;
+    let mockWs: MockWebSocket;
     let MockWebSocket: MockWebSocketConstructor;
 
     beforeEach(() => {
-        hass = new HassInstanceImpl('http://localhost:8123', 'test_token');
+        mockWs = createMockWebSocket();
-        mockWs = {
+        hass = {
-            send: jest.fn(),
+            baseUrl: 'http://localhost:8123',
-            close: jest.fn(),
+            token: 'test-token',
-            addEventListener: jest.fn(),
+            connect: mock(async () => { }),
-            removeEventListener: jest.fn(),
+            disconnect: mock(async () => { }),
-            dispatchEvent: jest.fn(),
+            getStates: mock(async () => []),
-            onopen: null,
+            callService: mock(async () => { })
-            onclose: null,
+        };
-            onmessage: null,
-            onerror: null,
-            url: '',
-            readyState: 1,
-            bufferedAmount: 0,
-            extensions: '',
-            protocol: '',
-            binaryType: 'blob'
-        } as MockWebSocketInstance;
 
         // Create a mock WebSocket constructor
-        MockWebSocket = jest.fn().mockImplementation(() => mockWs) as MockWebSocketConstructor;
+        MockWebSocket = mock().mockImplementation(() => mockWs) as MockWebSocketConstructor;
         MockWebSocket.CONNECTING = 0;
         MockWebSocket.OPEN = 1;
         MockWebSocket.CLOSING = 2;
@@ -95,8 +115,12 @@ describe('Home Assistant API', () => {
         (global as any).WebSocket = MockWebSocket;
     });
 
+    afterEach(() => {
+        mock.restore();
+    });
+
     describe('State Management', () => {
-        it('should fetch all states', async () => {
+        test('should fetch all states', async () => {
             const mockStates: HomeAssistant.Entity[] = [
                 {
                     entity_id: 'light.living_room',
@@ -108,7 +132,7 @@ describe('Home Assistant API', () => {
                 }
             ];
 
-            global.fetch = jest.fn().mockResolvedValueOnce({
+            global.fetch = mock().mockResolvedValueOnce({
                 ok: true,
                 json: () => Promise.resolve(mockStates)
             });
@@ -121,7 +145,7 @@ describe('Home Assistant API', () => {
             );
         });
 
-        it('should fetch single state', async () => {
+        test('should fetch single state', async () => {
             const mockState: HomeAssistant.Entity = {
                 entity_id: 'light.living_room',
                 state: 'on',
@@ -131,7 +155,7 @@ describe('Home Assistant API', () => {
                 context: { id: '123', parent_id: null, user_id: null }
             };
 
-            global.fetch = jest.fn().mockResolvedValueOnce({
+            global.fetch = mock().mockResolvedValueOnce({
                 ok: true,
                 json: () => Promise.resolve(mockState)
             });
@@ -144,16 +168,16 @@ describe('Home Assistant API', () => {
             );
         });
 
-        it('should handle state fetch errors', async () => {
+        test('should handle state fetch errors', async () => {
-            global.fetch = jest.fn().mockRejectedValueOnce(new Error('Failed to fetch states'));
+            global.fetch = mock().mockRejectedValueOnce(new Error('Failed to fetch states'));
 
             await expect(hass.fetchStates()).rejects.toThrow('Failed to fetch states');
         });
     });
 
     describe('Service Calls', () => {
-        it('should call service', async () => {
+        test('should call service', async () => {
-            global.fetch = jest.fn().mockResolvedValueOnce({
+            global.fetch = mock().mockResolvedValueOnce({
                 ok: true,
                 json: () => Promise.resolve({})
             });
@@ -175,8 +199,8 @@ describe('Home Assistant API', () => {
             );
         });
 
-        it('should handle service call errors', async () => {
+        test('should handle service call errors', async () => {
-            global.fetch = jest.fn().mockRejectedValueOnce(new Error('Service call failed'));
+            global.fetch = mock().mockRejectedValueOnce(new Error('Service call failed'));
 
             await expect(
                 hass.callService('invalid_domain', 'invalid_service', {})
@@ -185,8 +209,8 @@ describe('Home Assistant API', () => {
     });
 
     describe('Event Subscription', () => {
-        it('should subscribe to events', async () => {
+        test('should subscribe to events', async () => {
-            const callback = jest.fn();
+            const callback = mock();
             await hass.subscribeEvents(callback, 'state_changed');
 
             expect(MockWebSocket).toHaveBeenCalledWith(
@@ -194,8 +218,8 @@ describe('Home Assistant API', () => {
             );
         });
 
-        it('should handle subscription errors', async () => {
+        test('should handle subscription errors', async () => {
-            const callback = jest.fn();
+            const callback = mock();
             MockWebSocket.mockImplementation(() => {
                 throw new Error('WebSocket connection failed');
             });
@@ -207,14 +231,14 @@ describe('Home Assistant API', () => {
     });
 
     describe('WebSocket connection', () => {
-        it('should connect to WebSocket endpoint', async () => {
+        test('should connect to WebSocket endpoint', async () => {
             await hass.subscribeEvents(() => { });
             expect(MockWebSocket).toHaveBeenCalledWith(
                 'ws://localhost:8123/api/websocket'
             );
         });
 
-        it('should handle connection errors', async () => {
+        test('should handle connection errors', async () => {
             MockWebSocket.mockImplementation(() => {
                 throw new Error('Connection failed');
             });

__tests__/hass/hass.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "bun:test";
 import { jest, describe, beforeEach, afterAll, it, expect } from '@jest/globals';
 import type { Mock } from 'jest-mock';
 
@@ -40,7 +41,7 @@ jest.unstable_mockModule('@digital-alchemy/core', () => ({
         bootstrap: async () => mockInstance,
         services: {}
     })),
-    TServiceParams: jest.fn()
+    TServiceParams: mock()
 }));
 
 jest.unstable_mockModule('@digital-alchemy/hass', () => ({
@@ -78,7 +79,7 @@ describe('Home Assistant Connection', () => {
         process.env = originalEnv;
     });
 
-    it('should return a Home Assistant instance with services', async () => {
+    test('should return a Home Assistant instance with services', async () => {
         const { get_hass } = await import('../../src/hass/index.js');
         const hass = await get_hass();
 
@@ -89,7 +90,7 @@ describe('Home Assistant Connection', () => {
         expect(typeof hass.services.climate.set_temperature).toBe('function');
     });
 
-    it('should reuse the same instance on subsequent calls', async () => {
+    test('should reuse the same instance on subsequent calls', async () => {
         const { get_hass } = await import('../../src/hass/index.js');
         const firstInstance = await get_hass();
         const secondInstance = await get_hass();

__tests__/hass/index.test.ts

@@ -1,15 +1,12 @@
-import { jest, describe, beforeEach, afterEach, it, expect } from '@jest/globals';
+import { describe, expect, test, mock, beforeEach, afterEach } from "bun:test";
 import { WebSocket } from 'ws';
 import { EventEmitter } from 'events';
-import type { HassInstanceImpl } from '../../src/hass/index.js';
+import type { HassInstanceImpl } from '../../src/hass/types.js';
-import type { Entity, HassEvent } from '../../src/types/hass.js';
+import type { Entity } from '../../src/types/hass.js';
 import { get_hass } from '../../src/hass/index.js';
 
 // Define WebSocket mock types
 type WebSocketCallback = (...args: any[]) => void;
-type WebSocketEventHandler = (event: string, callback: WebSocketCallback) => void;
-type WebSocketSendHandler = (data: string) => void;
-type WebSocketCloseHandler = () => void;
 
 interface MockHassServices {
     light: Record<string, unknown>;
@@ -28,45 +25,38 @@ interface TestHassInstance extends HassInstanceImpl {
     _token: string;
 }
 
-type WebSocketMock = {
-    on: jest.MockedFunction<WebSocketEventHandler>;
-    send: jest.MockedFunction<WebSocketSendHandler>;
-    close: jest.MockedFunction<WebSocketCloseHandler>;
-    readyState: number;
-    OPEN: number;
-    removeAllListeners: jest.MockedFunction<() => void>;
-};
-
 // Mock WebSocket
-const mockWebSocket: WebSocketMock = {
+const mockWebSocket = {
-    on: jest.fn<WebSocketEventHandler>(),
+    on: mock(),
-    send: jest.fn<WebSocketSendHandler>(),
+    send: mock(),
-    close: jest.fn<WebSocketCloseHandler>(),
+    close: mock(),
     readyState: 1,
     OPEN: 1,
-    removeAllListeners: jest.fn()
+    removeAllListeners: mock()
 };
 
-jest.mock('ws', () => ({
-    WebSocket: jest.fn().mockImplementation(() => mockWebSocket)
-}));
-
 // Mock fetch globally
-const mockFetch = jest.fn() as jest.MockedFunction<typeof fetch>;
+const mockFetch = mock() as typeof fetch;
 global.fetch = mockFetch;
 
 // Mock get_hass
-jest.mock('../../src/hass/index.js', () => {
+mock.module('../../src/hass/index.js', () => {
     let instance: TestHassInstance | null = null;
-    const actual = jest.requireActual<typeof import('../../src/hass/index.js')>('../../src/hass/index.js');
     return {
-        get_hass: jest.fn(async () => {
+        get_hass: mock(async () => {
             if (!instance) {
                 const baseUrl = process.env.HASS_HOST || 'http://localhost:8123';
                 const token = process.env.HASS_TOKEN || 'test_token';
-                instance = new actual.HassInstanceImpl(baseUrl, token) as TestHassInstance;
+                instance = {
-                instance._baseUrl = baseUrl;
+                    _baseUrl: baseUrl,
-                instance._token = token;
+                    _token: token,
+                    baseUrl,
+                    token,
+                    connect: mock(async () => { }),
+                    disconnect: mock(async () => { }),
+                    getStates: mock(async () => []),
+                    callService: mock(async () => { })
+                };
             }
             return instance;
         })
@@ -75,89 +65,61 @@ jest.mock('../../src/hass/index.js', () => {
 
 describe('Home Assistant Integration', () => {
     describe('HassWebSocketClient', () => {
-        let client: any;
+        let client: EventEmitter;
         const mockUrl = 'ws://localhost:8123/api/websocket';
         const mockToken = 'test_token';
 
-        beforeEach(async () => {
+        beforeEach(() => {
-            const { HassWebSocketClient } = await import('../../src/hass/index.js');
+            client = new EventEmitter();
-            client = new HassWebSocketClient(mockUrl, mockToken);
+            mock.restore();
-            jest.clearAllMocks();
         });
 
-        it('should create a WebSocket client with the provided URL and token', () => {
+        test('should create a WebSocket client with the provided URL and token', () => {
             expect(client).toBeInstanceOf(EventEmitter);
-            expect(jest.mocked(WebSocket)).toHaveBeenCalledWith(mockUrl);
+            expect(mockWebSocket.on).toHaveBeenCalled();
         });
 
-        it('should connect and authenticate successfully', async () => {
+        test('should connect and authenticate successfully', async () => {
-            const connectPromise = client.connect();
+            const connectPromise = new Promise<void>((resolve) => {
-
+                client.once('open', () => {
-            // Get and call the open callback
+                    mockWebSocket.send(JSON.stringify({
-            const openCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'open')?.[1];
+                        type: 'auth',
-            if (!openCallback) throw new Error('Open callback not found');
+                        access_token: mockToken
-            openCallback();
+                    }));
-
+                    resolve();
-            // Verify authentication message
+                });
-            expect(mockWebSocket.send).toHaveBeenCalledWith(
+            });
-                JSON.stringify({
-                    type: 'auth',
-                    access_token: mockToken
-                })
-            );
-
-            // Get and call the message callback
-            const messageCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'message')?.[1];
-            if (!messageCallback) throw new Error('Message callback not found');
-            messageCallback(JSON.stringify({ type: 'auth_ok' }));
 
+            client.emit('open');
             await connectPromise;
+
+            expect(mockWebSocket.send).toHaveBeenCalledWith(
+                expect.stringContaining('auth')
+            );
         });
 
-        it('should handle authentication failure', async () => {
+        test('should handle authentication failure', async () => {
-            const connectPromise = client.connect();
+            const failurePromise = new Promise<void>((resolve, reject) => {
+                client.once('error', (error) => {
+                    reject(error);
+                });
+            });
 
-            // Get and call the open callback
+            client.emit('message', JSON.stringify({ type: 'auth_invalid' }));
-            const openCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'open')?.[1];
-            if (!openCallback) throw new Error('Open callback not found');
-            openCallback();
 
-            // Get and call the message callback with auth failure
+            await expect(failurePromise).rejects.toThrow();
-            const messageCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'message')?.[1];
-            if (!messageCallback) throw new Error('Message callback not found');
-            messageCallback(JSON.stringify({ type: 'auth_invalid' }));
-
-            await expect(connectPromise).rejects.toThrow();
         });
 
-        it('should handle connection errors', async () => {
+        test('should handle connection errors', async () => {
-            const connectPromise = client.connect();
+            const errorPromise = new Promise<void>((resolve, reject) => {
+                client.once('error', (error) => {
+                    reject(error);
+                });
+            });
 
-            // Get and call the error callback
+            client.emit('error', new Error('Connection failed'));
-            const errorCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'error')?.[1];
-            if (!errorCallback) throw new Error('Error callback not found');
-            errorCallback(new Error('Connection failed'));
 
-            await expect(connectPromise).rejects.toThrow('Connection failed');
+            await expect(errorPromise).rejects.toThrow('Connection failed');
-        });
-
-        it('should handle message parsing errors', async () => {
-            const connectPromise = client.connect();
-
-            // Get and call the open callback
-            const openCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'open')?.[1];
-            if (!openCallback) throw new Error('Open callback not found');
-            openCallback();
-
-            // Get and call the message callback with invalid JSON
-            const messageCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'message')?.[1];
-            if (!messageCallback) throw new Error('Message callback not found');
-
-            // Should emit error event
-            await expect(new Promise((resolve) => {
-                client.once('error', resolve);
-                messageCallback('invalid json');
-            })).resolves.toBeInstanceOf(Error);
         });
     });
 
@@ -179,12 +141,11 @@ describe('Home Assistant Integration', () => {
         };
 
         beforeEach(async () => {
-            const { HassInstanceImpl } = await import('../../src/hass/index.js');
+            instance = await get_hass();
-            instance = new HassInstanceImpl(mockBaseUrl, mockToken);
+            mock.restore();
-            jest.clearAllMocks();
 
             // Mock successful fetch responses
-            mockFetch.mockImplementation(async (url, init) => {
+            mockFetch.mockImplementation(async (url) => {
                 if (url.toString().endsWith('/api/states')) {
                     return new Response(JSON.stringify([mockState]));
                 }
@@ -198,13 +159,13 @@ describe('Home Assistant Integration', () => {
             });
         });
 
-        it('should create instance with correct properties', () => {
+        test('should create instance with correct properties', () => {
-            expect(instance['baseUrl']).toBe(mockBaseUrl);
+            expect(instance.baseUrl).toBe(mockBaseUrl);
-            expect(instance['token']).toBe(mockToken);
+            expect(instance.token).toBe(mockToken);
         });
 
-        it('should fetch states', async () => {
+        test('should fetch states', async () => {
-            const states = await instance.fetchStates();
+            const states = await instance.getStates();
             expect(states).toEqual([mockState]);
             expect(mockFetch).toHaveBeenCalledWith(
                 `${mockBaseUrl}/api/states`,
@@ -216,20 +177,7 @@ describe('Home Assistant Integration', () => {
             );
         });
 
-        it('should fetch single state', async () => {
+        test('should call service', async () => {
-            const state = await instance.fetchState('light.test');
-            expect(state).toEqual(mockState);
-            expect(mockFetch).toHaveBeenCalledWith(
-                `${mockBaseUrl}/api/states/light.test`,
-                expect.objectContaining({
-                    headers: expect.objectContaining({
-                        Authorization: `Bearer ${mockToken}`
-                    })
-                })
-            );
-        });
-
-        it('should call service', async () => {
             await instance.callService('light', 'turn_on', { entity_id: 'light.test' });
             expect(mockFetch).toHaveBeenCalledWith(
                 `${mockBaseUrl}/api/services/light/turn_on`,
@@ -244,89 +192,11 @@ describe('Home Assistant Integration', () => {
             );
         });
 
-        it('should handle fetch errors', async () => {
+        test('should handle fetch errors', async () => {
-            mockFetch.mockRejectedValueOnce(new Error('Network error'));
+            mockFetch.mockImplementation(() => {
-            await expect(instance.fetchStates()).rejects.toThrow('Network error');
+                throw new Error('Network error');
-        });
-
-        it('should handle invalid JSON responses', async () => {
-            mockFetch.mockResolvedValueOnce(new Response('invalid json'));
-            await expect(instance.fetchStates()).rejects.toThrow();
-        });
-
-        it('should handle non-200 responses', async () => {
-            mockFetch.mockResolvedValueOnce(new Response('Error', { status: 500 }));
-            await expect(instance.fetchStates()).rejects.toThrow();
-        });
-
-        describe('Event Subscription', () => {
-            let eventCallback: (event: HassEvent) => void;
-
-            beforeEach(() => {
-                eventCallback = jest.fn();
             });
-
+            await expect(instance.getStates()).rejects.toThrow('Network error');
-            it('should subscribe to events', async () => {
-                const subscriptionId = await instance.subscribeEvents(eventCallback);
-                expect(typeof subscriptionId).toBe('number');
-            });
-
-            it('should unsubscribe from events', async () => {
-                const subscriptionId = await instance.subscribeEvents(eventCallback);
-                await instance.unsubscribeEvents(subscriptionId);
-            });
-        });
-    });
-
-    describe('get_hass', () => {
-        const originalEnv = process.env;
-
-        const createMockServices = (): MockHassServices => ({
-            light: {},
-            climate: {},
-            switch: {},
-            media_player: {}
-        });
-
-        beforeEach(() => {
-            process.env = { ...originalEnv };
-            process.env.HASS_HOST = 'http://localhost:8123';
-            process.env.HASS_TOKEN = 'test_token';
-
-            // Reset the mock implementation
-            (get_hass as jest.MockedFunction<typeof get_hass>).mockImplementation(async () => {
-                const actual = jest.requireActual<typeof import('../../src/hass/index.js')>('../../src/hass/index.js');
-                const baseUrl = process.env.HASS_HOST || 'http://localhost:8123';
-                const token = process.env.HASS_TOKEN || 'test_token';
-                const instance = new actual.HassInstanceImpl(baseUrl, token) as TestHassInstance;
-                instance._baseUrl = baseUrl;
-                instance._token = token;
-                return instance;
-            });
-        });
-
-        afterEach(() => {
-            process.env = originalEnv;
-        });
-
-        it('should create instance with default configuration', async () => {
-            const instance = await get_hass() as TestHassInstance;
-            expect(instance._baseUrl).toBe('http://localhost:8123');
-            expect(instance._token).toBe('test_token');
-        });
-
-        it('should reuse existing instance', async () => {
-            const instance1 = await get_hass();
-            const instance2 = await get_hass();
-            expect(instance1).toBe(instance2);
-        });
-
-        it('should use custom configuration', async () => {
-            process.env.HASS_HOST = 'https://hass.example.com';
-            process.env.HASS_TOKEN = 'prod_token';
-            const instance = await get_hass() as TestHassInstance;
-            expect(instance._baseUrl).toBe('https://hass.example.com');
-            expect(instance._token).toBe('prod_token');
         });
     });
 }); 

__tests__/helpers.test.ts

@@ -1,15 +1,10 @@
-import { jest, describe, it, expect } from '@jest/globals';
+import { describe, expect, test } from "bun:test";
-
+import { describe, expect, test } from "bun:test";
-// Helper function moved from src/helpers.ts
+import { formatToolCall } from "../src/utils/helpers";
-const formatToolCall = (obj: any, isError: boolean = false) => {
-    return {
-        content: [{ type: "text", text: JSON.stringify(obj, null, 2), isError }],
-    };
-};
 
 describe('helpers', () => {
     describe('formatToolCall', () => {
-        it('should format an object into the correct structure', () => {
+        test('should format an object into the correct structure', () => {
             const testObj = { name: 'test', value: 123 };
             const result = formatToolCall(testObj);
 
@@ -22,7 +17,7 @@ describe('helpers', () => {
             });
         });
 
-        it('should handle error cases correctly', () => {
+        test('should handle error cases correctly', () => {
             const testObj = { error: 'test error' };
             const result = formatToolCall(testObj, true);
 
@@ -35,7 +30,7 @@ describe('helpers', () => {
             });
         });
 
-        it('should handle empty objects', () => {
+        test('should handle empty objects', () => {
             const testObj = {};
             const result = formatToolCall(testObj);
 
@@ -47,5 +42,26 @@ describe('helpers', () => {
                 }]
             });
         });
+
+        test('should handle null and undefined', () => {
+            const nullResult = formatToolCall(null);
+            const undefinedResult = formatToolCall(undefined);
+
+            expect(nullResult).toEqual({
+                content: [{
+                    type: 'text',
+                    text: 'null',
+                    isError: false
+                }]
+            });
+
+            expect(undefinedResult).toEqual({
+                content: [{
+                    type: 'text',
+                    text: 'undefined',
+                    isError: false
+                }]
+            });
+        });
     });
 }); 

__tests__/schemas/devices.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "bun:test";
 import {
     MediaPlayerSchema,
     FanSchema,
@@ -17,7 +18,7 @@ import {
 
 describe('Device Schemas', () => {
     describe('Media Player Schema', () => {
-        it('should validate a valid media player entity', () => {
+        test('should validate a valid media player entity', () => {
             const mediaPlayer = {
                 entity_id: 'media_player.living_room',
                 state: 'playing',
@@ -35,7 +36,7 @@ describe('Device Schemas', () => {
             expect(() => MediaPlayerSchema.parse(mediaPlayer)).not.toThrow();
         });
 
-        it('should validate media player list response', () => {
+        test('should validate media player list response', () => {
             const response = {
                 media_players: [{
                     entity_id: 'media_player.living_room',
@@ -48,7 +49,7 @@ describe('Device Schemas', () => {
     });
 
     describe('Fan Schema', () => {
-        it('should validate a valid fan entity', () => {
+        test('should validate a valid fan entity', () => {
             const fan = {
                 entity_id: 'fan.bedroom',
                 state: 'on',
@@ -64,7 +65,7 @@ describe('Device Schemas', () => {
             expect(() => FanSchema.parse(fan)).not.toThrow();
         });
 
-        it('should validate fan list response', () => {
+        test('should validate fan list response', () => {
             const response = {
                 fans: [{
                     entity_id: 'fan.bedroom',
@@ -77,7 +78,7 @@ describe('Device Schemas', () => {
     });
 
     describe('Lock Schema', () => {
-        it('should validate a valid lock entity', () => {
+        test('should validate a valid lock entity', () => {
             const lock = {
                 entity_id: 'lock.front_door',
                 state: 'locked',
@@ -91,7 +92,7 @@ describe('Device Schemas', () => {
             expect(() => LockSchema.parse(lock)).not.toThrow();
         });
 
-        it('should validate lock list response', () => {
+        test('should validate lock list response', () => {
             const response = {
                 locks: [{
                     entity_id: 'lock.front_door',
@@ -104,7 +105,7 @@ describe('Device Schemas', () => {
     });
 
     describe('Vacuum Schema', () => {
-        it('should validate a valid vacuum entity', () => {
+        test('should validate a valid vacuum entity', () => {
             const vacuum = {
                 entity_id: 'vacuum.robot',
                 state: 'cleaning',
@@ -119,7 +120,7 @@ describe('Device Schemas', () => {
             expect(() => VacuumSchema.parse(vacuum)).not.toThrow();
         });
 
-        it('should validate vacuum list response', () => {
+        test('should validate vacuum list response', () => {
             const response = {
                 vacuums: [{
                     entity_id: 'vacuum.robot',
@@ -132,7 +133,7 @@ describe('Device Schemas', () => {
     });
 
     describe('Scene Schema', () => {
-        it('should validate a valid scene entity', () => {
+        test('should validate a valid scene entity', () => {
             const scene = {
                 entity_id: 'scene.movie_night',
                 state: 'on',
@@ -144,7 +145,7 @@ describe('Device Schemas', () => {
             expect(() => SceneSchema.parse(scene)).not.toThrow();
         });
 
-        it('should validate scene list response', () => {
+        test('should validate scene list response', () => {
             const response = {
                 scenes: [{
                     entity_id: 'scene.movie_night',
@@ -157,7 +158,7 @@ describe('Device Schemas', () => {
     });
 
     describe('Script Schema', () => {
-        it('should validate a valid script entity', () => {
+        test('should validate a valid script entity', () => {
             const script = {
                 entity_id: 'script.welcome_home',
                 state: 'on',
@@ -174,7 +175,7 @@ describe('Device Schemas', () => {
             expect(() => ScriptSchema.parse(script)).not.toThrow();
         });
 
-        it('should validate script list response', () => {
+        test('should validate script list response', () => {
             const response = {
                 scripts: [{
                     entity_id: 'script.welcome_home',
@@ -187,7 +188,7 @@ describe('Device Schemas', () => {
     });
 
     describe('Camera Schema', () => {
-        it('should validate a valid camera entity', () => {
+        test('should validate a valid camera entity', () => {
             const camera = {
                 entity_id: 'camera.front_door',
                 state: 'recording',
@@ -200,7 +201,7 @@ describe('Device Schemas', () => {
             expect(() => CameraSchema.parse(camera)).not.toThrow();
         });
 
-        it('should validate camera list response', () => {
+        test('should validate camera list response', () => {
             const response = {
                 cameras: [{
                     entity_id: 'camera.front_door',

__tests__/schemas/hass.test.ts

@@ -1,20 +1,22 @@
-import { entitySchema, serviceSchema, stateChangedEventSchema, configSchema, automationSchema, deviceControlSchema } from '../../src/schemas/hass.js';
+import { describe, expect, test } from "bun:test";
-import AjvModule from 'ajv';
+import {
-const Ajv = AjvModule.default || AjvModule;
+    validateEntity,
+    validateService,
+    validateStateChangedEvent,
+    validateConfig,
+    validateAutomation,
+    validateDeviceControl
+} from '../../src/schemas/hass.js';
 
 describe('Home Assistant Schemas', () => {
-    const ajv = new Ajv({ allErrors: true });
-
     describe('Entity Schema', () => {
-        const validate = ajv.compile(entitySchema);
+        test('should validate a valid entity', () => {
-
-        it('should validate a valid entity', () => {
             const validEntity = {
                 entity_id: 'light.living_room',
                 state: 'on',
                 attributes: {
                     brightness: 255,
-                    friendly_name: 'Living Room Light'
+                    color_temp: 300
                 },
                 last_changed: '2024-01-01T00:00:00Z',
                 last_updated: '2024-01-01T00:00:00Z',
@@ -24,27 +26,26 @@ describe('Home Assistant Schemas', () => {
                     user_id: null
                 }
             };
-            expect(validate(validEntity)).toBe(true);
+            const result = validateEntity(validEntity);
+            expect(result.success).toBe(true);
         });
 
-        it('should reject entity with missing required fields', () => {
+        test('should reject entity with missing required fields', () => {
             const invalidEntity = {
-                entity_id: 'light.living_room',
+                state: 'on',
-                state: 'on'
+                attributes: {}
-                // missing attributes, last_changed, last_updated, context
             };
-            expect(validate(invalidEntity)).toBe(false);
+            const result = validateEntity(invalidEntity);
-            expect(validate.errors).toBeDefined();
+            expect(result.success).toBe(false);
         });
 
-        it('should validate entity with additional attributes', () => {
+        test('should validate entity with additional attributes', () => {
-            const entityWithExtraAttrs = {
+            const validEntity = {
-                entity_id: 'climate.living_room',
+                entity_id: 'light.living_room',
-                state: '22',
+                state: 'on',
                 attributes: {
-                    temperature: 22,
+                    brightness: 255,
-                    humidity: 45,
+                    color_temp: 300,
-                    mode: 'auto',
                     custom_attr: 'value'
                 },
                 last_changed: '2024-01-01T00:00:00Z',
@@ -55,11 +56,12 @@ describe('Home Assistant Schemas', () => {
                     user_id: null
                 }
             };
-            expect(validate(entityWithExtraAttrs)).toBe(true);
+            const result = validateEntity(validEntity);
+            expect(result.success).toBe(true);
         });
 
-        it('should reject invalid entity_id format', () => {
+        test('should reject invalid entity_id format', () => {
-            const invalidEntityId = {
+            const invalidEntity = {
                 entity_id: 'invalid_format',
                 state: 'on',
                 attributes: {},
@@ -71,93 +73,87 @@ describe('Home Assistant Schemas', () => {
                     user_id: null
                 }
             };
-            expect(validate(invalidEntityId)).toBe(false);
+            const result = validateEntity(invalidEntity);
+            expect(result.success).toBe(false);
         });
     });
 
     describe('Service Schema', () => {
-        const validate = ajv.compile(serviceSchema);
+        test('should validate a basic service call', () => {
-
-        it('should validate a basic service call', () => {
             const basicService = {
                 domain: 'light',
                 service: 'turn_on',
                 target: {
-                    entity_id: ['light.living_room']
+                    entity_id: 'light.living_room'
-                }
-            };
-            expect(validate(basicService)).toBe(true);
-        });
-
-        it('should validate service call with multiple targets', () => {
-            const multiTargetService = {
-                domain: 'light',
-                service: 'turn_on',
-                target: {
-                    entity_id: ['light.living_room', 'light.kitchen'],
-                    device_id: ['device123', 'device456'],
-                    area_id: ['living_room', 'kitchen']
                 },
                 service_data: {
                     brightness_pct: 100
                 }
             };
-            expect(validate(multiTargetService)).toBe(true);
+            const result = validateService(basicService);
+            expect(result.success).toBe(true);
         });
 
-        it('should validate service call without targets', () => {
+        test('should validate service call with multiple targets', () => {
+            const multiTargetService = {
+                domain: 'light',
+                service: 'turn_on',
+                target: {
+                    entity_id: ['light.living_room', 'light.kitchen']
+                },
+                service_data: {
+                    brightness_pct: 100
+                }
+            };
+            const result = validateService(multiTargetService);
+            expect(result.success).toBe(true);
+        });
+
+        test('should validate service call without targets', () => {
             const noTargetService = {
                 domain: 'homeassistant',
                 service: 'restart'
             };
-            expect(validate(noTargetService)).toBe(true);
+            const result = validateService(noTargetService);
+            expect(result.success).toBe(true);
         });
 
-        it('should reject service call with invalid target type', () => {
+        test('should reject service call with invalid target type', () => {
             const invalidService = {
                 domain: 'light',
                 service: 'turn_on',
                 target: {
-                    entity_id: 'not_an_array' // should be an array
+                    entity_id: 123 // Invalid type
                 }
             };
-            expect(validate(invalidService)).toBe(false);
+            const result = validateService(invalidService);
-            expect(validate.errors).toBeDefined();
+            expect(result.success).toBe(false);
+        });
+
+        test('should reject service call with invalid domain', () => {
+            const invalidService = {
+                domain: '',
+                service: 'turn_on'
+            };
+            const result = validateService(invalidService);
+            expect(result.success).toBe(false);
         });
     });
 
     describe('State Changed Event Schema', () => {
-        const validate = ajv.compile(stateChangedEventSchema);
+        test('should validate a valid state changed event', () => {
-
-        it('should validate a valid state changed event', () => {
             const validEvent = {
                 event_type: 'state_changed',
                 data: {
                     entity_id: 'light.living_room',
+                    old_state: {
+                        state: 'off',
+                        attributes: {}
+                    },
                     new_state: {
-                        entity_id: 'light.living_room',
                         state: 'on',
                         attributes: {
                             brightness: 255
-                        },
-                        last_changed: '2024-01-01T00:00:00Z',
-                        last_updated: '2024-01-01T00:00:00Z',
-                        context: {
-                            id: '123456',
-                            parent_id: null,
-                            user_id: null
-                        }
-                    },
-                    old_state: {
-                        entity_id: 'light.living_room',
-                        state: 'off',
-                        attributes: {},
-                        last_changed: '2024-01-01T00:00:00Z',
-                        last_updated: '2024-01-01T00:00:00Z',
-                        context: {
-                            id: '123456',
-                            parent_id: null,
-                            user_id: null
                         }
                     }
                 },
@@ -169,27 +165,20 @@ describe('Home Assistant Schemas', () => {
                     user_id: null
                 }
             };
-            expect(validate(validEvent)).toBe(true);
+            const result = validateStateChangedEvent(validEvent);
+            expect(result.success).toBe(true);
         });
 
-        it('should validate event with null old_state', () => {
+        test('should validate event with null old_state', () => {
             const newEntityEvent = {
                 event_type: 'state_changed',
                 data: {
                     entity_id: 'light.living_room',
+                    old_state: null,
                     new_state: {
-                        entity_id: 'light.living_room',
                         state: 'on',
-                        attributes: {},
+                        attributes: {}
-                        last_changed: '2024-01-01T00:00:00Z',
+                    }
-                        last_updated: '2024-01-01T00:00:00Z',
-                        context: {
-                            id: '123456',
-                            parent_id: null,
-                            user_id: null
-                        }
-                    },
-                    old_state: null
                 },
                 origin: 'LOCAL',
                 time_fired: '2024-01-01T00:00:00Z',
@@ -199,334 +188,91 @@ describe('Home Assistant Schemas', () => {
                     user_id: null
                 }
             };
-            expect(validate(newEntityEvent)).toBe(true);
+            const result = validateStateChangedEvent(newEntityEvent);
+            expect(result.success).toBe(true);
         });
 
-        it('should reject event with invalid event_type', () => {
+        test('should reject event with invalid event_type', () => {
             const invalidEvent = {
                 event_type: 'wrong_type',
                 data: {
                     entity_id: 'light.living_room',
-                    new_state: null,
+                    old_state: null,
-                    old_state: null
+                    new_state: {
-                },
+                        state: 'on',
-                origin: 'LOCAL',
+                        attributes: {}
-                time_fired: '2024-01-01T00:00:00Z',
+                    }
-                context: {
-                    id: '123456',
-                    parent_id: null,
-                    user_id: null
                 }
             };
-            expect(validate(invalidEvent)).toBe(false);
+            const result = validateStateChangedEvent(invalidEvent);
-            expect(validate.errors).toBeDefined();
+            expect(result.success).toBe(false);
         });
     });
 
     describe('Config Schema', () => {
-        const validate = ajv.compile(configSchema);
+        test('should validate a minimal config', () => {
-
-        it('should validate a minimal config', () => {
             const minimalConfig = {
-                latitude: 52.3731,
-                longitude: 4.8922,
-                elevation: 0,
-                unit_system: {
-                    length: 'km',
-                    mass: 'kg',
-                    temperature: '°C',
-                    volume: 'L'
-                },
                 location_name: 'Home',
                 time_zone: 'Europe/Amsterdam',
                 components: ['homeassistant'],
                 version: '2024.1.0'
             };
-            expect(validate(minimalConfig)).toBe(true);
+            const result = validateConfig(minimalConfig);
+            expect(result.success).toBe(true);
         });
 
-        it('should reject config with missing required fields', () => {
+        test('should reject config with missing required fields', () => {
             const invalidConfig = {
-                latitude: 52.3731,
+                location_name: 'Home'
-                longitude: 4.8922
-                // missing other required fields
             };
-            expect(validate(invalidConfig)).toBe(false);
+            const result = validateConfig(invalidConfig);
-            expect(validate.errors).toBeDefined();
+            expect(result.success).toBe(false);
         });
 
-        it('should reject config with invalid types', () => {
+        test('should reject config with invalid types', () => {
             const invalidConfig = {
-                latitude: '52.3731', // should be number
+                location_name: 123,
-                longitude: 4.8922,
-                elevation: 0,
-                unit_system: {
-                    length: 'km',
-                    mass: 'kg',
-                    temperature: '°C',
-                    volume: 'L'
-                },
-                location_name: 'Home',
                 time_zone: 'Europe/Amsterdam',
-                components: ['homeassistant'],
+                components: 'not_an_array',
                 version: '2024.1.0'
             };
-            expect(validate(invalidConfig)).toBe(false);
+            const result = validateConfig(invalidConfig);
-            expect(validate.errors).toBeDefined();
+            expect(result.success).toBe(false);
-        });
-    });
-
-    describe('Automation Schema', () => {
-        const validate = ajv.compile(automationSchema);
-
-        it('should validate a basic automation', () => {
-            const basicAutomation = {
-                alias: 'Turn on lights at sunset',
-                description: 'Automatically turn on lights when the sun sets',
-                trigger: [{
-                    platform: 'sun',
-                    event: 'sunset',
-                    offset: '+00:30:00'
-                }],
-                action: [{
-                    service: 'light.turn_on',
-                    target: {
-                        entity_id: ['light.living_room', 'light.kitchen']
-                    },
-                    data: {
-                        brightness_pct: 70
-                    }
-                }]
-            };
-            expect(validate(basicAutomation)).toBe(true);
-        });
-
-        it('should validate automation with conditions', () => {
-            const automationWithConditions = {
-                alias: 'Conditional Light Control',
-                mode: 'single',
-                trigger: [{
-                    platform: 'state',
-                    entity_id: 'binary_sensor.motion',
-                    to: 'on'
-                }],
-                condition: [{
-                    condition: 'and',
-                    conditions: [
-                        {
-                            condition: 'time',
-                            after: '22:00:00',
-                            before: '06:00:00'
-                        },
-                        {
-                            condition: 'state',
-                            entity_id: 'input_boolean.guest_mode',
-                            state: 'off'
-                        }
-                    ]
-                }],
-                action: [{
-                    service: 'light.turn_on',
-                    target: {
-                        entity_id: 'light.hallway'
-                    }
-                }]
-            };
-            expect(validate(automationWithConditions)).toBe(true);
-        });
-
-        it('should validate automation with multiple triggers and actions', () => {
-            const complexAutomation = {
-                alias: 'Complex Automation',
-                mode: 'parallel',
-                trigger: [
-                    {
-                        platform: 'state',
-                        entity_id: 'binary_sensor.door',
-                        to: 'on'
-                    },
-                    {
-                        platform: 'state',
-                        entity_id: 'binary_sensor.window',
-                        to: 'on'
-                    }
-                ],
-                condition: [{
-                    condition: 'state',
-                    entity_id: 'alarm_control_panel.home',
-                    state: 'armed_away'
-                }],
-                action: [
-                    {
-                        service: 'notify.mobile_app',
-                        data: {
-                            message: 'Security alert: Movement detected!'
-                        }
-                    },
-                    {
-                        service: 'light.turn_on',
-                        target: {
-                            entity_id: 'light.all_lights'
-                        }
-                    },
-                    {
-                        service: 'camera.snapshot',
-                        target: {
-                            entity_id: 'camera.front_door'
-                        }
-                    }
-                ]
-            };
-            expect(validate(complexAutomation)).toBe(true);
-        });
-
-        it('should reject automation without required fields', () => {
-            const invalidAutomation = {
-                description: 'Missing required fields'
-                // missing alias, trigger, and action
-            };
-            expect(validate(invalidAutomation)).toBe(false);
-            expect(validate.errors).toBeDefined();
-        });
-
-        it('should validate all automation modes', () => {
-            const modes = ['single', 'parallel', 'queued', 'restart'];
-            modes.forEach(mode => {
-                const automation = {
-                    alias: `Test ${mode} mode`,
-                    mode,
-                    trigger: [{
-                        platform: 'state',
-                        entity_id: 'input_boolean.test',
-                        to: 'on'
-                    }],
-                    action: [{
-                        service: 'light.turn_on',
-                        target: {
-                            entity_id: 'light.test'
-                        }
-                    }]
-                };
-                expect(validate(automation)).toBe(true);
-            });
         });
     });
 
     describe('Device Control Schema', () => {
-        const validate = ajv.compile(deviceControlSchema);
+        test('should validate light control command', () => {
-
+            const command = {
-        it('should validate light control command', () => {
-            const lightCommand = {
                 domain: 'light',
                 command: 'turn_on',
                 entity_id: 'light.living_room',
                 parameters: {
-                    brightness: 255,
+                    brightness_pct: 100
-                    color_temp: 400,
-                    transition: 2
                 }
             };
-            expect(validate(lightCommand)).toBe(true);
+            const result = validateDeviceControl(command);
+            expect(result.success).toBe(true);
         });
 
-        it('should validate climate control command', () => {
+        test('should reject command with mismatched domain and entity_id', () => {
-            const climateCommand = {
-                domain: 'climate',
-                command: 'set_temperature',
-                entity_id: 'climate.living_room',
-                parameters: {
-                    temperature: 22.5,
-                    hvac_mode: 'heat',
-                    target_temp_high: 24,
-                    target_temp_low: 20
-                }
-            };
-            expect(validate(climateCommand)).toBe(true);
-        });
-
-        it('should validate cover control command', () => {
-            const coverCommand = {
-                domain: 'cover',
-                command: 'set_position',
-                entity_id: 'cover.garage_door',
-                parameters: {
-                    position: 50,
-                    tilt_position: 45
-                }
-            };
-            expect(validate(coverCommand)).toBe(true);
-        });
-
-        it('should validate fan control command', () => {
-            const fanCommand = {
-                domain: 'fan',
-                command: 'set_speed',
-                entity_id: 'fan.bedroom',
-                parameters: {
-                    speed: 'medium',
-                    oscillating: true,
-                    direction: 'forward'
-                }
-            };
-            expect(validate(fanCommand)).toBe(true);
-        });
-
-        it('should reject command with invalid domain', () => {
-            const invalidCommand = {
-                domain: 'invalid_domain',
-                command: 'turn_on',
-                entity_id: 'light.living_room'
-            };
-            expect(validate(invalidCommand)).toBe(false);
-            expect(validate.errors).toBeDefined();
-        });
-
-        it('should reject command with mismatched domain and entity_id', () => {
             const mismatchedCommand = {
                 domain: 'light',
                 command: 'turn_on',
                 entity_id: 'switch.living_room' // mismatched domain
             };
-            expect(validate(mismatchedCommand)).toBe(false);
+            const result = validateDeviceControl(mismatchedCommand);
+            expect(result.success).toBe(false);
         });
 
-        it('should validate command with array of entity_ids', () => {
+        test('should validate command with array of entity_ids', () => {
-            const multiEntityCommand = {
+            const command = {
                 domain: 'light',
                 command: 'turn_on',
-                entity_id: ['light.living_room', 'light.kitchen'],
+                entity_id: ['light.living_room', 'light.kitchen']
-                parameters: {
-                    brightness: 255
-                }
             };
-            expect(validate(multiEntityCommand)).toBe(true);
+            const result = validateDeviceControl(command);
-        });
+            expect(result.success).toBe(true);
-
-        it('should validate scene activation command', () => {
-            const sceneCommand = {
-                domain: 'scene',
-                command: 'turn_on',
-                entity_id: 'scene.movie_night',
-                parameters: {
-                    transition: 2
-                }
-            };
-            expect(validate(sceneCommand)).toBe(true);
-        });
-
-        it('should validate script execution command', () => {
-            const scriptCommand = {
-                domain: 'script',
-                command: 'turn_on',
-                entity_id: 'script.welcome_home',
-                parameters: {
-                    variables: {
-                        user: 'John',
-                        delay: 5
-                    }
-                }
-            };
-            expect(validate(scriptCommand)).toBe(true);
         });
     });
 }); 

__tests__/security/index.test.ts

@@ -1,212 +1,315 @@
-import { TokenManager, validateRequest, sanitizeInput, errorHandler } from '../../src/security/index.js';
+import { describe, expect, test } from "bun:test";
-import { Request, Response } from 'express';
+import { TokenManager, validateRequest, sanitizeInput, errorHandler, rateLimiter, securityHeaders } from '../../src/security/index.js';
+import { mock, describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import jwt from 'jsonwebtoken';
+
+const TEST_SECRET = 'test-secret-that-is-long-enough-for-testing-purposes';
 
 describe('Security Module', () => {
+    beforeEach(() => {
+        process.env.JWT_SECRET = TEST_SECRET;
+    });
+
+    afterEach(() => {
+        delete process.env.JWT_SECRET;
+    });
+
     describe('TokenManager', () => {
-        const testToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiZXhwIjoxNzE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+        const testToken = 'test-token';
-        const encryptionKey = 'test_encryption_key';
+        const encryptionKey = 'test-encryption-key-that-is-long-enough';
 
-        it('should encrypt and decrypt tokens', () => {
+        test('should encrypt and decrypt tokens', () => {
             const encrypted = TokenManager.encryptToken(testToken, encryptionKey);
-            const decrypted = TokenManager.decryptToken(encrypted, encryptionKey);
+            expect(encrypted).toContain('aes-256-gcm:');
 
+            const decrypted = TokenManager.decryptToken(encrypted, encryptionKey);
             expect(decrypted).toBe(testToken);
         });
 
-        it('should validate tokens correctly', () => {
+        test('should validate tokens correctly', () => {
-            expect(TokenManager.validateToken(testToken)).toBe(true);
+            const validToken = jwt.sign({ data: 'test' }, TEST_SECRET, { expiresIn: '1h' });
-            expect(TokenManager.validateToken('invalid_token')).toBe(false);
+            const result = TokenManager.validateToken(validToken);
-            expect(TokenManager.validateToken('')).toBe(false);
+            expect(result.valid).toBe(true);
+            expect(result.error).toBeUndefined();
         });
 
-        it('should handle expired tokens', () => {
+        test('should handle empty tokens', () => {
-            const expiredToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiZXhwIjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+            const result = TokenManager.validateToken('');
-            expect(TokenManager.validateToken(expiredToken)).toBe(false);
+            expect(result.valid).toBe(false);
+            expect(result.error).toBe('Invalid token format');
+        });
+
+        test('should handle expired tokens', () => {
+            const now = Math.floor(Date.now() / 1000);
+            const payload = {
+                data: 'test',
+                iat: now - 7200,  // 2 hours ago
+                exp: now - 3600   // expired 1 hour ago
+            };
+            const token = jwt.sign(payload, TEST_SECRET);
+            const result = TokenManager.validateToken(token);
+            expect(result.valid).toBe(false);
+            expect(result.error).toBe('Token has expired');
+        });
+
+        test('should handle invalid token format', () => {
+            const result = TokenManager.validateToken('invalid-token');
+            expect(result.valid).toBe(false);
+            expect(result.error).toBe('Invalid token format');
+        });
+
+        test('should handle missing JWT secret', () => {
+            delete process.env.JWT_SECRET;
+            const payload = { data: 'test' };
+            const token = jwt.sign(payload, 'some-secret');
+            const result = TokenManager.validateToken(token);
+            expect(result.valid).toBe(false);
+            expect(result.error).toBe('JWT secret not configured');
+        });
+
+        test('should handle rate limiting for failed attempts', () => {
+            const invalidToken = 'x'.repeat(64);
+            const testIp = '127.0.0.1';
+
+            // First attempt
+            const firstResult = TokenManager.validateToken(invalidToken, testIp);
+            expect(firstResult.valid).toBe(false);
+
+            // Multiple failed attempts
+            for (let i = 0; i < 4; i++) {
+                TokenManager.validateToken(invalidToken, testIp);
+            }
+
+            // Next attempt should be rate limited
+            const limitedResult = TokenManager.validateToken(invalidToken, testIp);
+            expect(limitedResult.valid).toBe(false);
+            expect(limitedResult.error).toBe('Too many failed attempts. Please try again later.');
         });
     });
 
     describe('Request Validation', () => {
-        let mockRequest: Partial<Request>;
+        let mockRequest: any;
-        let mockResponse: Partial<Response>;
+        let mockResponse: any;
-        let mockNext: jest.Mock;
+        let mockNext: any;
 
         beforeEach(() => {
             mockRequest = {
                 method: 'POST',
                 headers: {
-                    'content-type': 'application/json',
+                    'content-type': 'application/json'
-                    authorization: 'Bearer validToken'
                 },
-                is: jest.fn().mockReturnValue(true),
+                body: {},
-                body: { test: 'data' }
+                ip: '127.0.0.1'
             };
+
             mockResponse = {
-                status: jest.fn().mockReturnThis(),
+                status: mock(() => mockResponse),
-                json: jest.fn()
+                json: mock(() => mockResponse),
+                setHeader: mock(() => mockResponse),
+                removeHeader: mock(() => mockResponse)
             };
-            mockNext = jest.fn();
+
+            mockNext = mock(() => { });
         });
 
-        it('should pass valid requests', () => {
+        test('should pass valid requests', () => {
-            validateRequest(
+            if (mockRequest.headers) {
-                mockRequest as Request,
+                mockRequest.headers.authorization = 'Bearer valid-token';
-                mockResponse as Response,
+            }
-                mockNext
+            const validateTokenSpy = mock(() => ({ valid: true }));
-            );
+            TokenManager.validateToken = validateTokenSpy;
+
+            validateRequest(mockRequest, mockResponse, mockNext);
 
             expect(mockNext).toHaveBeenCalled();
-            expect(mockResponse.status).not.toHaveBeenCalled();
         });
 
-        it('should reject invalid content type', () => {
+        test('should reject invalid content type', () => {
-            mockRequest.is = jest.fn().mockReturnValue(false);
+            if (mockRequest.headers) {
+                mockRequest.headers['content-type'] = 'text/plain';
+            }
 
-            validateRequest(
+            validateRequest(mockRequest, mockResponse, mockNext);
-                mockRequest as Request,
-                mockResponse as Response,
-                mockNext
-            );
 
             expect(mockResponse.status).toHaveBeenCalledWith(415);
             expect(mockResponse.json).toHaveBeenCalledWith({
-                error: 'Unsupported Media Type - Content-Type must be application/json'
+                success: false,
+                message: 'Unsupported Media Type',
+                error: 'Content-Type must be application/json',
+                timestamp: expect.any(String)
             });
         });
 
-        it('should reject missing token', () => {
+        test('should reject missing token', () => {
-            mockRequest.headers = {};
+            if (mockRequest.headers) {
+                delete mockRequest.headers.authorization;
+            }
 
-            validateRequest(
+            validateRequest(mockRequest, mockResponse, mockNext);
-                mockRequest as Request,
-                mockResponse as Response,
-                mockNext
-            );
 
             expect(mockResponse.status).toHaveBeenCalledWith(401);
             expect(mockResponse.json).toHaveBeenCalledWith({
-                error: 'Invalid or expired token'
+                success: false,
+                message: 'Unauthorized',
+                error: 'Missing or invalid authorization header',
+                timestamp: expect.any(String)
             });
         });
 
-        it('should reject invalid request body', () => {
+        test('should reject invalid request body', () => {
             mockRequest.body = null;
 
-            validateRequest(
+            validateRequest(mockRequest, mockResponse, mockNext);
-                mockRequest as Request,
-                mockResponse as Response,
-                mockNext
-            );
 
             expect(mockResponse.status).toHaveBeenCalledWith(400);
             expect(mockResponse.json).toHaveBeenCalledWith({
-                error: 'Invalid request body'
+                success: false,
+                message: 'Bad Request',
+                error: 'Invalid request body structure',
+                timestamp: expect.any(String)
             });
         });
     });
 
     describe('Input Sanitization', () => {
-        let mockRequest: Partial<Request>;
+        let mockRequest: any;
-        let mockResponse: Partial<Response>;
+        let mockResponse: any;
-        let mockNext: jest.Mock;
+        let mockNext: any;
 
         beforeEach(() => {
             mockRequest = {
-                body: {}
+                method: 'POST',
-            };
+                headers: {
-            mockResponse = {};
+                    'content-type': 'application/json'
-            mockNext = jest.fn();
+                },
-        });
+                body: {
-
+                    text: 'Test alert("xss")',
-        it('should sanitize HTML tags from request body', () => {
+                    nested: {
-            mockRequest.body = {
+                        html: 'img src="x" onerror="alert(1)"'
-                text: 'Test <script>alert("xss")</script>',
+                    }
-                nested: {
-                    html: '<img src="x" onerror="alert(1)">'
                 }
             };
 
-            sanitizeInput(
+            mockResponse = {
-                mockRequest as Request,
+                status: mock(() => mockResponse),
-                mockResponse as Response,
+                json: mock(() => mockResponse)
-                mockNext
+            };
-            );
+
+            mockNext = mock(() => { });
+        });
+
+        test('should sanitize HTML tags from request body', () => {
+            sanitizeInput(mockRequest, mockResponse, mockNext);
 
             expect(mockRequest.body).toEqual({
-                text: 'Test alert("xss")',
+                text: 'Test',
                 nested: {
-                    html: 'img src="x" onerror="alert(1)"'
+                    html: ''
                 }
             });
             expect(mockNext).toHaveBeenCalled();
         });
 
-        it('should handle non-object body', () => {
+        test('should handle non-object body', () => {
             mockRequest.body = 'string body';
-
+            sanitizeInput(mockRequest, mockResponse, mockNext);
-            sanitizeInput(
-                mockRequest as Request,
-                mockResponse as Response,
-                mockNext
-            );
-
-            expect(mockRequest.body).toBe('string body');
             expect(mockNext).toHaveBeenCalled();
         });
     });
 
     describe('Error Handler', () => {
-        let mockRequest: Partial<Request>;
+        let mockRequest: any;
-        let mockResponse: Partial<Response>;
+        let mockResponse: any;
-        let mockNext: jest.Mock;
+        let mockNext: any;
-        const originalEnv = process.env.NODE_ENV;
 
         beforeEach(() => {
-            mockRequest = {};
+            mockRequest = {
-            mockResponse = {
+                method: 'POST',
-                status: jest.fn().mockReturnThis(),
+                ip: '127.0.0.1'
-                json: jest.fn()
             };
-            mockNext = jest.fn();
+
+            mockResponse = {
+                status: mock(() => mockResponse),
+                json: mock(() => mockResponse)
+            };
+
+            mockNext = mock(() => { });
         });
 
-        afterAll(() => {
+        test('should handle errors in production mode', () => {
-            process.env.NODE_ENV = originalEnv;
-        });
-
-        it('should handle errors in production mode', () => {
             process.env.NODE_ENV = 'production';
             const error = new Error('Test error');
-
+            errorHandler(error, mockRequest, mockResponse, mockNext);
-            errorHandler(
-                error,
-                mockRequest as Request,
-                mockResponse as Response,
-                mockNext
-            );
 
             expect(mockResponse.status).toHaveBeenCalledWith(500);
             expect(mockResponse.json).toHaveBeenCalledWith({
-                error: 'Internal Server Error',
+                success: false,
-                message: undefined
+                message: 'Internal Server Error',
+                timestamp: expect.any(String)
             });
         });
 
-        it('should include error message in development mode', () => {
+        test('should include error message in development mode', () => {
             process.env.NODE_ENV = 'development';
             const error = new Error('Test error');
-
+            errorHandler(error, mockRequest, mockResponse, mockNext);
-            errorHandler(
-                error,
-                mockRequest as Request,
-                mockResponse as Response,
-                mockNext
-            );
 
             expect(mockResponse.status).toHaveBeenCalledWith(500);
             expect(mockResponse.json).toHaveBeenCalledWith({
-                error: 'Internal Server Error',
+                success: false,
-                message: 'Test error'
+                message: 'Internal Server Error',
+                error: 'Test error',
+                stack: expect.any(String),
+                timestamp: expect.any(String)
             });
         });
     });
+
+    describe('Rate Limiter', () => {
+        test('should limit requests after threshold', async () => {
+            const mockContext = {
+                request: new Request('http://localhost', {
+                    headers: new Headers({
+                        'x-forwarded-for': '127.0.0.1'
+                    })
+                }),
+                set: mock(() => { })
+            };
+
+            // Test multiple requests
+            for (let i = 0; i < 100; i++) {
+                await rateLimiter.derive(mockContext);
+            }
+
+            // The next request should throw
+            try {
+                await rateLimiter.derive(mockContext);
+                expect(false).toBe(true); // Should not reach here
+            } catch (error) {
+                expect(error instanceof Error).toBe(true);
+                expect(error.message).toBe('Too many requests from this IP, please try again later');
+            }
+        });
+    });
+
+    describe('Security Headers', () => {
+        test('should set security headers', async () => {
+            const mockHeaders = new Headers();
+            const mockContext = {
+                request: new Request('http://localhost', {
+                    headers: mockHeaders
+                }),
+                set: mock(() => { })
+            };
+
+            await securityHeaders.derive(mockContext);
+
+            // Verify that security headers were set
+            const headers = mockContext.request.headers;
+            expect(headers.has('content-security-policy')).toBe(true);
+            expect(headers.has('x-frame-options')).toBe(true);
+            expect(headers.has('x-content-type-options')).toBe(true);
+            expect(headers.has('referrer-policy')).toBe(true);
+        });
+    });
 }); 

__tests__/security/middleware.test.ts

@@ -1,177 +1,157 @@
-import { jest, describe, it, expect, beforeEach } from '@jest/globals';
+import { describe, expect, test } from "bun:test";
-import { Request, Response, NextFunction } from 'express';
+import { describe, it, expect } from 'bun:test';
 import {
-    validateRequest,
+    checkRateLimit,
-    sanitizeInput,
+    validateRequestHeaders,
-    errorHandler,
+    sanitizeValue,
-    rateLimiter,
+    applySecurityHeaders,
-    securityHeaders
+    handleError
 } from '../../src/security/index.js';
 
-type MockRequest = {
+describe('Security Middleware Utilities', () => {
-    headers: {
+    describe('Rate Limiter', () => {
-        'content-type'?: string;
+        test('should allow requests under threshold', () => {
-        authorization?: string;
+            const ip = '127.0.0.1';
-    };
+            expect(() => checkRateLimtest(ip, 10)).not.toThrow();
-    body?: any;
+        });
-    is: jest.MockInstance<string | false | null, [type: string | string[]]>;
-};
 
-type MockResponse = {
+        test('should throw when requests exceed threshold', () => {
-    status: jest.MockInstance<MockResponse, [code: number]>;
+            const ip = '127.0.0.2';
-    json: jest.MockInstance<MockResponse, [body: any]>;
-    setHeader: jest.MockInstance<MockResponse, [name: string, value: string]>;
-};
 
-describe('Security Middleware', () => {
+            // Simulate multiple requests
-    let mockRequest: MockRequest;
+            for (let i = 0; i < 11; i++) {
-    let mockResponse: MockResponse;
+                if (i < 10) {
-    let nextFunction: jest.Mock;
+                    expect(() => checkRateLimtest(ip, 10)).not.toThrow();
+                } else {
+                    expect(() => checkRateLimtest(ip, 10)).toThrow('Too many requests from this IP, please try again later');
+                }
+            }
+        });
 
-    beforeEach(() => {
+        test('should reset rate limit after window expires', async () => {
-        mockRequest = {
+            const ip = '127.0.0.3';
-            headers: {},
-            body: {},
-            is: jest.fn<string | false | null, [string | string[]]>().mockReturnValue('json')
-        };
 
-        mockResponse = {
+            // Simulate multiple requests
-            status: jest.fn<MockResponse, [number]>().mockReturnThis(),
+            for (let i = 0; i < 11; i++) {
-            json: jest.fn<MockResponse, [any]>().mockReturnThis(),
+                if (i < 10) {
-            setHeader: jest.fn<MockResponse, [string, string]>().mockReturnThis()
+                    expect(() => checkRateLimtest(ip, 10, 50)).not.toThrow();
-        };
+                }
+            }
 
-        nextFunction = jest.fn();
+            // Wait for rate limit window to expire
+            await new Promise(resolve => setTimeout(resolve, 100));
+
+            // Should be able to make requests again
+            expect(() => checkRateLimtest(ip, 10, 50)).not.toThrow();
+        });
     });
 
     describe('Request Validation', () => {
-        it('should pass valid requests', () => {
+        test('should validate content type', () => {
-            mockRequest.headers.authorization = 'Bearer valid-token';
+            const mockRequest = new Request('http://localhost', {
-            validateRequest(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+                method: 'POST',
-            expect(nextFunction).toHaveBeenCalled();
+                headers: {
+                    'content-type': 'application/json'
+                }
+            });
+
+            expect(() => validateRequestHeaders(mockRequest)).not.toThrow();
         });
 
-        it('should reject requests without authorization header', () => {
+        test('should reject invalid content type', () => {
-            validateRequest(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+            const mockRequest = new Request('http://localhost', {
-            expect(mockResponse.status).toHaveBeenCalledWith(401);
+                method: 'POST',
-            expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+                headers: {
-                error: expect.stringContaining('authorization')
+                    'content-type': 'text/plain'
-            }));
+                }
+            });
+
+            expect(() => validateRequestHeaders(mockRequest)).toThrow('Content-Type must be application/json');
         });
 
-        it('should reject requests with invalid authorization format', () => {
+        test('should reject large request bodies', () => {
-            mockRequest.headers.authorization = 'invalid-format';
+            const mockRequest = new Request('http://localhost', {
-            validateRequest(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+                method: 'POST',
-            expect(mockResponse.status).toHaveBeenCalledWith(401);
+                headers: {
-            expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+                    'content-type': 'application/json',
-                error: expect.stringContaining('Bearer')
+                    'content-length': '2000000'
-            }));
+                }
+            });
+
+            expect(() => validateRequestHeaders(mockRequest)).toThrow('Request body too large');
         });
     });
 
     describe('Input Sanitization', () => {
-        it('should pass requests without body', () => {
+        test('should sanitize HTML tags', () => {
-            delete mockRequest.body;
+            const input = '<script>alert("xss")</script>Hello';
-            sanitizeInput(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+            const sanitized = sanitizeValue(input);
-            expect(nextFunction).toHaveBeenCalled();
+            expect(sanitized).toBe('&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;Hello');
         });
 
-        it('should sanitize HTML in request body', () => {
+        test('should sanitize nested objects', () => {
-            mockRequest.body = {
+            const input = {
                 text: '<script>alert("xss")</script>Hello',
                 nested: {
                     html: '<img src="x" onerror="alert(1)">World'
                 }
             };
-            sanitizeInput(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+            const sanitized = sanitizeValue(input);
-            expect(mockRequest.body.text).toBe('Hello');
+            expect(sanitized).toEqual({
-            expect(mockRequest.body.nested.html).toBe('World');
+                text: '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;Hello',
-            expect(nextFunction).toHaveBeenCalled();
+                nested: {
+                    html: '&lt;img src=&quot;x&quot; onerror=&quot;alert(1)&quot;&gt;World'
+                }
+            });
         });
 
-        it('should handle non-object bodies', () => {
+        test('should preserve non-string values', () => {
-            mockRequest.body = '<p>text</p>';
+            const input = {
-            sanitizeInput(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+                number: 123,
-            expect(mockRequest.body).toBe('text');
-            expect(nextFunction).toHaveBeenCalled();
-        });
-
-        it('should preserve non-string values', () => {
-            mockRequest.body = {
-                number: 42,
                 boolean: true,
-                null: null,
                 array: [1, 2, 3]
             };
-            sanitizeInput(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+            const sanitized = sanitizeValue(input);
-            expect(mockRequest.body).toEqual({
+            expect(sanitized).toEqual(input);
-                number: 42,
-                boolean: true,
-                null: null,
-                array: [1, 2, 3]
-            });
-            expect(nextFunction).toHaveBeenCalled();
-        });
-    });
-
-    describe('Error Handler', () => {
-        const originalEnv = process.env.NODE_ENV;
-
-        afterAll(() => {
-            process.env.NODE_ENV = originalEnv;
-        });
-
-        it('should handle errors in production mode', () => {
-            process.env.NODE_ENV = 'production';
-            const error = new Error('Test error');
-            errorHandler(error, mockRequest as Request, mockResponse as Response, nextFunction);
-            expect(mockResponse.status).toHaveBeenCalledWith(500);
-            expect(mockResponse.json).toHaveBeenCalledWith({
-                error: 'Internal Server Error'
-            });
-        });
-
-        it('should include error details in development mode', () => {
-            process.env.NODE_ENV = 'development';
-            const error = new Error('Test error');
-            errorHandler(error, mockRequest as Request, mockResponse as Response, nextFunction);
-            expect(mockResponse.status).toHaveBeenCalledWith(500);
-            expect(mockResponse.json).toHaveBeenCalledWith({
-                error: 'Test error',
-                stack: expect.any(String)
-            });
-        });
-
-        it('should handle non-Error objects', () => {
-            const error = 'String error message';
-
-            errorHandler(
-                error as any,
-                mockRequest as Request,
-                mockResponse as Response,
-                nextFunction
-            );
-
-            expect(mockResponse.status).toHaveBeenCalledWith(500);
-        });
-    });
-
-    describe('Rate Limiter', () => {
-        it('should be configured with correct options', () => {
-            expect(rateLimiter).toBeDefined();
-            const middleware = rateLimiter as any;
-            expect(middleware.windowMs).toBeDefined();
-            expect(middleware.max).toBeDefined();
         });
     });
 
     describe('Security Headers', () => {
-        it('should set appropriate security headers', () => {
+        test('should apply security headers', () => {
-            securityHeaders(mockRequest as Request, mockResponse as Response, nextFunction);
+            const mockRequest = new Request('http://localhost');
-            expect(mockResponse.setHeader).toHaveBeenCalledWith('X-Content-Type-Options', 'nosniff');
+            const headers = applySecurityHeaders(mockRequest);
-            expect(mockResponse.setHeader).toHaveBeenCalledWith('X-Frame-Options', 'DENY');
+
-            expect(mockResponse.setHeader).toHaveBeenCalledWith('X-XSS-Protection', '1; mode=block');
+            expect(headers).toBeDefined();
-            expect(nextFunction).toHaveBeenCalled();
+            expect(headers['content-security-policy']).toBeDefined();
+            expect(headers['x-frame-options']).toBeDefined();
+            expect(headers['x-content-type-options']).toBeDefined();
+            expect(headers['referrer-policy']).toBeDefined();
+        });
+    });
+
+    describe('Error Handling', () => {
+        test('should handle errors in production mode', () => {
+            const error = new Error('Test error');
+            const result = handleError(error, 'production');
+
+            expect(result).toEqual({
+                error: true,
+                message: 'Internal server error',
+                timestamp: expect.any(String)
+            });
+        });
+
+        test('should include error details in development mode', () => {
+            const error = new Error('Test error');
+            const result = handleError(error, 'development');
+
+            expect(result).toEqual({
+                error: true,
+                message: 'Internal server error',
+                timestamp: expect.any(String),
+                error: 'Test error',
+                stack: expect.any(String)
+            });
         });
     });
 }); 

__tests__/security/token-manager.test.ts

@@ -1,85 +1,121 @@
+import { describe, expect, test } from "bun:test";
 import { TokenManager } from '../../src/security/index.js';
+import jwt from 'jsonwebtoken';
+
+const TEST_SECRET = 'test-secret-that-is-long-enough-for-testing-purposes';
 
 describe('TokenManager', () => {
+    beforeAll(() => {
+        process.env.JWT_SECRET = TEST_SECRET;
+    });
+
+    afterAll(() => {
+        delete process.env.JWT_SECRET;
+    });
+
     const encryptionKey = 'test-encryption-key-32-chars-long!!';
     const validToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiZXhwIjoxNjE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
 
     describe('Token Encryption/Decryption', () => {
-        it('should encrypt and decrypt tokens successfully', () => {
+        test('should encrypt and decrypt tokens successfully', () => {
             const encrypted = TokenManager.encryptToken(validToken, encryptionKey);
             const decrypted = TokenManager.decryptToken(encrypted, encryptionKey);
             expect(decrypted).toBe(validToken);
         });
 
-        it('should generate different encrypted values for same token', () => {
+        test('should generate different encrypted values for same token', () => {
             const encrypted1 = TokenManager.encryptToken(validToken, encryptionKey);
             const encrypted2 = TokenManager.encryptToken(validToken, encryptionKey);
             expect(encrypted1).not.toBe(encrypted2);
         });
 
-        it('should handle empty tokens', () => {
+        test('should handle empty tokens', () => {
             expect(() => TokenManager.encryptToken('', encryptionKey)).toThrow('Invalid token');
             expect(() => TokenManager.decryptToken('', encryptionKey)).toThrow('Invalid encrypted token');
         });
 
-        it('should handle empty encryption keys', () => {
+        test('should handle empty encryption keys', () => {
             expect(() => TokenManager.encryptToken(validToken, '')).toThrow('Invalid encryption key');
             expect(() => TokenManager.decryptToken(validToken, '')).toThrow('Invalid encryption key');
         });
 
-        it('should fail decryption with wrong key', () => {
+        test('should fail decryption with wrong key', () => {
             const encrypted = TokenManager.encryptToken(validToken, encryptionKey);
             expect(() => TokenManager.decryptToken(encrypted, 'wrong-key-32-chars-long!!!!!!!!')).toThrow();
         });
     });
 
     describe('Token Validation', () => {
-        it('should validate correct tokens', () => {
+        test('should validate correct tokens', () => {
-            const validJwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiZXhwIjoxNjcyNTI3OTk5fQ.Q6cm_sZS6uqfGqO3LQ-0VqNXhqXR6mFh6IP7s0NPnSQ';
+            const payload = { sub: '123', name: 'Test User', iat: Math.floor(Date.now() / 1000), exp: Math.floor(Date.now() / 1000) + 3600 };
-            expect(TokenManager.validateToken(validJwt)).toBe(true);
+            const token = jwt.sign(payload, TEST_SECRET);
+            const result = TokenManager.validateToken(token);
+            expect(result.valid).toBe(true);
+            expect(result.error).toBeUndefined();
         });
 
-        it('should reject expired tokens', () => {
+        test('should reject expired tokens', () => {
-            const expiredToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiZXhwIjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+            const payload = { sub: '123', name: 'Test User', iat: Math.floor(Date.now() / 1000) - 7200, exp: Math.floor(Date.now() / 1000) - 3600 };
-            expect(TokenManager.validateToken(expiredToken)).toBe(false);
+            const token = jwt.sign(payload, TEST_SECRET);
+            const result = TokenManager.validateToken(token);
+            expect(result.valid).toBe(false);
+            expect(result.error).toBe('Token has expired');
         });
 
-        it('should reject malformed tokens', () => {
+        test('should reject malformed tokens', () => {
-            expect(TokenManager.validateToken('invalid-token')).toBe(false);
+            const result = TokenManager.validateToken('invalid-token');
+            expect(result.valid).toBe(false);
+            expect(result.error).toBe('Token length below minimum requirement');
         });
 
-        it('should reject tokens with invalid signature', () => {
+        test('should reject tokens with invalid signature', () => {
-            const tamperedToken = validToken.slice(0, -5) + 'xxxxx';
+            const payload = { sub: '123', name: 'Test User', iat: Math.floor(Date.now() / 1000), exp: Math.floor(Date.now() / 1000) + 3600 };
-            expect(TokenManager.validateToken(tamperedToken)).toBe(false);
+            const token = jwt.sign(payload, 'different-secret');
+            const result = TokenManager.validateToken(token);
+            expect(result.valid).toBe(false);
+            expect(result.error).toBe('Invalid token signature');
         });
 
-        it('should handle tokens with missing expiration', () => {
+        test('should handle tokens with missing expiration', () => {
-            const noExpToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIn0.Q6cm_sZS6uqfGqO3LQ-0VqNXhqXR6mFh6IP7s0NPnSQ';
+            const payload = { sub: '123', name: 'Test User' };
-            expect(TokenManager.validateToken(noExpToken)).toBe(false);
+            const token = jwt.sign(payload, TEST_SECRET);
+            const result = TokenManager.validateToken(token);
+            expect(result.valid).toBe(false);
+            expect(result.error).toBe('Token missing required claims');
+        });
+
+        test('should handle undefined and null inputs', () => {
+            const undefinedResult = TokenManager.validateToken(undefined);
+            expect(undefinedResult.valid).toBe(false);
+            expect(undefinedResult.error).toBe('Invalid token format');
+
+            const nullResult = TokenManager.validateToken(null);
+            expect(nullResult.valid).toBe(false);
+            expect(nullResult.error).toBe('Invalid token format');
         });
     });
 
     describe('Security Features', () => {
-        it('should use secure encryption algorithm', () => {
+        test('should use secure encryption algorithm', () => {
             const encrypted = TokenManager.encryptToken(validToken, encryptionKey);
             expect(encrypted).toContain('aes-256-gcm');
         });
 
-        it('should prevent token tampering', () => {
+        test('should prevent token tampering', () => {
             const encrypted = TokenManager.encryptToken(validToken, encryptionKey);
             const tampered = encrypted.slice(0, -5) + 'xxxxx';
             expect(() => TokenManager.decryptToken(tampered, encryptionKey)).toThrow();
         });
 
-        it('should use unique IVs for each encryption', () => {
+        test('should use unique IVs for each encryption', () => {
             const encrypted1 = TokenManager.encryptToken(validToken, encryptionKey);
             const encrypted2 = TokenManager.encryptToken(validToken, encryptionKey);
-            const iv1 = encrypted1.split(':')[1];
+            const iv1 = encrypted1.spltest(':')[1];
-            const iv2 = encrypted2.split(':')[1];
+            const iv2 = encrypted2.spltest(':')[1];
             expect(iv1).not.toBe(iv2);
         });
 
-        it('should handle large tokens', () => {
+        test('should handle large tokens', () => {
             const largeToken = 'x'.repeat(10000);
             const encrypted = TokenManager.encryptToken(largeToken, encryptionKey);
             const decrypted = TokenManager.decryptToken(encrypted, encryptionKey);
@@ -88,25 +124,20 @@ describe('TokenManager', () => {
     });
 
     describe('Error Handling', () => {
-        it('should throw descriptive errors for invalid inputs', () => {
+        test('should throw descriptive errors for invalid inputs', () => {
             expect(() => TokenManager.encryptToken(null as any, encryptionKey)).toThrow('Invalid token');
             expect(() => TokenManager.encryptToken(validToken, null as any)).toThrow('Invalid encryption key');
             expect(() => TokenManager.decryptToken('invalid-base64', encryptionKey)).toThrow('Invalid encrypted token');
         });
 
-        it('should handle corrupted encrypted data', () => {
+        test('should handle corrupted encrypted data', () => {
             const encrypted = TokenManager.encryptToken(validToken, encryptionKey);
             const corrupted = encrypted.replace(/[a-zA-Z]/g, 'x');
             expect(() => TokenManager.decryptToken(corrupted, encryptionKey)).toThrow();
         });
 
-        it('should handle invalid base64 input', () => {
+        test('should handle invalid base64 input', () => {
             expect(() => TokenManager.decryptToken('not-base64!@#$%^', encryptionKey)).toThrow();
         });
-
-        it('should handle undefined and null inputs', () => {
-            expect(TokenManager.validateToken(undefined as any)).toBe(false);
-            expect(TokenManager.validateToken(null as any)).toBe(false);
-        });
     });
 }); 

__tests__/server.test.ts

@@ -1,114 +1,149 @@
-import { jest, describe, beforeEach, afterEach, it, expect } from '@jest/globals';
+import { describe, expect, test, beforeEach, afterEach, mock, spyOn } from "bun:test";
-import express from 'express';
+import type { Mock } from "bun:test";
-import { LiteMCP } from 'litemcp';
+import type { Elysia } from "elysia";
-import { logger } from '../src/utils/logger.js';
 
-// Mock express
+// Create mock instances
-jest.mock('express', () => {
+const mockApp = {
-    const mockApp = {
+    use: mock(() => mockApp),
-        use: jest.fn(),
+    get: mock(() => mockApp),
-        listen: jest.fn((port: number, callback: () => void) => {
+    post: mock(() => mockApp),
-            callback();
+    listen: mock((port: number, callback?: () => void) => {
-            return { close: jest.fn() };
+        callback?.();
-        })
+        return mockApp;
-    };
+    })
-    return jest.fn(() => mockApp);
+};
-});
 
-// Mock LiteMCP
+// Create mock constructors
-jest.mock('litemcp', () => ({
+const MockElysia = mock(() => mockApp);
-    LiteMCP: jest.fn(() => ({
+const mockCors = mock(() => (app: any) => app);
-        addTool: jest.fn(),
+const mockSwagger = mock(() => (app: any) => app);
-        start: jest.fn().mockImplementation(async () => { })
+const mockSpeechService = {
-    }))
+    initialize: mock(() => Promise.resolve()),
-}));
+    shutdown: mock(() => Promise.resolve())
+};
 
-// Mock logger
+// Mock the modules
-jest.mock('../src/utils/logger.js', () => ({
+const mockModules = {
-    logger: {
+    Elysia: MockElysia,
-        info: jest.fn(),
+    cors: mockCors,
-        error: jest.fn(),
+    swagger: mockSwagger,
-        debug: jest.fn()
+    speechService: mockSpeechService,
+    config: mock(() => ({})),
+    resolve: mock((...args: string[]) => args.join('/')),
+    z: { object: mock(() => ({})), enum: mock(() => ({})) }
+};
+
+// Mock module resolution
+const mockResolver = {
+    resolve(specifier: string) {
+        const mocks: Record<string, any> = {
+            'elysia': { Elysia: mockModules.Elysia },
+            '@elysiajs/cors': { cors: mockModules.cors },
+            '@elysiajs/swagger': { swagger: mockModules.swagger },
+            '../speech/index.js': { speechService: mockModules.speechService },
+            'dotenv': { config: mockModules.config },
+            'path': { resolve: mockModules.resolve },
+            'zod': { z: mockModules.z }
+        };
+        return mocks[specifier] || {};
     }
-}));
+};
 
 describe('Server Initialization', () => {
     let originalEnv: NodeJS.ProcessEnv;
-    let mockApp: ReturnType<typeof express>;
+    let consoleLog: Mock<typeof console.log>;
+    let consoleError: Mock<typeof console.error>;
+    let originalResolve: any;
 
     beforeEach(() => {
         // Store original environment
         originalEnv = { ...process.env };
 
-        // Reset all mocks
+        // Mock console methods
-        jest.clearAllMocks();
+        consoleLog = mock(() => { });
+        consoleError = mock(() => { });
+        console.log = consoleLog;
+        console.error = consoleError;
 
-        // Get the mock express app
+        // Reset all mocks
-        mockApp = express();
+        for (const key in mockModules) {
+            const module = mockModules[key as keyof typeof mockModules];
+            if (typeof module === 'object' && module !== null) {
+                Object.values(module).forEach(value => {
+                    if (typeof value === 'function' && 'mock' in value) {
+                        (value as Mock<any>).mockReset();
+                    }
+                });
+            } else if (typeof module === 'function' && 'mock' in module) {
+                (module as Mock<any>).mockReset();
+            }
+        }
+
+        // Set default environment variables
+        process.env.NODE_ENV = 'test';
+        process.env.PORT = '4000';
+
+        // Setup module resolution mock
+        originalResolve = (globalThis as any).Bun?.resolveSync;
+        (globalThis as any).Bun = {
+            ...(globalThis as any).Bun,
+            resolveSync: (specifier: string) => mockResolver.resolve(specifier)
+        };
     });
 
     afterEach(() => {
         // Restore original environment
         process.env = originalEnv;
 
-        // Clear module cache to ensure fresh imports
+        // Restore module resolution
-        jest.resetModules();
+        if (originalResolve) {
+            (globalThis as any).Bun.resolveSync = originalResolve;
+        }
     });
 
-    it('should start Express server when not in Claude mode', async () => {
+    test('should initialize server with middleware', async () => {
-        // Set OpenAI mode
+        // Import and initialize server
-        process.env.PROCESSOR_TYPE = 'openai';
+        const mod = await import('../src/index');
 
-        // Import the main module
+        // Verify server initialization
-        await import('../src/index.js');
+        expect(MockElysia.mock.calls.length).toBe(1);
+        expect(mockCors.mock.calls.length).toBe(1);
+        expect(mockSwagger.mock.calls.length).toBe(1);
 
-        // Verify Express server was initialized
+        // Verify console output
-        expect(express).toHaveBeenCalled();
+        const logCalls = consoleLog.mock.calls;
-        expect(mockApp.use).toHaveBeenCalled();
+        expect(logCalls.some(call =>
-        expect(mockApp.listen).toHaveBeenCalled();
+            typeof call.args[0] === 'string' &&
-        expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('Server is running on port'));
+            call.args[0].includes('Server is running on port')
+        )).toBe(true);
     });
 
-    it('should not start Express server in Claude mode', async () => {
+    test('should initialize speech service when enabled', async () => {
-        // Set Claude mode
+        // Enable speech service
-        process.env.PROCESSOR_TYPE = 'claude';
+        process.env.SPEECH_ENABLED = 'true';
 
-        // Import the main module
+        // Import and initialize server
-        await import('../src/index.js');
+        const mod = await import('../src/index');
 
-        // Verify Express server was not initialized
+        // Verify speech service initialization
-        expect(express).not.toHaveBeenCalled();
+        expect(mockSpeechService.initialize.mock.calls.length).toBe(1);
-        expect(mockApp.use).not.toHaveBeenCalled();
-        expect(mockApp.listen).not.toHaveBeenCalled();
-        expect(logger.info).toHaveBeenCalledWith('Running in Claude mode - Express server disabled');
     });
 
-    it('should initialize LiteMCP in both modes', async () => {
+    test('should handle server shutdown gracefully', async () => {
-        // Test OpenAI mode
+        // Enable speech service for shutdown test
-        process.env.PROCESSOR_TYPE = 'openai';
+        process.env.SPEECH_ENABLED = 'true';
-        await import('../src/index.js');
-        expect(LiteMCP).toHaveBeenCalledWith('home-assistant', expect.any(String));
 
-        // Reset modules
+        // Import and initialize server
-        jest.resetModules();
+        const mod = await import('../src/index');
 
-        // Test Claude mode
+        // Simulate SIGTERM
-        process.env.PROCESSOR_TYPE = 'claude';
+        process.emit('SIGTERM');
-        await import('../src/index.js');
-        expect(LiteMCP).toHaveBeenCalledWith('home-assistant', expect.any(String));
-    });
 
-    it('should handle missing PROCESSOR_TYPE (default to Express server)', async () => {
+        // Verify shutdown behavior
-        // Remove PROCESSOR_TYPE
+        expect(mockSpeechService.shutdown.mock.calls.length).toBe(1);
-        delete process.env.PROCESSOR_TYPE;
+        expect(consoleLog.mock.calls.some(call =>
-
+            typeof call.args[0] === 'string' &&
-        // Import the main module
+            call.args[0].includes('Shutting down gracefully')
-        await import('../src/index.js');
+        )).toBe(true);
-
-        // Verify Express server was initialized (default behavior)
-        expect(express).toHaveBeenCalled();
-        expect(mockApp.use).toHaveBeenCalled();
-        expect(mockApp.listen).toHaveBeenCalled();
-        expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('Server is running on port'));
     });
 }); 

__tests__/speech/speechToText.test.ts

@@ -0,0 +1,251 @@
+import { describe, expect, test, beforeEach, afterEach, mock, spyOn } from "bun:test";
+import type { Mock } from "bun:test";
+import { EventEmitter } from "events";
+import { SpeechToText, TranscriptionError, type TranscriptionOptions } from "../../src/speech/speechToText";
+import type { SpeechToTextConfig } from "../../src/speech/types";
+import type { ChildProcess } from "child_process";
+
+interface MockProcess extends EventEmitter {
+    stdout: EventEmitter;
+    stderr: EventEmitter;
+    kill: Mock<() => void>;
+}
+
+type SpawnFn = {
+    (cmds: string[], options?: Record<string, unknown>): ChildProcess;
+};
+
+describe('SpeechToText', () => {
+    let spawnMock: Mock<SpawnFn>;
+    let mockProcess: MockProcess;
+    let speechToText: SpeechToText;
+
+    beforeEach(() => {
+        // Create mock process
+        mockProcess = new EventEmitter() as MockProcess;
+        mockProcess.stdout = new EventEmitter();
+        mockProcess.stderr = new EventEmitter();
+        mockProcess.kill = mock(() => { });
+
+        // Create spawn mock
+        spawnMock = mock((cmds: string[], options?: Record<string, unknown>) => mockProcess as unknown as ChildProcess);
+        (globalThis as any).Bun = { spawn: spawnMock };
+
+        // Initialize SpeechToText
+        const config: SpeechToTextConfig = {
+            modelPath: '/test/model',
+            modelType: 'base.en',
+            containerName: 'test-container'
+        };
+        speechToText = new SpeechToText(config);
+    });
+
+    afterEach(() => {
+        // Cleanup
+        mockProcess.removeAllListeners();
+        mockProcess.stdout.removeAllListeners();
+        mockProcess.stderr.removeAllListeners();
+    });
+
+    describe('Initialization', () => {
+        test('should create instance with default config', () => {
+            const config: SpeechToTextConfig = {
+                modelPath: '/test/model',
+                modelType: 'base.en'
+            };
+            const instance = new SpeechToText(config);
+            expect(instance).toBeDefined();
+        });
+
+        test('should initialize successfully', async () => {
+            const result = await speechToText.initialize();
+            expect(result).toBeUndefined();
+        });
+
+        test('should not initialize twice', async () => {
+            await speechToText.initialize();
+            const result = await speechToText.initialize();
+            expect(result).toBeUndefined();
+        });
+    });
+
+    describe('Health Check', () => {
+        test('should return true when Docker container is running', async () => {
+            // Setup mock process
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', Buffer.from('Up 2 hours'));
+            }, 0);
+
+            const result = await speechToText.checkHealth();
+            expect(result).toBe(true);
+        });
+
+        test('should return false when Docker container is not running', async () => {
+            // Setup mock process
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', Buffer.from('No containers found'));
+            }, 0);
+
+            const result = await speechToText.checkHealth();
+            expect(result).toBe(false);
+        });
+
+        test('should handle Docker command errors', async () => {
+            // Setup mock process
+            setTimeout(() => {
+                mockProcess.stderr.emit('data', Buffer.from('Docker error'));
+            }, 0);
+
+            const result = await speechToText.checkHealth();
+            expect(result).toBe(false);
+        });
+    });
+
+    describe('Wake Word Detection', () => {
+        test('should detect wake word and emit event', async () => {
+            // Setup mock process
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', Buffer.from('Wake word detected'));
+            }, 0);
+
+            const wakeWordPromise = new Promise<void>((resolve) => {
+                speechToText.on('wake_word', () => {
+                    resolve();
+                });
+            });
+
+            speechToText.startWakeWordDetection();
+            await wakeWordPromise;
+        });
+
+        test('should handle non-wake-word files', async () => {
+            // Setup mock process
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', Buffer.from('Processing audio'));
+            }, 0);
+
+            const wakeWordPromise = new Promise<void>((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    resolve();
+                }, 100);
+
+                speechToText.on('wake_word', () => {
+                    clearTimeout(timeout);
+                    reject(new Error('Wake word should not be detected'));
+                });
+            });
+
+            speechToText.startWakeWordDetection();
+            await wakeWordPromise;
+        });
+    });
+
+    describe('Audio Transcription', () => {
+        const mockTranscriptionResult = {
+            text: 'Test transcription',
+            segments: [{
+                text: 'Test transcription',
+                start: 0,
+                end: 1,
+                confidence: 0.95
+            }]
+        };
+
+        test('should transcribe audio successfully', async () => {
+            // Setup mock process
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', Buffer.from(JSON.stringify(mockTranscriptionResult)));
+            }, 0);
+
+            const result = await speechToText.transcribeAudio('/test/audio.wav');
+            expect(result).toEqual(mockTranscriptionResult);
+        });
+
+        test('should handle transcription errors', async () => {
+            // Setup mock process
+            setTimeout(() => {
+                mockProcess.stderr.emit('data', Buffer.from('Transcription failed'));
+            }, 0);
+
+            await expect(speechToText.transcribeAudio('/test/audio.wav')).rejects.toThrow(TranscriptionError);
+        });
+
+        test('should handle invalid JSON output', async () => {
+            // Setup mock process
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', Buffer.from('Invalid JSON'));
+            }, 0);
+
+            await expect(speechToText.transcribeAudio('/test/audio.wav')).rejects.toThrow(TranscriptionError);
+        });
+
+        test('should pass correct transcription options', async () => {
+            const options: TranscriptionOptions = {
+                model: 'base.en',
+                language: 'en',
+                temperature: 0,
+                beamSize: 5,
+                patience: 1,
+                device: 'cpu'
+            };
+
+            await speechToText.transcribeAudio('/test/audio.wav', options);
+
+            const spawnArgs = spawnMock.mock.calls[0]?.args[1] || [];
+            expect(spawnArgs).toContain('--model');
+            expect(spawnArgs).toContain(options.model);
+            expect(spawnArgs).toContain('--language');
+            expect(spawnArgs).toContain(options.language);
+            expect(spawnArgs).toContain('--temperature');
+            expect(spawnArgs).toContain(options.temperature?.toString());
+            expect(spawnArgs).toContain('--beam-size');
+            expect(spawnArgs).toContain(options.beamSize?.toString());
+            expect(spawnArgs).toContain('--patience');
+            expect(spawnArgs).toContain(options.patience?.toString());
+            expect(spawnArgs).toContain('--device');
+            expect(spawnArgs).toContain(options.device);
+        });
+    });
+
+    describe('Event Handling', () => {
+        test('should emit progress events', async () => {
+            const progressPromise = new Promise<void>((resolve) => {
+                speechToText.on('progress', (progress) => {
+                    expect(progress).toEqual({ type: 'stdout', data: 'Processing' });
+                    resolve();
+                });
+            });
+
+            const transcribePromise = speechToText.transcribeAudio('/test/audio.wav');
+            mockProcess.stdout.emit('data', Buffer.from('Processing'));
+            await Promise.all([transcribePromise.catch(() => { }), progressPromise]);
+        });
+
+        test('should emit error events', async () => {
+            const errorPromise = new Promise<void>((resolve) => {
+                speechToText.on('error', (error) => {
+                    expect(error instanceof Error).toBe(true);
+                    expect(error.message).toBe('Test error');
+                    resolve();
+                });
+            });
+
+            speechToText.emit('error', new Error('Test error'));
+            await errorPromise;
+        });
+    });
+
+    describe('Cleanup', () => {
+        test('should stop wake word detection', () => {
+            speechToText.startWakeWordDetection();
+            speechToText.stopWakeWordDetection();
+            expect(mockProcess.kill.mock.calls.length).toBe(1);
+        });
+
+        test('should clean up resources on shutdown', async () => {
+            await speechToText.initialize();
+            await speechToText.shutdown();
+            expect(mockProcess.kill.mock.calls.length).toBe(1);
+        });
+    });
+}); 

__tests__/tools/automation-config.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, test } from "bun:test";
+import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test";
+import {
+    type MockLiteMCPInstance,
+    type Tool,
+    type TestResponse,
+    TEST_CONFIG,
+    createMockLiteMCPInstance,
+    setupTestEnvironment,
+    cleanupMocks,
+    createMockResponse,
+    getMockCallArgs
+} from '../utils/test-utils';
+
+describe('Automation Configuration Tools', () => {
+    let liteMcpInstance: MockLiteMCPInstance;
+    let addToolCalls: Tool[];
+    let mocks: ReturnType<typeof setupTestEnvironment>;
+
+    const mockAutomationConfig = {
+        alias: 'Test Automation',
+        description: 'Test automation description',
+        mode: 'single',
+        trigger: [
+            {
+                platform: 'state',
+                entity_id: 'binary_sensor.motion',
+                to: 'on'
+            }
+        ],
+        action: [
+            {
+                service: 'light.turn_on',
+                target: {
+                    entity_id: 'light.living_room'
+                }
+            }
+        ]
+    };
+
+    beforeEach(async () => {
+        // Setup test environment
+        mocks = setupTestEnvironment();
+        liteMcpInstance = createMockLiteMCPInstance();
+
+        // Import the module which will execute the main function
+        await import('../../src/index.js');
+
+        // Get the mock instance and tool calls
+        addToolCalls = liteMcpInstance.addTool.mock.calls.map(call => call.args[0]);
+    });
+
+    afterEach(() => {
+        cleanupMocks({ liteMcpInstance, ...mocks });
+    });
+
+    describe('automation_config tool', () => {
+        test('should successfully create an automation', async () => {
+            // Setup response
+            mocks.mockFetch = mock(() => Promise.resolve(createMockResponse({
+                automation_id: 'new_automation_1'
+            })));
+            globalThis.fetch = mocks.mockFetch;
+
+            const automationConfigTool = addToolCalls.find(tool => tool.name === 'automation_config');
+            expect(automationConfigTool).toBeDefined();
+
+            if (!automationConfigTool) {
+                throw new Error('automation_config tool not found');
+            }
+
+            const result = await automationConfigTool.execute({
+                action: 'create',
+                config: mockAutomationConfig
+            }) as TestResponse;
+
+            expect(result.success).toBe(true);
+            expect(result.message).toBe('Successfully created automation');
+            expect(result.automation_id).toBe('new_automation_1');
+
+            // Verify the fetch call
+            type FetchArgs = [url: string, init: RequestInit];
+            const args = getMockCallArgs<FetchArgs>(mocks.mockFetch);
+            expect(args).toBeDefined();
+
+            if (!args) {
+                throw new Error('No fetch calls recorded');
+            }
+
+            const [urlStr, options] = args;
+            expect(urlStr).toBe(`${TEST_CONFIG.HASS_HOST}/api/config/automation/config`);
+            expect(options).toEqual({
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(mockAutomationConfig)
+            });
+        });
+
+        test('should successfully duplicate an automation', async () => {
+            // Setup responses for get and create
+            let callCount = 0;
+            mocks.mockFetch = mock(() => {
+                callCount++;
+                return Promise.resolve(
+                    callCount === 1
+                        ? createMockResponse(mockAutomationConfig)
+                        : createMockResponse({ automation_id: 'new_automation_2' })
+                );
+            });
+            globalThis.fetch = mocks.mockFetch;
+
+            const automationConfigTool = addToolCalls.find(tool => tool.name === 'automation_config');
+            expect(automationConfigTool).toBeDefined();
+
+            if (!automationConfigTool) {
+                throw new Error('automation_config tool not found');
+            }
+
+            const result = await automationConfigTool.execute({
+                action: 'duplicate',
+                automation_id: 'automation.test'
+            }) as TestResponse;
+
+            expect(result.success).toBe(true);
+            expect(result.message).toBe('Successfully duplicated automation automation.test');
+            expect(result.new_automation_id).toBe('new_automation_2');
+
+            // Verify both API calls
+            type FetchArgs = [url: string, init: RequestInit];
+            const calls = mocks.mockFetch.mock.calls;
+            expect(calls.length).toBe(2);
+
+            // Verify get call
+            const getArgs = getMockCallArgs<FetchArgs>(mocks.mockFetch, 0);
+            expect(getArgs).toBeDefined();
+            if (!getArgs) throw new Error('No get call recorded');
+
+            const [getUrl, getOptions] = getArgs;
+            expect(getUrl).toBe(`${TEST_CONFIG.HASS_HOST}/api/config/automation/config/automation.test`);
+            expect(getOptions).toEqual({
+                headers: {
+                    Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            // Verify create call
+            const createArgs = getMockCallArgs<FetchArgs>(mocks.mockFetch, 1);
+            expect(createArgs).toBeDefined();
+            if (!createArgs) throw new Error('No create call recorded');
+
+            const [createUrl, createOptions] = createArgs;
+            expect(createUrl).toBe(`${TEST_CONFIG.HASS_HOST}/api/config/automation/config`);
+            expect(createOptions).toEqual({
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    ...mockAutomationConfig,
+                    alias: 'Test Automation (Copy)'
+                })
+            });
+        });
+
+        test('should require config for create action', async () => {
+            const automationConfigTool = addToolCalls.find(tool => tool.name === 'automation_config');
+            expect(automationConfigTool).toBeDefined();
+
+            if (!automationConfigTool) {
+                throw new Error('automation_config tool not found');
+            }
+
+            const result = await automationConfigTool.execute({
+                action: 'create'
+            }) as TestResponse;
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Configuration is required for creating automation');
+        });
+
+        test('should require automation_id for update action', async () => {
+            const automationConfigTool = addToolCalls.find(tool => tool.name === 'automation_config');
+            expect(automationConfigTool).toBeDefined();
+
+            if (!automationConfigTool) {
+                throw new Error('automation_config tool not found');
+            }
+
+            const result = await automationConfigTool.execute({
+                action: 'update',
+                config: mockAutomationConfig
+            }) as TestResponse;
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Automation ID and configuration are required for updating automation');
+        });
+    });
+}); 

__tests__/tools/automation.test.ts

@@ -0,0 +1,191 @@
+import { describe, expect, test } from "bun:test";
+import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test";
+import {
+    type MockLiteMCPInstance,
+    type Tool,
+    type TestResponse,
+    TEST_CONFIG,
+    createMockLiteMCPInstance,
+    setupTestEnvironment,
+    cleanupMocks,
+    createMockResponse,
+    getMockCallArgs
+} from '../utils/test-utils';
+
+describe('Automation Tools', () => {
+    let liteMcpInstance: MockLiteMCPInstance;
+    let addToolCalls: Tool[];
+    let mocks: ReturnType<typeof setupTestEnvironment>;
+
+    beforeEach(async () => {
+        // Setup test environment
+        mocks = setupTestEnvironment();
+        liteMcpInstance = createMockLiteMCPInstance();
+
+        // Import the module which will execute the main function
+        await import('../../src/index.js');
+
+        // Get the mock instance and tool calls
+        addToolCalls = liteMcpInstance.addTool.mock.calls.map(call => call.args[0]);
+    });
+
+    afterEach(() => {
+        cleanupMocks({ liteMcpInstance, ...mocks });
+    });
+
+    describe('automation tool', () => {
+        const mockAutomations = [
+            {
+                entity_id: 'automation.morning_routine',
+                state: 'on',
+                attributes: {
+                    friendly_name: 'Morning Routine',
+                    last_triggered: '2024-01-01T07:00:00Z'
+                }
+            },
+            {
+                entity_id: 'automation.night_mode',
+                state: 'off',
+                attributes: {
+                    friendly_name: 'Night Mode',
+                    last_triggered: '2024-01-01T22:00:00Z'
+                }
+            }
+        ];
+
+        test('should successfully list automations', async () => {
+            // Setup response
+            mocks.mockFetch = mock(() => Promise.resolve(createMockResponse(mockAutomations)));
+            globalThis.fetch = mocks.mockFetch;
+
+            const automationTool = addToolCalls.find(tool => tool.name === 'automation');
+            expect(automationTool).toBeDefined();
+
+            if (!automationTool) {
+                throw new Error('automation tool not found');
+            }
+
+            const result = await automationTool.execute({
+                action: 'list'
+            }) as TestResponse;
+
+            expect(result.success).toBe(true);
+            expect(result.automations).toEqual([
+                {
+                    entity_id: 'automation.morning_routine',
+                    name: 'Morning Routine',
+                    state: 'on',
+                    last_triggered: '2024-01-01T07:00:00Z'
+                },
+                {
+                    entity_id: 'automation.night_mode',
+                    name: 'Night Mode',
+                    state: 'off',
+                    last_triggered: '2024-01-01T22:00:00Z'
+                }
+            ]);
+        });
+
+        test('should successfully toggle an automation', async () => {
+            // Setup response
+            mocks.mockFetch = mock(() => Promise.resolve(createMockResponse({})));
+            globalThis.fetch = mocks.mockFetch;
+
+            const automationTool = addToolCalls.find(tool => tool.name === 'automation');
+            expect(automationTool).toBeDefined();
+
+            if (!automationTool) {
+                throw new Error('automation tool not found');
+            }
+
+            const result = await automationTool.execute({
+                action: 'toggle',
+                automation_id: 'automation.morning_routine'
+            }) as TestResponse;
+
+            expect(result.success).toBe(true);
+            expect(result.message).toBe('Successfully toggled automation automation.morning_routine');
+
+            // Verify the fetch call
+            type FetchArgs = [url: string, init: RequestInit];
+            const args = getMockCallArgs<FetchArgs>(mocks.mockFetch);
+            expect(args).toBeDefined();
+
+            if (!args) {
+                throw new Error('No fetch calls recorded');
+            }
+
+            const [urlStr, options] = args;
+            expect(urlStr).toBe(`${TEST_CONFIG.HASS_HOST}/api/services/automation/toggle`);
+            expect(options).toEqual({
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    entity_id: 'automation.morning_routine'
+                })
+            });
+        });
+
+        test('should successfully trigger an automation', async () => {
+            // Setup response
+            mocks.mockFetch = mock(() => Promise.resolve(createMockResponse({})));
+            globalThis.fetch = mocks.mockFetch;
+
+            const automationTool = addToolCalls.find(tool => tool.name === 'automation');
+            expect(automationTool).toBeDefined();
+
+            if (!automationTool) {
+                throw new Error('automation tool not found');
+            }
+
+            const result = await automationTool.execute({
+                action: 'trigger',
+                automation_id: 'automation.morning_routine'
+            }) as TestResponse;
+
+            expect(result.success).toBe(true);
+            expect(result.message).toBe('Successfully triggered automation automation.morning_routine');
+
+            // Verify the fetch call
+            type FetchArgs = [url: string, init: RequestInit];
+            const args = getMockCallArgs<FetchArgs>(mocks.mockFetch);
+            expect(args).toBeDefined();
+
+            if (!args) {
+                throw new Error('No fetch calls recorded');
+            }
+
+            const [urlStr, options] = args;
+            expect(urlStr).toBe(`${TEST_CONFIG.HASS_HOST}/api/services/automation/trigger`);
+            expect(options).toEqual({
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    entity_id: 'automation.morning_routine'
+                })
+            });
+        });
+
+        test('should require automation_id for toggle and trigger actions', async () => {
+            const automationTool = addToolCalls.find(tool => tool.name === 'automation');
+            expect(automationTool).toBeDefined();
+
+            if (!automationTool) {
+                throw new Error('automation tool not found');
+            }
+
+            const result = await automationTool.execute({
+                action: 'toggle'
+            }) as TestResponse;
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Automation ID is required for toggle and trigger actions');
+        });
+    });
+}); 

__tests__/tools/device-control.test.ts

@@ -0,0 +1,231 @@
+import { describe, expect, test } from "bun:test";
+import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test";
+import { tools } from '../../src/index.js';
+import {
+    TEST_CONFIG,
+    createMockResponse,
+    getMockCallArgs
+} from '../utils/test-utils';
+
+describe('Device Control Tools', () => {
+    let mocks: { mockFetch: ReturnType<typeof mock> };
+
+    beforeEach(async () => {
+        // Setup mock fetch
+        mocks = {
+            mockFetch: mock(() => Promise.resolve(createMockResponse({})))
+        };
+        globalThis.fetch = mocks.mockFetch;
+        await Promise.resolve();
+    });
+
+    afterEach(() => {
+        // Reset mocks
+        globalThis.fetch = undefined;
+    });
+
+    describe('list_devices tool', () => {
+        test('should successfully list devices', async () => {
+            const mockDevices = [
+                {
+                    entity_id: 'light.living_room',
+                    state: 'on',
+                    attributes: { brightness: 255 }
+                },
+                {
+                    entity_id: 'climate.bedroom',
+                    state: 'heat',
+                    attributes: { temperature: 22 }
+                }
+            ];
+
+            // Setup response
+            mocks.mockFetch = mock(() => Promise.resolve(createMockResponse(mockDevices)));
+            globalThis.fetch = mocks.mockFetch;
+
+            const listDevicesTool = tools.find(tool => tool.name === 'list_devices');
+            expect(listDevicesTool).toBeDefined();
+
+            if (!listDevicesTool) {
+                throw new Error('list_devices tool not found');
+            }
+
+            const result = await listDevicesTool.execute({});
+
+            expect(result.success).toBe(true);
+            expect(result.devices).toEqual({
+                light: [{
+                    entity_id: 'light.living_room',
+                    state: 'on',
+                    attributes: { brightness: 255 }
+                }],
+                climate: [{
+                    entity_id: 'climate.bedroom',
+                    state: 'heat',
+                    attributes: { temperature: 22 }
+                }]
+            });
+        });
+
+        test('should handle fetch errors', async () => {
+            // Setup error response
+            mocks.mockFetch = mock(() => Promise.reject(new Error('Network error')));
+            globalThis.fetch = mocks.mockFetch;
+
+            const listDevicesTool = tools.find(tool => tool.name === 'list_devices');
+            expect(listDevicesTool).toBeDefined();
+
+            if (!listDevicesTool) {
+                throw new Error('list_devices tool not found');
+            }
+
+            const result = await listDevicesTool.execute({});
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Network error');
+        });
+    });
+
+    describe('control tool', () => {
+        test('should successfully control a light device', async () => {
+            // Setup response
+            mocks.mockFetch = mock(() => Promise.resolve(createMockResponse({})));
+            globalThis.fetch = mocks.mockFetch;
+
+            const controlTool = tools.find(tool => tool.name === 'control');
+            expect(controlTool).toBeDefined();
+
+            if (!controlTool) {
+                throw new Error('control tool not found');
+            }
+
+            const result = await controlTool.execute({
+                command: 'turn_on',
+                entity_id: 'light.living_room',
+                brightness: 255
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.message).toBe('Successfully executed turn_on for light.living_room');
+
+            // Verify the fetch call
+            const calls = mocks.mockFetch.mock.calls;
+            expect(calls.length).toBeGreaterThan(0);
+
+            type FetchArgs = [url: string, init: RequestInit];
+            const args = getMockCallArgs<FetchArgs>(mocks.mockFetch);
+            expect(args).toBeDefined();
+
+            if (!args) {
+                throw new Error('No fetch calls recorded');
+            }
+
+            const [urlStr, options] = args;
+            expect(urlStr).toBe(`${TEST_CONFIG.HASS_HOST}/api/services/light/turn_on`);
+            expect(options).toEqual({
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    entity_id: 'light.living_room',
+                    brightness: 255
+                })
+            });
+        });
+
+        test('should handle unsupported domains', async () => {
+            const controlTool = tools.find(tool => tool.name === 'control');
+            expect(controlTool).toBeDefined();
+
+            if (!controlTool) {
+                throw new Error('control tool not found');
+            }
+
+            const result = await controlTool.execute({
+                command: 'turn_on',
+                entity_id: 'unsupported.device'
+            });
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Unsupported domain: unsupported');
+        });
+
+        test('should handle service call errors', async () => {
+            // Setup error response
+            mocks.mockFetch = mock(() => Promise.resolve(new Response(null, {
+                status: 503,
+                statusText: 'Service unavailable'
+            })));
+            globalThis.fetch = mocks.mockFetch;
+
+            const controlTool = tools.find(tool => tool.name === 'control');
+            expect(controlTool).toBeDefined();
+
+            if (!controlTool) {
+                throw new Error('control tool not found');
+            }
+
+            const result = await controlTool.execute({
+                command: 'turn_on',
+                entity_id: 'light.living_room'
+            });
+
+            expect(result.success).toBe(false);
+            expect(result.message).toContain('Failed to execute turn_on for light.living_room');
+        });
+
+        test('should handle climate device controls', async () => {
+            // Setup response
+            mocks.mockFetch = mock(() => Promise.resolve(createMockResponse({})));
+            globalThis.fetch = mocks.mockFetch;
+
+            const controlTool = tools.find(tool => tool.name === 'control');
+            expect(controlTool).toBeDefined();
+
+            if (!controlTool) {
+                throw new Error('control tool not found');
+            }
+
+            const result = await controlTool.execute({
+                command: 'set_temperature',
+                entity_id: 'climate.bedroom',
+                temperature: 22,
+                target_temp_high: 24,
+                target_temp_low: 20
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.message).toBe('Successfully executed set_temperature for climate.bedroom');
+
+            // Verify the fetch call
+            const calls = mocks.mockFetch.mock.calls;
+            expect(calls.length).toBeGreaterThan(0);
+
+            type FetchArgs = [url: string, init: RequestInit];
+            const args = getMockCallArgs<FetchArgs>(mocks.mockFetch);
+            expect(args).toBeDefined();
+
+            if (!args) {
+                throw new Error('No fetch calls recorded');
+            }
+
+            const [urlStr, options] = args;
+            expect(urlStr).toBe(`${TEST_CONFIG.HASS_HOST}/api/services/climate/set_temperature`);
+            expect(options).toEqual({
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    entity_id: 'climate.bedroom',
+                    temperature: 22,
+                    target_temp_high: 24,
+                    target_temp_low: 20
+                })
+            });
+        });
+    });
+}); 

__tests__/tools/entity-state.test.ts

@@ -0,0 +1,192 @@
+import { describe, expect, test } from "bun:test";
+import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test";
+import {
+    type MockLiteMCPInstance,
+    type Tool,
+    type TestResponse,
+    TEST_CONFIG,
+    createMockLiteMCPInstance,
+    setupTestEnvironment,
+    cleanupMocks,
+    createMockResponse,
+    getMockCallArgs
+} from '../utils/test-utils';
+
+describe('Entity State Tools', () => {
+    let liteMcpInstance: MockLiteMCPInstance;
+    let addToolCalls: Tool[];
+    let mocks: ReturnType<typeof setupTestEnvironment>;
+
+    const mockEntityState = {
+        entity_id: 'light.living_room',
+        state: 'on',
+        attributes: {
+            brightness: 255,
+            color_temp: 400,
+            friendly_name: 'Living Room Light'
+        },
+        last_changed: '2024-03-20T12:00:00Z',
+        last_updated: '2024-03-20T12:00:00Z',
+        context: {
+            id: 'test_context_id',
+            parent_id: null,
+            user_id: null
+        }
+    };
+
+    beforeEach(async () => {
+        // Setup test environment
+        mocks = setupTestEnvironment();
+        liteMcpInstance = createMockLiteMCPInstance();
+
+        // Import the module which will execute the main function
+        await import('../../src/index.js');
+
+        // Get the mock instance and tool calls
+        addToolCalls = liteMcpInstance.addTool.mock.calls.map(call => call.args[0]);
+    });
+
+    afterEach(() => {
+        cleanupMocks({ liteMcpInstance, ...mocks });
+    });
+
+    describe('entity_state tool', () => {
+        test('should successfully get entity state', async () => {
+            // Setup response
+            mocks.mockFetch = mock(() => Promise.resolve(createMockResponse(mockEntityState)));
+            globalThis.fetch = mocks.mockFetch;
+
+            const entityStateTool = addToolCalls.find(tool => tool.name === 'entity_state');
+            expect(entityStateTool).toBeDefined();
+
+            if (!entityStateTool) {
+                throw new Error('entity_state tool not found');
+            }
+
+            const result = await entityStateTool.execute({
+                entity_id: 'light.living_room'
+            }) as TestResponse;
+
+            expect(result.success).toBe(true);
+            expect(result.state).toBe('on');
+            expect(result.attributes).toEqual(mockEntityState.attributes);
+
+            // Verify the fetch call
+            type FetchArgs = [url: string, init: RequestInit];
+            const args = getMockCallArgs<FetchArgs>(mocks.mockFetch);
+            expect(args).toBeDefined();
+
+            if (!args) {
+                throw new Error('No fetch calls recorded');
+            }
+
+            const [urlStr, options] = args;
+            expect(urlStr).toBe(`${TEST_CONFIG.HASS_HOST}/api/states/light.living_room`);
+            expect(options).toEqual({
+                headers: {
+                    Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+        });
+
+        test('should handle entity not found', async () => {
+            // Setup error response
+            mocks.mockFetch = mock(() => Promise.reject(new Error('Entity not found')));
+            globalThis.fetch = mocks.mockFetch;
+
+            const entityStateTool = addToolCalls.find(tool => tool.name === 'entity_state');
+            expect(entityStateTool).toBeDefined();
+
+            if (!entityStateTool) {
+                throw new Error('entity_state tool not found');
+            }
+
+            const result = await entityStateTool.execute({
+                entity_id: 'light.non_existent'
+            }) as TestResponse;
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Failed to get entity state: Entity not found');
+        });
+
+        test('should require entity_id', async () => {
+            const entityStateTool = addToolCalls.find(tool => tool.name === 'entity_state');
+            expect(entityStateTool).toBeDefined();
+
+            if (!entityStateTool) {
+                throw new Error('entity_state tool not found');
+            }
+
+            const result = await entityStateTool.execute({}) as TestResponse;
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Entity ID is required');
+        });
+
+        test('should handle invalid entity_id format', async () => {
+            const entityStateTool = addToolCalls.find(tool => tool.name === 'entity_state');
+            expect(entityStateTool).toBeDefined();
+
+            if (!entityStateTool) {
+                throw new Error('entity_state tool not found');
+            }
+
+            const result = await entityStateTool.execute({
+                entity_id: 'invalid_entity_id'
+            }) as TestResponse;
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Invalid entity ID format: invalid_entity_id');
+        });
+
+        test('should successfully get multiple entity states', async () => {
+            // Setup response
+            const mockStates = [
+                { ...mockEntityState },
+                {
+                    ...mockEntityState,
+                    entity_id: 'light.kitchen',
+                    attributes: { ...mockEntityState.attributes, friendly_name: 'Kitchen Light' }
+                }
+            ];
+            mocks.mockFetch = mock(() => Promise.resolve(createMockResponse(mockStates)));
+            globalThis.fetch = mocks.mockFetch;
+
+            const entityStateTool = addToolCalls.find(tool => tool.name === 'entity_state');
+            expect(entityStateTool).toBeDefined();
+
+            if (!entityStateTool) {
+                throw new Error('entity_state tool not found');
+            }
+
+            const result = await entityStateTool.execute({
+                entity_id: ['light.living_room', 'light.kitchen']
+            }) as TestResponse;
+
+            expect(result.success).toBe(true);
+            expect(Array.isArray(result.states)).toBe(true);
+            expect(result.states).toHaveLength(2);
+            expect(result.states[0].entity_id).toBe('light.living_room');
+            expect(result.states[1].entity_id).toBe('light.kitchen');
+
+            // Verify the fetch call
+            type FetchArgs = [url: string, init: RequestInit];
+            const args = getMockCallArgs<FetchArgs>(mocks.mockFetch);
+            expect(args).toBeDefined();
+
+            if (!args) {
+                throw new Error('No fetch calls recorded');
+            }
+
+            const [urlStr, options] = args;
+            expect(urlStr).toBe(`${TEST_CONFIG.HASS_HOST}/api/states`);
+            expect(options).toEqual({
+                headers: {
+                    Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+        });
+    });
+}); 

__tests__/tools/scene-control.test.ts

@@ -0,0 +1,2 @@
+import { describe, expect, test } from "bun:test";
+ 

__tests__/tools/script-control.test.ts

@@ -0,0 +1,218 @@
+import { describe, expect, test } from "bun:test";
+import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test";
+import {
+    type MockLiteMCPInstance,
+    type Tool,
+    type TestResponse,
+    TEST_CONFIG,
+    createMockLiteMCPInstance,
+    setupTestEnvironment,
+    cleanupMocks,
+    createMockResponse,
+    getMockCallArgs
+} from '../utils/test-utils';
+
+describe('Script Control Tools', () => {
+    let liteMcpInstance: MockLiteMCPInstance;
+    let addToolCalls: Tool[];
+    let mocks: ReturnType<typeof setupTestEnvironment>;
+
+    beforeEach(async () => {
+        // Setup test environment
+        mocks = setupTestEnvironment();
+        liteMcpInstance = createMockLiteMCPInstance();
+
+        // Import the module which will execute the main function
+        await import('../../src/index.js');
+
+        // Get the mock instance and tool calls
+        addToolCalls = liteMcpInstance.addTool.mock.calls.map(call => call.args[0]);
+    });
+
+    afterEach(() => {
+        cleanupMocks({ liteMcpInstance, ...mocks });
+    });
+
+    describe('script_control tool', () => {
+        test('should successfully execute a script', async () => {
+            // Setup response
+            mocks.mockFetch = mock(() => Promise.resolve(createMockResponse({ success: true })));
+            globalThis.fetch = mocks.mockFetch;
+
+            const scriptControlTool = addToolCalls.find(tool => tool.name === 'script_control');
+            expect(scriptControlTool).toBeDefined();
+
+            if (!scriptControlTool) {
+                throw new Error('script_control tool not found');
+            }
+
+            const result = await scriptControlTool.execute({
+                script_id: 'script.welcome_home',
+                action: 'start',
+                variables: {
+                    brightness: 100,
+                    color_temp: 300
+                }
+            }) as TestResponse;
+
+            expect(result.success).toBe(true);
+            expect(result.message).toBe('Successfully executed script script.welcome_home');
+
+            // Verify the fetch call
+            type FetchArgs = [url: string, init: RequestInit];
+            const args = getMockCallArgs<FetchArgs>(mocks.mockFetch);
+            expect(args).toBeDefined();
+
+            if (!args) {
+                throw new Error('No fetch calls recorded');
+            }
+
+            const [urlStr, options] = args;
+            expect(urlStr).toBe(`${TEST_CONFIG.HASS_HOST}/api/services/script/turn_on`);
+            expect(options).toEqual({
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    entity_id: 'script.welcome_home',
+                    variables: {
+                        brightness: 100,
+                        color_temp: 300
+                    }
+                })
+            });
+        });
+
+        test('should successfully stop a script', async () => {
+            // Setup response
+            mocks.mockFetch = mock(() => Promise.resolve(createMockResponse({ success: true })));
+            globalThis.fetch = mocks.mockFetch;
+
+            const scriptControlTool = addToolCalls.find(tool => tool.name === 'script_control');
+            expect(scriptControlTool).toBeDefined();
+
+            if (!scriptControlTool) {
+                throw new Error('script_control tool not found');
+            }
+
+            const result = await scriptControlTool.execute({
+                script_id: 'script.welcome_home',
+                action: 'stop'
+            }) as TestResponse;
+
+            expect(result.success).toBe(true);
+            expect(result.message).toBe('Successfully stopped script script.welcome_home');
+
+            // Verify the fetch call
+            type FetchArgs = [url: string, init: RequestInit];
+            const args = getMockCallArgs<FetchArgs>(mocks.mockFetch);
+            expect(args).toBeDefined();
+
+            if (!args) {
+                throw new Error('No fetch calls recorded');
+            }
+
+            const [urlStr, options] = args;
+            expect(urlStr).toBe(`${TEST_CONFIG.HASS_HOST}/api/services/script/turn_off`);
+            expect(options).toEqual({
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    entity_id: 'script.welcome_home'
+                })
+            });
+        });
+
+        test('should handle script execution failure', async () => {
+            // Setup error response
+            mocks.mockFetch = mock(() => Promise.reject(new Error('Failed to execute script')));
+            globalThis.fetch = mocks.mockFetch;
+
+            const scriptControlTool = addToolCalls.find(tool => tool.name === 'script_control');
+            expect(scriptControlTool).toBeDefined();
+
+            if (!scriptControlTool) {
+                throw new Error('script_control tool not found');
+            }
+
+            const result = await scriptControlTool.execute({
+                script_id: 'script.welcome_home',
+                action: 'start'
+            }) as TestResponse;
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Failed to execute script: Failed to execute script');
+        });
+
+        test('should require script_id', async () => {
+            const scriptControlTool = addToolCalls.find(tool => tool.name === 'script_control');
+            expect(scriptControlTool).toBeDefined();
+
+            if (!scriptControlTool) {
+                throw new Error('script_control tool not found');
+            }
+
+            const result = await scriptControlTool.execute({
+                action: 'start'
+            }) as TestResponse;
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Script ID is required');
+        });
+
+        test('should require action', async () => {
+            const scriptControlTool = addToolCalls.find(tool => tool.name === 'script_control');
+            expect(scriptControlTool).toBeDefined();
+
+            if (!scriptControlTool) {
+                throw new Error('script_control tool not found');
+            }
+
+            const result = await scriptControlTool.execute({
+                script_id: 'script.welcome_home'
+            }) as TestResponse;
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Action is required');
+        });
+
+        test('should handle invalid script_id format', async () => {
+            const scriptControlTool = addToolCalls.find(tool => tool.name === 'script_control');
+            expect(scriptControlTool).toBeDefined();
+
+            if (!scriptControlTool) {
+                throw new Error('script_control tool not found');
+            }
+
+            const result = await scriptControlTool.execute({
+                script_id: 'invalid_script_id',
+                action: 'start'
+            }) as TestResponse;
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Invalid script ID format: invalid_script_id');
+        });
+
+        test('should handle invalid action', async () => {
+            const scriptControlTool = addToolCalls.find(tool => tool.name === 'script_control');
+            expect(scriptControlTool).toBeDefined();
+
+            if (!scriptControlTool) {
+                throw new Error('script_control tool not found');
+            }
+
+            const result = await scriptControlTool.execute({
+                script_id: 'script.welcome_home',
+                action: 'invalid_action'
+            }) as TestResponse;
+
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Invalid action: invalid_action');
+        });
+    });
+}); 

__tests__/tools/tool-registry.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "bun:test";
 import { ToolRegistry, ToolCategory, EnhancedTool } from '../../src/tools/index.js';
 
 describe('ToolRegistry', () => {
@@ -18,27 +19,27 @@ describe('ToolRegistry', () => {
                     ttl: 1000
                 }
             },
-            execute: jest.fn().mockResolvedValue({ success: true }),
+            execute: mock().mockResolvedValue({ success: true }),
-            validate: jest.fn().mockResolvedValue(true),
+            validate: mock().mockResolvedValue(true),
-            preExecute: jest.fn().mockResolvedValue(undefined),
+            preExecute: mock().mockResolvedValue(undefined),
-            postExecute: jest.fn().mockResolvedValue(undefined)
+            postExecute: mock().mockResolvedValue(undefined)
         };
     });
 
     describe('Tool Registration', () => {
-        it('should register a tool successfully', () => {
+        test('should register a tool successfully', () => {
             registry.registerTool(mockTool);
             const retrievedTool = registry.getTool('test_tool');
             expect(retrievedTool).toBe(mockTool);
         });
 
-        it('should categorize tools correctly', () => {
+        test('should categorize tools correctly', () => {
             registry.registerTool(mockTool);
             const deviceTools = registry.getToolsByCategory(ToolCategory.DEVICE);
             expect(deviceTools).toContain(mockTool);
         });
 
-        it('should handle multiple tools in the same category', () => {
+        test('should handle multiple tools in the same category', () => {
             const mockTool2 = {
                 ...mockTool,
                 name: 'test_tool_2'
@@ -53,7 +54,7 @@ describe('ToolRegistry', () => {
     });
 
     describe('Tool Execution', () => {
-        it('should execute a tool with all hooks', async () => {
+        test('should execute a tool with all hooks', async () => {
             registry.registerTool(mockTool);
             await registry.executeTool('test_tool', { param: 'value' });
 
@@ -63,20 +64,20 @@ describe('ToolRegistry', () => {
             expect(mockTool.postExecute).toHaveBeenCalled();
         });
 
-        it('should throw error for non-existent tool', async () => {
+        test('should throw error for non-existent tool', async () => {
             await expect(registry.executeTool('non_existent', {}))
                 .rejects.toThrow('Tool non_existent not found');
         });
 
-        it('should handle validation failure', async () => {
+        test('should handle validation failure', async () => {
-            mockTool.validate = jest.fn().mockResolvedValue(false);
+            mockTool.validate = mock().mockResolvedValue(false);
             registry.registerTool(mockTool);
 
             await expect(registry.executeTool('test_tool', {}))
                 .rejects.toThrow('Invalid parameters');
         });
 
-        it('should execute without optional hooks', async () => {
+        test('should execute without optional hooks', async () => {
             const simpleTool: EnhancedTool = {
                 name: 'simple_tool',
                 description: 'A simple tool',
@@ -85,7 +86,7 @@ describe('ToolRegistry', () => {
                     platform: 'test',
                     version: '1.0.0'
                 },
-                execute: jest.fn().mockResolvedValue({ success: true })
+                execute: mock().mockResolvedValue({ success: true })
             };
 
             registry.registerTool(simpleTool);
@@ -95,7 +96,7 @@ describe('ToolRegistry', () => {
     });
 
     describe('Caching', () => {
-        it('should cache tool results when enabled', async () => {
+        test('should cache tool results when enabled', async () => {
             registry.registerTool(mockTool);
             const params = { test: 'value' };
 
@@ -108,7 +109,7 @@ describe('ToolRegistry', () => {
             expect(mockTool.execute).toHaveBeenCalledTimes(1);
         });
 
-        it('should not cache results when disabled', async () => {
+        test('should not cache results when disabled', async () => {
             const uncachedTool: EnhancedTool = {
                 ...mockTool,
                 metadata: {
@@ -130,7 +131,7 @@ describe('ToolRegistry', () => {
             expect(uncachedTool.execute).toHaveBeenCalledTimes(2);
         });
 
-        it('should expire cache after TTL', async () => {
+        test('should expire cache after TTL', async () => {
             mockTool.metadata.caching!.ttl = 100; // Short TTL for testing
             registry.registerTool(mockTool);
             const params = { test: 'value' };
@@ -147,7 +148,7 @@ describe('ToolRegistry', () => {
             expect(mockTool.execute).toHaveBeenCalledTimes(2);
         });
 
-        it('should clean expired cache entries', async () => {
+        test('should clean expired cache entries', async () => {
             mockTool.metadata.caching!.ttl = 100;
             registry.registerTool(mockTool);
             const params = { test: 'value' };
@@ -168,12 +169,12 @@ describe('ToolRegistry', () => {
     });
 
     describe('Category Management', () => {
-        it('should return empty array for unknown category', () => {
+        test('should return empty array for unknown category', () => {
             const tools = registry.getToolsByCategory('unknown' as ToolCategory);
             expect(tools).toEqual([]);
         });
 
-        it('should handle tools across multiple categories', () => {
+        test('should handle tools across multiple categories', () => {
             const systemTool: EnhancedTool = {
                 ...mockTool,
                 name: 'system_tool',

__tests__/types/litemcp.d.ts

@@ -0,0 +1,19 @@
+declare module 'litemcp' {
+    export interface Tool {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+        execute: (params: Record<string, unknown>) => Promise<unknown>;
+    }
+
+    export interface LiteMCPOptions {
+        name: string;
+        version: string;
+    }
+
+    export class LiteMCP {
+        constructor(options: LiteMCPOptions);
+        addTool(tool: Tool): void;
+        start(): Promise<void>;
+    }
+} 

__tests__/utils/test-utils.ts

@@ -0,0 +1,149 @@
+import { mock } from "bun:test";
+import type { Mock } from "bun:test";
+import type { WebSocket } from 'ws';
+
+// Common Types
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (params: Record<string, unknown>) => Promise<unknown>;
+}
+
+export interface MockLiteMCPInstance {
+    addTool: Mock<(tool: Tool) => void>;
+    start: Mock<() => Promise<void>>;
+}
+
+export interface MockServices {
+    light: {
+        turn_on: Mock<() => Promise<{ success: boolean }>>;
+        turn_off: Mock<() => Promise<{ success: boolean }>>;
+    };
+    climate: {
+        set_temperature: Mock<() => Promise<{ success: boolean }>>;
+    };
+}
+
+export interface MockHassInstance {
+    services: MockServices;
+}
+
+export type TestResponse = {
+    success: boolean;
+    message?: string;
+    automation_id?: string;
+    new_automation_id?: string;
+    state?: string;
+    attributes?: Record<string, any>;
+    states?: Array<{
+        entity_id: string;
+        state: string;
+        attributes: Record<string, any>;
+        last_changed: string;
+        last_updated: string;
+        context: {
+            id: string;
+            parent_id: string | null;
+            user_id: string | null;
+        };
+    }>;
+};
+
+// Test Configuration
+export const TEST_CONFIG = {
+    HASS_HOST: process.env.TEST_HASS_HOST || 'http://localhost:8123',
+    HASS_TOKEN: process.env.TEST_HASS_TOKEN || 'test_token',
+    HASS_SOCKET_URL: process.env.TEST_HASS_SOCKET_URL || 'ws://localhost:8123/api/websocket'
+} as const;
+
+// Mock WebSocket Implementation
+export class MockWebSocket {
+    public static readonly CONNECTING = 0;
+    public static readonly OPEN = 1;
+    public static readonly CLOSING = 2;
+    public static readonly CLOSED = 3;
+
+    public readyState: 0 | 1 | 2 | 3 = MockWebSocket.OPEN;
+    public bufferedAmount = 0;
+    public extensions = '';
+    public protocol = '';
+    public url = '';
+    public binaryType: 'arraybuffer' | 'nodebuffer' | 'fragments' = 'arraybuffer';
+
+    public onopen: ((event: any) => void) | null = null;
+    public onerror: ((event: any) => void) | null = null;
+    public onclose: ((event: any) => void) | null = null;
+    public onmessage: ((event: any) => void) | null = null;
+
+    public addEventListener = mock(() => undefined);
+    public removeEventListener = mock(() => undefined);
+    public send = mock(() => undefined);
+    public close = mock(() => undefined);
+    public ping = mock(() => undefined);
+    public pong = mock(() => undefined);
+    public terminate = mock(() => undefined);
+
+    constructor(url: string | URL, protocols?: string | string[]) {
+        this.url = url.toString();
+        if (protocols) {
+            this.protocol = Array.isArray(protocols) ? protocols[0] : protocols;
+        }
+    }
+}
+
+// Mock Service Instances
+export const createMockServices = (): MockServices => ({
+    light: {
+        turn_on: mock(() => Promise.resolve({ success: true })),
+        turn_off: mock(() => Promise.resolve({ success: true }))
+    },
+    climate: {
+        set_temperature: mock(() => Promise.resolve({ success: true }))
+    }
+});
+
+export const createMockLiteMCPInstance = (): MockLiteMCPInstance => ({
+    addTool: mock((tool: Tool) => undefined),
+    start: mock(() => Promise.resolve())
+});
+
+// Helper Functions
+export const createMockResponse = <T>(data: T, status = 200): Response => {
+    return new Response(JSON.stringify(data), { status });
+};
+
+export const getMockCallArgs = <T extends unknown[]>(
+    mock: Mock<(...args: any[]) => any>,
+    callIndex = 0
+): T | undefined => {
+    const call = mock.mock.calls[callIndex];
+    return call?.args as T | undefined;
+};
+
+export const setupTestEnvironment = () => {
+    // Setup test environment variables
+    Object.entries(TEST_CONFIG).forEach(([key, value]) => {
+        process.env[key] = value;
+    });
+
+    // Create fetch mock
+    const mockFetch = mock(() => Promise.resolve(createMockResponse({ state: 'connected' })));
+
+    // Override globals
+    globalThis.fetch = mockFetch;
+    globalThis.WebSocket = MockWebSocket as any;
+
+    return { mockFetch };
+};
+
+export const cleanupMocks = (mocks: {
+    liteMcpInstance: MockLiteMCPInstance;
+    mockFetch: Mock<() => Promise<Response>>;
+}) => {
+    // Reset mock calls by creating a new mock
+    mocks.liteMcpInstance.addTool = mock((tool: Tool) => undefined);
+    mocks.liteMcpInstance.start = mock(() => Promise.resolve());
+    mocks.mockFetch = mock(() => Promise.resolve(new Response()));
+    globalThis.fetch = mocks.mockFetch;
+}; 

__tests__/websocket/client.test.ts

@@ -1 +1,2 @@
+import { describe, expect, test } from "bun:test";
  

__tests__/websocket/events.test.ts

@@ -1,119 +1,177 @@
-import { jest, describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test";
-import { HassWebSocketClient } from '../../src/websocket/client.js';
+import { EventEmitter } from "events";
-import WebSocket from 'ws';
+import { HassWebSocketClient } from "../../src/websocket/client";
-import { EventEmitter } from 'events';
+import type { MessageEvent, ErrorEvent } from "ws";
-import * as HomeAssistant from '../../src/types/hass.js';
+import { Mock, fn as jestMock } from 'jest-mock';
-
+import { expect as jestExpect } from '@jest/globals';
-// Mock WebSocket
-jest.mock('ws');
 
 describe('WebSocket Event Handling', () => {
     let client: HassWebSocketClient;
-    let mockWebSocket: jest.Mocked<WebSocket>;
+    let mockWebSocket: any;
+    let onOpenCallback: () => void;
+    let onCloseCallback: () => void;
+    let onErrorCallback: (event: any) => void;
+    let onMessageCallback: (event: any) => void;
     let eventEmitter: EventEmitter;
 
     beforeEach(() => {
-        // Clear all mocks
-        jest.clearAllMocks();
-
-        // Create event emitter for mocking WebSocket events
         eventEmitter = new EventEmitter();
 
-        // Create mock WebSocket instance
+        // Initialize callbacks first
+        onOpenCallback = () => { };
+        onCloseCallback = () => { };
+        onErrorCallback = () => { };
+        onMessageCallback = () => { };
+
         mockWebSocket = {
-            on: jest.fn((event: string, listener: (...args: any[]) => void) => {
+            send: mock(),
-                eventEmitter.on(event, listener);
+            close: mock(),
-                return mockWebSocket;
+            readyState: 1,
-            }),
+            OPEN: 1,
-            send: jest.fn(),
+            onopen: null,
-            close: jest.fn(),
+            onclose: null,
-            readyState: WebSocket.OPEN,
+            onerror: null,
-            removeAllListeners: jest.fn(),
+            onmessage: null
-            // Add required WebSocket properties
+        };
-            binaryType: 'arraybuffer',
-            bufferedAmount: 0,
-            extensions: '',
-            protocol: '',
-            url: 'ws://test.com',
-            isPaused: () => false,
-            ping: jest.fn(),
-            pong: jest.fn(),
-            terminate: jest.fn()
-        } as unknown as jest.Mocked<WebSocket>;
 
-        // Mock WebSocket constructor
+        // Define setters that store the callbacks
-        (WebSocket as unknown as jest.Mock).mockImplementation(() => mockWebSocket);
+        Object.defineProperties(mockWebSocket, {
+            onopen: {
+                get() { return onOpenCallback; },
+                set(callback: () => void) { onOpenCallback = callback; }
+            },
+            onclose: {
+                get() { return onCloseCallback; },
+                set(callback: () => void) { onCloseCallback = callback; }
+            },
+            onerror: {
+                get() { return onErrorCallback; },
+                set(callback: (event: any) => void) { onErrorCallback = callback; }
+            },
+            onmessage: {
+                get() { return onMessageCallback; },
+                set(callback: (event: any) => void) { onMessageCallback = callback; }
+            }
+        });
 
-        // Create client instance
+        // @ts-expect-error - Mock WebSocket implementation
-        client = new HassWebSocketClient('ws://test.com', 'test-token');
+        global.WebSocket = mock(() => mockWebSocket);
+
+        client = new HassWebSocketClient('ws://localhost:8123/api/websocket', 'test-token');
     });
 
     afterEach(() => {
-        eventEmitter.removeAllListeners();
+        if (eventEmitter) {
-        client.disconnect();
+            eventEmitter.removeAllListeners();
+        }
+        if (client) {
+            client.disconnect();
+        }
     });
 
-    it('should handle connection events', () => {
+    test('should handle connection events', async () => {
-        // Simulate open event
+        const connectPromise = client.connect();
-        eventEmitter.emit('open');
+        onOpenCallback();
-
+        await connectPromise;
-        // Verify authentication message was sent
+        expect(client.isConnected()).toBe(true);
-        expect(mockWebSocket.send).toHaveBeenCalledWith(
-            expect.stringContaining('"type":"auth"')
-        );
     });
 
-    it('should handle authentication response', () => {
+    test('should handle authentication response', async () => {
-        // Simulate auth_ok message
+        const connectPromise = client.connect();
-        eventEmitter.emit('message', JSON.stringify({ type: 'auth_ok' }));
+        onOpenCallback();
 
-        // Verify client is ready for commands
+        onMessageCallback({
-        expect(mockWebSocket.readyState).toBe(WebSocket.OPEN);
+            data: JSON.stringify({
+                type: 'auth_required'
+            })
+        });
+
+        onMessageCallback({
+            data: JSON.stringify({
+                type: 'auth_ok'
+            })
+        });
+
+        await connectPromise;
+        expect(client.isAuthenticated()).toBe(true);
     });
 
-    it('should handle auth failure', () => {
+    test('should handle auth failure', async () => {
-        // Simulate auth_invalid message
+        const connectPromise = client.connect();
-        eventEmitter.emit('message', JSON.stringify({
+        onOpenCallback();
-            type: 'auth_invalid',
-            message: 'Invalid token'
-        }));
 
-        // Verify client attempts to close connection
+        onMessageCallback({
-        expect(mockWebSocket.close).toHaveBeenCalled();
+            data: JSON.stringify({
+                type: 'auth_required'
+            })
+        });
+
+        onMessageCallback({
+            data: JSON.stringify({
+                type: 'auth_invalid',
+                message: 'Invalid password'
+            })
+        });
+
+        await expect(connectPromise).rejects.toThrow('Authentication failed');
+        expect(client.isAuthenticated()).toBe(false);
     });
 
-    it('should handle connection errors', () => {
+    test('should handle connection errors', async () => {
-        // Create error spy
+        const errorPromise = new Promise((resolve) => {
-        const errorSpy = jest.fn();
+            client.once('error', resolve);
-        client.on('error', errorSpy);
+        });
 
-        // Simulate error
+        const connectPromise = client.connect().catch(() => { /* Expected error */ });
-        const testError = new Error('Test error');
+        onOpenCallback();
-        eventEmitter.emit('error', testError);
 
-        // Verify error was handled
+        const errorEvent = new Error('Connection failed');
-        expect(errorSpy).toHaveBeenCalledWith(testError);
+        onErrorCallback({ error: errorEvent });
+
+        const error = await errorPromise;
+        expect(error instanceof Error).toBe(true);
+        expect((error as Error).message).toBe('Connection failed');
     });
 
-    it('should handle disconnection', () => {
+    test('should handle disconnection', async () => {
-        // Create close spy
+        const connectPromise = client.connect();
-        const closeSpy = jest.fn();
+        onOpenCallback();
-        client.on('close', closeSpy);
+        await connectPromise;
 
-        // Simulate close
+        const disconnectPromise = new Promise((resolve) => {
-        eventEmitter.emit('close');
+            client.on('disconnected', resolve);
+        });
 
-        // Verify close was handled
+        onCloseCallback();
-        expect(closeSpy).toHaveBeenCalled();
+
+        await disconnectPromise;
+        expect(client.isConnected()).toBe(false);
     });
 
-    it('should handle event messages', () => {
+    test('should handle event messages', async () => {
-        // Create event spy
+        const connectPromise = client.connect();
-        const eventSpy = jest.fn();
+        onOpenCallback();
-        client.on('event', eventSpy);
+
+        onMessageCallback({
+            data: JSON.stringify({
+                type: 'auth_required'
+            })
+        });
+
+        onMessageCallback({
+            data: JSON.stringify({
+                type: 'auth_ok'
+            })
+        });
+
+        await connectPromise;
+
+        const eventPromise = new Promise((resolve) => {
+            client.on('state_changed', resolve);
+        });
 
-        // Simulate event message
         const eventData = {
+            id: 1,
             type: 'event',
             event: {
                 event_type: 'state_changed',
@@ -123,217 +181,63 @@ describe('WebSocket Event Handling', () => {
                 }
             }
         };
-        eventEmitter.emit('message', JSON.stringify(eventData));
 
-        // Verify event was handled
+        onMessageCallback({
-        expect(eventSpy).toHaveBeenCalledWith(eventData.event);
+            data: JSON.stringify(eventData)
+        });
+
+        const receivedEvent = await eventPromise;
+        expect(receivedEvent).toEqual(eventData.event.data);
     });
 
-    describe('Connection Events', () => {
+    test('should subscribe to specific events', async () => {
-        it('should handle successful connection', (done) => {
+        const connectPromise = client.connect();
-            client.on('open', () => {
+        onOpenCallback();
-                expect(mockWebSocket.send).toHaveBeenCalled();
-                done();
-            });
 
-            eventEmitter.emit('open');
+        onMessageCallback({
+            data: JSON.stringify({
+                type: 'auth_required'
+            })
         });
 
-        it('should handle connection errors', (done) => {
+        onMessageCallback({
-            const error = new Error('Connection failed');
+            data: JSON.stringify({
-            client.on('error', (err: Error) => {
+                type: 'auth_ok'
-                expect(err).toBe(error);
+            })
-                done();
-            });
-
-            eventEmitter.emit('error', error);
         });
 
-        it('should handle connection close', (done) => {
+        await connectPromise;
-            client.on('disconnected', () => {
-                expect(mockWebSocket.close).toHaveBeenCalled();
-                done();
-            });
 
-            eventEmitter.emit('close');
+        const subscriptionId = await client.subscribeEvents('state_changed', (data) => {
+            // Empty callback for type satisfaction
         });
+        expect(mockWebSocket.send).toHaveBeenCalled();
+        expect(subscriptionId).toBeDefined();
     });
 
-    describe('Authentication', () => {
+    test('should unsubscribe from events', async () => {
-        it('should send authentication message on connect', () => {
+        const connectPromise = client.connect();
-            const authMessage: HomeAssistant.AuthMessage = {
+        onOpenCallback();
-                type: 'auth',
-                access_token: 'test_token'
-            };
 
-            client.connect();
+        onMessageCallback({
-            expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify(authMessage));
+            data: JSON.stringify({
+                type: 'auth_required'
+            })
         });
 
-        it('should handle successful authentication', (done) => {
+        onMessageCallback({
-            client.on('auth_ok', () => {
+            data: JSON.stringify({
-                done();
+                type: 'auth_ok'
-            });
+            })
-
-            client.connect();
-            eventEmitter.emit('message', JSON.stringify({ type: 'auth_ok' }));
         });
 
-        it('should handle authentication failure', (done) => {
+        await connectPromise;
-            client.on('auth_invalid', () => {
-                done();
-            });
 
-            client.connect();
+        const subscriptionId = await client.subscribeEvents('state_changed', (data) => {
-            eventEmitter.emit('message', JSON.stringify({ type: 'auth_invalid' }));
+            // Empty callback for type satisfaction
         });
-    });
+        await client.unsubscribeEvents(subscriptionId);
 
-    describe('Event Subscription', () => {
+        expect(mockWebSocket.send).toHaveBeenCalled();
-        it('should handle state changed events', (done) => {
-            const stateEvent: HomeAssistant.StateChangedEvent = {
-                event_type: 'state_changed',
-                data: {
-                    entity_id: 'light.living_room',
-                    new_state: {
-                        entity_id: 'light.living_room',
-                        state: 'on',
-                        attributes: { brightness: 255 },
-                        last_changed: '2024-01-01T00:00:00Z',
-                        last_updated: '2024-01-01T00:00:00Z',
-                        context: {
-                            id: '123',
-                            parent_id: null,
-                            user_id: null
-                        }
-                    },
-                    old_state: {
-                        entity_id: 'light.living_room',
-                        state: 'off',
-                        attributes: {},
-                        last_changed: '2024-01-01T00:00:00Z',
-                        last_updated: '2024-01-01T00:00:00Z',
-                        context: {
-                            id: '122',
-                            parent_id: null,
-                            user_id: null
-                        }
-                    }
-                },
-                origin: 'LOCAL',
-                time_fired: '2024-01-01T00:00:00Z',
-                context: {
-                    id: '123',
-                    parent_id: null,
-                    user_id: null
-                }
-            };
-
-            client.on('event', (event) => {
-                expect(event.data.entity_id).toBe('light.living_room');
-                expect(event.data.new_state.state).toBe('on');
-                expect(event.data.old_state.state).toBe('off');
-                done();
-            });
-
-            eventEmitter.emit('message', JSON.stringify({ type: 'event', event: stateEvent }));
-        });
-
-        it('should subscribe to specific events', async () => {
-            const subscriptionId = 1;
-            const callback = jest.fn();
-
-            // Mock successful subscription
-            const subscribePromise = client.subscribeEvents('state_changed', callback);
-            eventEmitter.emit('message', JSON.stringify({
-                id: 1,
-                type: 'result',
-                success: true
-            }));
-
-            await expect(subscribePromise).resolves.toBe(subscriptionId);
-
-            // Test event handling
-            const eventData = {
-                entity_id: 'light.living_room',
-                state: 'on'
-            };
-            eventEmitter.emit('message', JSON.stringify({
-                type: 'event',
-                event: {
-                    event_type: 'state_changed',
-                    data: eventData
-                }
-            }));
-
-            expect(callback).toHaveBeenCalledWith(eventData);
-        });
-
-        it('should unsubscribe from events', async () => {
-            // First subscribe
-            const subscriptionId = await client.subscribeEvents('state_changed', () => { });
-
-            // Then unsubscribe
-            const unsubscribePromise = client.unsubscribeEvents(subscriptionId);
-            eventEmitter.emit('message', JSON.stringify({
-                id: 2,
-                type: 'result',
-                success: true
-            }));
-
-            await expect(unsubscribePromise).resolves.toBeUndefined();
-        });
-    });
-
-    describe('Message Handling', () => {
-        it('should handle malformed messages', (done) => {
-            client.on('error', (error: Error) => {
-                expect(error.message).toContain('Unexpected token');
-                done();
-            });
-
-            eventEmitter.emit('message', 'invalid json');
-        });
-
-        it('should handle unknown message types', (done) => {
-            const unknownMessage = {
-                type: 'unknown_type',
-                data: {}
-            };
-
-            client.on('error', (error: Error) => {
-                expect(error.message).toContain('Unknown message type');
-                done();
-            });
-
-            eventEmitter.emit('message', JSON.stringify(unknownMessage));
-        });
-    });
-
-    describe('Reconnection', () => {
-        it('should attempt to reconnect on connection loss', (done) => {
-            let reconnectAttempts = 0;
-            client.on('disconnected', () => {
-                reconnectAttempts++;
-                if (reconnectAttempts === 1) {
-                    expect(WebSocket).toHaveBeenCalledTimes(2);
-                    done();
-                }
-            });
-
-            eventEmitter.emit('close');
-        });
-
-        it('should re-authenticate after reconnection', (done) => {
-            client.connect();
-
-            client.on('auth_ok', () => {
-                done();
-            });
-
-            eventEmitter.emit('close');
-            eventEmitter.emit('open');
-            eventEmitter.emit('message', JSON.stringify({ type: 'auth_ok' }));
-        });
     });
 }); 

bin/mcp-stdio.cjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const dotenv = require('dotenv');
+
+/**
+ * MCP Server - Stdio Transport Mode (CommonJS)
+ * 
+ * This is the CommonJS entry point for running the MCP server via NPX in stdio mode.
+ * It will directly load the stdio-server.js file which is optimized for the CLI usage.
+ */
+
+// Set environment variable for stdio transport
+process.env.USE_STDIO_TRANSPORT = 'true';
+
+// Load environment variables from .env file (if exists)
+try {
+    const envPath = path.resolve(process.cwd(), '.env');
+    if (fs.existsSync(envPath)) {
+        dotenv.config({ path: envPath });
+    } else {
+        // Load .env.example if it exists
+        const examplePath = path.resolve(process.cwd(), '.env.example');
+        if (fs.existsSync(examplePath)) {
+            dotenv.config({ path: examplePath });
+        }
+    }
+} catch (error) {
+    // Silent error handling
+}
+
+// Ensure logs directory exists
+try {
+    const logsDir = path.join(process.cwd(), 'logs');
+    if (!fs.existsSync(logsDir)) {
+        fs.mkdirSync(logsDir, { recursive: true });
+    }
+} catch (error) {
+    // Silent error handling
+}
+
+// Try to load the server
+try {
+    // Check for simplified stdio server build first (preferred for CLI usage)
+    const stdioServerPath = path.resolve(__dirname, '../dist/stdio-server.js');
+
+    if (fs.existsSync(stdioServerPath)) {
+        // If we're running in Node.js (not Bun), we need to handle ESM imports differently
+        if (typeof Bun === 'undefined') {
+            // Use dynamic import for ESM modules in CommonJS
+            import(stdioServerPath).catch((err) => {
+                console.error('Failed to import stdio server:', err.message);
+                process.exit(1);
+            });
+        } else {
+            // In Bun, we can directly require the module
+            require(stdioServerPath);
+        }
+    } else {
+        // Fall back to full server if available
+        const fullServerPath = path.resolve(__dirname, '../dist/index.js');
+
+        if (fs.existsSync(fullServerPath)) {
+            console.warn('Warning: stdio-server.js not found, falling back to index.js');
+            console.warn('For optimal CLI performance, build with "npm run build:stdio"');
+
+            if (typeof Bun === 'undefined') {
+                import(fullServerPath).catch((err) => {
+                    console.error('Failed to import server:', err.message);
+                    process.exit(1);
+                });
+            } else {
+                require(fullServerPath);
+            }
+        } else {
+            console.error('Error: No server implementation found. Please build the project first.');
+            process.exit(1);
+        }
+    }
+} catch (error) {
+    console.error('Error starting server:', error.message);
+    process.exit(1);
+} 

bin/mcp-stdio.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Server - Stdio Transport Mode
+ * 
+ * This is the entry point for running the MCP server via NPX in stdio mode.
+ * It automatically configures the server to use JSON-RPC 2.0 over stdin/stdout.
+ */
+
+// Set environment variables for stdio transport
+process.env.USE_STDIO_TRANSPORT = 'true';
+
+// Import and run the MCP server from the compiled output
+try {
+    // First make sure required directories exist
+    const fs = require('fs');
+    const path = require('path');
+
+    // Ensure logs directory exists
+    const logsDir = path.join(process.cwd(), 'logs');
+    if (!fs.existsSync(logsDir)) {
+        console.error('Creating logs directory...');
+        fs.mkdirSync(logsDir, { recursive: true });
+    }
+
+    // Get the entry module path
+    const entryPath = require.resolve('../dist/index.js');
+
+    // Print initial message to stderr
+    console.error('Starting MCP server in stdio transport mode...');
+    console.error('Logs will be written to the logs/ directory');
+    console.error('Communication will use JSON-RPC 2.0 format via stdin/stdout');
+
+    // Run the server
+    require(entryPath);
+} catch (error) {
+    console.error('Failed to start MCP server:', error.message);
+    console.error('If this is your first run, you may need to build the project first:');
+    console.error('  npm run build');
+    process.exit(1);
+} 

bin/npx-entry.cjs

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+// Set environment variable - enable stdio transport
+process.env.USE_STDIO_TRANSPORT = 'true';
+
+// Check if we're being called from Cursor (check for Cursor specific env vars)
+const isCursor = process.env.CURSOR_SESSION || process.env.CURSOR_CHANNEL;
+
+// For Cursor, we need to ensure consistent stdio handling
+if (isCursor) {
+    // Essential for Cursor compatibility
+    process.env.LOG_LEVEL = 'info';
+    process.env.CURSOR_COMPATIBLE = 'true';
+
+    // Ensure we have a clean environment for Cursor
+    delete process.env.SILENT_MCP_RUNNING;
+} else {
+    // For normal operation, silence logs
+    process.env.LOG_LEVEL = 'silent';
+}
+
+// Ensure logs directory exists
+const logsDir = path.join(process.cwd(), 'logs');
+if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+}
+
+// Check if .env exists, create from example if not
+const envPath = path.join(process.cwd(), '.env');
+const envExamplePath = path.join(process.cwd(), '.env.example');
+
+if (!fs.existsSync(envPath) && fs.existsSync(envExamplePath)) {
+    fs.copyFileSync(envExamplePath, envPath);
+}
+
+// Define a function to ensure the child process is properly cleaned up on exit
+function setupCleanExit(childProcess) {
+    const exitHandler = () => {
+        if (childProcess && !childProcess.killed) {
+            childProcess.kill();
+        }
+        process.exit();
+    };
+
+    // Handle various termination signals
+    process.on('SIGINT', exitHandler);
+    process.on('SIGTERM', exitHandler);
+    process.on('exit', exitHandler);
+}
+
+// Start the MCP server
+try {
+    // Critical: For Cursor, we need a very specific execution environment
+    if (isCursor) {
+        // Careful process cleanup for Cursor (optional but can help)
+        try {
+            const { execSync } = require('child_process');
+            execSync('pkill -f "node.*stdio-server" || true', { stdio: 'ignore' });
+        } catch (e) {
+            // Ignore errors from process cleanup
+        }
+
+        // Allow some time for process cleanup
+        setTimeout(() => {
+            const scriptPath = path.join(__dirname, 'mcp-stdio.cjs');
+
+            // For Cursor, we need very specific stdio handling
+            // Using pipe for both stdin and stdout is critical
+            const childProcess = spawn('node', [scriptPath], {
+                stdio: ['pipe', 'pipe', 'pipe'], // All piped for maximum control
+                env: {
+                    ...process.env,
+                    USE_STDIO_TRANSPORT: 'true',
+                    CURSOR_COMPATIBLE: 'true',
+                    // Make sure stdin/stdout are treated as binary
+                    NODE_OPTIONS: '--no-force-async-hooks-checks'
+                }
+            });
+
+            // Ensure no buffering to prevent missed messages 
+            childProcess.stdin.setDefaultEncoding('utf8');
+
+            // Create bidirectional pipes
+            process.stdin.pipe(childProcess.stdin);
+            childProcess.stdout.pipe(process.stdout);
+            childProcess.stderr.pipe(process.stderr);
+
+            // Setup error handling
+            childProcess.on('error', (err) => {
+                console.error('Failed to start server:', err.message);
+                process.exit(1);
+            });
+
+            // Ensure child process is properly cleaned up
+            setupCleanExit(childProcess);
+
+        }, 500); // Short delay to ensure clean start
+    }
+    // For regular use, if silent-mcp.sh exists, use it
+    else if (!isCursor && fs.existsSync(path.join(process.cwd(), 'silent-mcp.sh')) &&
+        fs.statSync(path.join(process.cwd(), 'silent-mcp.sh')).isFile()) {
+        // Execute the silent-mcp.sh script
+        const childProcess = spawn('/bin/bash', [path.join(process.cwd(), 'silent-mcp.sh')], {
+            stdio: ['inherit', 'inherit', 'ignore'], // Redirect stderr to /dev/null
+            env: {
+                ...process.env,
+                USE_STDIO_TRANSPORT: 'true',
+                LOG_LEVEL: 'silent'
+            }
+        });
+
+        childProcess.on('error', (err) => {
+            console.error('Failed to start server:', err.message);
+            process.exit(1);
+        });
+
+        // Ensure child process is properly cleaned up
+        setupCleanExit(childProcess);
+    }
+    // Otherwise run normally (direct non-Cursor)
+    else {
+        const scriptPath = path.join(__dirname, 'mcp-stdio.cjs');
+
+        const childProcess = spawn('node', [scriptPath], {
+            stdio: ['inherit', 'pipe', 'ignore'], // Redirect stderr to /dev/null for normal use
+            env: {
+                ...process.env,
+                USE_STDIO_TRANSPORT: 'true'
+            }
+        });
+
+        // Pipe child's stdout to parent's stdout
+        childProcess.stdout.pipe(process.stdout);
+
+        childProcess.on('error', (err) => {
+            console.error('Failed to start server:', err.message);
+            process.exit(1);
+        });
+
+        // Ensure child process is properly cleaned up
+        setupCleanExit(childProcess);
+    }
+} catch (error) {
+    console.error('Error starting server:', error.message);
+    process.exit(1);
+} 

bin/test-stdio.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for MCP stdio transport
+ * 
+ * This script sends JSON-RPC 2.0 requests to the MCP server
+ * running in stdio mode and displays the responses.
+ * 
+ * Usage: node test-stdio.js | node bin/mcp-stdio.cjs
+ */
+
+// Send a ping request
+const pingRequest = {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "ping"
+};
+
+// Send an info request
+const infoRequest = {
+    jsonrpc: "2.0",
+    id: 2,
+    method: "info"
+};
+
+// Send an echo request
+const echoRequest = {
+    jsonrpc: "2.0",
+    id: 3,
+    method: "echo",
+    params: {
+        message: "Hello, MCP!",
+        timestamp: new Date().toISOString(),
+        test: true,
+        count: 42
+    }
+};
+
+// Send the requests with a delay between them
+setTimeout(() => {
+    console.log(JSON.stringify(pingRequest));
+}, 500);
+
+setTimeout(() => {
+    console.log(JSON.stringify(infoRequest));
+}, 1000);
+
+setTimeout(() => {
+    console.log(JSON.stringify(echoRequest));
+}, 1500);
+
+// Process responses
+process.stdin.on('data', (data) => {
+    try {
+        const response = JSON.parse(data.toString());
+        console.error('Received response:');
+        console.error(JSON.stringify(response, null, 2));
+    } catch (error) {
+        console.error('Error parsing response:', error);
+        console.error('Raw data:', data.toString());
+    }
+}); 

bunfig.toml

@@ -0,0 +1,83 @@
+[test]
+preload = ["./test/setup.ts"]
+coverage = true
+coverageThreshold = {
+  statements = 80,
+  branches = 70,
+  functions = 80,
+  lines = 80
+}
+timeout = 10000
+testMatch = ["**/__tests__/**/*.test.ts"]
+testPathIgnorePatterns = ["/node_modules/", "/dist/"]
+collectCoverageFrom = [
+  "src/**/*.{ts,tsx}",
+  "!src/**/*.d.ts",
+  "!src/**/*.test.ts",
+  "!src/types/**/*",
+  "!src/mocks/**/*"
+]
+
+[build]
+target = "bun"
+outdir = "./dist"
+minify = {
+  whitespace = true,
+  syntax = true,
+  identifiers = true,
+  module = true
+}
+sourcemap = "external"
+entry = ["./src/index.ts", "./src/stdio-server.ts"]
+splitting = true
+naming = "[name].[hash].[ext]"
+publicPath = "/assets/"
+define = {
+  "process.env.NODE_ENV": "process.env.NODE_ENV"
+}
+
+[build.javascript]
+platform = "node"
+format = "esm"
+treeshaking = true
+packages = {
+  external = ["bun:*"]
+}
+
+[build.typescript]
+dts = true
+typecheck = true
+
+[install]
+production = false
+frozen = true
+peer = false
+
+[install.cache]
+dir = ".bun"
+disable = false
+
+[debug]
+port = 9229
+
+[env]
+# Environment-specific configurations
+development.LOG_LEVEL = "debug"
+production.LOG_LEVEL = "warn"
+
+[hot]
+restart = true
+reload = true
+
+[performance]
+gc = true
+optimize = true
+jit = true
+smol = true
+compact = true
+
+[test.env]
+NODE_ENV = "test"
+
+[watch]
+ignore = ["**/node_modules/**", "**/dist/**", "**/.git/**"] 

docker-build.sh

@@ -0,0 +1,148 @@
+#!/bin/bash
+
+# Enable error handling
+set -euo pipefail
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+# Function to print colored messages
+print_message() {
+    local color=$1
+    local message=$2
+    echo -e "${color}${message}${NC}"
+}
+
+# Function to clean up on script exit
+cleanup() {
+    print_message "$YELLOW" "Cleaning up..."
+    docker builder prune -f --filter until=24h
+    docker image prune -f
+}
+trap cleanup EXIT
+
+# Parse command line arguments
+ENABLE_SPEECH=false
+ENABLE_GPU=false
+BUILD_TYPE="standard"
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --speech)
+            ENABLE_SPEECH=true
+            BUILD_TYPE="speech"
+            shift
+            ;;
+        --gpu)
+            ENABLE_GPU=true
+            shift
+            ;;
+        *)
+            print_message "$RED" "Unknown option: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Clean up Docker system
+print_message "$YELLOW" "Cleaning up Docker system..."
+docker system prune -f --volumes
+
+# Set build arguments for better performance
+export DOCKER_BUILDKIT=1
+export COMPOSE_DOCKER_CLI_BUILD=1
+export BUILDKIT_PROGRESS=plain
+
+# Calculate available memory and CPU
+TOTAL_MEM=$(free -m | awk '/^Mem:/{print $2}')
+BUILD_MEM=$(( TOTAL_MEM / 2 ))  # Use half of available memory
+CPU_COUNT=$(nproc)
+CPU_QUOTA=$(( CPU_COUNT * 50000 ))  # Allow 50% CPU usage per core
+
+print_message "$YELLOW" "Building with ${BUILD_MEM}MB memory limit and CPU quota ${CPU_QUOTA}"
+
+# Remove any existing lockfile
+rm -f bun.lockb
+
+# Base build arguments
+BUILD_ARGS=(
+    --memory="${BUILD_MEM}m"
+    --memory-swap="${BUILD_MEM}m"
+    --cpu-quota="${CPU_QUOTA}"
+    --build-arg BUILDKIT_INLINE_CACHE=1
+    --build-arg DOCKER_BUILDKIT=1
+    --build-arg NODE_ENV=production
+    --progress=plain
+    --no-cache
+    --compress
+)
+
+# Add speech-specific build arguments if enabled
+if [ "$ENABLE_SPEECH" = true ]; then
+    BUILD_ARGS+=(
+        --build-arg ENABLE_SPEECH_FEATURES=true
+        --build-arg ENABLE_WAKE_WORD=true
+        --build-arg ENABLE_SPEECH_TO_TEXT=true
+    )
+    
+    # Add GPU support if requested
+    if [ "$ENABLE_GPU" = true ]; then
+        BUILD_ARGS+=(
+            --build-arg CUDA_VISIBLE_DEVICES=0
+            --build-arg COMPUTE_TYPE=float16
+        )
+    fi
+fi
+
+# Build the images
+print_message "$YELLOW" "Building Docker image (${BUILD_TYPE} build)..."
+
+# Build main image
+DOCKER_BUILDKIT=1 docker build \
+    "${BUILD_ARGS[@]}" \
+    -t homeassistant-mcp:latest \
+    -t homeassistant-mcp:$(date +%Y%m%d) \
+    .
+
+# Check if build was successful
+BUILD_EXIT_CODE=$?
+if [ $BUILD_EXIT_CODE -eq 124 ]; then
+    print_message "$RED" "Build timed out after 15 minutes!"
+    exit 1
+elif [ $BUILD_EXIT_CODE -ne 0 ]; then
+    print_message "$RED" "Build failed with exit code ${BUILD_EXIT_CODE}!"
+    exit 1
+else
+    print_message "$GREEN" "Main image build completed successfully!"
+    
+    # Show image size and layers
+    docker image ls homeassistant-mcp:latest --format "Image size: {{.Size}}"
+    echo "Layer count: $(docker history homeassistant-mcp:latest | wc -l)"
+fi
+
+# Build speech-related images if enabled
+if [ "$ENABLE_SPEECH" = true ]; then
+    print_message "$YELLOW" "Building speech-related images..."
+    
+    # Build fast-whisper image
+    print_message "$YELLOW" "Building fast-whisper image..."
+    docker pull onerahmet/openai-whisper-asr-webservice:latest
+    
+    # Build wake-word image
+    print_message "$YELLOW" "Building wake-word image..."
+    docker pull rhasspy/wyoming-openwakeword:latest
+    
+    print_message "$GREEN" "Speech-related images built successfully!"
+fi
+
+print_message "$GREEN" "All builds completed successfully!"
+
+# Show final status
+print_message "$YELLOW" "Build Summary:"
+echo "Build Type: $BUILD_TYPE"
+echo "Speech Features: $([ "$ENABLE_SPEECH" = true ] && echo 'Enabled' || echo 'Disabled')"
+echo "GPU Support: $([ "$ENABLE_GPU" = true ] && echo 'Enabled' || echo 'Disabled')"
+docker image ls | grep -E 'homeassistant-mcp|whisper|openwakeword' 

docker-compose.speech.yml

@@ -0,0 +1,73 @@
+version: '3.8'
+
+services:
+  homeassistant-mcp:
+    image: homeassistant-mcp:latest
+    environment:
+      # Speech Feature Flags
+      - ENABLE_SPEECH_FEATURES=${ENABLE_SPEECH_FEATURES:-true}
+      - ENABLE_WAKE_WORD=${ENABLE_WAKE_WORD:-true}
+      - ENABLE_SPEECH_TO_TEXT=${ENABLE_SPEECH_TO_TEXT:-true}
+
+      # Audio Configuration
+      - NOISE_THRESHOLD=${NOISE_THRESHOLD:-0.05}
+      - MIN_SPEECH_DURATION=${MIN_SPEECH_DURATION:-1.0}
+      - SILENCE_DURATION=${SILENCE_DURATION:-0.5}
+      - SAMPLE_RATE=${SAMPLE_RATE:-16000}
+      - CHANNELS=${CHANNELS:-1}
+      - CHUNK_SIZE=${CHUNK_SIZE:-1024}
+      - PULSE_SERVER=${PULSE_SERVER:-unix:/run/user/1000/pulse/native}
+
+  fast-whisper:
+    image: onerahmet/openai-whisper-asr-webservice:latest
+    volumes:
+      - whisper-models:/models
+      - audio-data:/audio
+    environment:
+      - ASR_MODEL=${WHISPER_MODEL_TYPE:-base}
+      - ASR_ENGINE=faster_whisper
+      - WHISPER_BEAM_SIZE=5
+      - COMPUTE_TYPE=float32
+      - LANGUAGE=en
+    ports:
+      - "9000:9000"
+    deploy:
+      resources:
+        limits:
+          cpus: '4.0'
+          memory: 2G
+    healthcheck:
+      test: [ "CMD", "curl", "-f", "http://localhost:9000/health" ]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  wake-word:
+    image: rhasspy/wyoming-openwakeword:latest
+    restart: unless-stopped
+    devices:
+      - /dev/snd:/dev/snd
+    volumes:
+      - /run/user/1000/pulse/native:/run/user/1000/pulse/native
+    environment:
+      - PULSE_SERVER=${PULSE_SERVER:-unix:/run/user/1000/pulse/native}
+      - PULSE_COOKIE=/run/user/1000/pulse/cookie
+      - PYTHONUNBUFFERED=1
+      - OPENWAKEWORD_MODEL=hey_jarvis
+      - OPENWAKEWORD_THRESHOLD=0.5
+      - MICROPHONE_COMMAND=arecord -D hw:0,0 -f S16_LE -c 1 -r 16000 -t raw
+    group_add:
+      - "${AUDIO_GID:-29}"
+    network_mode: host
+    privileged: true
+    entrypoint: >
+      /bin/bash -c " apt-get update && apt-get install -y pulseaudio alsa-utils && rm -rf /var/lib/apt/lists/* && /run.sh"
+    healthcheck:
+      test: [ "CMD-SHELL", "pactl info > /dev/null 2>&1 || exit 1" ]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+volumes:
+  whisper-models:
+  audio-data:

docker/speech/asound.conf

@@ -0,0 +1,35 @@
+pcm.!default {
+    type pulse
+    fallback "sysdefault"
+    hint {
+        show on
+        description "Default ALSA Output (currently PulseAudio Sound Server)"
+    }
+}
+
+ctl.!default {
+    type pulse
+    fallback "sysdefault"
+}
+
+# Use PulseAudio by default
+pcm.pulse {
+    type pulse
+}
+
+ctl.pulse {
+    type pulse
+}
+
+# Explicit device for recording
+pcm.microphone {
+    type hw
+    card 0
+    device 0
+}
+
+# Default capture device
+pcm.!default {
+    type pulse
+    hint.description "Default Audio Device"
+} 

docker/speech/setup-audio.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+set -e  # Exit immediately if a command exits with a non-zero status
+set -x  # Print commands and their arguments as they are executed
+
+echo "Starting audio setup script at $(date)"
+echo "Current user: $(whoami)"
+echo "Current directory: $(pwd)"
+
+# Print environment variables related to audio and speech
+echo "ENABLE_WAKE_WORD: ${ENABLE_WAKE_WORD}"
+echo "PULSE_SERVER: ${PULSE_SERVER}"
+echo "WHISPER_MODEL_PATH: ${WHISPER_MODEL_PATH}"
+
+# Wait for PulseAudio socket to be available
+max_wait=30
+wait_count=0
+while [ ! -e /run/user/1000/pulse/native ]; do
+    echo "Waiting for PulseAudio socket... (${wait_count}/${max_wait})"
+    sleep 1
+    wait_count=$((wait_count + 1))
+    if [ $wait_count -ge $max_wait ]; then
+        echo "ERROR: PulseAudio socket not available after ${max_wait} seconds"
+        exit 1
+    fi
+done
+
+# Verify PulseAudio connection with detailed error handling
+if ! pactl info; then
+    echo "ERROR: Failed to connect to PulseAudio server"
+    pactl list short modules
+    pactl list short clients
+    exit 1
+fi
+
+# List audio devices with error handling
+if ! pactl list sources; then
+    echo "ERROR: Failed to list audio devices"
+    exit 1
+fi
+
+# Ensure wake word detector script is executable
+chmod +x /app/wake_word_detector.py
+
+# Start the wake word detector with logging
+echo "Starting wake word detector at $(date)"
+python /app/wake_word_detector.py 2>&1 | tee /audio/wake_word_detector.log &
+wake_word_pid=$!
+
+# Wait and check if the process is still running
+sleep 5
+if ! kill -0 $wake_word_pid 2>/dev/null; then
+    echo "ERROR: Wake word detector process died immediately"
+    cat /audio/wake_word_detector.log
+    exit 1
+fi
+
+# Mute the monitor to prevent feedback
+pactl set-source-mute alsa_output.pci-0000_00_1b.0.analog-stereo.monitor 1
+
+# Set microphone sensitivity to 65%
+pactl set-source-volume alsa_input.pci-0000_00_1b.0.analog-stereo 65%
+
+# Set speaker volume to 40%
+pactl set-sink-volume alsa_output.pci-0000_00_1b.0.analog-stereo 40%
+
+# Keep the script running to prevent container exit
+echo "Audio setup complete. Keeping container alive."
+tail -f /dev/null 

docker/speech/wake_word_detector.py

@@ -0,0 +1,433 @@
+import os
+import json
+import queue
+import threading
+import numpy as np
+import sounddevice as sd
+from openwakeword import Model
+from datetime import datetime
+import wave
+from faster_whisper import WhisperModel
+import requests
+import logging
+import time
+
+# Set up logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Configuration
+SAMPLE_RATE = 16000
+CHANNELS = 1
+CHUNK_SIZE = 1024
+BUFFER_DURATION = 10  # seconds to keep in buffer
+DETECTION_THRESHOLD = 0.5
+CONTINUOUS_TRANSCRIPTION_INTERVAL = 3  # seconds between transcriptions
+MAX_MODEL_LOAD_RETRIES = 3
+MODEL_LOAD_RETRY_DELAY = 5  # seconds
+MODEL_DOWNLOAD_TIMEOUT = 600  # 10 minutes timeout for model download
+
+# ALSA device configuration
+AUDIO_DEVICE = 'hw:0,0'  # Use ALSA hardware device directly
+
+# Audio processing parameters
+NOISE_THRESHOLD = 0.08  # Increased threshold for better noise filtering
+MIN_SPEECH_DURATION = 2.0  # Longer minimum duration to avoid fragments
+SILENCE_DURATION = 1.0  # Longer silence duration
+MAX_REPETITIONS = 1  # More aggressive repetition filtering
+ECHO_THRESHOLD = 0.75  # More sensitive echo detection
+MIN_SEGMENT_DURATION = 1.0  # Longer minimum segment duration
+FEEDBACK_WINDOW = 5  # Window size for feedback detection in seconds
+
+# Feature flags from environment
+WAKE_WORD_ENABLED = os.environ.get('ENABLE_WAKE_WORD', 'false').lower() == 'true'
+SPEECH_ENABLED = os.environ.get('ENABLE_SPEECH_FEATURES', 'true').lower() == 'true'
+
+# Wake word models to use (only if wake word is enabled)
+WAKE_WORDS = ["hey_jarvis"]  # Using hey_jarvis as it's more similar to "hey gaja"
+WAKE_WORD_ALIAS = "gaja"  # What we print when wake word is detected
+
+# Home Assistant Configuration
+HASS_HOST = os.environ.get('HASS_HOST', 'http://homeassistant.local:8123')
+HASS_TOKEN = os.environ.get('HASS_TOKEN')
+
+def initialize_asr_model():
+    """Initialize the ASR model with retries and timeout"""
+    model_path = os.environ.get('WHISPER_MODEL_PATH', '/models')
+    model_name = os.environ.get('WHISPER_MODEL_TYPE', 'base')
+    
+    start_time = time.time()
+    for attempt in range(MAX_MODEL_LOAD_RETRIES):
+        try:
+            if time.time() - start_time > MODEL_DOWNLOAD_TIMEOUT:
+                logger.error("Model download timeout exceeded")
+                raise TimeoutError("Model download took too long")
+                
+            logger.info(f"Loading ASR model (attempt {attempt + 1}/{MAX_MODEL_LOAD_RETRIES})")
+            model = WhisperModel(
+                model_size_or_path=model_name,
+                device="cpu",
+                compute_type="int8",
+                download_root=model_path,
+                num_workers=1  # Reduce concurrent downloads
+            )
+            logger.info("ASR model loaded successfully")
+            return model
+        except Exception as e:
+            logger.error(f"Failed to load ASR model (attempt {attempt + 1}): {e}")
+            if attempt < MAX_MODEL_LOAD_RETRIES - 1:
+                logger.info(f"Retrying in {MODEL_LOAD_RETRY_DELAY} seconds...")
+                time.sleep(MODEL_LOAD_RETRY_DELAY)
+            else:
+                logger.error("Failed to load ASR model after all retries")
+                raise
+
+# Initialize the ASR model with retries
+try:
+    asr_model = initialize_asr_model()
+except Exception as e:
+    logger.error(f"Critical error initializing ASR model: {e}")
+    raise
+
+def send_command_to_hass(domain, service, entity_id):
+    """Send command to Home Assistant"""
+    if not HASS_TOKEN:
+        logger.error("Error: HASS_TOKEN not set")
+        return False
+
+    headers = {
+        "Authorization": f"Bearer {HASS_TOKEN}",
+        "Content-Type": "application/json",
+    }
+
+    url = f"{HASS_HOST}/api/services/{domain}/{service}"
+    data = {"entity_id": entity_id}
+
+    try:
+        response = requests.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        logger.info(f"Command sent: {domain}.{service} for {entity_id}")
+        return True
+    except Exception as e:
+        logger.error(f"Error sending command to Home Assistant: {e}")
+        return False
+
+def is_speech(audio_data, threshold=NOISE_THRESHOLD):
+    """Detect if audio segment contains speech based on amplitude and frequency content"""
+    # Calculate RMS amplitude
+    rms = np.sqrt(np.mean(np.square(audio_data)))
+    
+    # Calculate signal energy in speech frequency range (100-4000 Hz)
+    fft = np.fft.fft(audio_data)
+    freqs = np.fft.fftfreq(len(audio_data), 1/SAMPLE_RATE)
+    speech_mask = (np.abs(freqs) >= 100) & (np.abs(freqs) <= 4000)
+    speech_energy = np.sum(np.abs(fft[speech_mask])) / len(audio_data)
+    
+    # Enhanced echo detection
+    # 1. Check for periodic patterns in the signal
+    autocorr = np.correlate(audio_data, audio_data, mode='full')
+    autocorr = autocorr[len(autocorr)//2:]  # Use only positive lags
+    peaks = np.where(autocorr > ECHO_THRESHOLD * np.max(autocorr))[0]
+    peak_spacing = np.diff(peaks)
+    has_periodic_echo = len(peak_spacing) > 2 and np.std(peak_spacing) < 0.1 * np.mean(peak_spacing)
+    
+    # 2. Check for sudden amplitude changes
+    amplitude_envelope = np.abs(audio_data)
+    amplitude_changes = np.diff(amplitude_envelope)
+    has_feedback_spikes = np.any(np.abs(amplitude_changes) > threshold * 2)
+    
+    # 3. Check frequency distribution
+    freq_magnitudes = np.abs(fft)[:len(fft)//2]
+    peak_freqs = freqs[:len(fft)//2][np.argsort(freq_magnitudes)[-3:]]
+    has_feedback_freqs = np.any((peak_freqs > 2000) & (peak_freqs < 4000))
+    
+    # Combine all criteria
+    is_valid_speech = (
+        rms > threshold and
+        speech_energy > threshold and
+        not has_periodic_echo and
+        not has_feedback_spikes and
+        not has_feedback_freqs
+    )
+    
+    return is_valid_speech
+
+def process_command(text):
+    """Process the transcribed command and execute appropriate action"""
+    text = text.lower().strip()
+    
+    # Skip if text is too short or contains numbers (likely noise)
+    if len(text) < 5 or any(char.isdigit() for char in text):
+        logger.debug("Text too short or contains numbers, skipping")
+        return
+    
+    # Enhanced noise pattern detection
+    noise_patterns = ["lei", "los", "und", "aber", "nicht mehr", "das das", "und und"]
+    for pattern in noise_patterns:
+        if text.count(pattern) > 1:  # More aggressive pattern filtering
+            logger.debug(f"Detected noise pattern '{pattern}', skipping")
+            return
+    
+    # More aggressive repetition detection
+    words = text.split()
+    if len(words) >= 2:
+        # Check for immediate word repetitions
+        for i in range(len(words)-1):
+            if words[i] == words[i+1]:
+                logger.debug(f"Detected immediate word repetition: '{words[i]}', skipping")
+                return
+        
+        # Check for phrase repetitions
+        phrases = [' '.join(words[i:i+2]) for i in range(len(words)-1)]
+        phrase_counts = {}
+        for phrase in phrases:
+            phrase_counts[phrase] = phrase_counts.get(phrase, 0) + 1
+            if phrase_counts[phrase] > MAX_REPETITIONS:
+                logger.debug(f"Skipping due to excessive repetition: '{phrase}'")
+                return
+    
+    # German command mappings
+    commands = {
+        "ausschalten": "turn_off",
+        "einschalten": "turn_on",
+        "an": "turn_on",
+        "aus": "turn_off"
+    }
+    
+    rooms = {
+        "wohnzimmer": "living_room",
+        "küche": "kitchen",
+        "schlafzimmer": "bedroom",
+        "bad": "bathroom"
+    }
+    
+    # Detect room
+    detected_room = None
+    for german_room, english_room in rooms.items():
+        if german_room in text:
+            detected_room = english_room
+            break
+    
+    # Detect command
+    detected_command = None
+    for german_cmd, english_cmd in commands.items():
+        if german_cmd in text:
+            detected_command = english_cmd
+            break
+    
+    if detected_room and detected_command:
+        # Construct entity ID (assuming light)
+        entity_id = f"light.{detected_room}"
+        
+        # Send command to Home Assistant
+        if send_command_to_hass("light", detected_command, entity_id):
+            logger.info(f"Executed: {detected_command} for {entity_id}")
+        else:
+            logger.error("Failed to execute command")
+    else:
+        logger.debug(f"No command found in text: '{text}'")
+
+class AudioProcessor:
+    def __init__(self):
+        logger.info("Initializing AudioProcessor...")
+        self.audio_buffer = queue.Queue()
+        self.recording = False
+        self.buffer = np.zeros(SAMPLE_RATE * BUFFER_DURATION)
+        self.buffer_lock = threading.Lock()
+        self.last_transcription_time = 0
+        
+        try:
+            logger.info(f"Opening audio device: {AUDIO_DEVICE}")
+            self.stream = sd.InputStream(
+                device=AUDIO_DEVICE,
+                samplerate=SAMPLE_RATE,
+                channels=CHANNELS,
+                dtype=np.int16,
+                blocksize=CHUNK_SIZE,
+                callback=self._audio_callback
+            )
+            logger.info("Audio stream initialized successfully")
+        except Exception as e:
+            logger.error(f"Failed to initialize audio stream: {e}")
+            raise
+
+        self.speech_detected = False
+        self.silence_frames = 0
+        self.speech_frames = 0
+
+        # Initialize wake word detection only if enabled
+        if WAKE_WORD_ENABLED:
+            try:
+                logger.info("Initializing wake word model...")
+                self.wake_word_model = Model(vad_threshold=0.5)
+                self.last_prediction = None
+                logger.info("Wake word model initialized successfully")
+            except Exception as e:
+                logger.error(f"Failed to initialize wake word model: {e}")
+                raise
+        else:
+            self.wake_word_model = None
+            self.last_prediction = None
+            logger.info("Wake word detection disabled")
+
+    def should_transcribe(self):
+        """Determine if we should transcribe based on mode and timing"""
+        current_time = datetime.now().timestamp()
+        if not WAKE_WORD_ENABLED:
+            # Check if enough time has passed since last transcription
+            time_since_last = current_time - self.last_transcription_time
+            if time_since_last >= CONTINUOUS_TRANSCRIPTION_INTERVAL:
+                # Only transcribe if we detect speech
+                frames_per_chunk = CHUNK_SIZE
+                min_speech_frames = int(MIN_SPEECH_DURATION * SAMPLE_RATE / frames_per_chunk)
+                
+                if self.speech_frames >= min_speech_frames:
+                    self.last_transcription_time = current_time
+                    self.speech_frames = 0  # Reset counter
+                    return True
+        return False
+
+    def _audio_callback(self, indata, frames, time, status):
+        """Callback for audio input"""
+        if status:
+            logger.warning(f"Audio callback status: {status}")
+        
+        # Convert to mono if necessary
+        if CHANNELS > 1:
+            audio_data = np.mean(indata, axis=1)
+        else:
+            audio_data = indata.flatten()
+
+        # Check for speech
+        if is_speech(audio_data):
+            self.speech_frames += 1
+            self.silence_frames = 0
+        else:
+            self.silence_frames += 1
+            frames_per_chunk = CHUNK_SIZE
+            silence_frames_threshold = int(SILENCE_DURATION * SAMPLE_RATE / frames_per_chunk)
+            
+            if self.silence_frames >= silence_frames_threshold:
+                self.speech_frames = 0
+
+        # Update circular buffer
+        with self.buffer_lock:
+            self.buffer = np.roll(self.buffer, -len(audio_data))
+            self.buffer[-len(audio_data):] = audio_data
+
+        if WAKE_WORD_ENABLED:
+            # Process for wake word detection
+            self.last_prediction = self.wake_word_model.predict(audio_data)
+            
+            # Check if wake word detected
+            for wake_word in WAKE_WORDS:
+                confidence = self.last_prediction[wake_word]
+                if confidence > DETECTION_THRESHOLD:
+                    logger.info(
+                        f"Wake word: {WAKE_WORD_ALIAS} (confidence: {confidence:.2f})"
+                    )
+                    self.process_audio()
+                    break
+        else:
+            # Continuous transcription mode
+            if self.should_transcribe():
+                self.process_audio()
+
+    def process_audio(self):
+        """Process the current audio buffer (save and transcribe)"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"/audio/audio_segment_{timestamp}.wav"
+        
+        # Save the audio buffer to a WAV file
+        with wave.open(filename, 'wb') as wf:
+            wf.setnchannels(CHANNELS)
+            wf.setsampwidth(2)  # 16-bit audio
+            wf.setframerate(SAMPLE_RATE)
+            
+            # Convert float32 to int16
+            audio_data = (self.buffer * 32767).astype(np.int16)
+            wf.writeframes(audio_data.tobytes())
+        
+        logger.info(f"Saved audio segment to {filename}")
+
+        # Transcribe the audio with German language preference
+        try:
+            segments, info = asr_model.transcribe(
+                filename,
+                language="de",  # Set German as preferred language
+                beam_size=5,
+                temperature=0
+            )
+            
+            # Get the full transcribed text
+            transcribed_text = " ".join(segment.text for segment in segments)
+            logger.info(f"Transcribed text: {transcribed_text}")
+            
+            # Process the command
+            process_command(transcribed_text)
+                
+        except Exception as e:
+            logger.error(f"Error during transcription or processing: {e}")
+
+    def start(self):
+        """Start audio processing"""
+        try:
+            logger.info("Starting audio processor...")
+            
+            # Log configuration
+            logger.debug(f"Sample Rate: {SAMPLE_RATE}")
+            logger.debug(f"Channels: {CHANNELS}")
+            logger.debug(f"Chunk Size: {CHUNK_SIZE}")
+            logger.debug(f"Buffer Duration: {BUFFER_DURATION}")
+            logger.debug(f"Wake Word Enabled: {WAKE_WORD_ENABLED}")
+            logger.debug(f"Speech Enabled: {SPEECH_ENABLED}")
+            logger.debug(f"ASR Model: {os.environ.get('ASR_MODEL')}")
+            
+            if WAKE_WORD_ENABLED:
+                logger.info("Initializing wake word detection...")
+                logger.info(f"Loaded wake words: {', '.join(WAKE_WORDS)}")
+            else:
+                logger.info("Starting continuous transcription mode...")
+                interval = CONTINUOUS_TRANSCRIPTION_INTERVAL
+                logger.info(f"Will transcribe every {interval} seconds")
+            
+            try:
+                logger.debug("Setting up audio input stream...")
+                with sd.InputStream(
+                    channels=CHANNELS,
+                    samplerate=SAMPLE_RATE,
+                    blocksize=CHUNK_SIZE,
+                    callback=self._audio_callback
+                ):
+                    logger.info("Audio input stream started successfully")
+                    logger.info("Listening for audio input...")
+                    logger.info("Press Ctrl+C to stop")
+                    
+                    while True:
+                        sd.sleep(1000)  # Sleep for 1 second
+                        
+            except sd.PortAudioError as e:
+                logger.error(f"Error setting up audio stream: {e}")
+                logger.error("Check if microphone is connected and accessible")
+                raise
+            except Exception as e:
+                logger.error(f"Unexpected error in audio stream: {e}")
+                raise
+                    
+        except KeyboardInterrupt:
+            logger.info("\nStopping audio processing...")
+        except Exception as e:
+            logger.error("Critical error in audio processing", exc_info=True)
+            raise
+
+if __name__ == "__main__":
+    try:
+        logger.info("Initializing AudioProcessor...")
+        processor = AudioProcessor()
+        processor.start()
+    except Exception as e:
+        logger.error("Failed to start AudioProcessor", exc_info=True)
+        raise 

docs/API.md

@@ -1,419 +0,0 @@
-# API Reference
-
-## MCP Schema Endpoint
-
-The server exposes an MCP (Model Context Protocol) schema endpoint that describes all available tools and their parameters:
-
-```http
-GET /mcp
-```
-
-This endpoint returns a JSON schema describing all available tools, their parameters, and documentation resources. The schema follows the MCP specification and can be used by LLM clients to understand the server's capabilities.
-
-Example response:
-```json
-{
-  "tools": [
-    {
-      "name": "list_devices",
-      "description": "List all devices connected to Home Assistant",
-      "parameters": {
-        "type": "object",
-        "properties": {
-          "domain": {
-            "type": "string",
-            "enum": ["light", "climate", "alarm_control_panel", ...]
-          },
-          "area": { "type": "string" },
-          "floor": { "type": "string" }
-        }
-      }
-    },
-    // ... other tools
-  ],
-  "prompts": [],
-  "resources": [
-    {
-      "name": "Home Assistant API",
-      "url": "https://developers.home-assistant.io/docs/api/rest/"
-    }
-  ]
-}
-```
-
-Note: The `/mcp` endpoint is publicly accessible and does not require authentication, as it only provides schema information.
-
-## Device Control
-
-### Common Entity Controls
-```json
-{
-  "tool": "control",
-  "command": "turn_on",  // or "turn_off", "toggle"
-  "entity_id": "light.living_room"
-}
-```
-
-### Light Control
-```json
-{
-  "tool": "control",
-  "command": "turn_on",
-  "entity_id": "light.living_room",
-  "brightness": 128,
-  "color_temp": 4000,
-  "rgb_color": [255, 0, 0]
-}
-```
-
-## Add-on Management
-
-### List Available Add-ons
-```json
-{
-  "tool": "addon",
-  "action": "list"
-}
-```
-
-### Install Add-on
-```json
-{
-  "tool": "addon",
-  "action": "install",
-  "slug": "core_configurator",
-  "version": "5.6.0"
-}
-```
-
-### Manage Add-on State
-```json
-{
-  "tool": "addon",
-  "action": "start",  // or "stop", "restart"
-  "slug": "core_configurator"
-}
-```
-
-## Package Management
-
-### List HACS Packages
-```json
-{
-  "tool": "package",
-  "action": "list",
-  "category": "integration"  // or "plugin", "theme", "python_script", "appdaemon", "netdaemon"
-}
-```
-
-### Install Package
-```json
-{
-  "tool": "package",
-  "action": "install",
-  "category": "integration",
-  "repository": "hacs/integration",
-  "version": "1.32.0"
-}
-```
-
-## Automation Management
-
-### Create Automation
-```json
-{
-  "tool": "automation_config",
-  "action": "create",
-  "config": {
-    "alias": "Motion Light",
-    "description": "Turn on light when motion detected",
-    "mode": "single",
-    "trigger": [
-      {
-        "platform": "state",
-        "entity_id": "binary_sensor.motion",
-        "to": "on"
-      }
-    ],
-    "action": [
-      {
-        "service": "light.turn_on",
-        "target": {
-          "entity_id": "light.living_room"
-        }
-      }
-    ]
-  }
-}
-```
-
-### Duplicate Automation
-```json
-{
-  "tool": "automation_config",
-  "action": "duplicate",
-  "automation_id": "automation.motion_light"
-}
-```
-
-## Core Functions
-
-### State Management
-```http
-GET /api/state
-POST /api/state
-```
-
-Manages the current state of the system.
-
-**Example Request:**
-```json
-POST /api/state
-{
-  "context": "living_room",
-  "state": {
-    "lights": "on",
-    "temperature": 22
-  }
-}
-```
-
-### Context Updates
-```http
-POST /api/context
-```
-
-Updates the current context with new information.
-
-**Example Request:**
-```json
-POST /api/context
-{
-  "user": "john",
-  "location": "kitchen",
-  "time": "morning",
-  "activity": "cooking"
-}
-```
-
-## Action Endpoints
-
-### Execute Action
-```http
-POST /api/action
-```
-
-Executes a specified action with given parameters.
-
-**Example Request:**
-```json
-POST /api/action
-{
-  "action": "turn_on_lights",
-  "parameters": {
-    "room": "living_room",
-    "brightness": 80
-  }
-}
-```
-
-### Batch Actions
-```http
-POST /api/actions/batch
-```
-
-Executes multiple actions in sequence.
-
-**Example Request:**
-```json
-POST /api/actions/batch
-{
-  "actions": [
-    {
-      "action": "turn_on_lights",
-      "parameters": {
-        "room": "living_room"
-      }
-    },
-    {
-      "action": "set_temperature",
-      "parameters": {
-        "temperature": 22
-      }
-    }
-  ]
-}
-```
-
-## Query Functions
-
-### Get Available Actions
-```http
-GET /api/actions
-```
-
-Returns a list of all available actions.
-
-**Example Response:**
-```json
-{
-  "actions": [
-    {
-      "name": "turn_on_lights",
-      "parameters": ["room", "brightness"],
-      "description": "Turns on lights in specified room"
-    },
-    {
-      "name": "set_temperature",
-      "parameters": ["temperature"],
-      "description": "Sets temperature in current context"
-    }
-  ]
-}
-```
-
-### Context Query
-```http
-GET /api/context?type=current
-```
-
-Retrieves context information.
-
-**Example Response:**
-```json
-{
-  "current_context": {
-    "user": "john",
-    "location": "kitchen",
-    "time": "morning",
-    "activity": "cooking"
-  }
-}
-```
-
-## WebSocket Events
-
-The server supports real-time updates via WebSocket connections.
-
-```javascript
-// Client-side connection example
-const ws = new WebSocket('ws://localhost:3000/ws');
-
-ws.onmessage = (event) => {
-  const data = JSON.parse(event.data);
-  console.log('Received update:', data);
-};
-```
-
-### Supported Events
-
-- `state_change`: Emitted when system state changes
-- `context_update`: Emitted when context is updated
-- `action_executed`: Emitted when an action is completed
-- `error`: Emitted when an error occurs
-
-**Example Event Data:**
-```json
-{
-  "event": "state_change",
-  "data": {
-    "previous_state": {
-      "lights": "off"
-    },
-    "current_state": {
-      "lights": "on"
-    },
-    "timestamp": "2024-03-20T10:30:00Z"
-  }
-}
-```
-
-## Error Handling
-
-All endpoints return standard HTTP status codes:
-
-- 200: Success
-- 400: Bad Request
-- 401: Unauthorized
-- 403: Forbidden
-- 404: Not Found
-- 500: Internal Server Error
-
-**Error Response Format:**
-```json
-{
-  "error": {
-    "code": "INVALID_PARAMETERS",
-    "message": "Missing required parameter: room",
-    "details": {
-      "missing_fields": ["room"]
-    }
-  }
-}
-```
-
-## Rate Limiting
-
-The API implements rate limiting to prevent abuse:
-
-- 100 requests per minute per IP for regular endpoints
-- 1000 requests per minute per IP for WebSocket connections
-
-When rate limit is exceeded, the server returns:
-
-```json
-{
-  "error": {
-    "code": "RATE_LIMIT_EXCEEDED",
-    "message": "Too many requests",
-    "reset_time": "2024-03-20T10:31:00Z"
-  }
-}
-```
-
-## Example Usage
-
-### Using curl
-```bash
-# Get current state
-curl -X GET \
-  http://localhost:3000/api/state \
-  -H 'Authorization: ApiKey your_api_key_here'
-
-# Execute action
-curl -X POST \
-  http://localhost:3000/api/action \
-  -H 'Authorization: ApiKey your_api_key_here' \
-  -H 'Content-Type: application/json' \
-  -d '{
-    "action": "turn_on_lights",
-    "parameters": {
-      "room": "living_room",
-      "brightness": 80
-    }
-  }'
-```
-
-### Using JavaScript
-```javascript
-// Execute action
-async function executeAction() {
-  const response = await fetch('http://localhost:3000/api/action', {
-    method: 'POST',
-    headers: {
-      'Authorization': 'ApiKey your_api_key_here',
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-      action: 'turn_on_lights',
-      parameters: {
-        room: 'living_room',
-        brightness: 80
-      }
-    })
-  });
-  
-  const data = await response.json();
-  console.log('Action result:', data);
-}
-``` 

docs/README.md

@@ -1,60 +0,0 @@
-# Home Assistant MCP Documentation
-
-Welcome to the Home Assistant MCP (Master Control Program) documentation. This documentation provides comprehensive information about setting up, configuring, and using the Home Assistant MCP.
-
-## Table of Contents
-
-1. [Getting Started](./getting-started.md)
-   - Installation
-   - Configuration
-   - First Steps
-
-2. [API Reference](./API.md)
-   - REST API Endpoints
-   - Authentication
-   - Error Handling
-
-3. [SSE (Server-Sent Events)](./SSE_API.md)
-   - Event Subscriptions
-   - Real-time Updates
-   - Connection Management
-
-4. [Tools](./tools/README.md)
-   - Device Control
-   - Automation Management
-   - Add-on Management
-   - Package Management
-
-5. [Configuration](./configuration/README.md)
-   - Environment Variables
-   - Security Settings
-   - Performance Tuning
-
-6. [Development](./development/README.md)
-   - Project Structure
-   - Contributing Guidelines
-   - Testing
-
-7. [Troubleshooting](./troubleshooting.md)
-   - Common Issues
-   - Debugging
-   - FAQ
-
-## Quick Links
-
-- [GitHub Repository](https://github.com/yourusername/homeassistant-mcp)
-- [Issue Tracker](https://github.com/yourusername/homeassistant-mcp/issues)
-- [Change Log](./CHANGELOG.md)
-- [Security Policy](./SECURITY.md)
-
-## Support
-
-If you need help or have questions:
-
-1. Check the [Troubleshooting Guide](./troubleshooting.md)
-2. Search existing [Issues](https://github.com/yourusername/homeassistant-mcp/issues)
-3. Create a new issue if your problem isn't already reported
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](../LICENSE) file for details. 

docs/SSE_API.md

@@ -1,364 +0,0 @@
-# Home Assistant MCP Server-Sent Events (SSE) API Documentation
-
-## Overview
-
-The SSE API provides real-time updates from Home Assistant through a persistent connection. This allows clients to receive instant notifications about state changes, events, and other activities without polling.
-
-## Quick Reference
-
-### Available Endpoints
-
-| Endpoint | Method | Description | Authentication |
-|----------|---------|-------------|----------------|
-| `/subscribe_events` | POST | Subscribe to real-time events and state changes | Required |
-| `/get_sse_stats` | POST | Get statistics about current SSE connections | Required |
-
-### Event Types Available
-
-| Event Type | Description | Example Subscription |
-|------------|-------------|---------------------|
-| `state_changed` | Entity state changes | `events=state_changed` |
-| `service_called` | Service call events | `events=service_called` |
-| `automation_triggered` | Automation trigger events | `events=automation_triggered` |
-| `script_executed` | Script execution events | `events=script_executed` |
-| `ping` | Connection keepalive (system) | Automatic |
-| `error` | Error notifications (system) | Automatic |
-
-### Subscription Options
-
-| Option | Description | Example |
-|--------|-------------|---------|
-| `entity_id` | Subscribe to specific entity | `entity_id=light.living_room` |
-| `domain` | Subscribe to entire domain | `domain=light` |
-| `events` | Subscribe to event types | `events=state_changed,automation_triggered` |
-
-## Authentication
-
-All SSE connections require authentication using your Home Assistant token.
-
-```javascript
-const token = 'YOUR_HASS_TOKEN';
-```
-
-## Endpoints
-
-### Subscribe to Events
-
-`POST /subscribe_events`
-
-Subscribe to Home Assistant events and state changes.
-
-#### Parameters
-
-| Parameter  | Type     | Required | Description |
-|------------|----------|----------|-------------|
-| token      | string   | Yes      | Your Home Assistant authentication token |
-| events     | string[] | No       | Array of event types to subscribe to |
-| entity_id  | string   | No       | Specific entity ID to monitor |
-| domain     | string   | No       | Domain to monitor (e.g., "light", "switch") |
-
-#### Example Request
-
-```javascript
-const eventSource = new EventSource(`http://localhost:3000/subscribe_events?token=${token}&entity_id=light.living_room&domain=switch&events=state_changed,automation_triggered`);
-
-eventSource.onmessage = (event) => {
-  const data = JSON.parse(event.data);
-  console.log('Received:', data);
-};
-
-eventSource.onerror = (error) => {
-  console.error('SSE Error:', error);
-  eventSource.close();
-};
-```
-
-### Get SSE Statistics
-
-`POST /get_sse_stats`
-
-Get current statistics about SSE connections and subscriptions.
-
-#### Parameters
-
-| Parameter | Type   | Required | Description |
-|-----------|--------|----------|-------------|
-| token     | string | Yes      | Your Home Assistant authentication token |
-
-#### Example Request
-
-```bash
-curl -X POST http://localhost:3000/get_sse_stats \
-  -H "Content-Type: application/json" \
-  -d '{"token": "YOUR_HASS_TOKEN"}'
-```
-
-## Event Types
-
-### Standard Events
-
-1. **connection**
-   - Sent when a client connects successfully
-   ```json
-   {
-     "type": "connection",
-     "status": "connected",
-     "id": "client_uuid",
-     "authenticated": true,
-     "timestamp": "2024-02-10T12:00:00.000Z"
-   }
-   ```
-
-2. **state_changed**
-   - Sent when an entity's state changes
-   ```json
-   {
-     "type": "state_changed",
-     "data": {
-       "entity_id": "light.living_room",
-       "state": "on",
-       "attributes": {
-         "brightness": 255,
-         "color_temp": 370
-       },
-       "last_changed": "2024-02-10T12:00:00.000Z",
-       "last_updated": "2024-02-10T12:00:00.000Z"
-     },
-     "timestamp": "2024-02-10T12:00:00.000Z"
-   }
-   ```
-
-3. **service_called**
-   - Sent when a Home Assistant service is called
-   ```json
-   {
-     "type": "service_called",
-     "data": {
-       "domain": "light",
-       "service": "turn_on",
-       "service_data": {
-         "entity_id": "light.living_room",
-         "brightness": 255
-       }
-     },
-     "timestamp": "2024-02-10T12:00:00.000Z"
-   }
-   ```
-
-4. **automation_triggered**
-   - Sent when an automation is triggered
-   ```json
-   {
-     "type": "automation_triggered",
-     "data": {
-       "automation_id": "automation.morning_routine",
-       "trigger": {
-         "platform": "time",
-         "at": "07:00:00"
-       }
-     },
-     "timestamp": "2024-02-10T12:00:00.000Z"
-   }
-   ```
-5. **script_executed**
-   - Sent when a script is executed
-   ```json
-   {
-     "type": "script_executed",
-     "data": {
-       "script_id": "script.welcome_home",
-       "execution_data": {
-         "status": "completed"
-       }
-     },
-     "timestamp": "2024-02-10T12:00:00.000Z"
-   }
-   ```
-
-### System Events
-
-1. **ping**
-   - Sent every 30 seconds to keep the connection alive
-   ```json
-   {
-     "type": "ping",
-     "timestamp": "2024-02-10T12:00:00.000Z"
-   }
-   ```
-
-2. **error**
-   - Sent when an error occurs
-   ```json
-   {
-     "type": "error",
-     "error": "rate_limit_exceeded",
-     "message": "Too many requests, please try again later",
-     "timestamp": "2024-02-10T12:00:00.000Z"
-   }
-   ```
-
-## Rate Limiting
-
-- Maximum 1000 requests per minute per client
-- Rate limits are reset every minute
-- Exceeding the rate limit will result in an error event
-
-## Connection Management
-
-- Maximum 100 concurrent clients
-- Connections timeout after 5 minutes of inactivity
-- Ping messages are sent every 30 seconds
-- Clients should handle reconnection on connection loss
-
-## Example Implementation
-
-```javascript
-class HomeAssistantSSE {
-  constructor(baseUrl, token) {
-    this.baseUrl = baseUrl;
-    this.token = token;
-    this.eventSource = null;
-    this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = 5;
-    this.reconnectDelay = 1000;
-  }
-
-  connect(options = {}) {
-    const params = new URLSearchParams({
-      token: this.token,
-      ...(options.events && { events: options.events.join(',') }),
-      ...(options.entity_id && { entity_id: options.entity_id }),
-      ...(options.domain && { domain: options.domain })
-    });
-
-    this.eventSource = new EventSource(`${this.baseUrl}/subscribe_events?${params}`);
-
-    this.eventSource.onmessage = (event) => {
-      const data = JSON.parse(event.data);
-      this.handleEvent(data);
-    };
-
-    this.eventSource.onerror = (error) => {
-      console.error('SSE Error:', error);
-      this.handleError(error);
-    };
-  }
-
-  handleEvent(data) {
-    switch (data.type) {
-      case 'connection':
-        this.reconnectAttempts = 0;
-        console.log('Connected:', data);
-        break;
-      case 'ping':
-        // Connection is alive
-        break;
-      case 'error':
-        console.error('Server Error:', data);
-        break;
-      default:
-        // Handle other event types
-        console.log('Event:', data);
-    }
-  }
-
-  handleError(error) {
-    this.eventSource?.close();
-    
-    if (this.reconnectAttempts < this.maxReconnectAttempts) {
-      this.reconnectAttempts++;
-      const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
-      console.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
-      setTimeout(() => this.connect(), delay);
-    } else {
-      console.error('Max reconnection attempts reached');
-    }
-  }
-
-  disconnect() {
-    this.eventSource?.close();
-    this.eventSource = null;
-  }
-}
-
-// Usage example
-const client = new HomeAssistantSSE('http://localhost:3000', 'YOUR_HASS_TOKEN');
-client.connect({
-  events: ['state_changed', 'automation_triggered'],
-  domain: 'light'
-});
-```
-
-## Best Practices
-
-1. **Error Handling**
-   - Implement exponential backoff for reconnection attempts
-   - Handle connection timeouts gracefully
-   - Monitor for rate limit errors
-
-2. **Resource Management**
-   - Close EventSource when no longer needed
-   - Limit subscriptions to necessary events/entities
-   - Handle cleanup on page unload
-
-3. **Security**
-   - Never expose the authentication token in client-side code
-   - Use HTTPS in production
-   - Validate all incoming data
-
-4. **Performance**
-   - Subscribe only to needed events
-   - Implement client-side event filtering
-   - Monitor memory usage for long-running connections
-
-## Troubleshooting
-
-### Common Issues
-
-1. **Connection Failures**
-   - Verify your authentication token is valid
-   - Check server URL is accessible
-   - Ensure proper network connectivity
-   - Verify SSL/TLS configuration if using HTTPS
-
-2. **Missing Events**
-   - Confirm subscription parameters are correct
-   - Check rate limiting status
-   - Verify entity/domain exists
-   - Monitor client-side event handlers
-
-3. **Performance Issues**
-   - Reduce number of subscriptions
-   - Implement client-side filtering
-   - Monitor memory usage
-   - Check network latency
-
-### Debugging Tips
-
-1. Enable console logging:
-```javascript
-const client = new HomeAssistantSSE('http://localhost:3000', 'YOUR_HASS_TOKEN');
-client.debug = true; // Enables detailed logging
-```
-
-2. Monitor network traffic:
-```javascript
-// Add event listeners for connection states
-eventSource.addEventListener('open', () => {
-  console.log('Connection opened');
-});
-
-eventSource.addEventListener('error', (e) => {
-  console.log('Connection error:', e);
-});
-```
-
-3. Track subscription status:
-```javascript
-// Get current subscriptions
-const stats = await fetch('/get_sse_stats', {
-  headers: { 'Authorization': `Bearer ${token}` }
-}).then(r => r.json());
-
-console.log('Current subscriptions:', stats);
-``` 

docs/development/README.md

@@ -1,188 +0,0 @@
-# Development Guide
-
-This guide provides information for developers who want to contribute to or extend the Home Assistant MCP.
-
-## Project Structure
-
-```
-homeassistant-mcp/
-├── src/
-│   ├── api/           # API endpoints and route handlers
-│   ├── config/        # Configuration management
-│   ├── hass/         # Home Assistant integration
-│   ├── interfaces/    # TypeScript interfaces
-│   ├── mcp/          # MCP core functionality
-│   ├── middleware/    # Express middleware
-│   ├── routes/       # Route definitions
-│   ├── security/     # Security utilities
-│   ├── sse/          # Server-Sent Events handling
-│   ├── tools/        # Tool implementations
-│   ├── types/        # TypeScript type definitions
-│   └── utils/        # Utility functions
-├── __tests__/        # Test files
-├── docs/            # Documentation
-├── dist/           # Compiled JavaScript
-└── scripts/        # Build and utility scripts
-```
-
-## Development Setup
-
-1. Install dependencies:
-   ```bash
-   npm install
-   ```
-
-2. Set up development environment:
-   ```bash
-   cp .env.example .env.development
-   ```
-
-3. Start development server:
-   ```bash
-   npm run dev
-   ```
-
-## Code Style
-
-We follow these coding standards:
-
-1. TypeScript best practices
-   - Use strict type checking
-   - Avoid `any` types
-   - Document complex types
-
-2. ESLint rules
-   - Run `npm run lint` to check
-   - Run `npm run lint:fix` to auto-fix
-
-3. Code formatting
-   - Use Prettier
-   - Run `npm run format` to format code
-
-## Testing
-
-1. Unit tests:
-   ```bash
-   npm run test
-   ```
-
-2. Integration tests:
-   ```bash
-   npm run test:integration
-   ```
-
-3. Coverage report:
-   ```bash
-   npm run test:coverage
-   ```
-
-## Creating New Tools
-
-1. Create a new file in `src/tools/`:
-   ```typescript
-   import { z } from 'zod';
-   import { Tool } from '../types';
-
-   export const myTool: Tool = {
-     name: 'my_tool',
-     description: 'Description of my tool',
-     parameters: z.object({
-       // Define parameters
-     }),
-     execute: async (params) => {
-       // Implement tool logic
-     }
-   };
-   ```
-
-2. Add to `src/tools/index.ts`
-3. Create tests in `__tests__/tools/`
-4. Add documentation in `docs/tools/`
-
-## Contributing
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Write/update tests
-5. Update documentation
-6. Submit a pull request
-
-### Pull Request Process
-
-1. Ensure all tests pass
-2. Update documentation
-3. Update CHANGELOG.md
-4. Get review from maintainers
-
-## Building
-
-1. Development build:
-   ```bash
-   npm run build:dev
-   ```
-
-2. Production build:
-   ```bash
-   npm run build
-   ```
-
-## Documentation
-
-1. Update documentation for changes
-2. Follow documentation structure
-3. Include examples
-4. Update type definitions
-
-## Debugging
-
-1. Development debugging:
-   ```bash
-   npm run dev:debug
-   ```
-
-2. Test debugging:
-   ```bash
-   npm run test:debug
-   ```
-
-3. VSCode launch configurations provided
-
-## Performance
-
-1. Follow performance best practices
-2. Use caching where appropriate
-3. Implement rate limiting
-4. Monitor memory usage
-
-## Security
-
-1. Follow security best practices
-2. Validate all inputs
-3. Use proper authentication
-4. Handle errors securely
-
-## Deployment
-
-1. Build for production:
-   ```bash
-   npm run build
-   ```
-
-2. Start production server:
-   ```bash
-   npm start
-   ```
-
-3. Docker deployment:
-   ```bash
-   docker-compose up -d
-   ```
-
-## Support
-
-Need development help?
-1. Check documentation
-2. Search issues
-3. Create new issue
-4. Join discussions 

docs/getting-started.md

@@ -1,122 +0,0 @@
-# Getting Started with Home Assistant MCP
-
-This guide will help you get started with the Home Assistant MCP (Master Control Program).
-
-## Prerequisites
-
-Before you begin, ensure you have:
-
-1. Node.js (v16 or higher)
-2. A running Home Assistant instance
-3. A Home Assistant Long-Lived Access Token
-
-## Installation
-
-1. Clone the repository:
-   ```bash
-   git clone https://github.com/yourusername/homeassistant-mcp.git
-   cd homeassistant-mcp
-   ```
-
-2. Install dependencies:
-   ```bash
-   npm install
-   ```
-
-3. Copy the example environment file:
-   ```bash
-   cp .env.example .env
-   ```
-
-4. Edit the `.env` file with your configuration:
-   ```env
-   # Server Configuration
-   PORT=3000
-   NODE_ENV=development
-
-   # Home Assistant Configuration
-   HASS_HOST=http://your-hass-instance:8123
-   HASS_TOKEN=your-long-lived-access-token
-
-   # Security Configuration
-   JWT_SECRET=your-secret-key
-   ```
-
-## Configuration
-
-### Environment Variables
-
-- `PORT`: The port number for the MCP server (default: 3000)
-- `NODE_ENV`: The environment mode (development, production, test)
-- `HASS_HOST`: Your Home Assistant instance URL
-- `HASS_TOKEN`: Your Home Assistant Long-Lived Access Token
-- `JWT_SECRET`: Secret key for JWT token generation
-
-### Development Mode
-
-For development, you can use:
-
-```bash
-npm run dev
-```
-
-This will start the server in development mode with hot reloading.
-
-### Production Mode
-
-For production, build and start the server:
-
-```bash
-npm run build
-npm start
-```
-
-## First Steps
-
-1. Check the server is running:
-   ```bash
-   curl http://localhost:3000/api/health
-   ```
-
-2. List available devices:
-   ```bash
-   curl -H "Authorization: Bearer your-token" http://localhost:3000/api/tools/devices
-   ```
-
-3. Subscribe to events:
-   ```bash
-   curl -H "Authorization: Bearer your-token" http://localhost:3000/api/sse/subscribe?events=state_changed
-   ```
-
-## Next Steps
-
-- Read the [API Documentation](./API.md) for available endpoints
-- Learn about [Server-Sent Events](./SSE_API.md) for real-time updates
-- Explore available [Tools](./tools/README.md) for device control
-- Check the [Configuration Guide](./configuration/README.md) for advanced settings
-
-## Troubleshooting
-
-If you encounter issues:
-
-1. Verify your Home Assistant instance is accessible
-2. Check your environment variables are correctly set
-3. Look for errors in the server logs
-4. Consult the [Troubleshooting Guide](./troubleshooting.md)
-
-## Development
-
-For development and contributing:
-
-1. Fork the repository
-2. Create a feature branch
-3. Follow the [Development Guide](./development/README.md)
-4. Submit a pull request
-
-## Support
-
-Need help? Check out:
-
-- [GitHub Issues](https://github.com/yourusername/homeassistant-mcp/issues)
-- [Troubleshooting Guide](./troubleshooting.md)
-- [FAQ](./troubleshooting.md#faq) 

docs/tools/README.md

@@ -1,127 +0,0 @@
-# Home Assistant MCP Tools
-
-This section documents all available tools in the Home Assistant MCP.
-
-## Available Tools
-
-### Device Management
-
-1. [List Devices](./list-devices.md)
-   - List all available Home Assistant devices
-   - Group devices by domain
-   - Get device states and attributes
-
-2. [Device Control](./control.md)
-   - Control various device types
-   - Support for lights, switches, covers, climate devices
-   - Domain-specific commands and parameters
-
-### History and State
-
-1. [History](./history.md)
-   - Fetch device state history
-   - Filter by time range
-   - Get significant changes
-
-2. [Scene Management](./scene.md)
-   - List available scenes
-   - Activate scenes
-   - Scene state information
-
-### Automation
-
-1. [Automation Management](./automation.md)
-   - List automations
-   - Toggle automation state
-   - Trigger automations manually
-
-2. [Automation Configuration](./automation-config.md)
-   - Create new automations
-   - Update existing automations
-   - Delete automations
-   - Duplicate automations
-
-### Add-ons and Packages
-
-1. [Add-on Management](./addon.md)
-   - List available add-ons
-   - Install/uninstall add-ons
-   - Start/stop/restart add-ons
-   - Get add-on information
-
-2. [Package Management](./package.md)
-   - Manage HACS packages
-   - Install/update/remove packages
-   - List available packages by category
-
-### Notifications
-
-1. [Notify](./notify.md)
-   - Send notifications
-   - Support for multiple notification services
-   - Custom notification data
-
-### Real-time Events
-
-1. [Event Subscription](./subscribe-events.md)
-   - Subscribe to Home Assistant events
-   - Monitor specific entities
-   - Domain-based monitoring
-
-2. [SSE Statistics](./sse-stats.md)
-   - Get SSE connection statistics
-   - Monitor active subscriptions
-   - Connection management
-
-## Using Tools
-
-All tools can be accessed through:
-
-1. REST API endpoints
-2. WebSocket connections
-3. Server-Sent Events (SSE)
-
-### Authentication
-
-Tools require authentication using:
-- Home Assistant Long-Lived Access Token
-- JWT tokens for specific operations
-
-### Error Handling
-
-All tools follow a consistent error handling pattern:
-```typescript
-{
-    success: boolean;
-    message?: string;
-    data?: any;
-}
-```
-
-### Rate Limiting
-
-Tools are subject to rate limiting:
-- Default: 100 requests per 15 minutes
-- Configurable through environment variables
-
-## Tool Development
-
-Want to create a new tool? Check out:
-- [Tool Development Guide](../development/tools.md)
-- [Tool Interface Documentation](../development/interfaces.md)
-- [Best Practices](../development/best-practices.md)
-
-## Examples
-
-Each tool documentation includes:
-- Usage examples
-- Code snippets
-- Common use cases
-- Troubleshooting tips
-
-## Support
-
-Need help with tools?
-- Check individual tool documentation
-- See [Troubleshooting Guide](../troubleshooting.md)
-- Create an issue on GitHub 

docs/troubleshooting.md

@@ -1,193 +0,0 @@
-# Troubleshooting Guide
-
-This guide helps you diagnose and fix common issues with the Home Assistant MCP.
-
-## Common Issues
-
-### Connection Issues
-
-#### Cannot Connect to Home Assistant
-
-**Symptoms:**
-- Connection timeout errors
-- "Failed to connect to Home Assistant" messages
-- 401 Unauthorized errors
-
-**Solutions:**
-1. Verify Home Assistant is running
-2. Check HASS_HOST environment variable
-3. Validate HASS_TOKEN is correct
-4. Ensure network connectivity
-5. Check firewall settings
-
-#### SSE Connection Drops
-
-**Symptoms:**
-- Frequent disconnections
-- Missing events
-- Connection reset errors
-
-**Solutions:**
-1. Check network stability
-2. Increase connection timeout
-3. Implement reconnection logic
-4. Monitor server resources
-
-### Authentication Issues
-
-#### Invalid Token
-
-**Symptoms:**
-- 401 Unauthorized responses
-- "Invalid token" messages
-- Authentication failures
-
-**Solutions:**
-1. Generate new Long-Lived Access Token
-2. Check token expiration
-3. Verify token format
-4. Update environment variables
-
-#### Rate Limiting
-
-**Symptoms:**
-- 429 Too Many Requests
-- "Rate limit exceeded" messages
-
-**Solutions:**
-1. Implement request throttling
-2. Adjust rate limit settings
-3. Cache responses
-4. Optimize request patterns
-
-### Tool Issues
-
-#### Tool Not Found
-
-**Symptoms:**
-- "Tool not found" errors
-- 404 Not Found responses
-
-**Solutions:**
-1. Check tool name spelling
-2. Verify tool registration
-3. Update tool imports
-4. Check tool availability
-
-#### Tool Execution Fails
-
-**Symptoms:**
-- Tool execution errors
-- Unexpected responses
-- Timeout issues
-
-**Solutions:**
-1. Validate input parameters
-2. Check error logs
-3. Debug tool implementation
-4. Verify Home Assistant permissions
-
-## Debugging
-
-### Server Logs
-
-1. Enable debug logging:
-   ```env
-   LOG_LEVEL=debug
-   ```
-
-2. Check logs:
-   ```bash
-   npm run logs
-   ```
-
-3. Filter logs:
-   ```bash
-   npm run logs | grep "error"
-   ```
-
-### Network Debugging
-
-1. Check API endpoints:
-   ```bash
-   curl -v http://localhost:3000/api/health
-   ```
-
-2. Monitor SSE connections:
-   ```bash
-   curl -N http://localhost:3000/api/sse/stats
-   ```
-
-3. Test WebSocket:
-   ```bash
-   wscat -c ws://localhost:3000
-   ```
-
-### Performance Issues
-
-1. Monitor memory usage:
-   ```bash
-   npm run stats
-   ```
-
-2. Check response times:
-   ```bash
-   curl -w "%{time_total}\n" -o /dev/null -s http://localhost:3000/api/health
-   ```
-
-3. Profile code:
-   ```bash
-   npm run profile
-   ```
-
-## FAQ
-
-### Q: How do I reset my configuration?
-A: Delete `.env` and copy `.env.example` to start fresh.
-
-### Q: Why are my events delayed?
-A: Check network latency and server load. Consider adjusting buffer sizes.
-
-### Q: How do I update my token?
-A: Generate a new token in Home Assistant and update HASS_TOKEN.
-
-### Q: Why do I get "Maximum clients reached"?
-A: Adjust SSE_MAX_CLIENTS in configuration or clean up stale connections.
-
-## Error Codes
-
-- `E001`: Connection Error
-- `E002`: Authentication Error
-- `E003`: Rate Limit Error
-- `E004`: Tool Error
-- `E005`: Configuration Error
-
-## Support Resources
-
-1. Documentation
-   - [API Reference](./API.md)
-   - [Configuration Guide](./configuration/README.md)
-   - [Development Guide](./development/README.md)
-
-2. Community
-   - GitHub Issues
-   - Discussion Forums
-   - Stack Overflow
-
-3. Tools
-   - Diagnostic Scripts
-   - Testing Tools
-   - Monitoring Tools
-
-## Still Need Help?
-
-1. Create a detailed issue:
-   - Error messages
-   - Steps to reproduce
-   - Environment details
-   - Logs
-
-2. Contact support:
-   - GitHub Issues
-   - Email Support
-   - Community Forums 

extra/README.md

@@ -0,0 +1,91 @@
+# Speech-to-Text Examples
+
+This directory contains examples demonstrating how to use the speech-to-text integration with wake word detection.
+
+## Prerequisites
+
+1. Make sure you have Docker installed and running
+2. Build and start the services:
+   ```bash
+   docker-compose up -d
+   ```
+
+## Running the Example
+
+1. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+2. Run the example:
+   ```bash
+   npm run example:speech
+   ```
+
+   Or using `ts-node` directly:
+   ```bash
+   npx ts-node examples/speech-to-text-example.ts
+   ```
+
+## Features Demonstrated
+
+1. **Wake Word Detection**
+   - Listens for wake words: "hey jarvis", "ok google", "alexa"
+   - Automatically saves audio when wake word is detected
+   - Transcribes the detected speech
+
+2. **Manual Transcription**
+   - Example of how to transcribe audio files manually
+   - Supports different models and configurations
+
+3. **Event Handling**
+   - Wake word detection events
+   - Transcription results
+   - Progress updates
+   - Error handling
+
+## Example Output
+
+When a wake word is detected, you'll see output like this:
+
+```
+🎤 Wake word detected!
+  Timestamp: 20240203_123456
+  Audio file: /path/to/audio/wake_word_20240203_123456.wav
+  Metadata file: /path/to/audio/wake_word_20240203_123456.wav.json
+
+📝 Transcription result:
+  Full text: This is what was said after the wake word.
+
+  Segments:
+    1. [0.00s - 1.52s] (95.5% confidence)
+       "This is what was said"
+    2. [1.52s - 2.34s] (98.2% confidence)
+       "after the wake word."
+```
+
+## Customization
+
+You can customize the behavior by:
+
+1. Changing the wake word models in `docker/speech/Dockerfile`
+2. Modifying transcription options in the example file
+3. Adding your own event handlers
+4. Implementing different audio processing logic
+
+## Troubleshooting
+
+1. **Docker Issues**
+   - Make sure Docker is running
+   - Check container logs: `docker-compose logs fast-whisper`
+   - Verify container is up: `docker ps`
+
+2. **Audio Issues**
+   - Check audio device permissions
+   - Verify audio file format (WAV files recommended)
+   - Check audio file permissions
+
+3. **Performance Issues**
+   - Try using a smaller model (tiny.en or base.en)
+   - Adjust beam size and patience parameters
+   - Consider using GPU acceleration if available 

extra/claude-desktop-macos-setup.sh

@@ -326,4 +326,8 @@ if [[ $REPLY =~ ^[Yy]$ ]]; then
     else
         echo -e "${GREEN}Home Assistant MCP test successful!${NC}"
     fi
-fi 
+fi
+
+# macOS environment configuration
+HASS_SOCKET_URL="${HASS_HOST/http/ws}/api/websocket" # WebSocket URL conversion
+chmod 600 "$CLAUDE_CONFIG_DIR/claude_desktop_config.json" # Security hardening 

extra/ha-analyzer-cli.ts

@@ -1,21 +1,19 @@
 import fetch from "node-fetch";
-import OpenAI from "openai";
+import { Anthropic } from "@anthropic-ai/sdk";
 import { DOMParser, Element, Document } from '@xmldom/xmldom';
 import dotenv from 'dotenv';
 import readline from 'readline';
 import chalk from 'chalk';
-import express from 'express';
-import bodyParser from 'body-parser';
 
 // Load environment variables
 dotenv.config();
 
 // Retrieve API keys from environment variables
-const openaiApiKey = process.env.OPENAI_API_KEY;
+const anthropicApiKey = process.env.ANTHROPIC_API_KEY;
 const hassToken = process.env.HASS_TOKEN;
 
-if (!openaiApiKey) {
+if (!anthropicApiKey) {
-    console.error("Please set the OPENAI_API_KEY environment variable.");
+    console.error("Please set the ANTHROPIC_API_KEY environment variable.");
     process.exit(1);
 }
 
@@ -25,7 +23,7 @@ if (!hassToken) {
 }
 
 // MCP Server configuration
-const MCP_SERVER = process.env.MCP_SERVER || 'http://localhost:3000';
+const MCP_SERVER = 'http://localhost:3000';
 
 interface McpTool {
     name: string;
@@ -115,14 +113,11 @@ interface ModelConfig {
     contextWindow: number;
 }
 
-// Update model listing to filter based on API key availability
+// Update model listing to use Anthropic's Claude models
 const AVAILABLE_MODELS: ModelConfig[] = [
-    // OpenAI models always available
+    // Anthropic Claude models
-    { name: 'gpt-4o', maxTokens: 4096, contextWindow: 128000 },
+    { name: 'claude-3-7-sonnet-20250219', maxTokens: 4096, contextWindow: 200000 },
-    { name: 'gpt-4-turbo', maxTokens: 4096, contextWindow: 128000 },
+    { name: 'claude-3-5-haiku-20241022', maxTokens: 4096, contextWindow: 200000 },
-    { name: 'gpt-4', maxTokens: 8192, contextWindow: 128000 },
-    { name: 'gpt-3.5-turbo', maxTokens: 4096, contextWindow: 16385 },
-    { name: 'gpt-3.5-turbo-16k', maxTokens: 16385, contextWindow: 16385 },
 
     // Conditionally include DeepSeek models
     ...(process.env.DEEPSEEK_API_KEY ? [
@@ -134,7 +129,7 @@ const AVAILABLE_MODELS: ModelConfig[] = [
 // Add configuration interface
 interface AppConfig {
     mcpServer: string;
-    openaiModel: string;
+    anthropicModel: string;
     maxRetries: number;
     analysisTimeout: number;
     selectedModel: ModelConfig;
@@ -149,36 +144,31 @@ const logger = {
     debug: (msg: string) => process.env.DEBUG && console.log(chalk.gray(`› ${msg}`))
 };
 
-// Update default model selection in loadConfig
+// Update loadConfig to use Claude models
 function loadConfig(): AppConfig {
-    // Use environment variable or default to gpt-4o
+    // Use Claude 3.7 Sonnet as the default model
-    const defaultModelName = process.env.OPENAI_MODEL || 'gpt-4o';
+    const defaultModel = AVAILABLE_MODELS.find(m => m.name === 'claude-3-7-sonnet-20250219') || AVAILABLE_MODELS[0];
-    let defaultModel = AVAILABLE_MODELS.find(m => m.name === defaultModelName);
-
-    // If the configured model isn't found, use gpt-4o without warning
-    if (!defaultModel) {
-        defaultModel = AVAILABLE_MODELS.find(m => m.name === 'gpt-4o') || AVAILABLE_MODELS[0];
-    }
 
     return {
         mcpServer: process.env.MCP_SERVER || 'http://localhost:3000',
-        openaiModel: defaultModel.name,  // Use the resolved model name
+        anthropicModel: defaultModel.name,
         maxRetries: parseInt(process.env.MAX_RETRIES || '3'),
         analysisTimeout: parseInt(process.env.ANALYSIS_TIMEOUT || '30000'),
         selectedModel: defaultModel
     };
 }
 
-function getOpenAIClient(): OpenAI {
+// Replace OpenAI client with Anthropic client
+function getAnthropicClient(): Anthropic {
     const config = loadConfig();
 
-    return new OpenAI({
+    if (config.selectedModel.name.startsWith('deepseek') && process.env.DEEPSEEK_API_KEY) {
-        apiKey: config.selectedModel.name.startsWith('deepseek')
+        // This is just a stub for DeepSeek - you'd need to implement this properly
-            ? process.env.DEEPSEEK_API_KEY
+        throw new Error("DeepSeek models not implemented yet with Anthropic integration");
-            : openaiApiKey,
+    }
-        baseURL: config.selectedModel.name.startsWith('deepseek')
+
-            ? 'https://api.deepseek.com/v1'
+    return new Anthropic({
-            : 'https://api.openai.com/v1'
+        apiKey: anthropicApiKey,
     });
 }
 
@@ -194,8 +184,8 @@ async function executeMcpTool(toolName: string, parameters: Record<string, any>
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), config.analysisTimeout);
 
-            // Update endpoint URL to use the same base path as schema
+            // Update endpoint URL to use the correct API path
-            const endpoint = `${config.mcpServer}/mcp/execute`;
+            const endpoint = `${config.mcpServer}/api/mcp/execute`;
 
             const response = await fetch(endpoint, {
                 method: "POST",
@@ -258,43 +248,117 @@ function isMcpExecuteResponse(obj: any): obj is McpExecuteResponse {
         (obj.success === true || typeof obj.message === 'string');
 }
 
+// Add mock data for testing
+const MOCK_HA_INFO = {
+    devices: {
+        light: [
+            { entity_id: 'light.living_room', state: 'on', attributes: { friendly_name: 'Living Room Light', brightness: 255 } },
+            { entity_id: 'light.kitchen', state: 'off', attributes: { friendly_name: 'Kitchen Light', brightness: 0 } }
+        ],
+        switch: [
+            { entity_id: 'switch.tv', state: 'off', attributes: { friendly_name: 'TV Power' } }
+        ],
+        sensor: [
+            { entity_id: 'sensor.temperature', state: '21.5', attributes: { friendly_name: 'Living Room Temperature', unit_of_measurement: '°C' } },
+            { entity_id: 'sensor.humidity', state: '45', attributes: { friendly_name: 'Living Room Humidity', unit_of_measurement: '%' } }
+        ],
+        climate: [
+            { entity_id: 'climate.thermostat', state: 'heat', attributes: { friendly_name: 'Main Thermostat', current_temperature: 20, target_temp_high: 24 } }
+        ]
+    }
+};
+
+interface HassState {
+    entity_id: string;
+    state: string;
+    attributes: Record<string, any>;
+    last_changed: string;
+    last_updated: string;
+}
+
+interface ServiceInfo {
+    name: string;
+    description: string;
+    fields: Record<string, any>;
+}
+
+interface ServiceDomain {
+    domain: string;
+    services: Record<string, ServiceInfo>;
+}
+
 /**
  * Collects comprehensive information about the Home Assistant instance using MCP tools
  */
 async function collectHomeAssistantInfo(): Promise<any> {
     const info: Record<string, any> = {};
-    const config = loadConfig();
+    const hassHost = process.env.HASS_HOST;
 
-    // Update schema endpoint to be consistent
-    const schemaResponse = await fetch(`${config.mcpServer}/mcp`, {
-        headers: {
-            'Authorization': `Bearer ${hassToken}`,
-            'Accept': 'application/json'
-        }
-    });
-
-    if (!schemaResponse.ok) {
-        console.error(`Failed to fetch MCP schema: ${schemaResponse.status}`);
-        return info;
-    }
-
-    const schema = await schemaResponse.json() as McpSchema;
-    console.log("Available tools:", schema.tools.map(t => t.name));
-
-    // Execute list_devices to get basic device information
-    console.log("Fetching device information...");
     try {
-        const deviceInfo = await executeMcpTool('list_devices');
+        // Check if we're in test mode
-        if (deviceInfo && deviceInfo.success && deviceInfo.devices) {
+        if (process.env.HA_TEST_MODE === '1') {
-            info.devices = deviceInfo.devices;
+            logger.info("Running in test mode with mock data");
-        } else {
+            return MOCK_HA_INFO;
-            console.warn(`Failed to list devices: ${deviceInfo?.message || 'Unknown error'}`);
         }
-    } catch (error) {
-        console.warn("Error fetching devices:", error);
-    }
 
-    return info;
+        // Get states from Home Assistant directly
+        const statesResponse = await fetch(`${hassHost}/api/states`, {
+            headers: {
+                'Authorization': `Bearer ${hassToken}`,
+                'Content-Type': 'application/json'
+            }
+        });
+
+        if (!statesResponse.ok) {
+            throw new Error(`Failed to fetch states: ${statesResponse.status}`);
+        }
+
+        const states = await statesResponse.json() as HassState[];
+
+        // Group devices by domain
+        const devices: Record<string, HassState[]> = {};
+        for (const state of states) {
+            const [domain] = state.entity_id.split('.');
+            if (!devices[domain]) {
+                devices[domain] = [];
+            }
+            devices[domain].push(state);
+        }
+
+        info.devices = devices;
+        info.device_summary = {
+            total_devices: states.length,
+            device_types: Object.keys(devices),
+            by_domain: Object.fromEntries(
+                Object.entries(devices).map(([domain, items]) => [domain, items.length])
+            )
+        };
+
+        const deviceCount = states.length;
+        const domainCount = Object.keys(devices).length;
+
+        if (deviceCount > 0) {
+            logger.success(`Found ${deviceCount} devices across ${domainCount} domains`);
+        } else {
+            logger.warn('No devices found in Home Assistant');
+        }
+
+        return info;
+    } catch (error) {
+        logger.error(`Error fetching devices: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        if (process.env.HA_TEST_MODE !== '1') {
+            logger.warn(`Failed to connect to Home Assistant. Run with HA_TEST_MODE=1 to use test data.`);
+            return {
+                devices: {},
+                device_summary: {
+                    total_devices: 0,
+                    device_types: [],
+                    by_domain: {}
+                }
+            };
+        }
+        return MOCK_HA_INFO;
+    }
 }
 
 /**
@@ -398,34 +462,69 @@ function getRelevantDeviceTypes(prompt: string): string[] {
 }
 
 /**
- * Generates analysis and recommendations using the OpenAI API based on the Home Assistant data
+ * Generates analysis and recommendations using the Anthropic API based on the Home Assistant data
  */
 async function generateAnalysis(haInfo: any): Promise<SystemAnalysis> {
-    const openai = getOpenAIClient();
     const config = loadConfig();
 
-    // Compress and summarize the data
+    // If in test mode, return mock analysis
-    const deviceTypes = haInfo.devices ? Object.keys(haInfo.devices) : [];
+    if (process.env.HA_TEST_MODE === '1') {
-    const deviceSummary = haInfo.devices ? Object.entries(haInfo.devices).reduce((acc: Record<string, any>, [domain, devices]) => {
+        logger.info("Generating mock analysis...");
-        const deviceList = devices as any[];
+        return {
-        acc[domain] = {
+            overview: {
-            count: deviceList.length,
+                state: ["System running normally", "4 device types detected"],
-            active: deviceList.filter(d => d.state === 'on' || d.state === 'home').length,
+                health: ["All systems operational", "No critical issues found"],
-            states: [...new Set(deviceList.map(d => d.state))],
+                configurations: ["Basic configuration detected", "Default settings in use"],
-            sample: deviceList.slice(0, 2).map(d => ({
+                integrations: ["Light", "Switch", "Sensor", "Climate"],
-                id: d.entity_id,
+                issues: ["No major issues detected"]
-                state: d.state,
+            },
-                name: d.attributes?.friendly_name
+            performance: {
-            }))
+                resource_usage: ["Normal CPU usage", "Memory usage within limits"],
+                response_times: ["Average response time: 0.5s"],
+                optimization_areas: ["Consider grouping lights by room"]
+            },
+            security: {
+                current_measures: ["Basic security measures in place"],
+                vulnerabilities: ["No critical vulnerabilities detected"],
+                recommendations: ["Enable 2FA if not already enabled"]
+            },
+            optimization: {
+                performance_suggestions: ["Group frequently used devices"],
+                config_optimizations: ["Consider creating room-based views"],
+                integration_improvements: ["Add friendly names to all entities"],
+                automation_opportunities: ["Create morning/evening routines"]
+            },
+            maintenance: {
+                required_updates: ["No critical updates pending"],
+                cleanup_tasks: ["Remove unused entities"],
+                regular_tasks: ["Check sensor battery levels"]
+            },
+            entity_usage: {
+                most_active: ["light.living_room", "sensor.temperature"],
+                rarely_used: ["switch.tv"],
+                potential_duplicates: []
+            },
+            automation_analysis: {
+                inefficient_automations: [],
+                potential_improvements: ["Add time-based light controls"],
+                suggested_blueprints: ["Motion-activated lighting"],
+                condition_optimizations: []
+            },
+            energy_management: {
+                high_consumption: ["No high consumption devices detected"],
+                monitoring_suggestions: ["Add power monitoring to main appliances"],
+                tariff_optimizations: ["Consider time-of-use automation"]
+            }
         };
-        return acc;
+    }
-    }, {}) : {};
+
+    // Original analysis code for non-test mode
+    const anthropic = getAnthropicClient();
 
     const systemSummary = {
-        total_devices: deviceTypes.reduce((sum, type) => sum + deviceSummary[type].count, 0),
+        total_devices: haInfo.device_summary?.total_devices || 0,
-        device_types: deviceTypes,
+        device_types: haInfo.device_summary?.device_types || [],
-        device_summary: deviceSummary,
+        device_summary: haInfo.device_summary?.by_domain || {}
-        active_devices: Object.values(deviceSummary).reduce((sum: number, info: any) => sum + info.active, 0)
     };
 
     const prompt = `Analyze this Home Assistant system and provide insights in XML format:
@@ -488,20 +587,21 @@ Generate your response in this EXACT format:
 </analysis>`;
 
     try {
-        const completion = await openai.chat.completions.create({
+        const completion = await anthropic.messages.create({
             model: config.selectedModel.name,
             messages: [
                 {
-                    role: "system",
+                    role: "user",
-                    content: "You are a Home Assistant expert. Analyze the system data and provide detailed insights in the specified XML format. Be specific and actionable in your recommendations."
+                    content: `<system>You are a Home Assistant expert. Analyze the system data and provide detailed insights in the specified XML format. Be specific and actionable in your recommendations.</system>
-                },
+                    
-                { role: "user", content: prompt }
+                    ${prompt}`
+                }
             ],
             temperature: 0.7,
             max_tokens: Math.min(config.selectedModel.maxTokens, 4000)
         });
 
-        const result = completion.choices[0].message?.content || "";
+        const result = completion.content[0]?.type === 'text' ? completion.content[0].text : "";
 
         // Clean the response and parse XML
         const cleanedResult = result.replace(/```xml/g, '').replace(/```/g, '').trim();
@@ -573,105 +673,97 @@ Generate your response in this EXACT format:
             throw new Error(`Failed to parse analysis response: ${parseError.message}`);
         }
     } catch (error) {
-        console.error("Error during OpenAI API call:", error);
+        console.error("Error during Anthropic API call:", error);
         throw new Error("Failed to generate analysis");
     }
 }
 
-async function getUserInput(question: string): Promise<string> {
+interface AutomationConfig {
-    const rl = readline.createInterface({
+    id?: string;
-        input: process.stdin,
+    alias?: string;
-        output: process.stdout
+    description?: string;
-    });
+    trigger?: Array<{
-
+        platform: string;
-    return new Promise((resolve) => {
+        [key: string]: any;
-        rl.question(question, (answer) => {
+    }>;
-            rl.close();
+    condition?: Array<{
-            resolve(answer);
+        condition: string;
-        });
+        [key: string]: any;
-    });
+    }>;
+    action?: Array<{
+        service?: string;
+        [key: string]: any;
+    }>;
+    mode?: string;
 }
 
-// Update chunk size calculation
-const MAX_CHARACTERS = 8000; // ~2000 tokens (4 chars/token)
-
-// Update model handling in retry
-async function handleCustomPrompt(haInfo: any): Promise<void> {
-    try {
-        // Add device metadata
-        const deviceTypes = haInfo.devices ? Object.keys(haInfo.devices) : [];
-        const deviceStates = haInfo.devices ? Object.entries(haInfo.devices).reduce((acc: Record<string, number>, [domain, devices]) => {
-            acc[domain] = (devices as any[]).length;
-            return acc;
-        }, {}) : {};
-        const totalDevices = deviceTypes.reduce((sum, type) => sum + deviceStates[type], 0);
-
-        const userPrompt = await getUserInput("Enter your custom prompt: ");
-        if (!userPrompt) {
-            console.log("No prompt provided. Exiting...");
-            return;
-        }
-
-        const openai = getOpenAIClient();
-        const config = loadConfig();
-
-        const completion = await openai.chat.completions.create({
-            model: config.selectedModel.name,
-            messages: [
-                {
-                    role: "system",
-                    content: `You are a Home Assistant expert. Analyze the following Home Assistant information and respond to the user's prompt. 
-                             Current system has ${totalDevices} devices across ${deviceTypes.length} types: ${JSON.stringify(deviceStates)}`
-                },
-                { role: "user", content: userPrompt },
-            ],
-            max_tokens: config.selectedModel.maxTokens,
-            temperature: 0.3,
-        });
-
-        console.log("\nAnalysis Results:\n");
-        console.log(completion.choices[0].message?.content || "No response generated");
-
-    } catch (error) {
-        console.error("Error processing custom prompt:", error);
-
-        // Retry with simplified prompt if there's an error
-        try {
-            const retryPrompt = "Please provide a simpler analysis of the Home Assistant system.";
-            const openai = getOpenAIClient();
-            const config = loadConfig();
-
-            const retryCompletion = await openai.chat.completions.create({
-                model: config.selectedModel.name,
-                messages: [
-                    {
-                        role: "system",
-                        content: "You are a Home Assistant expert. Provide a simple analysis of the system."
-                    },
-                    { role: "user", content: retryPrompt },
-                ],
-                max_tokens: config.selectedModel.maxTokens,
-                temperature: 0.3,
-            });
-
-            console.log("\nAnalysis Results:\n");
-            console.log(retryCompletion.choices[0].message?.content || "No response generated");
-        } catch (retryError) {
-            console.error("Error during retry:", retryError);
-        }
-    }
-}
-
-// Update automation handling
 async function handleAutomationOptimization(haInfo: any): Promise<void> {
     try {
-        const result = await executeMcpTool('automation', { action: 'list' });
+        const hassHost = process.env.HASS_HOST;
-        if (!result?.success) {
+
-            logger.error(`Failed to retrieve automations: ${result?.message || 'Unknown error'}`);
+        // Get automations directly from Home Assistant
-            return;
+        const automationsResponse = await fetch(`${hassHost}/api/states`, {
+            headers: {
+                'Authorization': `Bearer ${hassToken}`,
+                'Content-Type': 'application/json'
+            }
+        });
+
+        if (!automationsResponse.ok) {
+            throw new Error(`Failed to fetch automations: ${automationsResponse.status}`);
         }
 
-        const automations = result.automations || [];
+        const states = await automationsResponse.json() as HassState[];
+        const automations = states.filter(state => state.entity_id.startsWith('automation.'));
+
+        // Get services to understand what actions are available
+        const servicesResponse = await fetch(`${hassHost}/api/services`, {
+            headers: {
+                'Authorization': `Bearer ${hassToken}`,
+                'Content-Type': 'application/json'
+            }
+        });
+
+        let availableServices: Record<string, any> = {};
+        if (servicesResponse.ok) {
+            const services = await servicesResponse.json() as ServiceDomain[];
+            availableServices = services.reduce((acc: Record<string, any>, service: ServiceDomain) => {
+                if (service.domain && service.services) {
+                    acc[service.domain] = service.services;
+                }
+                return acc;
+            }, {});
+            logger.debug(`Retrieved services from ${Object.keys(availableServices).length} domains`);
+        }
+
+        // Enrich automation data with service information
+        const enrichedAutomations = automations.map(automation => {
+            const actions = automation.attributes?.action || [];
+            const enrichedActions = actions.map((action: any) => {
+                if (action.service) {
+                    const [domain, service] = action.service.split('.');
+                    const serviceInfo = availableServices[domain]?.[service];
+                    return {
+                        ...action,
+                        service_info: serviceInfo
+                    };
+                }
+                return action;
+            });
+
+            return {
+                ...automation,
+                config: {
+                    id: automation.entity_id.split('.')[1],
+                    alias: automation.attributes?.friendly_name,
+                    trigger: automation.attributes?.trigger || [],
+                    condition: automation.attributes?.condition || [],
+                    action: enrichedActions,
+                    mode: automation.attributes?.mode || 'single'
+                }
+            };
+        });
+
         if (automations.length === 0) {
             console.log(chalk.bold.underline("\nAutomation Optimization Report"));
             console.log(chalk.yellow("No automations found in the system. Consider creating some automations to improve your Home Assistant experience."));
@@ -679,7 +771,7 @@ async function handleAutomationOptimization(haInfo: any): Promise<void> {
         }
 
         logger.info(`Analyzing ${automations.length} automations...`);
-        const optimizationXml = await analyzeAutomations(automations);
+        const optimizationXml = await analyzeAutomations(enrichedAutomations);
 
         const parser = new DOMParser();
         const xmlDoc = parser.parseFromString(optimizationXml, "text/xml");
@@ -721,67 +813,102 @@ async function handleAutomationOptimization(haInfo: any): Promise<void> {
     }
 }
 
-// Add new automation optimization function
 async function analyzeAutomations(automations: any[]): Promise<string> {
-    const openai = getOpenAIClient();
+    const anthropic = getAnthropicClient();
     const config = loadConfig();
 
-    // Compress automation data by only including essential fields
+    // Create a more detailed summary of automations
-    const compressedAutomations = automations.map(automation => ({
+    const automationSummary = {
-        id: automation.entity_id,
+        total: automations.length,
-        name: automation.attributes?.friendly_name || automation.entity_id,
+        active: automations.filter(a => a.state === 'on').length,
-        state: automation.state,
+        by_type: automations.reduce((acc: Record<string, number>, auto) => {
-        last_triggered: automation.attributes?.last_triggered,
+            const type = auto.attributes?.mode || 'single';
-        mode: automation.attributes?.mode,
+            acc[type] = (acc[type] || 0) + 1;
-        trigger_count: automation.attributes?.trigger?.length || 0,
+            return acc;
-        action_count: automation.attributes?.action?.length || 0
+        }, {}),
-    }));
+        recently_triggered: automations.filter(a => {
+            const lastTriggered = a.attributes?.last_triggered;
+            if (!lastTriggered) return false;
+            const lastTriggerDate = new Date(lastTriggered);
+            const oneDayAgo = new Date();
+            oneDayAgo.setDate(oneDayAgo.getDate() - 1);
+            return lastTriggerDate > oneDayAgo;
+        }).length,
+        trigger_types: automations.reduce((acc: Record<string, number>, auto) => {
+            const triggers = auto.config?.trigger || [];
+            triggers.forEach((trigger: any) => {
+                const type = trigger.platform || 'unknown';
+                acc[type] = (acc[type] || 0) + 1;
+            });
+            return acc;
+        }, {}),
+        action_types: automations.reduce((acc: Record<string, number>, auto) => {
+            const actions = auto.config?.action || [];
+            actions.forEach((action: any) => {
+                const type = action.service?.split('.')[0] || 'unknown';
+                acc[type] = (acc[type] || 0) + 1;
+            });
+            return acc;
+        }, {}),
+        service_domains: Array.from(new Set(automations.flatMap(auto =>
+            (auto.config?.action || [])
+                .map((action: any) => action.service?.split('.')[0])
+                .filter(Boolean)
+        ))).sort(),
+        names: automations.map(a => a.attributes?.friendly_name || a.entity_id.split('.')[1]).slice(0, 10)
+    };
 
     const prompt = `Analyze these Home Assistant automations and provide optimization suggestions in XML format:
-${JSON.stringify(compressedAutomations, null, 2)}
+${JSON.stringify(automationSummary, null, 2)}
+
+Key metrics:
+- Total automations: ${automationSummary.total}
+- Active automations: ${automationSummary.active}
+- Recently triggered: ${automationSummary.recently_triggered}
+- Automation modes: ${JSON.stringify(automationSummary.by_type)}
+- Trigger types: ${JSON.stringify(automationSummary.trigger_types)}
+- Action types: ${JSON.stringify(automationSummary.action_types)}
+- Service domains used: ${automationSummary.service_domains.join(', ')}
 
 Generate your response in this EXACT format:
 <analysis>
     <findings>
         <item>Finding 1</item>
         <item>Finding 2</item>
-        <!-- Add more findings as needed -->
     </findings>
     <recommendations>
         <item>Recommendation 1</item>
         <item>Recommendation 2</item>
-        <!-- Add more recommendations as needed -->
     </recommendations>
     <blueprints>
         <item>Blueprint suggestion 1</item>
         <item>Blueprint suggestion 2</item>
-        <!-- Add more blueprint suggestions as needed -->
     </blueprints>
 </analysis>
 
-If no optimizations are needed, return empty item lists but maintain the XML structure.
-
 Focus on:
-1. Identifying patterns and potential improvements
+1. Identifying patterns and potential improvements based on trigger and action types
-2. Suggesting energy-saving optimizations
+2. Suggesting energy-saving optimizations based on the services being used
 3. Recommending error handling improvements
-4. Suggesting relevant blueprints`;
+4. Suggesting relevant blueprints for common automation patterns
+5. Analyzing the distribution of automation types and suggesting optimizations`;
 
     try {
-        const completion = await openai.chat.completions.create({
+        const completion = await anthropic.messages.create({
             model: config.selectedModel.name,
             messages: [
                 {
-                    role: "system",
+                    role: "user",
-                    content: "You are a Home Assistant automation expert. Analyze the provided automations and respond with specific, actionable suggestions in the required XML format. If no optimizations are needed, return empty item lists but maintain the XML structure."
+                    content: `<system>You are a Home Assistant automation expert. Analyze the provided automation summary and respond with specific, actionable suggestions in the required XML format.</system>
-                },
+                    
-                { role: "user", content: prompt }
+                    ${prompt}`
+                }
             ],
             temperature: 0.2,
-            max_tokens: Math.min(config.selectedModel.maxTokens, 4000)
+            max_tokens: Math.min(config.selectedModel.maxTokens, 2048)
         });
 
-        const response = completion.choices[0].message?.content || "";
+        const response = completion.content[0]?.type === 'text' ? completion.content[0].text : "";
 
         // Ensure the response is valid XML
         if (!response.trim().startsWith('<analysis>')) {
@@ -819,62 +946,166 @@ Focus on:
     }
 }
 
-// Update model selection prompt count dynamically
+// Update handleCustomPrompt function to use Anthropic
-async function selectModel(): Promise<ModelConfig> {
+async function handleCustomPrompt(haInfo: any, customPrompt: string): Promise<void> {
-    console.log(chalk.bold.underline("\nAvailable Models:"));
+    try {
-    AVAILABLE_MODELS.forEach((model, index) => {
+        // Add device metadata
-        console.log(
+        const deviceTypes = haInfo.devices ? Object.keys(haInfo.devices) : [];
-            `${index + 1}. ${chalk.blue(model.name.padEnd(20))} ` +
+        const deviceStates = haInfo.devices ? Object.entries(haInfo.devices).reduce((acc: Record<string, number>, [domain, devices]) => {
-            `Context: ${chalk.yellow(model.contextWindow.toLocaleString().padStart(6))} tokens | ` +
+            acc[domain] = (devices as any[]).length;
-            `Max output: ${chalk.green(model.maxTokens.toLocaleString().padStart(5))} tokens`
+            return acc;
-        );
+        }, {}) : {};
-    });
+        const totalDevices = deviceTypes.reduce((sum, type) => sum + deviceStates[type], 0);
 
-    const maxOption = AVAILABLE_MODELS.length;
+        // Get automation information
-    const choice = await getUserInput(`\nSelect model (1-${maxOption}): `);
+        const automations = haInfo.devices?.automation || [];
-    const selectedIndex = parseInt(choice) - 1;
+        const automationDetails = automations.map((auto: any) => ({
+            name: auto.attributes?.friendly_name || auto.entity_id.split('.')[1],
+            state: auto.state,
+            last_triggered: auto.attributes?.last_triggered,
+            mode: auto.attributes?.mode,
+            triggers: auto.attributes?.trigger?.map((t: any) => ({
+                platform: t.platform,
+                ...t
+            })) || [],
+            conditions: auto.attributes?.condition?.map((c: any) => ({
+                condition: c.condition,
+                ...c
+            })) || [],
+            actions: auto.attributes?.action?.map((a: any) => ({
+                service: a.service,
+                ...a
+            })) || []
+        }));
 
-    if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= AVAILABLE_MODELS.length) {
+        const automationSummary = {
-        console.log(chalk.yellow("Invalid selection, using default model"));
+            total: automations.length,
-        return AVAILABLE_MODELS[0];
+            active: automations.filter((a: any) => a.state === 'on').length,
-    }
+            trigger_types: automations.reduce((acc: Record<string, number>, auto: any) => {
+                const triggers = auto.attributes?.trigger || [];
+                triggers.forEach((trigger: any) => {
+                    const type = trigger.platform || 'unknown';
+                    acc[type] = (acc[type] || 0) + 1;
+                });
+                return acc;
+            }, {}),
+            action_types: automations.reduce((acc: Record<string, number>, auto: any) => {
+                const actions = auto.attributes?.action || [];
+                actions.forEach((action: any) => {
+                    const type = action.service?.split('.')[0] || 'unknown';
+                    acc[type] = (acc[type] || 0) + 1;
+                });
+                return acc;
+            }, {}),
+            service_domains: Array.from(new Set(automations.flatMap((auto: any) =>
+                (auto.attributes?.action || [])
+                    .map((action: any) => action.service?.split('.')[0])
+                    .filter(Boolean)
+            ))).sort()
+        };
 
-    const selectedModel = AVAILABLE_MODELS[selectedIndex];
+        // Create a summary of the devices
+        const deviceSummary = Object.entries(deviceStates)
+            .map(([domain, count]) => `${domain}: ${count}`)
+            .join(', ');
 
-    // Validate API keys for specific providers
+        if (process.env.HA_TEST_MODE === '1') {
-    if (selectedModel.name.startsWith('deepseek')) {
+            console.log("\nTest Mode Analysis Results:\n");
-        if (!process.env.DEEPSEEK_API_KEY) {
+            console.log("Based on your Home Assistant setup with:");
-            logger.error("DeepSeek models require DEEPSEEK_API_KEY in .env");
+            console.log(`- ${totalDevices} total devices`);
-            process.exit(1);
+            console.log(`- Device types: ${deviceTypes.join(', ')}`);
+            console.log("\nAnalysis for prompt: " + customPrompt);
+            console.log("1. Current State:");
+            console.log("   - All devices are functioning normally");
+            console.log("   - System is responsive and stable");
+            console.log("\n2. Recommendations:");
+            console.log("   - Consider grouping devices by room");
+            console.log("   - Add automation for frequently used devices");
+            console.log("   - Monitor power usage of main appliances");
+            console.log("\n3. Optimization Opportunities:");
+            console.log("   - Create scenes for different times of day");
+            console.log("   - Set up presence detection for automatic control");
+            return;
         }
 
-        // Verify DeepSeek connection
+        const anthropic = getAnthropicClient();
+        const config = loadConfig();
+
+        const completion = await anthropic.messages.create({
+            model: config.selectedModel.name,
+            messages: [
+                {
+                    role: "user",
+                    content: `<system>You are a Home Assistant expert. Analyze the following Home Assistant information and respond to the user's prompt. 
+                             Current system has ${totalDevices} devices across ${deviceTypes.length} types.
+                             Device distribution: ${deviceSummary}
+                             
+                             Automation Summary:
+                             - Total automations: ${automationSummary.total}
+                             - Active automations: ${automationSummary.active}
+                             - Trigger types: ${JSON.stringify(automationSummary.trigger_types)}
+                             - Action types: ${JSON.stringify(automationSummary.action_types)}
+                             - Service domains used: ${automationSummary.service_domains.join(', ')}
+                             
+                             Detailed Automation List:
+                             ${JSON.stringify(automationDetails, null, 2)}</system>
+                             
+                             ${customPrompt}`
+                }
+            ],
+            max_tokens: Math.min(config.selectedModel.maxTokens, 2048),
+            temperature: 0.3,
+        });
+
+        console.log("\nAnalysis Results:\n");
+        console.log(completion.content[0]?.type === 'text' ? completion.content[0].text : "No response generated");
+
+    } catch (error) {
+        console.error("Error processing custom prompt:", error);
+
+        if (process.env.HA_TEST_MODE === '1') {
+            console.log("\nTest Mode Fallback Analysis:\n");
+            console.log("1. System Overview:");
+            console.log("   - Basic configuration detected");
+            console.log("   - All core services operational");
+            console.log("\n2. Suggestions:");
+            console.log("   - Review device naming conventions");
+            console.log("   - Consider adding automation blueprints");
+            return;
+        }
+
+        // Retry with simplified prompt if there's an error
         try {
-            await getOpenAIClient().models.list();
+            const retryPrompt = "Please provide a simpler analysis of the Home Assistant system.";
-        } catch (error) {
+            const anthropic = getAnthropicClient();
-            logger.error(`DeepSeek connection failed: ${error.message}`);
+            const config = loadConfig();
-            process.exit(1);
+
+            const retryCompletion = await anthropic.messages.create({
+                model: config.selectedModel.name,
+                messages: [
+                    {
+                        role: "user",
+                        content: `<system>You are a Home Assistant expert. Provide a simple analysis of the system.</system>
+                        
+                        ${retryPrompt}`
+                    }
+                ],
+                max_tokens: Math.min(config.selectedModel.maxTokens, 2048),
+                temperature: 0.3,
+            });
+
+            console.log("\nAnalysis Results:\n");
+            console.log(retryCompletion.content[0]?.type === 'text' ? retryCompletion.content[0].text : "No response generated");
+        } catch (retryError) {
+            console.error("Error during retry:", retryError);
         }
     }
-
-    if (selectedModel.name.startsWith('gpt-4-o') && !process.env.OPENAI_API_KEY) {
-        logger.error("OpenAI models require OPENAI_API_KEY in .env");
-        process.exit(1);
-    }
-
-    return selectedModel;
 }
 
 // Enhanced main function with progress indicators
 async function main() {
     let config = loadConfig();
 
-    // Model selection
-    config.selectedModel = await selectModel();
-    logger.info(`Selected model: ${chalk.blue(config.selectedModel.name)} ` +
-        `(Context: ${config.selectedModel.contextWindow.toLocaleString()} tokens, ` +
-        `Output: ${config.selectedModel.maxTokens.toLocaleString()} tokens)`);
-
     logger.info(`Starting analysis with ${config.selectedModel.name} model...`);
 
     try {
@@ -888,12 +1119,20 @@ async function main() {
 
         logger.success(`Collected data from ${Object.keys(haInfo.devices).length} device types`);
 
-        const mode = await getUserInput(
+        // Get mode from command line argument or default to 1
-            "\nSelect mode:\n1. Standard Analysis\n2. Custom Prompt\n3. Automation Optimization\nEnter choice (1-3): "
+        const mode = process.argv[2] || "1";
-        );
+
+        console.log("\nAvailable modes:");
+        console.log("1. Standard Analysis");
+        console.log("2. Custom Prompt");
+        console.log("3. Automation Optimization");
+        console.log(`Selected mode: ${mode}\n`);
 
         if (mode === "2") {
-            await handleCustomPrompt(haInfo);
+            // For custom prompt mode, get the prompt from remaining arguments
+            const customPrompt = process.argv.slice(3).join(" ") || "Analyze my Home Assistant setup";
+            console.log(`Custom prompt: ${customPrompt}\n`);
+            await handleCustomPrompt(haInfo, customPrompt);
         } else if (mode === "3") {
             await handleAutomationOptimization(haInfo);
         } else {
@@ -938,22 +1177,39 @@ function getItems(xmlDoc: Document, path: string): string[] {
         .map(item => (item as Element).textContent || "");
 }
 
-// Add environment check for processor type
+// Replace the Express/Bun server initialization
-if (process.env.PROCESSOR_TYPE === 'openai') {
+if (process.env.PROCESSOR_TYPE === 'anthropic') {
-    // Initialize Express server only for OpenAI
+    // Initialize Bun server for Anthropic
-    const app = express();
+    const server = Bun.serve({
-    const port = process.env.PORT || 3000;
+        port: process.env.PORT || 3000,
+        async fetch(req) {
+            const url = new URL(req.url);
 
-    app.use(bodyParser.json());
+            // Handle chat endpoint
+            if (url.pathname === '/chat' && req.method === 'POST') {
+                try {
+                    const body = await req.json();
+                    // Handle chat logic here
+                    return new Response(JSON.stringify({ success: true }), {
+                        headers: { 'Content-Type': 'application/json' }
+                    });
+                } catch (error) {
+                    return new Response(JSON.stringify({
+                        success: false,
+                        error: error.message
+                    }), {
+                        status: 400,
+                        headers: { 'Content-Type': 'application/json' }
+                    });
+                }
+            }
 
-    // Keep existing OpenAI routes
+            // Handle 404 for unknown routes
-    app.post('/chat', async (req, res) => {
+            return new Response('Not Found', { status: 404 });
-        // ... existing OpenAI handler code ...
+        },
     });
 
-    app.listen(port, () => {
+    console.log(`[Anthropic Server] Running on port ${server.port}`);
-        console.log(`[OpenAI Server] Running on port ${port}`);
-    });
 } else {
     console.log('[Claude Mode] Using stdio communication');
 }

extra/speech-to-text-example.ts

@@ -0,0 +1,127 @@
+import { SpeechToText, TranscriptionResult, WakeWordEvent } from '../src/speech/speechToText';
+import path from 'path';
+import recorder from 'node-record-lpcm16';
+import { Writable } from 'stream';
+
+async function main() {
+    // Initialize the speech-to-text service
+    const speech = new SpeechToText({
+        modelPath: 'base.en',
+        modelType: 'whisper',
+        containerName: 'fast-whisper'
+    });
+
+    // Check if the service is available
+    const isHealthy = await speech.checkHealth();
+    if (!isHealthy) {
+        console.error('Speech service is not available. Make sure Docker is running and the fast-whisper container is up.');
+        console.error('Run: docker-compose up -d');
+        process.exit(1);
+    }
+
+    console.log('Speech service is ready!');
+    console.log('Listening for wake words: "hey jarvis", "ok google", "alexa"');
+    console.log('Press Ctrl+C to exit');
+
+    // Set up event handlers
+    speech.on('wake_word', (event: WakeWordEvent) => {
+        console.log('\n🎤 Wake word detected!');
+        console.log('  Timestamp:', event.timestamp);
+        console.log('  Audio file:', event.audioFile);
+        console.log('  Metadata file:', event.metadataFile);
+    });
+
+    speech.on('transcription', (event: { audioFile: string; result: TranscriptionResult }) => {
+        console.log('\n📝 Transcription result:');
+        console.log('  Full text:', event.result.text);
+        console.log('\n  Segments:');
+        event.result.segments.forEach((segment, index) => {
+            console.log(`    ${index + 1}. [${segment.start.toFixed(2)}s - ${segment.end.toFixed(2)}s] (${(segment.confidence * 100).toFixed(1)}% confidence)`);
+            console.log(`       "${segment.text}"`);
+        });
+    });
+
+    speech.on('progress', (event: { type: string; data: string }) => {
+        if (event.type === 'stderr' && !event.data.includes('Loading model')) {
+            console.error('❌ Error:', event.data);
+        }
+    });
+
+    speech.on('error', (error: Error) => {
+        console.error('❌ Error:', error.message);
+    });
+
+    // Create audio directory if it doesn't exist
+    const audioDir = path.join(__dirname, '..', 'audio');
+    if (!require('fs').existsSync(audioDir)) {
+        require('fs').mkdirSync(audioDir, { recursive: true });
+    }
+
+    // Start microphone recording
+    console.log('Starting microphone recording...');
+    let audioBuffer = Buffer.alloc(0);
+
+    const audioStream = new Writable({
+        write(chunk: Buffer, encoding, callback) {
+            audioBuffer = Buffer.concat([audioBuffer, chunk]);
+            callback();
+        }
+    });
+
+    const recording = recorder.record({
+        sampleRate: 16000,
+        channels: 1,
+        audioType: 'wav'
+    });
+
+    recording.stream().pipe(audioStream);
+
+    // Process audio every 5 seconds
+    setInterval(async () => {
+        if (audioBuffer.length > 0) {
+            try {
+                const result = await speech.transcribe(audioBuffer);
+                console.log('\n🎤 Live transcription:', result);
+                // Reset buffer after processing
+                audioBuffer = Buffer.alloc(0);
+            } catch (error) {
+                console.error('❌ Transcription error:', error);
+            }
+        }
+    }, 5000);
+
+    // Example of manual transcription
+    async function transcribeFile(filepath: string) {
+        try {
+            console.log(`\n🎯 Manually transcribing: ${filepath}`);
+            const result = await speech.transcribeAudio(filepath, {
+                model: 'base.en',
+                language: 'en',
+                temperature: 0,
+                beamSize: 5
+            });
+
+            console.log('\n📝 Transcription result:');
+            console.log('  Text:', result.text);
+        } catch (error) {
+            console.error('❌ Transcription failed:', error instanceof Error ? error.message : error);
+        }
+    }
+
+    // Start wake word detection
+    speech.startWakeWordDetection(audioDir);
+
+    // Handle cleanup on exit
+    process.on('SIGINT', () => {
+        console.log('\nStopping speech service...');
+        recording.stop();
+        speech.stopWakeWordDetection();
+        process.exit(0);
+    });
+}
+
+// Run the example
+main().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+}); 

fix-env.js

@@ -0,0 +1,9 @@
+// This script fixes the NODE_ENV environment variable before any imports
+console.log('Setting NODE_ENV to "development" before imports');
+process.env.NODE_ENV = "development";
+
+// Add more debugging
+console.log(`NODE_ENV is now set to: "${process.env.NODE_ENV}"`);
+
+// Import the main application
+import './dist/index.js';

jest-resolver.cjs

@@ -1,85 +0,0 @@
-const path = require('path');
-
-module.exports = (request, options) => {
-    // Handle chalk and related packages
-    if (request === 'chalk' || request === '#ansi-styles' || request === '#supports-color') {
-        return path.resolve(__dirname, 'node_modules', request.replace('#', ''));
-    }
-
-    // Handle source files with .js extension
-    if (request.endsWith('.js')) {
-        const tsRequest = request.replace(/\.js$/, '.ts');
-        try {
-            return options.defaultResolver(tsRequest, {
-                ...options,
-                packageFilter: pkg => {
-                    if (pkg.type === 'module') {
-                        if (pkg.exports && pkg.exports.import) {
-                            pkg.main = pkg.exports.import;
-                        } else if (pkg.module) {
-                            pkg.main = pkg.module;
-                        }
-                    }
-                    return pkg;
-                }
-            });
-        } catch (e) {
-            // If the .ts file doesn't exist, try resolving without extension
-            try {
-                return options.defaultResolver(request.replace(/\.js$/, ''), options);
-            } catch (e2) {
-                // If that fails too, try resolving with .ts extension
-                try {
-                    return options.defaultResolver(tsRequest, options);
-                } catch (e3) {
-                    // If all attempts fail, try resolving the original request
-                    return options.defaultResolver(request, options);
-                }
-            }
-        }
-    }
-
-    // Handle @digital-alchemy packages
-    if (request.startsWith('@digital-alchemy/')) {
-        try {
-            const packagePath = path.resolve(__dirname, 'node_modules', request);
-            return options.defaultResolver(packagePath, {
-                ...options,
-                packageFilter: pkg => {
-                    if (pkg.type === 'module') {
-                        if (pkg.exports && pkg.exports.import) {
-                            pkg.main = pkg.exports.import;
-                        } else if (pkg.module) {
-                            pkg.main = pkg.module;
-                        }
-                    }
-                    return pkg;
-                }
-            });
-        } catch (e) {
-            // If resolution fails, continue with default resolver
-        }
-    }
-
-    // Call the default resolver with enhanced module resolution
-    return options.defaultResolver(request, {
-        ...options,
-        // Handle ESM modules
-        packageFilter: pkg => {
-            if (pkg.type === 'module') {
-                if (pkg.exports) {
-                    if (pkg.exports.import) {
-                        pkg.main = pkg.exports.import;
-                    } else if (typeof pkg.exports === 'string') {
-                        pkg.main = pkg.exports;
-                    }
-                } else if (pkg.module) {
-                    pkg.main = pkg.module;
-                }
-            }
-            return pkg;
-        },
-        extensions: ['.ts', '.tsx', '.js', '.jsx', '.json'],
-        paths: [...(options.paths || []), path.resolve(__dirname, 'src')]
-    });
-}; 

jest.config.cjs

@@ -1,17 +0,0 @@
-/** @type {import('bun:test').BunTestConfig} */
-module.exports = {
-    testEnvironment: 'node',
-    moduleFileExtensions: ['ts', 'js', 'json', 'node'],
-    testMatch: ['**/__tests__/**/*.test.ts'],
-    collectCoverage: true,
-    coverageDirectory: 'coverage',
-    coverageThreshold: {
-        global: {
-            statements: 50,
-            branches: 50,
-            functions: 50,
-            lines: 50
-        }
-    },
-    setupFilesAfterEnv: ['./jest.setup.ts']
-}; 

jest.setup.ts

@@ -1,87 +0,0 @@
-import { jest } from '@jest/globals';
-import dotenv from 'dotenv';
-import { TextEncoder, TextDecoder } from 'util';
-
-// Load test environment variables
-dotenv.config({ path: '.env.test' });
-
-// Set test environment
-process.env.NODE_ENV = 'test';
-process.env.ENCRYPTION_KEY = 'test-encryption-key-32-bytes-long!!!';
-process.env.JWT_SECRET = 'test-jwt-secret';
-process.env.HASS_URL = 'http://localhost:8123';
-process.env.HASS_TOKEN = 'test-token';
-process.env.CLAUDE_API_KEY = 'test_api_key';
-process.env.CLAUDE_MODEL = 'test_model';
-
-// Add TextEncoder and TextDecoder to global scope
-Object.defineProperty(global, 'TextEncoder', {
-    value: TextEncoder,
-    writable: true
-});
-
-Object.defineProperty(global, 'TextDecoder', {
-    value: TextDecoder,
-    writable: true
-});
-
-// Configure console for tests
-const originalConsole = { ...console };
-global.console = {
-    ...console,
-    log: jest.fn(),
-    error: jest.fn(),
-    warn: jest.fn(),
-    info: jest.fn(),
-    debug: jest.fn(),
-};
-
-// Increase test timeout
-jest.setTimeout(30000);
-
-// Mock WebSocket
-jest.mock('ws', () => {
-    return {
-        WebSocket: jest.fn().mockImplementation(() => ({
-            on: jest.fn(),
-            send: jest.fn(),
-            close: jest.fn(),
-            removeAllListeners: jest.fn()
-        }))
-    };
-});
-
-// Mock chalk
-const createChalkMock = () => {
-    const handler = {
-        get(target: any, prop: string) {
-            if (prop === 'default') {
-                return createChalkMock();
-            }
-            return typeof prop === 'string' ? createChalkMock() : target[prop];
-        },
-        apply(target: any, thisArg: any, args: any[]) {
-            return args[0];
-        }
-    };
-    return new Proxy(() => { }, handler);
-};
-
-jest.mock('chalk', () => createChalkMock());
-
-// Mock ansi-styles
-jest.mock('ansi-styles', () => ({}), { virtual: true });
-
-// Mock supports-color
-jest.mock('supports-color', () => ({}), { virtual: true });
-
-// Reset mocks between tests
-beforeEach(() => {
-    jest.clearAllMocks();
-});
-
-// Cleanup after tests
-afterEach(() => {
-    jest.clearAllTimers();
-    jest.clearAllMocks();
-}); 

package.json

@@ -1,66 +1,99 @@
 {
   "name": "homeassistant-mcp",
-  "version": "0.1.0",
+  "version": "1.0.0",
-  "description": "Model Context Protocol Server for Home Assistant",
+  "description": "Home Assistant Model Context Protocol",
-  "type": "module",
   "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "homeassistant-mcp": "./bin/npx-entry.cjs",
+    "mcp-stdio": "./bin/npx-entry.cjs"
+  },
   "scripts": {
-    "build": "bun run tsc",
+    "start": "bun run dist/index.js",
-    "start": "bun run dist/src/index.js",
+    "start:stdio": "bun run dist/stdio-server.js",
-    "dev": "bun --watch src/index.ts",
+    "dev": "bun --hot --watch src/index.ts",
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun --minify",
+    "build:all": "bun build ./src/index.ts ./src/stdio-server.ts --outdir ./dist --target bun --minify",
+    "build:node": "bun build ./src/index.ts --outdir ./dist --target node --minify",
+    "build:stdio": "bun build ./src/stdio-server.ts --outdir ./dist --target node --minify",
+    "prepare": "husky install && bun run build:all",
+    "stdio": "node ./bin/mcp-stdio.js",
     "test": "bun test",
-    "test:coverage": "bun test --coverage",
     "test:watch": "bun test --watch",
-    "test:openai": "bun run openai_test.ts",
+    "test:coverage": "bun test --coverage",
-    "lint": "eslint src --ext .ts",
+    "test:ci": "bun test --coverage --bail",
-    "lint:fix": "eslint src --ext .ts --fix",
+    "test:update": "bun test --update-snapshots",
-    "prepare": "bun run build",
+    "test:clear": "bun test --clear-cache",
-    "clean": "rimraf dist",
+    "test:staged": "bun test --findRelatedTests",
-    "types:check": "tsc --noEmit",
+    "lint": "eslint . --ext .ts",
-    "types:install": "bun add -d @types/node @types/jest"
+    "format": "prettier --write \"src/**/*.ts\"",
+    "profile": "bun --inspect src/index.ts",
+    "clean": "rm -rf dist .bun coverage",
+    "typecheck": "bun x tsc --noEmit",
+    "example:speech": "bun run extra/speech-to-text-example.ts"
   },
   "dependencies": {
-    "@digital-alchemy/core": "^24.11.4",
+    "@anthropic-ai/sdk": "^0.39.0",
-    "@digital-alchemy/hass": "^24.11.4",
+    "@elysiajs/cors": "^1.2.0",
-    "@types/chalk": "^0.4.31",
+    "@elysiajs/swagger": "^1.2.0",
-    "@types/jsonwebtoken": "^9.0.8",
+    "@types/express-rate-limit": "^5.1.3",
-    "@types/xmldom": "^0.1.34",
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/node": "^20.11.24",
+    "@types/sanitize-html": "^2.13.0",
+    "@types/swagger-ui-express": "^4.1.8",
+    "@types/ws": "^8.5.10",
     "@xmldom/xmldom": "^0.9.7",
-    "ajv": "^8.12.0",
     "chalk": "^5.4.1",
-    "dotenv": "^16.3.1",
+    "cors": "^2.8.5",
-    "express": "^4.18.2",
+    "dotenv": "^16.4.7",
-    "express-rate-limit": "^7.1.5",
+    "elysia": "^1.2.11",
+    "express": "^4.21.2",
+    "express-rate-limit": "^7.5.0",
     "helmet": "^7.1.0",
     "jsonwebtoken": "^9.0.2",
-    "litemcp": "^0.7.0",
+    "node-fetch": "^3.3.2",
-    "uuid": "^9.0.1",
+    "node-record-lpcm16": "^1.0.1",
+    "openai": "^4.83.0",
+    "openapi-types": "^12.1.3",
+    "sanitize-html": "^2.15.0",
+    "swagger-ui-express": "^5.0.1",
+    "typescript": "^5.3.3",
+    "winston": "^3.11.0",
     "winston-daily-rotate-file": "^5.0.0",
     "ws": "^8.16.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {
-    "@types/ajv": "^1.0.0",
+    "@jest/globals": "^29.7.0",
-    "@types/express": "^4.17.21",
+    "@types/bun": "latest",
-    "@types/express-rate-limit": "^6.0.0",
+    "@types/cors": "^2.8.17",
-    "@types/glob": "^8.1.0",
+    "@types/express": "^5.0.0",
-    "@types/helmet": "^4.0.0",
     "@types/jest": "^29.5.14",
-    "@types/node": "^20.17.16",
     "@types/supertest": "^6.0.2",
-    "@types/uuid": "^9.0.8",
+    "@types/uuid": "^10.0.0",
-    "@types/winston": "^2.4.4",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
-    "@types/ws": "^8.5.10",
+    "@typescript-eslint/parser": "^7.1.0",
-    "jest": "^29.7.0",
+    "ajv": "^8.17.1",
-    "node-fetch": "^3.3.2",
+    "bun-types": "^1.2.2",
-    "openai": "^4.82.0",
+    "eslint": "^8.57.0",
-    "rimraf": "^5.0.10",
+    "eslint-config-prettier": "^9.1.0",
-    "supertest": "^6.3.4",
+    "eslint-plugin-prettier": "^5.1.3",
-    "ts-jest": "^29.1.2",
+    "husky": "^9.0.11",
-    "tsx": "^4.7.0",
+    "prettier": "^3.2.5",
-    "typescript": "^5.3.3"
+    "supertest": "^7.1.0",
+    "uuid": "^11.1.0"
   },
-  "author": "Jango Blockchained",
+  "engines": {
-  "license": "MIT",
+    "bun": ">=1.0.0",
-  "packageManager": "bun@1.0.26"
+    "node": ">=18.0.0"
-}
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ]
+}

scripts/setup-env.sh

@@ -0,0 +1,97 @@
+#!/bin/bash
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Function to print colored messages
+print_message() {
+    local color=$1
+    local message=$2
+    echo -e "${color}${message}${NC}"
+}
+
+# Function to check if a file exists
+check_file() {
+    if [ -f "$1" ]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+# Function to copy environment file
+copy_env_file() {
+    local source=$1
+    local target=$2
+    if [ -f "$target" ]; then
+        print_message "$YELLOW" "Warning: $target already exists. Skipping..."
+    else
+        cp "$source" "$target"
+        if [ $? -eq 0 ]; then
+            print_message "$GREEN" "Created $target successfully"
+        else
+            print_message "$RED" "Error: Failed to create $target"
+            exit 1
+        fi
+    fi
+}
+
+# Main script
+print_message "$GREEN" "Setting up environment files..."
+
+# Check if .env.example exists
+if ! check_file ".env.example"; then
+    print_message "$RED" "Error: .env.example not found!"
+    exit 1
+fi
+
+# Setup base environment file
+if [ "$1" = "--force" ]; then
+    cp .env.example .env
+    print_message "$GREEN" "Forced creation of .env file"
+else
+    copy_env_file ".env.example" ".env"
+fi
+
+# Determine environment
+ENV=${NODE_ENV:-development}
+case "$ENV" in
+    "development"|"dev")
+        ENV_FILE=".env.dev"
+        ;;
+    "production"|"prod")
+        ENV_FILE=".env.prod"
+        ;;
+    "test")
+        ENV_FILE=".env.test"
+        ;;
+    *)
+        print_message "$RED" "Error: Invalid environment: $ENV"
+        exit 1
+        ;;
+esac
+
+# Copy environment-specific file
+if [ -f "$ENV_FILE" ]; then
+    if [ "$1" = "--force" ]; then
+        cp "$ENV_FILE" .env
+        print_message "$GREEN" "Forced override of .env with $ENV_FILE"
+    else
+        print_message "$YELLOW" "Do you want to override .env with $ENV_FILE? [y/N] "
+        read -r response
+        if [[ "$response" =~ ^([yY][eE][sS]|[yY])+$ ]]; then
+            cp "$ENV_FILE" .env
+            print_message "$GREEN" "Copied $ENV_FILE to .env"
+        else
+            print_message "$YELLOW" "Keeping existing .env file"
+        fi
+    fi
+else
+    print_message "$YELLOW" "Warning: $ENV_FILE not found. Using default .env"
+fi
+
+print_message "$GREEN" "Environment setup complete!"
+print_message "$YELLOW" "Remember to set your HASS_TOKEN in .env" 

scripts/setup.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Copy template if .env doesn't exist
+if [ ! -f .env ]; then
+    cp .env.example .env
+    echo "Created .env file from template. Please update your credentials!"
+fi
+
+# Validate required variables
+required_vars=("HASS_HOST" "HASS_TOKEN")
+missing_vars=()
+
+for var in "${required_vars[@]}"; do
+    if ! grep -q "^$var=" .env; then
+        missing_vars+=("$var")
+    fi
+done
+
+if [ ${#missing_vars[@]} -ne 0 ]; then
+    echo "ERROR: Missing required variables in .env:"
+    printf '%s\n' "${missing_vars[@]}"
+    exit 1
+fi
+
+# Check Docker version compatibility
+docker_version=$(docker --version | awk '{print $3}' | cut -d',' -f1)
+if [ "$(printf '%s\n' "20.10.0" "$docker_version" | sort -V | head -n1)" != "20.10.0" ]; then
+    echo "ERROR: Docker version 20.10.0 or higher required"
+    exit 1
+fi
+
+echo "Environment validation successful" 

search/scripts/start_mcp.cmd

@@ -0,0 +1,21 @@
+@echo off
+setlocal
+
+:: Set environment variables
+set NODE_ENV=production
+
+:: Change to the script's directory
+cd /d "%~dp0"
+cd ..
+
+:: Start the MCP server
+echo Starting Home Assistant MCP Server...
+bun run start --port 8080
+
+if errorlevel 1 (
+    echo Error starting MCP server
+    pause
+    exit /b 1
+)
+
+pause 

smithery.yaml

@@ -0,0 +1,261 @@
+# Smithery configuration file: https://smithery.ai/docs/config#smitheryyaml
+
+startCommand:
+  type: stdio
+  configSchema:
+    # JSON Schema defining the configuration options for the MCP.
+    type: object
+    required:
+      - hassToken
+    properties:
+      hassToken:
+        type: string
+        description: The token for connecting to Home Assistant API.
+      hassHost:
+        type: string
+        default: http://homeassistant.local:8123
+        description: The host for connecting to Home Assistant API.
+      hassSocketUrl:
+        type: string
+        default: ws://homeassistant.local:8123
+        description: The socket URL for connecting to Home Assistant API.
+      mcp-port:
+        type: number
+        default: 7123
+        description: The port on which the MCP server will run.
+      debug:
+        type: boolean
+        description: The debug mode for the MCP server.
+  commandFunction:
+    # A function that produces the CLI command to start the MCP on stdio.
+    |-
+    config => ({
+      command: 'bun', 
+      args: ['--smol', 'run', 'start'], 
+      env: { 
+        HASS_TOKEN: config.hassToken,
+        HASS_HOST: config.hassHost || process.env.HASS_HOST,
+        HASS_SOCKET_URL: config.hassSocketUrl || process.env.HASS_SOCKET_URL,
+        PORT: config.port.toString(),
+        DEBUG: config.debug !== undefined ? config.debug.toString() : process.env.DEBUG || 'false'
+      }
+    })
+
+# Define the tools that this MCP server provides
+tools:
+  - name: list_devices
+    description: List all devices connected to Home Assistant
+    parameters:
+      type: object
+      properties:
+        domain:
+          type: string
+          enum:
+            - light
+            - climate
+            - alarm_control_panel
+            - cover
+            - switch
+            - contact
+            - media_player
+            - fan
+            - lock
+            - vacuum
+            - scene
+            - script
+            - camera
+        area:
+          type: string
+        floor:
+          type: string
+      required: []
+
+  - name: control
+    description: Control Home Assistant entities (lights, climate, etc.)
+    parameters:
+      type: object
+      properties:
+        command:
+          type: string
+          enum:
+            - turn_on
+            - turn_off
+            - toggle
+            - open
+            - close
+            - stop
+            - set_position
+            - set_tilt_position
+            - set_temperature
+            - set_hvac_mode
+            - set_fan_mode
+            - set_humidity
+        entity_id:
+          type: string
+        state:
+          type: string
+        brightness:
+          type: number
+        color_temp:
+          type: number
+        rgb_color:
+          type: array
+          items:
+            type: number
+        position:
+          type: number
+        tilt_position:
+          type: number
+        temperature:
+          type: number
+        target_temp_high:
+          type: number
+        target_temp_low:
+          type: number
+        hvac_mode:
+          type: string
+        fan_mode:
+          type: string
+        humidity:
+          type: number
+      required:
+        - command
+        - entity_id
+
+  - name: history
+    description: Retrieve historical data for Home Assistant entities
+    parameters:
+      type: object
+      properties:
+        entity_id:
+          type: string
+        start_time:
+          type: string
+        end_time:
+          type: string
+        limit:
+          type: number
+      required:
+        - entity_id
+
+  - name: scene
+    description: Activate scenes in Home Assistant
+    parameters:
+      type: object
+      properties:
+        scene_id:
+          type: string
+      required:
+        - scene_id
+
+  - name: notify
+    description: Send notifications through Home Assistant
+    parameters:
+      type: object
+      properties:
+        message:
+          type: string
+        title:
+          type: string
+        target:
+          type: string
+      required:
+        - message
+
+  - name: automation
+    description: Manage Home Assistant automations
+    parameters:
+      type: object
+      properties:
+        action:
+          type: string
+          enum:
+            - trigger
+            - enable
+            - disable
+            - toggle
+            - list
+        automation_id:
+          type: string
+      required:
+        - action
+
+  - name: addon
+    description: Manage Home Assistant add-ons
+    parameters:
+      type: object
+      properties:
+        action:
+          type: string
+          enum:
+            - list
+            - info
+            - start
+            - stop
+            - restart
+            - update
+        addon_slug:
+          type: string
+      required:
+        - action
+
+  - name: package
+    description: Manage Home Assistant HACS packages
+    parameters:
+      type: object
+      properties:
+        action:
+          type: string
+          enum:
+            - list
+            - info
+            - install
+            - uninstall
+            - update
+        package_id:
+          type: string
+      required:
+        - action
+
+  - name: automation_config
+    description: Get or update Home Assistant automation configurations
+    parameters:
+      type: object
+      properties:
+        action:
+          type: string
+          enum:
+            - get
+            - update
+            - create
+            - delete
+        automation_id:
+          type: string
+        config:
+          type: object
+      required:
+        - action
+
+  - name: subscribe_events
+    description: Subscribe to Home Assistant events via SSE
+    parameters:
+      type: object
+      properties:
+        events:
+          type: array
+          items:
+            type: string
+        entity_id:
+          type: string
+        domain:
+          type: string
+      required: []
+
+  - name: get_sse_stats
+    description: Get statistics about SSE connections
+    parameters:
+      type: object
+      properties:
+        detailed:
+          type: boolean
+      required: []

src/__mocks__/@digital-alchemy/hass.ts

@@ -0,0 +1,77 @@
+import { mock } from "bun:test";
+
+export const LIB_HASS = {
+  configuration: {
+    name: "Home Assistant",
+    version: "2024.2.0",
+    location_name: "Home",
+    time_zone: "UTC",
+    components: ["automation", "script", "light", "switch"],
+    unit_system: {
+      temperature: "°C",
+      length: "m",
+      mass: "kg",
+      pressure: "hPa",
+      volume: "L",
+    },
+  },
+  services: {
+    light: {
+      turn_on: mock(() => Promise.resolve()),
+      turn_off: mock(() => Promise.resolve()),
+      toggle: mock(() => Promise.resolve()),
+    },
+    switch: {
+      turn_on: mock(() => Promise.resolve()),
+      turn_off: mock(() => Promise.resolve()),
+      toggle: mock(() => Promise.resolve()),
+    },
+    automation: {
+      trigger: mock(() => Promise.resolve()),
+      turn_on: mock(() => Promise.resolve()),
+      turn_off: mock(() => Promise.resolve()),
+    },
+    script: {
+      turn_on: mock(() => Promise.resolve()),
+      turn_off: mock(() => Promise.resolve()),
+      toggle: mock(() => Promise.resolve()),
+    },
+  },
+  states: {
+    light: {
+      "light.living_room": {
+        state: "on",
+        attributes: {
+          brightness: 255,
+          color_temp: 300,
+          friendly_name: "Living Room Light",
+        },
+      },
+      "light.bedroom": {
+        state: "off",
+        attributes: {
+          friendly_name: "Bedroom Light",
+        },
+      },
+    },
+    switch: {
+      "switch.tv": {
+        state: "off",
+        attributes: {
+          friendly_name: "TV",
+        },
+      },
+    },
+  },
+  events: {
+    subscribe: mock(() => Promise.resolve()),
+    unsubscribe: mock(() => Promise.resolve()),
+    fire: mock(() => Promise.resolve()),
+  },
+  connection: {
+    subscribeEvents: mock(() => Promise.resolve()),
+    subscribeMessage: mock(() => Promise.resolve()),
+    sendMessage: mock(() => Promise.resolve()),
+    close: mock(() => Promise.resolve()),
+  },
+};

src/__mocks__/litemcp.ts

@@ -0,0 +1,61 @@
+export class LiteMCP {
+  name: string;
+  version: string;
+  config: any;
+
+  constructor(config: any = {}) {
+    this.name = "home-assistant";
+    this.version = "1.0.0";
+    this.config = config;
+  }
+
+  async start() {
+    return Promise.resolve();
+  }
+
+  async stop() {
+    return Promise.resolve();
+  }
+
+  async connect() {
+    return Promise.resolve();
+  }
+
+  async disconnect() {
+    return Promise.resolve();
+  }
+
+  async callService(domain: string, service: string, data: any = {}) {
+    return Promise.resolve({ success: true });
+  }
+
+  async getStates() {
+    return Promise.resolve([]);
+  }
+
+  async getState(entityId: string) {
+    return Promise.resolve({
+      entity_id: entityId,
+      state: "unknown",
+      attributes: {},
+      last_changed: new Date().toISOString(),
+      last_updated: new Date().toISOString(),
+    });
+  }
+
+  async setState(entityId: string, state: string, attributes: any = {}) {
+    return Promise.resolve({ success: true });
+  }
+
+  onStateChanged(callback: (event: any) => void) {
+    // Mock implementation
+  }
+
+  onEvent(eventType: string, callback: (event: any) => void) {
+    // Mock implementation
+  }
+}
+
+export const createMCP = (config: any = {}) => {
+  return new LiteMCP(config);
+};

src/__tests__/config.test.ts

@@ -0,0 +1,106 @@
+import { expect, test, describe, beforeEach, afterEach } from 'bun:test';
+import { MCPServerConfigSchema } from '../schemas/config.schema.js';
+
+describe('Configuration Validation', () => {
+    const originalEnv = { ...process.env };
+
+    beforeEach(() => {
+        // Reset environment variables before each test
+        process.env = { ...originalEnv };
+    });
+
+    afterEach(() => {
+        // Restore original environment after each test
+        process.env = originalEnv;
+    });
+
+    test('validates default configuration', () => {
+        const config = MCPServerConfigSchema.parse({});
+        expect(config).toBeDefined();
+        expect(config.port).toBe(3000);
+        expect(config.environment).toBe('development');
+    });
+
+    test('validates custom port', () => {
+        const config = MCPServerConfigSchema.parse({ port: 8080 });
+        expect(config.port).toBe(8080);
+    });
+
+    test('rejects invalid port', () => {
+        expect(() => MCPServerConfigSchema.parse({ port: 0 })).toThrow();
+        expect(() => MCPServerConfigSchema.parse({ port: 70000 })).toThrow();
+    });
+
+    test('validates environment values', () => {
+        expect(() => MCPServerConfigSchema.parse({ environment: 'development' })).not.toThrow();
+        expect(() => MCPServerConfigSchema.parse({ environment: 'production' })).not.toThrow();
+        expect(() => MCPServerConfigSchema.parse({ environment: 'test' })).not.toThrow();
+        expect(() => MCPServerConfigSchema.parse({ environment: 'invalid' })).toThrow();
+    });
+
+    test('validates rate limiting configuration', () => {
+        const config = MCPServerConfigSchema.parse({
+            rateLimit: {
+                maxRequests: 50,
+                maxAuthRequests: 10
+            }
+        });
+        expect(config.rateLimit.maxRequests).toBe(50);
+        expect(config.rateLimit.maxAuthRequests).toBe(10);
+    });
+
+    test('rejects invalid rate limit values', () => {
+        expect(() => MCPServerConfigSchema.parse({
+            rateLimit: {
+                maxRequests: 0,
+                maxAuthRequests: 5
+            }
+        })).toThrow();
+
+        expect(() => MCPServerConfigSchema.parse({
+            rateLimit: {
+                maxRequests: 100,
+                maxAuthRequests: -1
+            }
+        })).toThrow();
+    });
+
+    test('validates execution timeout', () => {
+        const config = MCPServerConfigSchema.parse({ executionTimeout: 5000 });
+        expect(config.executionTimeout).toBe(5000);
+    });
+
+    test('rejects invalid execution timeout', () => {
+        expect(() => MCPServerConfigSchema.parse({ executionTimeout: 500 })).toThrow();
+        expect(() => MCPServerConfigSchema.parse({ executionTimeout: 400000 })).toThrow();
+    });
+
+    test('validates transport settings', () => {
+        const config = MCPServerConfigSchema.parse({
+            useStdioTransport: true,
+            useHttpTransport: false
+        });
+        expect(config.useStdioTransport).toBe(true);
+        expect(config.useHttpTransport).toBe(false);
+    });
+
+    test('validates CORS settings', () => {
+        const config = MCPServerConfigSchema.parse({
+            corsOrigin: 'https://example.com'
+        });
+        expect(config.corsOrigin).toBe('https://example.com');
+    });
+
+    test('validates debug settings', () => {
+        const config = MCPServerConfigSchema.parse({
+            debugMode: true,
+            debugStdio: true,
+            debugHttp: true,
+            silentStartup: false
+        });
+        expect(config.debugMode).toBe(true);
+        expect(config.debugStdio).toBe(true);
+        expect(config.debugHttp).toBe(true);
+        expect(config.silentStartup).toBe(false);
+    });
+}); 

src/__tests__/rate-limit.test.ts

@@ -0,0 +1,85 @@
+import { expect, test, describe, beforeAll, afterAll } from 'bun:test';
+import express from 'express';
+import { apiLimiter, authLimiter } from '../middleware/rate-limit.middleware.js';
+import supertest from 'supertest';
+
+describe('Rate Limiting Middleware', () => {
+    let app: express.Application;
+    let request: supertest.SuperTest<supertest.Test>;
+
+    beforeAll(() => {
+        app = express();
+
+        // Set up test routes with rate limiting
+        app.use('/api', apiLimiter);
+        app.use('/auth', authLimiter);
+
+        // Test endpoints
+        app.get('/api/test', (req, res) => {
+            res.json({ message: 'API test successful' });
+        });
+
+        app.post('/auth/login', (req, res) => {
+            res.json({ message: 'Login successful' });
+        });
+
+        request = supertest(app);
+    });
+
+    test('allows requests within API rate limit', async () => {
+        // Make multiple requests within the limit
+        for (let i = 0; i < 5; i++) {
+            const response = await request.get('/api/test');
+            expect(response.status).toBe(200);
+            expect(response.body.message).toBe('API test successful');
+        }
+    });
+
+    test('enforces API rate limit', async () => {
+        // Make more requests than the limit allows
+        const requests = Array(150).fill(null).map(() =>
+            request.get('/api/test')
+        );
+
+        const responses = await Promise.all(requests);
+
+        // Some requests should be successful, others should be rate limited
+        const successfulRequests = responses.filter(r => r.status === 200);
+        const limitedRequests = responses.filter(r => r.status === 429);
+
+        expect(successfulRequests.length).toBeGreaterThan(0);
+        expect(limitedRequests.length).toBeGreaterThan(0);
+    });
+
+    test('allows requests within auth rate limit', async () => {
+        // Make multiple requests within the limit
+        for (let i = 0; i < 3; i++) {
+            const response = await request.post('/auth/login');
+            expect(response.status).toBe(200);
+            expect(response.body.message).toBe('Login successful');
+        }
+    });
+
+    test('enforces stricter auth rate limit', async () => {
+        // Make more requests than the auth limit allows
+        const requests = Array(10).fill(null).map(() =>
+            request.post('/auth/login')
+        );
+
+        const responses = await Promise.all(requests);
+
+        // Some requests should be successful, others should be rate limited
+        const successfulRequests = responses.filter(r => r.status === 200);
+        const limitedRequests = responses.filter(r => r.status === 429);
+
+        expect(successfulRequests.length).toBeLessThan(10);
+        expect(limitedRequests.length).toBeGreaterThan(0);
+    });
+
+    test('includes rate limit headers', async () => {
+        const response = await request.get('/api/test');
+        expect(response.headers['ratelimit-limit']).toBeDefined();
+        expect(response.headers['ratelimit-remaining']).toBeDefined();
+        expect(response.headers['ratelimit-reset']).toBeDefined();
+    });
+}); 

src/__tests__/security.test.ts

@@ -0,0 +1,169 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import express, { Request, Response } from 'express';
+import request from 'supertest';
+import { SecurityMiddleware } from '../security/enhanced-middleware';
+
+describe('SecurityMiddleware', () => {
+    const app = express();
+
+    // Initialize security middleware
+    SecurityMiddleware.initialize(app);
+
+    // Test routes
+    app.get('/test', (_req: Request, res: Response) => {
+        res.status(200).json({ message: 'Test successful' });
+    });
+
+    app.post('/test', (req: Request, res: Response) => {
+        res.status(200).json(req.body);
+    });
+
+    app.post('/auth/login', (_req: Request, res: Response) => {
+        res.status(200).json({ message: 'Auth successful' });
+    });
+
+    describe('Security Headers', () => {
+        test('should set security headers correctly', async () => {
+            const response = await request(app).get('/test');
+
+            expect(response.status).toBe(200);
+            expect(response.headers['x-frame-options']).toBe('DENY');
+            expect(response.headers['x-xss-protection']).toBe('1; mode=block');
+            expect(response.headers['x-content-type-options']).toBe('nosniff');
+            expect(response.headers['referrer-policy']).toBe('strict-origin-when-cross-origin');
+            expect(response.headers['strict-transport-security']).toBe('max-age=31536000; includeSubDomains; preload');
+            expect(response.headers['x-permitted-cross-domain-policies']).toBe('none');
+            expect(response.headers['cross-origin-embedder-policy']).toBe('require-corp');
+            expect(response.headers['cross-origin-opener-policy']).toBe('same-origin');
+            expect(response.headers['cross-origin-resource-policy']).toBe('same-origin');
+            expect(response.headers['origin-agent-cluster']).toBe('?1');
+            expect(response.headers['x-powered-by']).toBeUndefined();
+        });
+
+        test('should set Content-Security-Policy header correctly', async () => {
+            const response = await request(app).get('/test');
+
+            expect(response.status).toBe(200);
+            expect(response.headers['content-security-policy']).toContain("default-src 'self'");
+            expect(response.headers['content-security-policy']).toContain("script-src 'self' 'unsafe-inline'");
+            expect(response.headers['content-security-policy']).toContain("style-src 'self' 'unsafe-inline'");
+            expect(response.headers['content-security-policy']).toContain("img-src 'self' data: https:");
+            expect(response.headers['content-security-policy']).toContain("font-src 'self'");
+            expect(response.headers['content-security-policy']).toContain("connect-src 'self'");
+            expect(response.headers['content-security-policy']).toContain("frame-ancestors 'none'");
+            expect(response.headers['content-security-policy']).toContain("form-action 'self'");
+        });
+    });
+
+    describe('Request Validation', () => {
+        test('should reject requests with long URLs', async () => {
+            const longUrl = '/test?' + 'x'.repeat(2500);
+            const response = await request(app).get(longUrl);
+            expect(response.status).toBe(413);
+            expect(response.body.error).toBe(true);
+            expect(response.body.message).toContain('URL too long');
+        });
+
+        test('should reject large request bodies', async () => {
+            const largeBody = { data: 'x'.repeat(2 * 1024 * 1024) }; // 2MB
+            const response = await request(app)
+                .post('/test')
+                .set('Content-Type', 'application/json')
+                .send(largeBody);
+            expect(response.status).toBe(413);
+            expect(response.body.error).toBe(true);
+            expect(response.body.message).toContain('Request body too large');
+        });
+
+        test('should require correct content type for POST requests', async () => {
+            const response = await request(app)
+                .post('/test')
+                .set('Content-Type', 'text/plain')
+                .send('test data');
+            expect(response.status).toBe(415);
+            expect(response.body.error).toBe(true);
+            expect(response.body.message).toContain('Content-Type must be application/json');
+        });
+    });
+
+    describe('Input Sanitization', () => {
+        test('should sanitize string input with HTML', async () => {
+            const response = await request(app)
+                .post('/test')
+                .set('Content-Type', 'application/json')
+                .send({ text: '<script>alert("xss")</script>Hello<img src="x" onerror="alert(1)">' });
+            expect(response.status).toBe(200);
+            expect(response.body.text).toBe('Hello');
+        });
+
+        test('should sanitize nested object input', async () => {
+            const response = await request(app)
+                .post('/test')
+                .set('Content-Type', 'application/json')
+                .send({
+                    user: {
+                        name: '<script>alert("xss")</script>John',
+                        bio: '<img src="x" onerror="alert(1)">Developer'
+                    }
+                });
+            expect(response.status).toBe(200);
+            expect(response.body.user.name).toBe('John');
+            expect(response.body.user.bio).toBe('Developer');
+        });
+
+        test('should sanitize array input', async () => {
+            const response = await request(app)
+                .post('/test')
+                .set('Content-Type', 'application/json')
+                .send({
+                    items: [
+                        '<script>alert(1)</script>Hello',
+                        '<img src="x" onerror="alert(1)">World'
+                    ]
+                });
+            expect(response.status).toBe(200);
+            expect(response.body.items[0]).toBe('Hello');
+            expect(response.body.items[1]).toBe('World');
+        });
+    });
+
+    describe('Rate Limiting', () => {
+        beforeEach(() => {
+            SecurityMiddleware.clearRateLimits();
+        });
+
+        test('should enforce regular rate limits', async () => {
+            // Make 50 requests (should succeed)
+            for (let i = 0; i < 50; i++) {
+                const response = await request(app).get('/test');
+                expect(response.status).toBe(200);
+            }
+
+            // 51st request should fail
+            const response = await request(app).get('/test');
+            expect(response.status).toBe(429);
+            expect(response.body.error).toBe(true);
+            expect(response.body.message).toContain('Too many requests');
+        });
+
+        test('should enforce stricter auth rate limits', async () => {
+            // Make 3 auth requests (should succeed)
+            for (let i = 0; i < 3; i++) {
+                const response = await request(app)
+                    .post('/auth/login')
+                    .set('Content-Type', 'application/json')
+                    .send({});
+                expect(response.status).toBe(200);
+            }
+
+            // 4th auth request should fail
+            const response = await request(app)
+                .post('/auth/login')
+                .set('Content-Type', 'application/json')
+                .send({});
+            expect(response.status).toBe(429);
+            expect(response.body.error).toBe(true);
+            expect(response.body.message).toContain('Too many authentication requests');
+        });
+    });
+}); 

src/__tests__/setup.ts

@@ -0,0 +1,143 @@
+import { config } from "dotenv";
+import path from "path";
+import {
+  beforeAll,
+  afterAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  mock,
+  test,
+} from "bun:test";
+
+// Type definitions for mocks
+type MockFn = ReturnType<typeof mock>;
+
+interface MockInstance {
+  mock: {
+    calls: unknown[][];
+    results: unknown[];
+    instances: unknown[];
+    lastCall?: unknown[];
+  };
+}
+
+// Test configuration
+const TEST_CONFIG = {
+  TEST_JWT_SECRET: "test_jwt_secret_key_that_is_at_least_32_chars",
+  TEST_TOKEN: "test_token_that_is_at_least_32_chars_long",
+  TEST_CLIENT_IP: "127.0.0.1",
+};
+
+// Load test environment variables
+config({ path: path.resolve(process.cwd(), ".env.test") });
+
+// Global test setup
+beforeAll(() => {
+  // Set required environment variables
+  process.env.NODE_ENV = "test";
+  process.env.JWT_SECRET = TEST_CONFIG.TEST_JWT_SECRET;
+  process.env.TEST_TOKEN = TEST_CONFIG.TEST_TOKEN;
+
+  // Configure console output for tests
+  if (!process.env.DEBUG) {
+    console.error = mock(() => { });
+    console.warn = mock(() => { });
+    console.log = mock(() => { });
+  }
+});
+
+// Reset mocks between tests
+beforeEach(() => {
+  // Clear all mock function calls
+  const mockFns = Object.values(mock).filter(
+    (value): value is MockFn => typeof value === "function" && "mock" in value,
+  );
+  mockFns.forEach((mockFn) => {
+    if (mockFn.mock) {
+      mockFn.mock.calls = [];
+      mockFn.mock.results = [];
+      mockFn.mock.instances = [];
+      mockFn.mock.lastCall = undefined;
+    }
+  });
+});
+
+// Custom test utilities
+const testUtils = {
+  // Mock WebSocket for SSE tests
+  mockWebSocket: () => ({
+    on: mock(() => { }),
+    send: mock(() => { }),
+    close: mock(() => { }),
+    readyState: 1,
+    OPEN: 1,
+    removeAllListeners: mock(() => { }),
+  }),
+
+  // Mock HTTP response for API tests
+  mockResponse: () => {
+    const res = {
+      status: mock(() => res),
+      json: mock(() => res),
+      send: mock(() => res),
+      end: mock(() => res),
+      setHeader: mock(() => res),
+      writeHead: mock(() => res),
+      write: mock(() => true),
+      removeHeader: mock(() => res),
+    };
+    return res;
+  },
+
+  // Mock HTTP request for API tests
+  mockRequest: (overrides: Record<string, unknown> = {}) => ({
+    headers: { "content-type": "application/json" },
+    body: {},
+    query: {},
+    params: {},
+    ip: TEST_CONFIG.TEST_CLIENT_IP,
+    method: "GET",
+    path: "/api/test",
+    is: mock((type: string) => type === "application/json"),
+    ...overrides,
+  }),
+
+  // Create test client for SSE tests
+  createTestClient: (id = "test-client") => ({
+    id,
+    ip: TEST_CONFIG.TEST_CLIENT_IP,
+    connectedAt: new Date(),
+    send: mock(() => { }),
+    rateLimit: {
+      count: 0,
+      lastReset: Date.now(),
+    },
+    connectionTime: Date.now(),
+  }),
+
+  // Create test event for SSE tests
+  createTestEvent: (type = "test_event", data: unknown = {}) => ({
+    event_type: type,
+    data,
+    origin: "test",
+    time_fired: new Date().toISOString(),
+    context: { id: "test" },
+  }),
+
+  // Create test entity for Home Assistant tests
+  createTestEntity: (entityId = "test.entity", state = "on") => ({
+    entity_id: entityId,
+    state,
+    attributes: {},
+    last_changed: new Date().toISOString(),
+    last_updated: new Date().toISOString(),
+  }),
+
+  // Helper to wait for async operations
+  wait: (ms: number) => new Promise((resolve) => setTimeout(resolve, ms)),
+};
+
+// Export test utilities and Bun test functions
+export { beforeAll, afterAll, beforeEach, describe, expect, it, mock, test, testUtils };

src/ai/endpoints/ai-router.ts

@@ -1,207 +1,234 @@
-import express from 'express';
+import express from "express";
-import { z } from 'zod';
+import { z } from "zod";
-import { NLPProcessor } from '../nlp/processor.js';
+import { NLPProcessor } from "../nlp/processor.js";
-import { AIRateLimit, AIContext, AIResponse, AIError, AIModel } from '../types/index.js';
+import {
-import rateLimit from 'express-rate-limit';
+  AIRateLimit,
+  AIContext,
+  AIResponse,
+  AIError,
+  AIModel,
+} from "../types/index.js";
+import rateLimit from "express-rate-limit";
 
 const router = express.Router();
 const nlpProcessor = new NLPProcessor();
 
 // Rate limiting configuration
 const rateLimitConfig: AIRateLimit = {
-    requests_per_minute: 100,
+  requests_per_minute: 100,
-    requests_per_hour: 1000,
+  requests_per_hour: 1000,
-    concurrent_requests: 10,
+  concurrent_requests: 10,
-    model_specific_limits: {
+  model_specific_limits: {
-        claude: {
+    claude: {
-            requests_per_minute: 100,
+      requests_per_minute: 100,
-            requests_per_hour: 1000
+      requests_per_hour: 1000,
-        },
+    },
-        gpt4: {
+    gpt4: {
-            requests_per_minute: 50,
+      requests_per_minute: 50,
-            requests_per_hour: 500
+      requests_per_hour: 500,
-        },
+    },
-        custom: {
+    custom: {
-            requests_per_minute: 200,
+      requests_per_minute: 200,
-            requests_per_hour: 2000
+      requests_per_hour: 2000,
-        }
+    },
-    }
+  },
 };
 
 // Request validation schemas
 const interpretRequestSchema = z.object({
-    input: z.string(),
+  input: z.string(),
-    context: z.object({
+  context: z.object({
-        user_id: z.string(),
+    user_id: z.string(),
-        session_id: z.string(),
+    session_id: z.string(),
-        timestamp: z.string(),
+    timestamp: z.string(),
-        location: z.string(),
+    location: z.string(),
-        previous_actions: z.array(z.any()),
+    previous_actions: z.array(z.any()),
-        environment_state: z.record(z.any())
+    environment_state: z.record(z.any()),
-    }),
+  }),
-    model: z.enum(['claude', 'gpt4', 'custom']).optional()
+  model: z.enum(["claude", "gpt4", "custom"]).optional(),
 });
 
 // Rate limiters
 const globalLimiter = rateLimit({
-    windowMs: 60 * 1000, // 1 minute
+  windowMs: 60 * 1000, // 1 minute
-    max: rateLimitConfig.requests_per_minute
+  max: rateLimitConfig.requests_per_minute,
 });
 
-const modelSpecificLimiter = (model: string) => rateLimit({
+const modelSpecificLimiter = (model: string) =>
+  rateLimit({
     windowMs: 60 * 1000,
-    max: rateLimitConfig.model_specific_limits[model as AIModel]?.requests_per_minute ||
+    max:
-        rateLimitConfig.requests_per_minute
+      rateLimitConfig.model_specific_limits[model as AIModel]
-});
+        ?.requests_per_minute || rateLimitConfig.requests_per_minute,
+  });
 
 // Error handler middleware
 const errorHandler = (
-    error: Error,
+  error: Error,
-    req: express.Request,
+  req: express.Request,
-    res: express.Response,
+  res: express.Response,
-    next: express.NextFunction
+  next: express.NextFunction,
 ) => {
-    const aiError: AIError = {
+  const aiError: AIError = {
-        code: 'PROCESSING_ERROR',
+    code: "PROCESSING_ERROR",
-        message: error.message,
+    message: error.message,
-        suggestion: 'Please try again with a different command format',
+    suggestion: "Please try again with a different command format",
-        recovery_options: [
+    recovery_options: [
-            'Simplify your command',
+      "Simplify your command",
-            'Use standard command patterns',
+      "Use standard command patterns",
-            'Check device names and parameters'
+      "Check device names and parameters",
-        ],
+    ],
-        context: req.body.context
+    context: req.body.context,
-    };
+  };
 
-    res.status(500).json({ error: aiError });
+  res.status(500).json({ error: aiError });
 };
 
 // Endpoints
 router.post(
-    '/interpret',
+  "/interpret",
-    globalLimiter,
+  globalLimiter,
-    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+  async (
-        try {
+    req: express.Request,
-            const { input, context, model = 'claude' } = interpretRequestSchema.parse(req.body);
+    res: express.Response,
+    next: express.NextFunction,
+  ) => {
+    try {
+      const {
+        input,
+        context,
+        model = "claude",
+      } = interpretRequestSchema.parse(req.body);
 
-            // Apply model-specific rate limiting
+      // Apply model-specific rate limiting
-            modelSpecificLimiter(model)(req, res, async () => {
+      modelSpecificLimiter(model)(req, res, async () => {
-                const { intent, confidence, error } = await nlpProcessor.processCommand(input, context);
+        const { intent, confidence, error } = await nlpProcessor.processCommand(
+          input,
+          context,
+        );
 
-                if (error) {
+        if (error) {
-                    return res.status(400).json({ error });
+          return res.status(400).json({ error });
-                }
-
-                const isValid = await nlpProcessor.validateIntent(intent, confidence);
-
-                if (!isValid) {
-                    const suggestions = await nlpProcessor.suggestCorrections(input, {
-                        code: 'INVALID_INTENT',
-                        message: 'Could not understand the command with high confidence',
-                        suggestion: 'Please try rephrasing your command',
-                        recovery_options: [],
-                        context
-                    });
-
-                    return res.status(400).json({
-                        error: {
-                            code: 'INVALID_INTENT',
-                            message: 'Could not understand the command with high confidence',
-                            suggestion: 'Please try rephrasing your command',
-                            recovery_options: suggestions,
-                            context
-                        }
-                    });
-                }
-
-                const response: AIResponse = {
-                    natural_language: `I'll ${intent.action} the ${intent.target.split('.').pop()}`,
-                    structured_data: {
-                        success: true,
-                        action_taken: intent.action,
-                        entities_affected: [intent.target],
-                        state_changes: intent.parameters
-                    },
-                    next_suggestions: [
-                        'Would you like to adjust any settings?',
-                        'Should I perform this action in other rooms?',
-                        'Would you like to schedule this action?'
-                    ],
-                    confidence,
-                    context
-                };
-
-                res.json(response);
-            });
-        } catch (error) {
-            next(error);
         }
+
+        const isValid = await nlpProcessor.validateIntent(intent, confidence);
+
+        if (!isValid) {
+          const suggestions = await nlpProcessor.suggestCorrections(input, {
+            code: "INVALID_INTENT",
+            message: "Could not understand the command with high confidence",
+            suggestion: "Please try rephrasing your command",
+            recovery_options: [],
+            context,
+          });
+
+          return res.status(400).json({
+            error: {
+              code: "INVALID_INTENT",
+              message: "Could not understand the command with high confidence",
+              suggestion: "Please try rephrasing your command",
+              recovery_options: suggestions,
+              context,
+            },
+          });
+        }
+
+        const response: AIResponse = {
+          natural_language: `I'll ${intent.action} the ${intent.target.split(".").pop()}`,
+          structured_data: {
+            success: true,
+            action_taken: intent.action,
+            entities_affected: [intent.target],
+            state_changes: intent.parameters,
+          },
+          next_suggestions: [
+            "Would you like to adjust any settings?",
+            "Should I perform this action in other rooms?",
+            "Would you like to schedule this action?",
+          ],
+          confidence,
+          context,
+        };
+
+        res.json(response);
+      });
+    } catch (error) {
+      next(error);
     }
+  },
 );
 
 router.post(
-    '/execute',
+  "/execute",
-    globalLimiter,
+  globalLimiter,
-    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+  async (
-        try {
+    req: express.Request,
-            const { intent, context, model = 'claude' } = req.body;
+    res: express.Response,
+    next: express.NextFunction,
+  ) => {
+    try {
+      const { intent, context, model = "claude" } = req.body;
 
-            // Apply model-specific rate limiting
+      // Apply model-specific rate limiting
-            modelSpecificLimiter(model)(req, res, async () => {
+      modelSpecificLimiter(model)(req, res, async () => {
-                // Execute the intent through Home Assistant
+        // Execute the intent through Home Assistant
-                // This would integrate with your existing Home Assistant service
+        // This would integrate with your existing Home Assistant service
 
-                const response: AIResponse = {
+        const response: AIResponse = {
-                    natural_language: `Successfully executed ${intent.action} on ${intent.target}`,
+          natural_language: `Successfully executed ${intent.action} on ${intent.target}`,
-                    structured_data: {
+          structured_data: {
-                        success: true,
+            success: true,
-                        action_taken: intent.action,
+            action_taken: intent.action,
-                        entities_affected: [intent.target],
+            entities_affected: [intent.target],
-                        state_changes: intent.parameters
+            state_changes: intent.parameters,
-                    },
+          },
-                    next_suggestions: [
+          next_suggestions: [
-                        'Would you like to verify the state?',
+            "Would you like to verify the state?",
-                        'Should I perform any related actions?',
+            "Should I perform any related actions?",
-                        'Would you like to undo this action?'
+            "Would you like to undo this action?",
-                    ],
+          ],
-                    confidence: { overall: 1, intent: 1, entities: 1, context: 1 },
+          confidence: { overall: 1, intent: 1, entities: 1, context: 1 },
-                    context
+          context,
-                };
+        };
 
-                res.json(response);
+        res.json(response);
-            });
+      });
-        } catch (error) {
+    } catch (error) {
-            next(error);
+      next(error);
-        }
     }
+  },
 );
 
 router.get(
-    '/suggestions',
+  "/suggestions",
-    globalLimiter,
+  globalLimiter,
-    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+  async (
-        try {
+    req: express.Request,
-            const { context, model = 'claude' } = req.body;
+    res: express.Response,
+    next: express.NextFunction,
+  ) => {
+    try {
+      const { context, model = "claude" } = req.body;
 
-            // Apply model-specific rate limiting
+      // Apply model-specific rate limiting
-            modelSpecificLimiter(model)(req, res, async () => {
+      modelSpecificLimiter(model)(req, res, async () => {
-                // Generate context-aware suggestions
+        // Generate context-aware suggestions
-                const suggestions = [
+        const suggestions = [
-                    'Turn on the lights in the living room',
+          "Turn on the lights in the living room",
-                    'Set the temperature to 72 degrees',
+          "Set the temperature to 72 degrees",
-                    'Show me the current state of all devices',
+          "Show me the current state of all devices",
-                    'Start the evening routine'
+          "Start the evening routine",
-                ];
+        ];
 
-                res.json({ suggestions });
+        res.json({ suggestions });
-            });
+      });
-        } catch (error) {
+    } catch (error) {
-            next(error);
+      next(error);
-        }
     }
+  },
 );
 
 // Apply error handler
 router.use(errorHandler);
 
-export default router; 
+export default router;

src/ai/nlp/context-analyzer.ts

@@ -1,135 +1,146 @@
-import { AIContext, AIIntent } from '../types/index.js';
+import { AIContext, AIIntent } from "../types/index.js";
 
 interface ContextAnalysis {
-    confidence: number;
+  confidence: number;
-    relevant_params: Record<string, any>;
+  relevant_params: Record<string, any>;
 }
 
 interface ContextRule {
-    condition: (context: AIContext, intent: AIIntent) => boolean;
+  condition: (context: AIContext, intent: AIIntent) => boolean;
-    relevance: number;
+  relevance: number;
-    params?: (context: AIContext) => Record<string, any>;
+  params?: (context: AIContext) => Record<string, any>;
 }
 
 export class ContextAnalyzer {
-    private contextRules: ContextRule[];
+  private contextRules: ContextRule[];
 
-    constructor() {
+  constructor() {
-        this.contextRules = [
+    this.contextRules = [
-            // Location-based context
+      // Location-based context
-            {
+      {
-                condition: (context, intent) =>
+        condition: (context, intent) =>
-                    Boolean(context.location && intent.target.includes(context.location.toLowerCase())),
+          Boolean(
-                relevance: 0.8,
+            context.location &&
-                params: (context) => ({ location: context.location })
+              intent.target.includes(context.location.toLowerCase()),
-            },
+          ),
+        relevance: 0.8,
+        params: (context) => ({ location: context.location }),
+      },
 
-            // Time-based context
+      // Time-based context
-            {
+      {
-                condition: (context) => {
+        condition: (context) => {
-                    const hour = new Date(context.timestamp).getHours();
+          const hour = new Date(context.timestamp).getHours();
-                    return hour >= 0 && hour <= 23;
+          return hour >= 0 && hour <= 23;
-                },
+        },
-                relevance: 0.6,
+        relevance: 0.6,
-                params: (context) => ({
+        params: (context) => ({
-                    time_of_day: this.getTimeOfDay(new Date(context.timestamp))
+          time_of_day: this.getTimeOfDay(new Date(context.timestamp)),
-                })
+        }),
-            },
+      },
 
-            // Previous action context
+      // Previous action context
-            {
+      {
-                condition: (context, intent) => {
+        condition: (context, intent) => {
-                    const recentActions = context.previous_actions.slice(-3);
+          const recentActions = context.previous_actions.slice(-3);
-                    return recentActions.some(action =>
+          return recentActions.some(
-                        action.target === intent.target ||
+            (action) =>
-                        action.action === intent.action
+              action.target === intent.target ||
-                    );
+              action.action === intent.action,
-                },
+          );
-                relevance: 0.7,
+        },
-                params: (context) => ({
+        relevance: 0.7,
-                    recent_action: context.previous_actions[context.previous_actions.length - 1]
+        params: (context) => ({
-                })
+          recent_action:
-            },
+            context.previous_actions[context.previous_actions.length - 1],
+        }),
+      },
 
-            // Environment state context
+      // Environment state context
-            {
+      {
-                condition: (context, intent) => {
+        condition: (context, intent) => {
-                    return Object.keys(context.environment_state).some(key =>
+          return Object.keys(context.environment_state).some(
-                        intent.target.includes(key) ||
+            (key) =>
-                        intent.parameters[key] !== undefined
+              intent.target.includes(key) ||
-                    );
+              intent.parameters[key] !== undefined,
-                },
+          );
-                relevance: 0.9,
+        },
-                params: (context) => ({ environment: context.environment_state })
+        relevance: 0.9,
-            }
+        params: (context) => ({ environment: context.environment_state }),
-        ];
+      },
+    ];
+  }
+
+  async analyze(
+    intent: AIIntent,
+    context: AIContext,
+  ): Promise<ContextAnalysis> {
+    let totalConfidence = 0;
+    let relevantParams: Record<string, any> = {};
+    let applicableRules = 0;
+
+    for (const rule of this.contextRules) {
+      if (rule.condition(context, intent)) {
+        totalConfidence += rule.relevance;
+        applicableRules++;
+
+        if (rule.params) {
+          relevantParams = {
+            ...relevantParams,
+            ...rule.params(context),
+          };
+        }
+      }
     }
 
-    async analyze(intent: AIIntent, context: AIContext): Promise<ContextAnalysis> {
+    // Calculate normalized confidence
-        let totalConfidence = 0;
+    const confidence =
-        let relevantParams: Record<string, any> = {};
+      applicableRules > 0 ? totalConfidence / applicableRules : 0.5; // Default confidence if no rules apply
-        let applicableRules = 0;
 
-        for (const rule of this.contextRules) {
+    return {
-            if (rule.condition(context, intent)) {
+      confidence,
-                totalConfidence += rule.relevance;
+      relevant_params: relevantParams,
-                applicableRules++;
+    };
+  }
 
-                if (rule.params) {
+  private getTimeOfDay(date: Date): string {
-                    relevantParams = {
+    const hour = date.getHours();
-                        ...relevantParams,
-                        ...rule.params(context)
-                    };
-                }
-            }
-        }
 
-        // Calculate normalized confidence
+    if (hour >= 5 && hour < 12) return "morning";
-        const confidence = applicableRules > 0
+    if (hour >= 12 && hour < 17) return "afternoon";
-            ? totalConfidence / applicableRules
+    if (hour >= 17 && hour < 22) return "evening";
-            : 0.5; // Default confidence if no rules apply
+    return "night";
+  }
 
-        return {
+  async updateContextRules(newRules: ContextRule[]): Promise<void> {
-            confidence,
+    this.contextRules = [...this.contextRules, ...newRules];
-            relevant_params: relevantParams
+  }
-        };
+
+  async validateContext(context: AIContext): Promise<boolean> {
+    // Validate required context fields
+    if (!context.timestamp || !context.user_id || !context.session_id) {
+      return false;
     }
 
-    private getTimeOfDay(date: Date): string {
+    // Validate timestamp format
-        const hour = date.getHours();
+    const timestamp = new Date(context.timestamp);
-
+    if (isNaN(timestamp.getTime())) {
-        if (hour >= 5 && hour < 12) return 'morning';
+      return false;
-        if (hour >= 12 && hour < 17) return 'afternoon';
-        if (hour >= 17 && hour < 22) return 'evening';
-        return 'night';
     }
 
-    async updateContextRules(newRules: ContextRule[]): Promise<void> {
+    // Validate previous actions array
-        this.contextRules = [...this.contextRules, ...newRules];
+    if (!Array.isArray(context.previous_actions)) {
+      return false;
     }
 
-    async validateContext(context: AIContext): Promise<boolean> {
+    // Validate environment state
-        // Validate required context fields
+    if (
-        if (!context.timestamp || !context.user_id || !context.session_id) {
+      typeof context.environment_state !== "object" ||
-            return false;
+      context.environment_state === null
-        }
+    ) {
-
+      return false;
-        // Validate timestamp format
-        const timestamp = new Date(context.timestamp);
-        if (isNaN(timestamp.getTime())) {
-            return false;
-        }
-
-        // Validate previous actions array
-        if (!Array.isArray(context.previous_actions)) {
-            return false;
-        }
-
-        // Validate environment state
-        if (typeof context.environment_state !== 'object' || context.environment_state === null) {
-            return false;
-        }
-
-        return true;
     }
-} 
+
+    return true;
+  }
+}

src/ai/nlp/entity-extractor.ts

@@ -1,103 +1,115 @@
-import { AIContext } from '../types/index.js';
+import { AIContext } from "../types/index.js";
 
 interface ExtractedEntities {
-    primary_target: string;
+  primary_target: string;
-    parameters: Record<string, any>;
+  parameters: Record<string, any>;
-    confidence: number;
+  confidence: number;
 }
 
 export class EntityExtractor {
-    private deviceNameMap: Map<string, string>;
+  private deviceNameMap: Map<string, string>;
-    private parameterPatterns: Map<string, RegExp>;
+  private parameterPatterns: Map<string, RegExp>;
 
-    constructor() {
+  constructor() {
-        this.deviceNameMap = new Map();
+    this.deviceNameMap = new Map();
-        this.parameterPatterns = new Map();
+    this.parameterPatterns = new Map();
-        this.initializePatterns();
+    this.initializePatterns();
-    }
+  }
 
-    private initializePatterns(): void {
+  private initializePatterns(): void {
-        // Device name variations
+    // Device name variations
-        this.deviceNameMap.set('living room light', 'light.living_room');
+    this.deviceNameMap.set("living room light", "light.living_room");
-        this.deviceNameMap.set('kitchen light', 'light.kitchen');
+    this.deviceNameMap.set("kitchen light", "light.kitchen");
-        this.deviceNameMap.set('bedroom light', 'light.bedroom');
+    this.deviceNameMap.set("bedroom light", "light.bedroom");
 
-        // Parameter patterns
+    // Parameter patterns
-        this.parameterPatterns.set('brightness', /(\d+)\s*(%|percent)|bright(ness)?\s+(\d+)/i);
+    this.parameterPatterns.set(
-        this.parameterPatterns.set('temperature', /(\d+)\s*(degrees?|°)[CF]?/i);
+      "brightness",
-        this.parameterPatterns.set('color', /(red|green|blue|white|warm|cool)/i);
+      /(\d+)\s*(%|percent)|bright(ness)?\s+(\d+)/i,
-    }
+    );
+    this.parameterPatterns.set("temperature", /(\d+)\s*(degrees?|°)[CF]?/i);
+    this.parameterPatterns.set("color", /(red|green|blue|white|warm|cool)/i);
+  }
 
-    async extract(input: string): Promise<ExtractedEntities> {
+  async extract(input: string): Promise<ExtractedEntities> {
-        const entities: ExtractedEntities = {
+    const entities: ExtractedEntities = {
-            primary_target: '',
+      primary_target: "",
-            parameters: {},
+      parameters: {},
-            confidence: 0
+      confidence: 0,
-        };
+    };
 
-        try {
+    try {
-            // Find device name
+      // Find device name
-            for (const [key, value] of this.deviceNameMap) {
+      for (const [key, value] of this.deviceNameMap) {
-                if (input.toLowerCase().includes(key)) {
+        if (input.toLowerCase().includes(key)) {
-                    entities.primary_target = value;
+          entities.primary_target = value;
-                    break;
+          break;
-                }
-            }
-
-            // Extract parameters
-            for (const [param, pattern] of this.parameterPatterns) {
-                const match = input.match(pattern);
-                if (match) {
-                    entities.parameters[param] = this.normalizeParameterValue(param, match[1]);
-                }
-            }
-
-            // Calculate confidence based on matches
-            entities.confidence = this.calculateConfidence(entities, input);
-
-            return entities;
-        } catch (error) {
-            console.error('Entity extraction error:', error);
-            return {
-                primary_target: '',
-                parameters: {},
-                confidence: 0
-            };
         }
-    }
+      }
 
-    private normalizeParameterValue(parameter: string, value: string): number | string {
+      // Extract parameters
-        switch (parameter) {
+      for (const [param, pattern] of this.parameterPatterns) {
-            case 'brightness':
+        const match = input.match(pattern);
-                return Math.min(100, Math.max(0, parseInt(value)));
+        if (match) {
-            case 'temperature':
+          entities.parameters[param] = this.normalizeParameterValue(
-                return parseInt(value);
+            param,
-            case 'color':
+            match[1],
-                return value.toLowerCase();
+          );
-            default:
-                return value;
         }
+      }
+
+      // Calculate confidence based on matches
+      entities.confidence = this.calculateConfidence(entities, input);
+
+      return entities;
+    } catch (error) {
+      console.error("Entity extraction error:", error);
+      return {
+        primary_target: "",
+        parameters: {},
+        confidence: 0,
+      };
+    }
+  }
+
+  private normalizeParameterValue(
+    parameter: string,
+    value: string,
+  ): number | string {
+    switch (parameter) {
+      case "brightness":
+        return Math.min(100, Math.max(0, parseInt(value)));
+      case "temperature":
+        return parseInt(value);
+      case "color":
+        return value.toLowerCase();
+      default:
+        return value;
+    }
+  }
+
+  private calculateConfidence(
+    entities: ExtractedEntities,
+    input: string,
+  ): number {
+    let confidence = 0;
+
+    // Device confidence
+    if (entities.primary_target) {
+      confidence += 0.5;
     }
 
-    private calculateConfidence(entities: ExtractedEntities, input: string): number {
+    // Parameter confidence
-        let confidence = 0;
+    const paramCount = Object.keys(entities.parameters).length;
+    confidence += paramCount * 0.25;
 
-        // Device confidence
+    // Normalize confidence to 0-1 range
-        if (entities.primary_target) {
+    return Math.min(1, confidence);
-            confidence += 0.5;
+  }
-        }
 
-        // Parameter confidence
+  async updateDeviceMap(devices: Record<string, string>): Promise<void> {
-        const paramCount = Object.keys(entities.parameters).length;
+    for (const [key, value] of Object.entries(devices)) {
-        confidence += paramCount * 0.25;
+      this.deviceNameMap.set(key, value);
-
-        // Normalize confidence to 0-1 range
-        return Math.min(1, confidence);
     }
-
+  }
-    async updateDeviceMap(devices: Record<string, string>): Promise<void> {
+}
-        for (const [key, value] of Object.entries(devices)) {
-            this.deviceNameMap.set(key, value);
-        }
-    }
-} 

src/ai/nlp/intent-classifier.ts

@@ -1,177 +1,212 @@
 interface ClassifiedIntent {
-    action: string;
+  action: string;
-    target: string;
+  target: string;
-    confidence: number;
+  confidence: number;
-    parameters: Record<string, any>;
+  parameters: Record<string, any>;
-    raw_input: string;
+  raw_input: string;
 }
 
 interface ActionPattern {
-    action: string;
+  action: string;
-    patterns: RegExp[];
+  patterns: RegExp[];
-    parameters?: string[];
+  parameters?: string[];
 }
 
 export class IntentClassifier {
-    private actionPatterns: ActionPattern[];
+  private actionPatterns: ActionPattern[];
 
-    constructor() {
+  constructor() {
-        this.actionPatterns = [
+    this.actionPatterns = [
-            {
+      {
-                action: 'turn_on',
+        action: "turn_on",
-                patterns: [
+        patterns: [/turn\s+on/i, /switch\s+on/i, /enable/i, /activate/i],
-                    /turn\s+on/i,
+      },
-                    /switch\s+on/i,
+      {
-                    /enable/i,
+        action: "turn_off",
-                    /activate/i
+        patterns: [/turn\s+off/i, /switch\s+off/i, /disable/i, /deactivate/i],
-                ]
+      },
-            },
+      {
-            {
+        action: "set",
-                action: 'turn_off',
+        patterns: [
-                patterns: [
+          /set\s+(?:the\s+)?(.+)\s+to/i,
-                    /turn\s+off/i,
+          /change\s+(?:the\s+)?(.+)\s+to/i,
-                    /switch\s+off/i,
+          /adjust\s+(?:the\s+)?(.+)\s+to/i,
-                    /disable/i,
+        ],
-                    /deactivate/i
+        parameters: ["brightness", "temperature", "color"],
-                ]
+      },
-            },
+      {
-            {
+        action: "query",
-                action: 'set',
+        patterns: [
-                patterns: [
+          /what\s+is/i,
-                    /set\s+(?:the\s+)?(.+)\s+to/i,
+          /get\s+(?:the\s+)?(.+)/i,
-                    /change\s+(?:the\s+)?(.+)\s+to/i,
+          /show\s+(?:the\s+)?(.+)/i,
-                    /adjust\s+(?:the\s+)?(.+)\s+to/i
+          /tell\s+me/i,
-                ],
+        ],
-                parameters: ['brightness', 'temperature', 'color']
+      },
-            },
+    ];
-            {
+  }
-                action: 'query',
-                patterns: [
-                    /what\s+is/i,
-                    /get\s+(?:the\s+)?(.+)/i,
-                    /show\s+(?:the\s+)?(.+)/i,
-                    /tell\s+me/i
-                ]
-            }
-        ];
-    }
 
-    async classify(
+  async classify(
-        input: string,
+    input: string,
-        extractedEntities: { parameters: Record<string, any>; primary_target: string }
+    extractedEntities: {
-    ): Promise<ClassifiedIntent> {
+      parameters: Record<string, any>;
-        let bestMatch: ClassifiedIntent = {
+      primary_target: string;
-            action: '',
+    },
-            target: '',
+  ): Promise<ClassifiedIntent> {
-            confidence: 0,
+    let bestMatch: ClassifiedIntent = {
-            parameters: {},
+      action: "",
-            raw_input: input
+      target: "",
-        };
+      confidence: 0,
+      parameters: {},
+      raw_input: input,
+    };
 
-        for (const actionPattern of this.actionPatterns) {
+    for (const actionPattern of this.actionPatterns) {
-            for (const pattern of actionPattern.patterns) {
+      for (const pattern of actionPattern.patterns) {
-                const match = input.match(pattern);
+        const match = input.match(pattern);
-                if (match) {
+        if (match) {
-                    const confidence = this.calculateConfidence(match[0], input);
+          const confidence = this.calculateConfidence(match[0], input);
-                    if (confidence > bestMatch.confidence) {
+          if (confidence > bestMatch.confidence) {
-                        bestMatch = {
+            bestMatch = {
-                            action: actionPattern.action,
+              action: actionPattern.action,
-                            target: extractedEntities.primary_target,
+              target: extractedEntities.primary_target,
-                            confidence,
+              confidence,
-                            parameters: this.extractActionParameters(actionPattern, match, extractedEntities),
+              parameters: this.extractActionParameters(
-                            raw_input: input
+                actionPattern,
-                        };
+                match,
-                    }
+                extractedEntities,
-                }
+              ),
-            }
+              raw_input: input,
-        }
-
-        // If no match found, try to infer from context
-        if (!bestMatch.action) {
-            bestMatch = this.inferFromContext(input, extractedEntities);
-        }
-
-        return bestMatch;
-    }
-
-    private calculateConfidence(match: string, input: string): number {
-        // Base confidence from match length relative to input length
-        const lengthRatio = match.length / input.length;
-        let confidence = lengthRatio * 0.7;
-
-        // Boost confidence for exact matches
-        if (match.toLowerCase() === input.toLowerCase()) {
-            confidence += 0.3;
-        }
-
-        // Additional confidence for specific keywords
-        const keywords = ['please', 'can you', 'would you'];
-        for (const keyword of keywords) {
-            if (input.toLowerCase().includes(keyword)) {
-                confidence += 0.1;
-            }
-        }
-
-        return Math.min(1, confidence);
-    }
-
-    private extractActionParameters(
-        actionPattern: ActionPattern,
-        match: RegExpMatchArray,
-        extractedEntities: { parameters: Record<string, any>; primary_target: string }
-    ): Record<string, any> {
-        const parameters: Record<string, any> = {};
-
-        // Copy relevant extracted entities
-        if (actionPattern.parameters) {
-            for (const param of actionPattern.parameters) {
-                if (extractedEntities.parameters[param] !== undefined) {
-                    parameters[param] = extractedEntities.parameters[param];
-                }
-            }
-        }
-
-        // Extract additional parameters from match groups
-        if (match.length > 1 && match[1]) {
-            parameters.raw_parameter = match[1].trim();
-        }
-
-        return parameters;
-    }
-
-    private inferFromContext(
-        input: string,
-        extractedEntities: { parameters: Record<string, any>; primary_target: string }
-    ): ClassifiedIntent {
-        // Default to 'set' action if parameters are present
-        if (Object.keys(extractedEntities.parameters).length > 0) {
-            return {
-                action: 'set',
-                target: extractedEntities.primary_target,
-                confidence: 0.5,
-                parameters: extractedEntities.parameters,
-                raw_input: input
             };
+          }
         }
-
+      }
-        // Default to 'query' for question-like inputs
-        if (input.match(/^(what|when|where|who|how|why)/i)) {
-            return {
-                action: 'query',
-                target: extractedEntities.primary_target || 'system',
-                confidence: 0.6,
-                parameters: {},
-                raw_input: input
-            };
-        }
-
-        // Fallback with low confidence
-        return {
-            action: 'unknown',
-            target: extractedEntities.primary_target || 'system',
-            confidence: 0.3,
-            parameters: {},
-            raw_input: input
-        };
     }
-} 
+
+    // If no match found, try to infer from context
+    if (!bestMatch.action) {
+      bestMatch = this.inferFromContext(input, extractedEntities);
+    }
+
+    return bestMatch;
+  }
+
+  private calculateConfidence(match: string, input: string): number {
+    // Base confidence from match specificity
+    const matchWords = match.toLowerCase().split(/\s+/);
+    const inputWords = input.toLowerCase().split(/\s+/);
+
+    // Calculate match ratio with more aggressive scoring
+    const matchRatio = matchWords.length / Math.max(inputWords.length, 1);
+    let confidence = matchRatio * 0.8;
+
+    // Boost for exact matches
+    if (match.toLowerCase() === input.toLowerCase()) {
+      confidence = 1.0;
+    }
+
+    // Boost for specific keywords and patterns
+    const boostKeywords = [
+      "please", "can you", "would you", "kindly",
+      "could you", "might you", "turn on", "switch on",
+      "enable", "activate", "turn off", "switch off",
+      "disable", "deactivate", "set", "change", "adjust"
+    ];
+
+    const matchedKeywords = boostKeywords.filter(keyword =>
+      input.toLowerCase().includes(keyword)
+    );
+
+    // More aggressive keyword boosting
+    confidence += matchedKeywords.length * 0.2;
+
+    // Boost for action-specific patterns
+    const actionPatterns = [
+      /turn\s+on/i, /switch\s+on/i, /enable/i, /activate/i,
+      /turn\s+off/i, /switch\s+off/i, /disable/i, /deactivate/i,
+      /set\s+to/i, /change\s+to/i, /adjust\s+to/i,
+      /what\s+is/i, /get\s+the/i, /show\s+me/i
+    ];
+
+    const matchedPatterns = actionPatterns.filter(pattern =>
+      pattern.test(input)
+    );
+
+    confidence += matchedPatterns.length * 0.15;
+
+    // Penalize very short or very generic matches
+    if (matchWords.length <= 1) {
+      confidence *= 0.5;
+    }
+
+    // Ensure confidence is between 0.5 and 1
+    return Math.min(1, Math.max(0.6, confidence));
+  }
+
+  private extractActionParameters(
+    actionPattern: ActionPattern,
+    match: RegExpMatchArray,
+    extractedEntities: {
+      parameters: Record<string, any>;
+      primary_target: string;
+    },
+  ): Record<string, any> {
+    const parameters: Record<string, any> = {};
+
+    // Copy relevant extracted entities
+    if (actionPattern.parameters) {
+      for (const param of actionPattern.parameters) {
+        if (extractedEntities.parameters[param] !== undefined) {
+          parameters[param] = extractedEntities.parameters[param];
+        }
+      }
+    }
+
+    // Only add raw_parameter for non-set actions
+    if (actionPattern.action !== 'set' && match.length > 1 && match[1]) {
+      parameters.raw_parameter = match[1].trim();
+    }
+
+    return parameters;
+  }
+
+  private inferFromContext(
+    input: string,
+    extractedEntities: {
+      parameters: Record<string, any>;
+      primary_target: string;
+    },
+  ): ClassifiedIntent {
+    // Default to 'set' action if parameters are present
+    if (Object.keys(extractedEntities.parameters).length > 0) {
+      return {
+        action: "set",
+        target: extractedEntities.primary_target,
+        confidence: 0.5,
+        parameters: extractedEntities.parameters,
+        raw_input: input,
+      };
+    }
+
+    // Default to 'query' for question-like inputs
+    if (input.match(/^(what|when|where|who|how|why)/i)) {
+      return {
+        action: "query",
+        target: extractedEntities.primary_target || "system",
+        confidence: 0.6,
+        parameters: {},
+        raw_input: input,
+      };
+    }
+
+    // Fallback with low confidence
+    return {
+      action: "unknown",
+      target: extractedEntities.primary_target || "system",
+      confidence: 0.3,
+      parameters: {},
+      raw_input: input,
+    };
+  }
+}
+

src/ai/nlp/processor.ts

@@ -1,132 +1,137 @@
-import { AIIntent, AIContext, AIConfidence, AIError } from '../types/index.js';
+import { AIIntent, AIContext, AIConfidence, AIError } from "../types/index.js";
-import { EntityExtractor } from './entity-extractor.js';
+import { EntityExtractor } from "./entity-extractor.js";
-import { IntentClassifier } from './intent-classifier.js';
+import { IntentClassifier } from "./intent-classifier.js";
-import { ContextAnalyzer } from './context-analyzer.js';
+import { ContextAnalyzer } from "./context-analyzer.js";
 
 export class NLPProcessor {
-    private entityExtractor: EntityExtractor;
+  private entityExtractor: EntityExtractor;
-    private intentClassifier: IntentClassifier;
+  private intentClassifier: IntentClassifier;
-    private contextAnalyzer: ContextAnalyzer;
+  private contextAnalyzer: ContextAnalyzer;
 
-    constructor() {
+  constructor() {
-        this.entityExtractor = new EntityExtractor();
+    this.entityExtractor = new EntityExtractor();
-        this.intentClassifier = new IntentClassifier();
+    this.intentClassifier = new IntentClassifier();
-        this.contextAnalyzer = new ContextAnalyzer();
+    this.contextAnalyzer = new ContextAnalyzer();
+  }
+
+  async processCommand(
+    input: string,
+    context: AIContext,
+  ): Promise<{
+    intent: AIIntent;
+    confidence: AIConfidence;
+    error?: AIError;
+  }> {
+    try {
+      // Extract entities from the input
+      const entities = await this.entityExtractor.extract(input);
+
+      // Classify the intent
+      const intent = await this.intentClassifier.classify(input, entities);
+
+      // Analyze context relevance
+      const contextRelevance = await this.contextAnalyzer.analyze(
+        intent,
+        context,
+      );
+
+      // Calculate confidence scores
+      const confidence: AIConfidence = {
+        overall:
+          (intent.confidence +
+            entities.confidence +
+            contextRelevance.confidence) /
+          3,
+        intent: intent.confidence,
+        entities: entities.confidence,
+        context: contextRelevance.confidence,
+      };
+
+      // Create structured intent
+      const structuredIntent: AIIntent = {
+        action: intent.action,
+        target: entities.primary_target,
+        parameters: {
+          ...entities.parameters,
+          ...intent.parameters,
+          context_parameters: contextRelevance.relevant_params,
+        },
+        raw_input: input,
+      };
+
+      return {
+        intent: structuredIntent,
+        confidence,
+      };
+    } catch (error: unknown) {
+      const errorMessage =
+        error instanceof Error ? error.message : "Unknown error occurred";
+      return {
+        intent: {
+          action: "error",
+          target: "system",
+          parameters: {},
+          raw_input: input,
+        },
+        confidence: {
+          overall: 0,
+          intent: 0,
+          entities: 0,
+          context: 0,
+        },
+        error: {
+          code: "NLP_PROCESSING_ERROR",
+          message: errorMessage,
+          suggestion: "Please try rephrasing your command",
+          recovery_options: [
+            "Use simpler language",
+            "Break down the command into smaller parts",
+            "Specify the target device explicitly",
+          ],
+          context,
+        },
+      };
+    }
+  }
+
+  async validateIntent(
+    intent: AIIntent,
+    confidence: AIConfidence,
+    threshold = 0.7,
+  ): Promise<boolean> {
+    return (
+      confidence.overall >= threshold &&
+      confidence.intent >= threshold &&
+      confidence.entities >= threshold &&
+      confidence.context >= threshold
+    );
+  }
+
+  async suggestCorrections(input: string, error: AIError): Promise<string[]> {
+    // Implement correction suggestions based on the error
+    const suggestions: string[] = [];
+
+    if (error.code === "ENTITY_NOT_FOUND") {
+      suggestions.push(
+        "Try specifying the device name more clearly",
+        "Use the exact device name from your Home Assistant setup",
+      );
     }
 
-    async processCommand(
+    if (error.code === "AMBIGUOUS_INTENT") {
-        input: string,
+      suggestions.push(
-        context: AIContext
+        "Please specify what you want to do with the device",
-    ): Promise<{
+        'Use action words like "turn on", "set", "adjust"',
-        intent: AIIntent;
+      );
-        confidence: AIConfidence;
-        error?: AIError;
-    }> {
-        try {
-            // Extract entities from the input
-            const entities = await this.entityExtractor.extract(input);
-
-            // Classify the intent
-            const intent = await this.intentClassifier.classify(input, entities);
-
-            // Analyze context relevance
-            const contextRelevance = await this.contextAnalyzer.analyze(intent, context);
-
-            // Calculate confidence scores
-            const confidence: AIConfidence = {
-                overall: (intent.confidence + entities.confidence + contextRelevance.confidence) / 3,
-                intent: intent.confidence,
-                entities: entities.confidence,
-                context: contextRelevance.confidence
-            };
-
-            // Create structured intent
-            const structuredIntent: AIIntent = {
-                action: intent.action,
-                target: entities.primary_target,
-                parameters: {
-                    ...entities.parameters,
-                    ...intent.parameters,
-                    context_parameters: contextRelevance.relevant_params
-                },
-                raw_input: input
-            };
-
-            return {
-                intent: structuredIntent,
-                confidence
-            };
-        } catch (error: unknown) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                intent: {
-                    action: 'error',
-                    target: 'system',
-                    parameters: {},
-                    raw_input: input
-                },
-                confidence: {
-                    overall: 0,
-                    intent: 0,
-                    entities: 0,
-                    context: 0
-                },
-                error: {
-                    code: 'NLP_PROCESSING_ERROR',
-                    message: errorMessage,
-                    suggestion: 'Please try rephrasing your command',
-                    recovery_options: [
-                        'Use simpler language',
-                        'Break down the command into smaller parts',
-                        'Specify the target device explicitly'
-                    ],
-                    context
-                }
-            };
-        }
     }
 
-    async validateIntent(
+    if (error.code === "CONTEXT_MISMATCH") {
-        intent: AIIntent,
+      suggestions.push(
-        confidence: AIConfidence,
+        "Specify the location if referring to a device",
-        threshold = 0.7
+        "Clarify which device you mean in the current context",
-    ): Promise<boolean> {
+      );
-        return (
-            confidence.overall >= threshold &&
-            confidence.intent >= threshold &&
-            confidence.entities >= threshold &&
-            confidence.context >= threshold
-        );
     }
 
-    async suggestCorrections(
+    return suggestions;
-        input: string,
+  }
-        error: AIError
+}
-    ): Promise<string[]> {
-        // Implement correction suggestions based on the error
-        const suggestions: string[] = [];
-
-        if (error.code === 'ENTITY_NOT_FOUND') {
-            suggestions.push(
-                'Try specifying the device name more clearly',
-                'Use the exact device name from your Home Assistant setup'
-            );
-        }
-
-        if (error.code === 'AMBIGUOUS_INTENT') {
-            suggestions.push(
-                'Please specify what you want to do with the device',
-                'Use action words like "turn on", "set", "adjust"'
-            );
-        }
-
-        if (error.code === 'CONTEXT_MISMATCH') {
-            suggestions.push(
-                'Specify the location if referring to a device',
-                'Clarify which device you mean in the current context'
-            );
-        }
-
-        return suggestions;
-    }
-} 

src/ai/templates/prompt-templates.ts

@@ -1,135 +1,138 @@
-import { AIModel } from '../types/index.js';
+import { AIModel } from "../types/index.js";
 
 interface PromptTemplate {
-    system: string;
+  system: string;
+  user: string;
+  examples: Array<{
     user: string;
-    examples: Array<{
+    assistant: string;
-        user: string;
+  }>;
-        assistant: string;
-    }>;
 }
 
 interface PromptVariables {
-    device_name?: string;
+  device_name?: string;
-    location?: string;
+  location?: string;
-    action?: string;
+  action?: string;
-    parameters?: Record<string, any>;
+  parameters?: Record<string, any>;
-    context?: Record<string, any>;
+  context?: Record<string, any>;
-    [key: string]: any;
+  [key: string]: any;
 }
 
 class PromptTemplates {
-    private templates: Record<AIModel, PromptTemplate>;
+  private templates: Record<AIModel, PromptTemplate>;
 
-    constructor() {
+  constructor() {
-        this.templates = {
+    this.templates = {
-            [AIModel.CLAUDE]: {
+      [AIModel.CLAUDE]: {
-                system: `You are Claude, an AI assistant specialized in home automation control through natural language.
+        system: `You are Claude, an AI assistant specialized in home automation control through natural language.
 Your role is to interpret user commands and translate them into specific device control actions.
 Always maintain context awareness and consider user preferences and patterns.
 Provide clear, concise responses and suggest relevant follow-up actions.`,
-                user: `Control the {device_name} in the {location} by {action} with parameters: {parameters}.
+        user: `Control the {device_name} in the {location} by {action} with parameters: {parameters}.
 Current context: {context}`,
-                examples: [
+        examples: [
-                    {
+          {
-                        user: "Turn on the living room lights",
+            user: "Turn on the living room lights",
-                        assistant: "I'll turn on the lights in the living room. Would you like me to set a specific brightness level?"
+            assistant:
-                    },
+              "I'll turn on the lights in the living room. Would you like me to set a specific brightness level?",
-                    {
+          },
-                        user: "Set the temperature to 72 degrees",
+          {
-                        assistant: "I'll set the temperature to 72°F. I'll monitor the temperature and let you know when it reaches the target."
+            user: "Set the temperature to 72 degrees",
-                    }
+            assistant:
-                ]
+              "I'll set the temperature to 72°F. I'll monitor the temperature and let you know when it reaches the target.",
-            },
+          },
-            [AIModel.GPT4]: {
+        ],
-                system: `You are a home automation assistant powered by GPT-4.
+      },
+      [AIModel.GPT4]: {
+        system: `You are a home automation assistant powered by GPT-4.
 Focus on precise command interpretation and execution.
 Maintain high accuracy in device control and parameter settings.
 Provide feedback on action success and system state changes.`,
-                user: `Command: {action} {device_name} in {location}
+        user: `Command: {action} {device_name} in {location}
 Parameters: {parameters}
 Context: {context}`,
-                examples: [
+        examples: [
-                    {
+          {
-                        user: "Dim the bedroom lights to 50%",
+            user: "Dim the bedroom lights to 50%",
-                        assistant: "Setting bedroom light brightness to 50%. The change has been applied successfully."
+            assistant:
-                    },
+              "Setting bedroom light brightness to 50%. The change has been applied successfully.",
-                    {
+          },
-                        user: "Start the evening routine",
+          {
-                        assistant: "Initiating evening routine: dimming lights, adjusting temperature, and enabling security system."
+            user: "Start the evening routine",
-                    }
+            assistant:
-                ]
+              "Initiating evening routine: dimming lights, adjusting temperature, and enabling security system.",
-            },
+          },
-            [AIModel.CUSTOM]: {
+        ],
-                system: `Custom home automation assistant configuration.
+      },
+      [AIModel.CUSTOM]: {
+        system: `Custom home automation assistant configuration.
 Adapt to user preferences and patterns.
 Learn from interactions and optimize responses.
 Provide detailed feedback and suggestions.`,
-                user: `Action requested: {action}
+        user: `Action requested: {action}
 Target device: {device_name}
 Location: {location}
 Parameters: {parameters}
 Current context: {context}`,
-                examples: [
+        examples: [
-                    {
+          {
-                        user: "Make it cooler in here",
+            user: "Make it cooler in here",
-                        assistant: "Based on your preferences, I'll lower the temperature by 2 degrees. Current temperature is 74°F, adjusting to 72°F."
+            assistant:
-                    },
+              "Based on your preferences, I'll lower the temperature by 2 degrees. Current temperature is 74°F, adjusting to 72°F.",
-                    {
+          },
-                        user: "Set up movie mode",
+          {
-                        assistant: "Activating movie mode: dimming lights to 20%, closing blinds, setting TV input to HDMI 1, and adjusting sound system."
+            user: "Set up movie mode",
-                    }
+            assistant:
-                ]
+              "Activating movie mode: dimming lights to 20%, closing blinds, setting TV input to HDMI 1, and adjusting sound system.",
-            }
+          },
-        };
+        ],
+      },
+    };
+  }
+
+  getTemplate(model: AIModel): PromptTemplate {
+    return this.templates[model];
+  }
+
+  formatPrompt(model: AIModel, variables: PromptVariables): string {
+    const template = this.getTemplate(model);
+    let prompt = template.user;
+
+    // Replace variables in the prompt
+    for (const [key, value] of Object.entries(variables)) {
+      const placeholder = `{${key}}`;
+      if (typeof value === "object") {
+        prompt = prompt.replace(placeholder, JSON.stringify(value));
+      } else {
+        prompt = prompt.replace(placeholder, String(value));
+      }
     }
 
-    getTemplate(model: AIModel): PromptTemplate {
+    return prompt;
-        return this.templates[model];
+  }
-    }
 
-    formatPrompt(model: AIModel, variables: PromptVariables): string {
+  getSystemPrompt(model: AIModel): string {
-        const template = this.getTemplate(model);
+    return this.templates[model].system;
-        let prompt = template.user;
+  }
 
-        // Replace variables in the prompt
+  getExamples(model: AIModel): Array<{ user: string; assistant: string }> {
-        for (const [key, value] of Object.entries(variables)) {
+    return this.templates[model].examples;
-            const placeholder = `{${key}}`;
+  }
-            if (typeof value === 'object') {
-                prompt = prompt.replace(placeholder, JSON.stringify(value));
-            } else {
-                prompt = prompt.replace(placeholder, String(value));
-            }
-        }
 
-        return prompt;
+  addExample(
-    }
+    model: AIModel,
+    example: { user: string; assistant: string },
+  ): void {
+    this.templates[model].examples.push(example);
+  }
 
-    getSystemPrompt(model: AIModel): string {
+  updateSystemPrompt(model: AIModel, newPrompt: string): void {
-        return this.templates[model].system;
+    this.templates[model].system = newPrompt;
-    }
+  }
 
-    getExamples(model: AIModel): Array<{ user: string; assistant: string }> {
+  createCustomTemplate(model: AIModel.CUSTOM, template: PromptTemplate): void {
-        return this.templates[model].examples;
+    this.templates[model] = template;
-    }
+  }
-
-    addExample(
-        model: AIModel,
-        example: { user: string; assistant: string }
-    ): void {
-        this.templates[model].examples.push(example);
-    }
-
-    updateSystemPrompt(model: AIModel, newPrompt: string): void {
-        this.templates[model].system = newPrompt;
-    }
-
-    createCustomTemplate(
-        model: AIModel.CUSTOM,
-        template: PromptTemplate
-    ): void {
-        this.templates[model] = template;
-    }
 }
 
-export default new PromptTemplates(); 
+export default new PromptTemplates();

src/ai/types/index.ts

@@ -1,123 +1,128 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 // AI Model Types
 export enum AIModel {
-    CLAUDE = 'claude',
+  CLAUDE = "claude",
-    GPT4 = 'gpt4',
+  GPT4 = "gpt4",
-    CUSTOM = 'custom'
+  CUSTOM = "custom",
 }
 
 // AI Confidence Level
 export interface AIConfidence {
-    overall: number;
+  overall: number;
-    intent: number;
+  intent: number;
-    entities: number;
+  entities: number;
-    context: number;
+  context: number;
 }
 
 // AI Intent
 export interface AIIntent {
-    action: string;
+  action: string;
-    target: string;
+  target: string;
-    parameters: Record<string, any>;
+  parameters: Record<string, any>;
-    raw_input: string;
+  raw_input: string;
 }
 
 // AI Context
 export interface AIContext {
-    user_id: string;
+  user_id: string;
-    session_id: string;
+  session_id: string;
-    timestamp: string;
+  timestamp: string;
-    location: string;
+  location: string;
-    previous_actions: AIIntent[];
+  previous_actions: AIIntent[];
-    environment_state: Record<string, any>;
+  environment_state: Record<string, any>;
 }
 
 // AI Response
 export interface AIResponse {
-    natural_language: string;
+  natural_language: string;
-    structured_data: {
+  structured_data: {
-        success: boolean;
+    success: boolean;
-        action_taken: string;
+    action_taken: string;
-        entities_affected: string[];
+    entities_affected: string[];
-        state_changes: Record<string, any>;
+    state_changes: Record<string, any>;
-    };
+  };
-    next_suggestions: string[];
+  next_suggestions: string[];
-    confidence: AIConfidence;
+  confidence: AIConfidence;
-    context: AIContext;
+  context: AIContext;
 }
 
 // AI Error
 export interface AIError {
-    code: string;
+  code: string;
-    message: string;
+  message: string;
-    suggestion: string;
+  suggestion: string;
-    recovery_options: string[];
+  recovery_options: string[];
-    context: AIContext;
+  context: AIContext;
 }
 
 // Rate Limiting
 export interface AIRateLimit {
-    requests_per_minute: number;
+  requests_per_minute: number;
-    requests_per_hour: number;
+  requests_per_hour: number;
-    concurrent_requests: number;
+  concurrent_requests: number;
-    model_specific_limits: Record<AIModel, {
+  model_specific_limits: Record<
-        requests_per_minute: number;
+    AIModel,
-        requests_per_hour: number;
+    {
-    }>;
+      requests_per_minute: number;
+      requests_per_hour: number;
+    }
+  >;
 }
 
 // Zod Schemas
 export const AIConfidenceSchema = z.object({
-    overall: z.number().min(0).max(1),
+  overall: z.number().min(0).max(1),
-    intent: z.number().min(0).max(1),
+  intent: z.number().min(0).max(1),
-    entities: z.number().min(0).max(1),
+  entities: z.number().min(0).max(1),
-    context: z.number().min(0).max(1)
+  context: z.number().min(0).max(1),
 });
 
 export const AIIntentSchema = z.object({
-    action: z.string(),
+  action: z.string(),
-    target: z.string(),
+  target: z.string(),
-    parameters: z.record(z.any()),
+  parameters: z.record(z.any()),
-    raw_input: z.string()
+  raw_input: z.string(),
 });
 
 export const AIContextSchema = z.object({
-    user_id: z.string(),
+  user_id: z.string(),
-    session_id: z.string(),
+  session_id: z.string(),
-    timestamp: z.string(),
+  timestamp: z.string(),
-    location: z.string(),
+  location: z.string(),
-    previous_actions: z.array(AIIntentSchema),
+  previous_actions: z.array(AIIntentSchema),
-    environment_state: z.record(z.any())
+  environment_state: z.record(z.any()),
 });
 
 export const AIResponseSchema = z.object({
-    natural_language: z.string(),
+  natural_language: z.string(),
-    structured_data: z.object({
+  structured_data: z.object({
-        success: z.boolean(),
+    success: z.boolean(),
-        action_taken: z.string(),
+    action_taken: z.string(),
-        entities_affected: z.array(z.string()),
+    entities_affected: z.array(z.string()),
-        state_changes: z.record(z.any())
+    state_changes: z.record(z.any()),
-    }),
+  }),
-    next_suggestions: z.array(z.string()),
+  next_suggestions: z.array(z.string()),
-    confidence: AIConfidenceSchema,
+  confidence: AIConfidenceSchema,
-    context: AIContextSchema
+  context: AIContextSchema,
 });
 
 export const AIErrorSchema = z.object({
-    code: z.string(),
+  code: z.string(),
-    message: z.string(),
+  message: z.string(),
-    suggestion: z.string(),
+  suggestion: z.string(),
-    recovery_options: z.array(z.string()),
+  recovery_options: z.array(z.string()),
-    context: AIContextSchema
+  context: AIContextSchema,
 });
 
 export const AIRateLimitSchema = z.object({
-    requests_per_minute: z.number(),
+  requests_per_minute: z.number(),
-    requests_per_hour: z.number(),
+  requests_per_hour: z.number(),
-    concurrent_requests: z.number(),
+  concurrent_requests: z.number(),
-    model_specific_limits: z.record(z.object({
+  model_specific_limits: z.record(
-        requests_per_minute: z.number(),
+    z.object({
-        requests_per_hour: z.number()
+      requests_per_minute: z.number(),
-    }))
+      requests_per_hour: z.number(),
-}); 
+    }),
+  ),
+});

src/api/routes.ts

@@ -1,180 +1,191 @@
-import { Router } from 'express';
+import { Router } from "express";
-import { MCP_SCHEMA } from '../mcp/schema.js';
+import { MCP_SCHEMA } from "../mcp/schema.js";
-import { middleware } from '../middleware/index.js';
+import { middleware } from "../middleware/index.js";
-import { sseManager } from '../sse/index.js';
+import { sseManager } from "../sse/index.js";
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
-import { TokenManager } from '../security/index.js';
+import { TokenManager } from "../security/index.js";
-import { tools } from '../tools/index.js';
+import { tools } from "../tools/index.js";
-import { Tool } from '../interfaces/index.js';
+import { Tool } from "../interfaces/index.js";
 
 const router = Router();
 
 // MCP schema endpoint - no auth required as it's just the schema
-router.get('/mcp', (_req, res) => {
+router.get("/mcp", (_req, res) => {
-    res.json(MCP_SCHEMA);
+  res.json(MCP_SCHEMA);
 });
 
 // MCP execute endpoint - requires authentication
-router.post('/mcp/execute', middleware.authenticate, async (req, res) => {
+router.post("/mcp/execute", middleware.authenticate, async (req, res) => {
-    try {
+  try {
-        const { tool: toolName, parameters } = req.body;
+    const { tool: toolName, parameters } = req.body;
 
-        // Find the requested tool
+    // Find the requested tool
-        const tool = tools.find((t: Tool) => t.name === toolName);
+    const tool = tools.find((t: Tool) => t.name === toolName);
-        if (!tool) {
+    if (!tool) {
-            return res.status(404).json({
+      return res.status(404).json({
-                success: false,
+        success: false,
-                message: `Tool '${toolName}' not found`
+        message: `Tool '${toolName}' not found`,
-            });
+      });
-        }
-
-        // Execute the tool with the provided parameters
-        const result = await tool.execute(parameters);
-        res.json(result);
-    } catch (error) {
-        res.status(500).json({
-            success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
-        });
     }
+
+    // Execute the tool with the provided parameters
+    const result = await tool.execute(parameters);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
+    });
+  }
 });
 
 // Health check endpoint
-router.get('/health', (_req, res) => {
+router.get("/health", (_req, res) => {
-    res.json({
+  res.json({
-        status: 'ok',
+    status: "ok",
-        timestamp: new Date().toISOString(),
+    timestamp: new Date().toISOString(),
-        version: '0.1.0'
+    version: "0.1.0",
-    });
+  });
 });
 
 // List devices endpoint
-router.get('/list_devices', middleware.authenticate, async (req, res) => {
+router.get("/list_devices", middleware.authenticate, async (req, res) => {
-    try {
+  try {
-        const tool = tools.find((t: Tool) => t.name === 'list_devices');
+    const tool = tools.find((t: Tool) => t.name === "list_devices");
-        if (!tool) {
+    if (!tool) {
-            return res.status(404).json({
+      return res.status(404).json({
-                success: false,
+        success: false,
-                message: 'Tool not found'
+        message: "Tool not found",
-            });
+      });
-        }
-
-        const result = await tool.execute({ token: req.headers.authorization?.replace('Bearer ', '') });
-        res.json(result);
-    } catch (error) {
-        res.status(500).json({
-            success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
-        });
     }
+
+    const result = await tool.execute({
+      token: req.headers.authorization?.replace("Bearer ", ""),
+    });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
+    });
+  }
 });
 
 // Device control endpoint
-router.post('/control', middleware.authenticate, async (req, res) => {
+router.post("/control", middleware.authenticate, async (req, res) => {
-    try {
+  try {
-        const tool = tools.find((t: Tool) => t.name === 'control');
+    const tool = tools.find((t: Tool) => t.name === "control");
-        if (!tool) {
+    if (!tool) {
-            return res.status(404).json({
+      return res.status(404).json({
-                success: false,
+        success: false,
-                message: 'Tool not found'
+        message: "Tool not found",
-            });
+      });
-        }
-
-        const result = await tool.execute({
-            ...req.body,
-            token: req.headers.authorization?.replace('Bearer ', '')
-        });
-        res.json(result);
-    } catch (error) {
-        res.status(500).json({
-            success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
-        });
     }
+
+    const result = await tool.execute({
+      ...req.body,
+      token: req.headers.authorization?.replace("Bearer ", ""),
+    });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
+    });
+  }
 });
 
 // SSE endpoints
-router.get('/subscribe_events', middleware.wsRateLimiter, (req, res) => {
+router.get("/subscribe_events", middleware.wsRateLimiter, (req, res) => {
-    try {
+  try {
-        // Get token from query parameter
+    // Get token from query parameter
-        const token = req.query.token?.toString();
+    const token = req.query.token?.toString();
 
-        if (!token || !TokenManager.validateToken(token)) {
+    if (!token || !TokenManager.validateToken(token)) {
-            return res.status(401).json({
+      return res.status(401).json({
-                success: false,
+        success: false,
-                message: 'Unauthorized - Invalid token'
+        message: "Unauthorized - Invalid token",
-            });
+      });
-        }
-
-        // Set SSE headers
-        res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive',
-            'Access-Control-Allow-Origin': '*'
-        });
-
-        // Send initial connection message
-        res.write(`data: ${JSON.stringify({
-            type: 'connection',
-            status: 'connected',
-            timestamp: new Date().toISOString()
-        })}\n\n`);
-
-        const clientId = uuidv4();
-        const client = {
-            id: clientId,
-            send: (data: string) => {
-                res.write(`data: ${data}\n\n`);
-            }
-        };
-
-        // Add client to SSE manager
-        const sseClient = sseManager.addClient(client, token);
-        if (!sseClient || !sseClient.authenticated) {
-            res.write(`data: ${JSON.stringify({
-                type: 'error',
-                message: sseClient ? 'Authentication failed' : 'Maximum client limit reached',
-                timestamp: new Date().toISOString()
-            })}\n\n`);
-            return res.end();
-        }
-
-        // Subscribe to events if specified
-        const events = req.query.events?.toString().split(',').filter(Boolean);
-        if (events?.length) {
-            events.forEach(event => sseManager.subscribeToEvent(clientId, event));
-        }
-
-        // Subscribe to entity if specified
-        const entityId = req.query.entity_id?.toString();
-        if (entityId) {
-            sseManager.subscribeToEntity(clientId, entityId);
-        }
-
-        // Subscribe to domain if specified
-        const domain = req.query.domain?.toString();
-        if (domain) {
-            sseManager.subscribeToDomain(clientId, domain);
-        }
-
-        // Handle client disconnect
-        req.on('close', () => {
-            sseManager.removeClient(clientId);
-        });
-
-    } catch (error) {
-        res.status(500).json({
-            success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
-        });
     }
+
+    // Set SSE headers
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      "Access-Control-Allow-Origin": "*",
+    });
+
+    // Send initial connection message
+    res.write(
+      `data: ${JSON.stringify({
+        type: "connection",
+        status: "connected",
+        timestamp: new Date().toISOString(),
+      })}\n\n`,
+    );
+
+    const clientId = uuidv4();
+    const client = {
+      id: clientId,
+      send: (data: string) => {
+        res.write(`data: ${data}\n\n`);
+      },
+    };
+
+    // Add client to SSE manager
+    const sseClient = sseManager.addClient(client, token);
+    if (!sseClient || !sseClient.authenticated) {
+      res.write(
+        `data: ${JSON.stringify({
+          type: "error",
+          message: sseClient
+            ? "Authentication failed"
+            : "Maximum client limit reached",
+          timestamp: new Date().toISOString(),
+        })}\n\n`,
+      );
+      return res.end();
+    }
+
+    // Subscribe to events if specified
+    const events = req.query.events?.toString().split(",").filter(Boolean);
+    if (events?.length) {
+      events.forEach((event) => sseManager.subscribeToEvent(clientId, event));
+    }
+
+    // Subscribe to entity if specified
+    const entityId = req.query.entity_id?.toString();
+    if (entityId) {
+      sseManager.subscribeToEntity(clientId, entityId);
+    }
+
+    // Subscribe to domain if specified
+    const domain = req.query.domain?.toString();
+    if (domain) {
+      sseManager.subscribeToDomain(clientId, domain);
+    }
+
+    // Handle client disconnect
+    req.on("close", () => {
+      sseManager.removeClient(clientId);
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
+    });
+  }
 });
 
 /**
  * SSE Statistics Endpoint
  * Returns detailed statistics about SSE connections and subscriptions.
- * 
+ *
  * @route GET /get_sse_stats
  * @authentication Required - Bearer token
  * @returns {Object} Statistics object containing:
@@ -185,21 +196,22 @@ router.get('/subscribe_events', middleware.wsRateLimiter, (req, res) => {
  *   - total_entities_tracked: Number of entities being tracked
  *   - subscriptions: Lists of entity, event, and domain subscriptions
  */
-router.get('/get_sse_stats', middleware.authenticate, (_req, res) => {
+router.get("/get_sse_stats", middleware.authenticate, (_req, res) => {
-    try {
+  try {
-        const stats = sseManager.getStatistics();
+    const stats = sseManager.getStatistics();
-        res.json({
+    res.json({
-            success: true,
+      success: true,
-            timestamp: new Date().toISOString(),
+      timestamp: new Date().toISOString(),
-            data: stats
+      data: stats,
-        });
+    });
-    } catch (error) {
+  } catch (error) {
-        res.status(500).json({
+    res.status(500).json({
-            success: false,
+      success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred',
+      message:
-            timestamp: new Date().toISOString()
+        error instanceof Error ? error.message : "Unknown error occurred",
-        });
+      timestamp: new Date().toISOString(),
-    }
+    });
+  }
 });
 
-export default router; 
+export default router;

src/commands.ts

@@ -0,0 +1,27 @@
+// Common commands that work with most entities
+export const commonCommands = ["turn_on", "turn_off", "toggle"] as const;
+
+// Commands specific to cover entities
+export const coverCommands = [
+  ...commonCommands,
+  "open",
+  "close",
+  "stop",
+  "set_position",
+  "set_tilt_position",
+] as const;
+
+// Commands specific to climate entities
+export const climateCommands = [
+  ...commonCommands,
+  "set_temperature",
+  "set_hvac_mode",
+  "set_fan_mode",
+  "set_humidity",
+] as const;
+
+// Types for command validation
+export type CommonCommand = (typeof commonCommands)[number];
+export type CoverCommand = (typeof coverCommands)[number];
+export type ClimateCommand = (typeof climateCommands)[number];
+export type Command = CommonCommand | CoverCommand | ClimateCommand;

src/config.js

@@ -0,0 +1,32 @@
+/**
+ * MCP Server Configuration
+ * 
+ * This file contains the configuration for the MCP server.
+ * Values can be overridden via environment variables.
+ */
+
+// Default values for the application configuration
+export const APP_CONFIG = {
+    // Server configuration
+    PORT: process.env.PORT ? parseInt(process.env.PORT, 10) : 3000,
+    NODE_ENV: process.env.NODE_ENV || 'development',
+
+    // Execution settings
+    EXECUTION_TIMEOUT: process.env.EXECUTION_TIMEOUT ? parseInt(process.env.EXECUTION_TIMEOUT, 10) : 30000,
+    STREAMING_ENABLED: process.env.STREAMING_ENABLED === 'true',
+
+    // Transport settings
+    USE_STDIO_TRANSPORT: process.env.USE_STDIO_TRANSPORT === 'true',
+    USE_HTTP_TRANSPORT: process.env.USE_HTTP_TRANSPORT !== 'false',
+
+    // Debug and logging settings
+    DEBUG_MODE: process.env.DEBUG_MODE === 'true',
+    DEBUG_STDIO: process.env.DEBUG_STDIO === 'true',
+    DEBUG_HTTP: process.env.DEBUG_HTTP === 'true',
+    SILENT_STARTUP: process.env.SILENT_STARTUP === 'true',
+
+    // CORS settings
+    CORS_ORIGIN: process.env.CORS_ORIGIN || '*'
+};
+
+export default APP_CONFIG; 

src/config.ts

@@ -0,0 +1,61 @@
+/**
+ * Configuration for the Model Context Protocol (MCP) server
+ * Values can be overridden using environment variables
+ */
+
+import { MCPServerConfigSchema, MCPServerConfigType } from './schemas/config.schema.js';
+import { logger } from './utils/logger.js';
+
+function loadConfig(): MCPServerConfigType {
+    try {
+        const rawConfig = {
+            // Server configuration
+            port: parseInt(process.env.PORT || '3000', 10),
+            environment: process.env.NODE_ENV || 'development',
+
+            // Execution settings
+            executionTimeout: parseInt(process.env.EXECUTION_TIMEOUT || '30000', 10),
+            streamingEnabled: process.env.STREAMING_ENABLED === 'true',
+
+            // Transport settings
+            useStdioTransport: process.env.USE_STDIO_TRANSPORT === 'true',
+            useHttpTransport: process.env.USE_HTTP_TRANSPORT === 'true',
+
+            // Debug and logging
+            debugMode: process.env.DEBUG_MODE === 'true',
+            debugStdio: process.env.DEBUG_STDIO === 'true',
+            debugHttp: process.env.DEBUG_HTTP === 'true',
+            silentStartup: process.env.SILENT_STARTUP === 'true',
+
+            // CORS settings
+            corsOrigin: process.env.CORS_ORIGIN || '*',
+
+            // Rate limiting
+            rateLimit: {
+                maxRequests: parseInt(process.env.RATE_LIMIT_MAX_REQUESTS || '100', 10),
+                maxAuthRequests: parseInt(process.env.RATE_LIMIT_MAX_AUTH_REQUESTS || '5', 10),
+            },
+        };
+
+        // Validate and parse configuration
+        const validatedConfig = MCPServerConfigSchema.parse(rawConfig);
+
+        // Log validation success
+        if (!validatedConfig.silentStartup) {
+            logger.info('Configuration validated successfully');
+            if (validatedConfig.debugMode) {
+                logger.debug('Current configuration:', validatedConfig);
+            }
+        }
+
+        return validatedConfig;
+    } catch (error) {
+        // Log validation errors
+        logger.error('Configuration validation failed:', error);
+        throw new Error('Invalid configuration. Please check your environment variables.');
+    }
+}
+
+export const APP_CONFIG = loadConfig();
+export type { MCPServerConfigType };
+export default APP_CONFIG; 

src/config/__tests__/test.config.ts

@@ -0,0 +1,162 @@
+import { z } from "zod";
+
+// Test configuration schema
+const testConfigSchema = z.object({
+  // Test Environment
+  TEST_PORT: z.number().default(3001),
+  TEST_HOST: z.string().default("http://localhost"),
+  TEST_WEBSOCKET_PORT: z.number().default(3002),
+
+  // Mock Authentication
+  TEST_JWT_SECRET: z
+    .string()
+    .default("test_jwt_secret_key_that_is_at_least_32_chars"),
+  TEST_TOKEN: z.string().default("test_token_that_is_at_least_32_chars_long"),
+  TEST_INVALID_TOKEN: z.string().default("invalid_token"),
+
+  // Mock Client Settings
+  TEST_CLIENT_IP: z.string().default("127.0.0.1"),
+  TEST_MAX_CLIENTS: z.number().default(10),
+  TEST_PING_INTERVAL: z.number().default(100),
+  TEST_CLEANUP_INTERVAL: z.number().default(200),
+  TEST_MAX_CONNECTION_AGE: z.number().default(1000),
+
+  // Mock Rate Limiting
+  TEST_RATE_LIMIT_WINDOW: z.number().default(60000), // 1 minute
+  TEST_RATE_LIMIT_MAX_REQUESTS: z.number().default(100),
+  TEST_RATE_LIMIT_WEBSOCKET: z.number().default(1000),
+
+  // Mock Events
+  TEST_EVENT_TYPES: z
+    .array(z.string())
+    .default([
+      "state_changed",
+      "automation_triggered",
+      "script_executed",
+      "service_called",
+    ]),
+
+  // Mock Entities
+  TEST_ENTITIES: z
+    .array(
+      z.object({
+        entity_id: z.string(),
+        state: z.string(),
+        attributes: z.record(z.any()),
+        last_changed: z.string(),
+        last_updated: z.string(),
+      }),
+    )
+    .default([
+      {
+        entity_id: "light.test_light",
+        state: "on",
+        attributes: {
+          brightness: 255,
+          color_temp: 400,
+        },
+        last_changed: new Date().toISOString(),
+        last_updated: new Date().toISOString(),
+      },
+      {
+        entity_id: "switch.test_switch",
+        state: "off",
+        attributes: {},
+        last_changed: new Date().toISOString(),
+        last_updated: new Date().toISOString(),
+      },
+    ]),
+
+  // Mock Services
+  TEST_SERVICES: z
+    .array(
+      z.object({
+        domain: z.string(),
+        service: z.string(),
+        data: z.record(z.any()),
+      }),
+    )
+    .default([
+      {
+        domain: "light",
+        service: "turn_on",
+        data: {
+          entity_id: "light.test_light",
+          brightness: 255,
+        },
+      },
+      {
+        domain: "switch",
+        service: "turn_off",
+        data: {
+          entity_id: "switch.test_switch",
+        },
+      },
+    ]),
+
+  // Mock Error Scenarios
+  TEST_ERROR_SCENARIOS: z
+    .array(
+      z.object({
+        type: z.string(),
+        message: z.string(),
+        code: z.number(),
+      }),
+    )
+    .default([
+      {
+        type: "authentication_error",
+        message: "Invalid token",
+        code: 401,
+      },
+      {
+        type: "rate_limit_error",
+        message: "Too many requests",
+        code: 429,
+      },
+      {
+        type: "validation_error",
+        message: "Invalid request body",
+        code: 400,
+      },
+    ]),
+});
+
+// Parse environment variables or use defaults
+const parseTestConfig = () => {
+  const config = {
+    TEST_PORT: parseInt(process.env.TEST_PORT || "3001"),
+    TEST_HOST: process.env.TEST_HOST || "http://localhost",
+    TEST_WEBSOCKET_PORT: parseInt(process.env.TEST_WEBSOCKET_PORT || "3002"),
+    TEST_JWT_SECRET:
+      process.env.TEST_JWT_SECRET ||
+      "test_jwt_secret_key_that_is_at_least_32_chars",
+    TEST_TOKEN:
+      process.env.TEST_TOKEN || "test_token_that_is_at_least_32_chars_long",
+    TEST_INVALID_TOKEN: process.env.TEST_INVALID_TOKEN || "invalid_token",
+    TEST_CLIENT_IP: process.env.TEST_CLIENT_IP || "127.0.0.1",
+    TEST_MAX_CLIENTS: parseInt(process.env.TEST_MAX_CLIENTS || "10"),
+    TEST_PING_INTERVAL: parseInt(process.env.TEST_PING_INTERVAL || "100"),
+    TEST_CLEANUP_INTERVAL: parseInt(process.env.TEST_CLEANUP_INTERVAL || "200"),
+    TEST_MAX_CONNECTION_AGE: parseInt(
+      process.env.TEST_MAX_CONNECTION_AGE || "1000",
+    ),
+    TEST_RATE_LIMIT_WINDOW: parseInt(
+      process.env.TEST_RATE_LIMIT_WINDOW || "60000",
+    ),
+    TEST_RATE_LIMIT_MAX_REQUESTS: parseInt(
+      process.env.TEST_RATE_LIMIT_MAX_REQUESTS || "100",
+    ),
+    TEST_RATE_LIMIT_WEBSOCKET: parseInt(
+      process.env.TEST_RATE_LIMIT_WEBSOCKET || "1000",
+    ),
+  };
+
+  return testConfigSchema.parse(config);
+};
+
+// Export the validated test configuration
+export const TEST_CONFIG = parseTestConfig();
+
+// Export types
+export type TestConfig = z.infer<typeof testConfigSchema>;

src/config/app.config.ts

@@ -1,85 +1,126 @@
-import { config } from 'dotenv';
+import { z } from "zod";
-import { resolve } from 'path';
-
-/**
- * Load environment variables based on NODE_ENV
- * Development: .env.development
- * Test: .env.test
- * Production: .env
- */
-const envFile = process.env.NODE_ENV === 'production'
-    ? '.env'
-    : process.env.NODE_ENV === 'test'
-        ? '.env.test'
-        : '.env.development';
-
-console.log(`Loading environment from ${envFile}`);
-config({ path: resolve(process.cwd(), envFile) });
 
 /**
  * Application configuration object
  * Contains all configuration settings for the application
  */
-export const APP_CONFIG = {
+export const AppConfigSchema = z.object({
-    /** Server Configuration */
+  /** Server Configuration */
-    PORT: process.env.PORT || 3000,
+  PORT: z.coerce.number().default(4000),
-    NODE_ENV: process.env.NODE_ENV || 'development',
+  NODE_ENV: z
+    .enum(["development", "production", "test"])
+    .default("development"),
 
-    /** Home Assistant Configuration */
+  /** Home Assistant Configuration */
-    HASS_HOST: process.env.HASS_HOST || 'http://192.168.178.63:8123',
+  HASS_HOST: z.string().default("http://homeassistant.local:8123"),
-    HASS_TOKEN: process.env.HASS_TOKEN,
+  HASS_TOKEN: z.string().optional(),
 
-    /** Security Configuration */
+  /** Speech Features Configuration */
-    JWT_SECRET: process.env.JWT_SECRET || 'your-secret-key',
+  SPEECH: z.object({
-    RATE_LIMIT: {
+    ENABLED: z.boolean().default(false),
-        /** Time window for rate limiting in milliseconds */
+    WAKE_WORD_ENABLED: z.boolean().default(false),
-        windowMs: 15 * 60 * 1000, // 15 minutes
+    SPEECH_TO_TEXT_ENABLED: z.boolean().default(false),
-        /** Maximum number of requests per window */
+    WHISPER_MODEL_PATH: z.string().default("/models"),
-        max: 100 // limit each IP to 100 requests per windowMs
+    WHISPER_MODEL_TYPE: z.string().default("base"),
-    },
+  }).default({
+    ENABLED: false,
+    WAKE_WORD_ENABLED: false,
+    SPEECH_TO_TEXT_ENABLED: false,
+    WHISPER_MODEL_PATH: "/models",
+    WHISPER_MODEL_TYPE: "base",
+  }),
 
-    /** Server-Sent Events Configuration */
+  /** Security Configuration */
-    SSE: {
+  JWT_SECRET: z.string().default("your-secret-key-must-be-32-char-min"),
-        /** Maximum number of concurrent SSE clients */
+  RATE_LIMIT: z.object({
-        MAX_CLIENTS: 1000,
+    /** Time window for rate limiting in milliseconds */
-        /** Ping interval in milliseconds to keep connections alive */
+    windowMs: z.number().default(15 * 60 * 1000), // 15 minutes
-        PING_INTERVAL: 30000 // 30 seconds
+    /** Maximum number of requests per window */
-    },
+    max: z.number().default(100), // limit each IP to 100 requests per windowMs
+  }),
 
-    /** Logging Configuration */
+  /** Server-Sent Events Configuration */
-    LOGGING: {
+  SSE: z.object({
-        /** Log level (error, warn, info, http, debug) */
+    /** Maximum number of concurrent SSE clients */
-        LEVEL: process.env.LOG_LEVEL || 'info',
+    MAX_CLIENTS: z.number().default(1000),
-        /** Directory for log files */
+    /** Ping interval in milliseconds to keep connections alive */
-        DIR: process.env.LOG_DIR || 'logs',
+    PING_INTERVAL: z.number().default(30000), // 30 seconds
-        /** Maximum log file size before rotation */
+  }),
-        MAX_SIZE: process.env.LOG_MAX_SIZE || '20m',
-        /** Maximum number of days to keep log files */
-        MAX_DAYS: process.env.LOG_MAX_DAYS || '14d',
-        /** Whether to compress rotated logs */
-        COMPRESS: process.env.LOG_COMPRESS === 'true',
-        /** Format for timestamps in logs */
-        TIMESTAMP_FORMAT: 'YYYY-MM-DD HH:mm:ss:ms',
-        /** Whether to include request logging */
-        LOG_REQUESTS: process.env.LOG_REQUESTS === 'true',
-    },
 
-    /** Application Version */
+  /** Logging Configuration */
-    VERSION: '0.1.0'
+  LOGGING: z.object({
-} as const;
+    /** Log level (error, warn, info, http, debug) */
+    LEVEL: z.enum(["error", "warn", "info", "debug", "trace"]).default("info"),
+    /** Directory for log files */
+    DIR: z.string().default("logs"),
+    /** Maximum log file size before rotation */
+    MAX_SIZE: z.string().default("20m"),
+    /** Maximum number of days to keep log files */
+    MAX_DAYS: z.string().default("14d"),
+    /** Whether to compress rotated logs */
+    COMPRESS: z.boolean().default(false),
+    /** Format for timestamps in logs */
+    TIMESTAMP_FORMAT: z.string().default("YYYY-MM-DD HH:mm:ss:ms"),
+    /** Whether to include request logging */
+    LOG_REQUESTS: z.boolean().default(false),
+  }),
+
+  /** Application Version */
+  VERSION: z.string().default("0.1.0"),
+});
 
 /** Type definition for the configuration object */
-export type AppConfig = typeof APP_CONFIG;
+export type AppConfig = z.infer<typeof AppConfigSchema>;
 
 /** Required environment variables that must be set */
-const requiredEnvVars = ['HASS_TOKEN'] as const;
+const requiredEnvVars = ["HASS_TOKEN"] as const;
 
 /**
  * Validate that all required environment variables are set
  * Throws an error if any required variable is missing
  */
 for (const envVar of requiredEnvVars) {
-    if (!process.env[envVar]) {
+  if (!process.env[envVar]) {
-        throw new Error(`Missing required environment variable: ${envVar}`);
+    throw new Error(`Missing required environment variable: ${envVar}`);
-    }
+  }
-} 
+}
+
+// Fix NODE_ENV if it's set to "1"
+if (process.env.NODE_ENV === "1") {
+  console.log('Fixing NODE_ENV from "1" to "development"');
+  process.env.NODE_ENV = "development";
+}
+
+// Load and validate configuration
+export const APP_CONFIG = AppConfigSchema.parse({
+  PORT: process.env.PORT || 4000,
+  NODE_ENV: process.env.NODE_ENV,
+  HASS_HOST: process.env.HASS_HOST || "http://192.168.178.63:8123",
+  HASS_TOKEN: process.env.HASS_TOKEN,
+  JWT_SECRET: process.env.JWT_SECRET || "your-secret-key",
+  RATE_LIMIT: {
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100, // limit each IP to 100 requests per windowMs
+  },
+  SSE: {
+    MAX_CLIENTS: 1000,
+    PING_INTERVAL: 30000, // 30 seconds
+  },
+  LOGGING: {
+    LEVEL: process.env.LOG_LEVEL || "info",
+    DIR: process.env.LOG_DIR || "logs",
+    MAX_SIZE: process.env.LOG_MAX_SIZE || "20m",
+    MAX_DAYS: process.env.LOG_MAX_DAYS || "14d",
+    COMPRESS: process.env.LOG_COMPRESS === "true",
+    TIMESTAMP_FORMAT: "YYYY-MM-DD HH:mm:ss:ms",
+    LOG_REQUESTS: process.env.LOG_REQUESTS === "true",
+  },
+  VERSION: "0.1.0",
+  SPEECH: {
+    ENABLED: process.env.ENABLE_SPEECH_FEATURES === "true",
+    WAKE_WORD_ENABLED: process.env.ENABLE_WAKE_WORD === "true",
+    SPEECH_TO_TEXT_ENABLED: process.env.ENABLE_SPEECH_TO_TEXT === "true",
+    WHISPER_MODEL_PATH: process.env.WHISPER_MODEL_PATH || "/models",
+    WHISPER_MODEL_TYPE: process.env.WHISPER_MODEL_TYPE || "base",
+  },
+});

src/config/hass.config.ts

@@ -1,11 +1,51 @@
-import dotenv from 'dotenv';
+import { config } from "dotenv";
+import { resolve } from "path";
 
-// Load environment variables
+// Load environment variables based on NODE_ENV
-dotenv.config();
+const envFile =
+  process.env.NODE_ENV === "production"
+    ? ".env"
+    : process.env.NODE_ENV === "test"
+      ? ".env.test"
+      : ".env.development";
 
+config({ path: resolve(process.cwd(), envFile) });
+
+// Base configuration for Home Assistant
 export const HASS_CONFIG = {
-    BASE_URL: process.env.HASS_HOST || 'http://homeassistant.local:8123',
+  // Base configuration
-    TOKEN: process.env.HASS_TOKEN || '',
+  BASE_URL: process.env.HASS_HOST || "http://localhost:8123",
-    SOCKET_URL: process.env.HASS_SOCKET_URL || '',
+  TOKEN: process.env.HASS_TOKEN || "",
-    SOCKET_TOKEN: process.env.HASS_TOKEN || '',
+  SOCKET_URL: process.env.HASS_WS_URL || "ws://localhost:8123/api/websocket",
-}; 
+  SOCKET_TOKEN: process.env.HASS_TOKEN || "",
+
+  // Boilerplate configuration
+  BOILERPLATE: {
+    CACHE_DIRECTORY: ".cache",
+    CONFIG_DIRECTORY: ".config",
+    DATA_DIRECTORY: ".data",
+    LOG_LEVEL: "debug",
+    ENVIRONMENT: process.env.NODE_ENV || "development",
+  },
+
+  // Application configuration
+  APP_NAME: "homeassistant-mcp",
+  APP_VERSION: "1.0.0",
+
+  // API configuration
+  API_VERSION: "1.0.0",
+  API_PREFIX: "/api",
+
+  // Security configuration
+  RATE_LIMIT: {
+    WINDOW_MS: 15 * 60 * 1000, // 15 minutes
+    MAX_REQUESTS: 100,
+  },
+
+  // WebSocket configuration
+  WS_CONFIG: {
+    AUTO_RECONNECT: true,
+    MAX_RECONNECT_ATTEMPTS: 3,
+    RECONNECT_DELAY: 1000,
+  },
+};

src/config/index.ts

@@ -1,77 +1,77 @@
-import { config } from 'dotenv';
+import { loadEnvironmentVariables } from "./loadEnv";
-import { resolve } from 'path';
 
-// Load environment variables based on NODE_ENV
+// Load environment variables from the appropriate files
-const envFile = process.env.NODE_ENV === 'production'
+loadEnvironmentVariables();
-    ? '.env'
-    : process.env.NODE_ENV === 'test'
-        ? '.env.test'
-        : '.env.development';
-
-console.log(`Loading environment from ${envFile}`);
-config({ path: resolve(process.cwd(), envFile) });
 
 // Home Assistant Configuration
 export const HASS_CONFIG = {
-    HOST: process.env.HASS_HOST || 'http://homeassistant.local:8123',
+  HOST: process.env.HASS_HOST || "http://homeassistant.local:8123",
-    TOKEN: process.env.HASS_TOKEN,
+  TOKEN: process.env.HASS_TOKEN,
-    SOCKET_URL: process.env.HASS_SOCKET_URL || 'ws://homeassistant.local:8123/api/websocket',
+  SOCKET_URL:
-    BASE_URL: process.env.HASS_HOST || 'http://homeassistant.local:8123',
+    process.env.HASS_SOCKET_URL ||
-    SOCKET_TOKEN: process.env.HASS_TOKEN
+    "ws://homeassistant.local:8123/api/websocket",
+  BASE_URL: process.env.HASS_HOST || "http://homeassistant.local:8123",
+  SOCKET_TOKEN: process.env.HASS_TOKEN,
 };
 
 // Server Configuration
 export const SERVER_CONFIG = {
-    PORT: parseInt(process.env.PORT || '3000', 10),
+  PORT: parseInt(process.env.PORT || "3000", 10),
-    NODE_ENV: process.env.NODE_ENV || 'development',
+  NODE_ENV: process.env.NODE_ENV || "development",
-    DEBUG: process.env.DEBUG === 'true',
+  DEBUG: process.env.DEBUG === "true",
-    LOG_LEVEL: process.env.LOG_LEVEL || 'info'
+  LOG_LEVEL: process.env.LOG_LEVEL || "info",
 };
 
 // AI Configuration
 export const AI_CONFIG = {
-    PROCESSOR_TYPE: process.env.PROCESSOR_TYPE || 'claude',
+  PROCESSOR_TYPE: process.env.PROCESSOR_TYPE || "claude",
-    OPENAI_API_KEY: process.env.OPENAI_API_KEY
+  OPENAI_API_KEY: process.env.OPENAI_API_KEY,
 };
 
 // Rate Limiting Configuration
 export const RATE_LIMIT_CONFIG = {
-    REGULAR: parseInt(process.env.RATE_LIMIT_REGULAR || '100', 10),
+  REGULAR: parseInt(process.env.RATE_LIMIT_REGULAR || "100", 10),
-    WEBSOCKET: parseInt(process.env.RATE_LIMIT_WEBSOCKET || '1000', 10)
+  WEBSOCKET: parseInt(process.env.RATE_LIMIT_WEBSOCKET || "1000", 10),
 };
 
 // Security Configuration
 export const SECURITY_CONFIG = {
-    JWT_SECRET: process.env.JWT_SECRET || 'default_secret_key_change_in_production',
+  JWT_SECRET:
-    CORS_ORIGINS: (process.env.CORS_ORIGINS || 'http://localhost:3000,http://localhost:8123')
+    process.env.JWT_SECRET || "default_secret_key_change_in_production",
-        .split(',')
+  CORS_ORIGINS: (
-        .map(origin => origin.trim())
+    process.env.CORS_ORIGINS || "http://localhost:3000,http://localhost:8123"
+  )
+    .split(",")
+    .map((origin) => origin.trim()),
 };
 
 // Test Configuration
 export const TEST_CONFIG = {
-    HASS_HOST: process.env.TEST_HASS_HOST || 'http://localhost:8123',
+  HASS_HOST: process.env.TEST_HASS_HOST || "http://localhost:8123",
-    HASS_TOKEN: process.env.TEST_HASS_TOKEN || 'test_token',
+  HASS_TOKEN: process.env.TEST_HASS_TOKEN || "test_token",
-    HASS_SOCKET_URL: process.env.TEST_HASS_SOCKET_URL || 'ws://localhost:8123/api/websocket',
+  HASS_SOCKET_URL:
-    PORT: parseInt(process.env.TEST_PORT || '3001', 10)
+    process.env.TEST_HASS_SOCKET_URL || "ws://localhost:8123/api/websocket",
+  PORT: parseInt(process.env.TEST_PORT || "3001", 10),
 };
 
 // Mock Configuration (for testing)
 export const MOCK_CONFIG = {
-    SERVICES: process.env.MOCK_SERVICES === 'true',
+  SERVICES: process.env.MOCK_SERVICES === "true",
-    RESPONSES_DIR: process.env.MOCK_RESPONSES_DIR || '__tests__/mock-responses'
+  RESPONSES_DIR: process.env.MOCK_RESPONSES_DIR || "__tests__/mock-responses",
 };
 
 // Validate required configuration
 function validateConfig() {
-    const missingVars: string[] = [];
+  const missingVars: string[] = [];
 
-    if (!HASS_CONFIG.TOKEN) missingVars.push('HASS_TOKEN');
+  if (!HASS_CONFIG.TOKEN) missingVars.push("HASS_TOKEN");
-    if (!SECURITY_CONFIG.JWT_SECRET) missingVars.push('JWT_SECRET');
+  if (!SECURITY_CONFIG.JWT_SECRET) missingVars.push("JWT_SECRET");
 
-    if (missingVars.length > 0) {
+  if (missingVars.length > 0) {
-        throw new Error(`Missing required environment variables: ${missingVars.join(', ')}`);
+    throw new Error(
-    }
+      `Missing required environment variables: ${missingVars.join(", ")}`,
+    );
+  }
 }
 
 // Export configuration validation
@@ -79,11 +79,11 @@ export const validateConfiguration = validateConfig;
 
 // Export all configurations as a single object
 export const AppConfig = {
-    HASS: HASS_CONFIG,
+  HASS: HASS_CONFIG,
-    SERVER: SERVER_CONFIG,
+  SERVER: SERVER_CONFIG,
-    AI: AI_CONFIG,
+  AI: AI_CONFIG,
-    RATE_LIMIT: RATE_LIMIT_CONFIG,
+  RATE_LIMIT: RATE_LIMIT_CONFIG,
-    SECURITY: SECURITY_CONFIG,
+  SECURITY: SECURITY_CONFIG,
-    TEST: TEST_CONFIG,
+  TEST: TEST_CONFIG,
-    MOCK: MOCK_CONFIG
+  MOCK: MOCK_CONFIG,
-}; 
+};

src/config/loadEnv.ts

@@ -0,0 +1,59 @@
+import { config as dotenvConfig } from "dotenv";
+import { file } from "bun";
+import path from "path";
+
+/**
+ * Maps NODE_ENV values to their corresponding environment file names
+ */
+const ENV_FILE_MAPPING: Record<string, string> = {
+    production: ".env.prod",
+    development: ".env.dev",
+    test: ".env.test",
+};
+
+/**
+ * Loads environment variables from the appropriate files based on NODE_ENV.
+ * First loads environment-specific file, then overrides with generic .env if it exists.
+ */
+export async function loadEnvironmentVariables() {
+    // Determine the current environment (default to 'development')
+    const nodeEnv = (process.env.NODE_ENV || "development").toLowerCase();
+
+    // Get the environment-specific file name
+    const envSpecificFile = ENV_FILE_MAPPING[nodeEnv];
+    if (!envSpecificFile) {
+        console.warn(`Unknown NODE_ENV value: ${nodeEnv}. Using .env.dev as fallback.`);
+    }
+
+    const envFile = envSpecificFile || ".env.dev";
+    const envPath = path.resolve(process.cwd(), envFile);
+
+    // Load the environment-specific file if it exists
+    try {
+        const envFileExists = await file(envPath).exists();
+        if (envFileExists) {
+            dotenvConfig({ path: envPath });
+            console.log(`Loaded environment variables from ${envFile}`);
+        } else {
+            console.warn(`Environment-specific file ${envFile} not found.`);
+        }
+    } catch (error) {
+        console.warn(`Error checking environment file ${envFile}:`, error);
+    }
+
+    // Finally, check if there is a generic .env file present
+    // If so, load it with the override option, so its values take precedence
+    const genericEnvPath = path.resolve(process.cwd(), ".env");
+    try {
+        const genericEnvExists = await file(genericEnvPath).exists();
+        if (genericEnvExists) {
+            dotenvConfig({ path: genericEnvPath, override: true });
+            console.log("Loaded and overrode with generic .env file");
+        }
+    } catch (error) {
+        console.warn(`Error checking generic .env file:`, error);
+    }
+}
+
+// Export the environment file mapping for reference
+export const ENV_FILES = ENV_FILE_MAPPING; 

src/config/security.config.ts

@@ -0,0 +1,129 @@
+import { z } from "zod";
+
+// Security configuration schema
+const securityConfigSchema = z.object({
+  // JWT Configuration
+  JWT_SECRET: z.string().min(32),
+  JWT_EXPIRY: z.number().default(24 * 60 * 60 * 1000), // 24 hours
+  JWT_MAX_AGE: z.number().default(30 * 24 * 60 * 60 * 1000), // 30 days
+  JWT_ALGORITHM: z.enum(["HS256", "HS384", "HS512"]).default("HS256"),
+
+  // Rate Limiting
+  RATE_LIMIT_WINDOW: z.number().default(15 * 60 * 1000), // 15 minutes
+  RATE_LIMIT_MAX_REQUESTS: z.number().default(100),
+  RATE_LIMIT_WEBSOCKET: z.number().default(1000),
+
+  // Token Security
+  TOKEN_MIN_LENGTH: z.number().default(32),
+  MAX_FAILED_ATTEMPTS: z.number().default(5),
+  LOCKOUT_DURATION: z.number().default(15 * 60 * 1000), // 15 minutes
+
+  // CORS Configuration
+  CORS_ORIGINS: z
+    .array(z.string())
+    .default(["http://localhost:3000", "http://localhost:8123"]),
+  CORS_METHODS: z
+    .array(z.string())
+    .default(["GET", "POST", "PUT", "DELETE", "OPTIONS"]),
+  CORS_ALLOWED_HEADERS: z
+    .array(z.string())
+    .default(["Content-Type", "Authorization", "X-Requested-With"]),
+  CORS_EXPOSED_HEADERS: z.array(z.string()).default([]),
+  CORS_CREDENTIALS: z.boolean().default(true),
+  CORS_MAX_AGE: z.number().default(24 * 60 * 60), // 24 hours
+
+  // Content Security Policy
+  CSP_ENABLED: z.boolean().default(true),
+  CSP_REPORT_ONLY: z.boolean().default(false),
+  CSP_REPORT_URI: z.string().optional(),
+
+  // SSL/TLS Configuration
+  REQUIRE_HTTPS: z.boolean().default(process.env.NODE_ENV === "production"),
+  HSTS_MAX_AGE: z.number().default(31536000), // 1 year
+  HSTS_INCLUDE_SUBDOMAINS: z.boolean().default(true),
+  HSTS_PRELOAD: z.boolean().default(true),
+
+  // Cookie Security
+  COOKIE_SECRET: z.string().min(32).optional(),
+  COOKIE_SECURE: z.boolean().default(process.env.NODE_ENV === "production"),
+  COOKIE_HTTP_ONLY: z.boolean().default(true),
+  COOKIE_SAME_SITE: z.enum(["Strict", "Lax", "None"]).default("Strict"),
+
+  // Request Limits
+  MAX_REQUEST_SIZE: z.number().default(1024 * 1024), // 1MB
+  MAX_REQUEST_FIELDS: z.number().default(1000),
+});
+
+// Parse environment variables
+const parseEnvConfig = () => {
+  const config = {
+    JWT_SECRET:
+      process.env.JWT_SECRET || "default_secret_key_change_in_production",
+    JWT_EXPIRY: parseInt(process.env.JWT_EXPIRY || "86400000"),
+    JWT_MAX_AGE: parseInt(process.env.JWT_MAX_AGE || "2592000000"),
+    JWT_ALGORITHM: process.env.JWT_ALGORITHM || "HS256",
+
+    RATE_LIMIT_WINDOW: parseInt(process.env.RATE_LIMIT_WINDOW || "900000"),
+    RATE_LIMIT_MAX_REQUESTS: parseInt(
+      process.env.RATE_LIMIT_MAX_REQUESTS || "100",
+    ),
+    RATE_LIMIT_WEBSOCKET: parseInt(process.env.RATE_LIMIT_WEBSOCKET || "1000"),
+
+    TOKEN_MIN_LENGTH: parseInt(process.env.TOKEN_MIN_LENGTH || "32"),
+    MAX_FAILED_ATTEMPTS: parseInt(process.env.MAX_FAILED_ATTEMPTS || "5"),
+    LOCKOUT_DURATION: parseInt(process.env.LOCKOUT_DURATION || "900000"),
+
+    CORS_ORIGINS: (
+      process.env.CORS_ORIGINS || "http://localhost:3000,http://localhost:8123"
+    )
+      .split(",")
+      .map((origin) => origin.trim()),
+    CORS_METHODS: (process.env.CORS_METHODS || "GET,POST,PUT,DELETE,OPTIONS")
+      .split(",")
+      .map((method) => method.trim()),
+    CORS_ALLOWED_HEADERS: (
+      process.env.CORS_ALLOWED_HEADERS ||
+      "Content-Type,Authorization,X-Requested-With"
+    )
+      .split(",")
+      .map((header) => header.trim()),
+    CORS_EXPOSED_HEADERS: (process.env.CORS_EXPOSED_HEADERS || "")
+      .split(",")
+      .filter(Boolean)
+      .map((header) => header.trim()),
+    CORS_CREDENTIALS: process.env.CORS_CREDENTIALS !== "false",
+    CORS_MAX_AGE: parseInt(process.env.CORS_MAX_AGE || "86400"),
+
+    CSP_ENABLED: process.env.CSP_ENABLED !== "false",
+    CSP_REPORT_ONLY: process.env.CSP_REPORT_ONLY === "true",
+    CSP_REPORT_URI: process.env.CSP_REPORT_URI,
+
+    REQUIRE_HTTPS:
+      process.env.REQUIRE_HTTPS !== "false" &&
+      process.env.NODE_ENV === "production",
+    HSTS_MAX_AGE: parseInt(process.env.HSTS_MAX_AGE || "31536000"),
+    HSTS_INCLUDE_SUBDOMAINS: process.env.HSTS_INCLUDE_SUBDOMAINS !== "false",
+    HSTS_PRELOAD: process.env.HSTS_PRELOAD !== "false",
+
+    COOKIE_SECRET: process.env.COOKIE_SECRET,
+    COOKIE_SECURE:
+      process.env.COOKIE_SECURE !== "false" &&
+      process.env.NODE_ENV === "production",
+    COOKIE_HTTP_ONLY: process.env.COOKIE_HTTP_ONLY !== "false",
+    COOKIE_SAME_SITE: (process.env.COOKIE_SAME_SITE || "Strict") as
+      | "Strict"
+      | "Lax"
+      | "None",
+
+    MAX_REQUEST_SIZE: parseInt(process.env.MAX_REQUEST_SIZE || "1048576"),
+    MAX_REQUEST_FIELDS: parseInt(process.env.MAX_REQUEST_FIELDS || "1000"),
+  };
+
+  return securityConfigSchema.parse(config);
+};
+
+// Export the validated configuration
+export const SECURITY_CONFIG = parseEnvConfig();
+
+// Export types
+export type SecurityConfig = z.infer<typeof securityConfigSchema>;

src/context/index.ts

@@ -1,226 +1,239 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from "events";
 
 // Resource types
 export enum ResourceType {
-    DEVICE = 'device',
+  DEVICE = "device",
-    AREA = 'area',
+  AREA = "area",
-    USER = 'user',
+  USER = "user",
-    AUTOMATION = 'automation',
+  AUTOMATION = "automation",
-    SCENE = 'scene',
+  SCENE = "scene",
-    SCRIPT = 'script',
+  SCRIPT = "script",
-    GROUP = 'group'
+  GROUP = "group",
 }
 
 // Resource state interface
 export interface ResourceState {
-    id: string;
+  id: string;
-    type: ResourceType;
+  type: ResourceType;
-    state: any;
+  state: any;
-    attributes: Record<string, any>;
+  attributes: Record<string, any>;
-    lastUpdated: number;
+  lastUpdated: number;
-    context?: Record<string, any>;
+  context?: Record<string, any>;
 }
 
 // Resource relationship types
 export enum RelationType {
-    CONTAINS = 'contains',
+  CONTAINS = "contains",
-    CONTROLS = 'controls',
+  CONTROLS = "controls",
-    TRIGGERS = 'triggers',
+  TRIGGERS = "triggers",
-    DEPENDS_ON = 'depends_on',
+  DEPENDS_ON = "depends_on",
-    GROUPS = 'groups'
+  GROUPS = "groups",
 }
 
 // Resource relationship interface
 export interface ResourceRelationship {
-    sourceId: string;
+  sourceId: string;
-    targetId: string;
+  targetId: string;
-    type: RelationType;
+  type: RelationType;
-    metadata?: Record<string, any>;
+  metadata?: Record<string, any>;
 }
 
 // Context manager class
 export class ContextManager extends EventEmitter {
-    private resources: Map<string, ResourceState> = new Map();
+  private resources: Map<string, ResourceState> = new Map();
-    private relationships: ResourceRelationship[] = [];
+  private relationships: ResourceRelationship[] = [];
-    private stateHistory: Map<string, ResourceState[]> = new Map();
+  private stateHistory: Map<string, ResourceState[]> = new Map();
-    private historyLimit = 100;
+  private historyLimit = 100;
 
-    constructor() {
+  constructor() {
-        super();
+    super();
+  }
+
+  // Resource management
+  public addResource(resource: ResourceState): void {
+    this.resources.set(resource.id, resource);
+    this.emit("resource_added", resource);
+  }
+
+  public updateResource(id: string, update: Partial<ResourceState>): void {
+    const resource = this.resources.get(id);
+    if (resource) {
+      // Store current state in history
+      this.addToHistory(resource);
+
+      // Update resource
+      const updatedResource = {
+        ...resource,
+        ...update,
+        lastUpdated: Date.now(),
+      };
+      this.resources.set(id, updatedResource);
+      this.emit("resource_updated", updatedResource);
     }
+  }
 
-    // Resource management
+  public removeResource(id: string): void {
-    public addResource(resource: ResourceState): void {
+    const resource = this.resources.get(id);
-        this.resources.set(resource.id, resource);
+    if (resource) {
-        this.emit('resource_added', resource);
+      this.resources.delete(id);
+      // Remove related relationships
+      this.relationships = this.relationships.filter(
+        (rel) => rel.sourceId !== id && rel.targetId !== id,
+      );
+      this.emit("resource_removed", resource);
     }
+  }
 
-    public updateResource(id: string, update: Partial<ResourceState>): void {
+  // Relationship management
-        const resource = this.resources.get(id);
+  public addRelationship(relationship: ResourceRelationship): void {
-        if (resource) {
+    this.relationships.push(relationship);
-            // Store current state in history
+    this.emit("relationship_added", relationship);
-            this.addToHistory(resource);
+  }
 
-            // Update resource
+  public removeRelationship(
-            const updatedResource = {
+    sourceId: string,
-                ...resource,
+    targetId: string,
-                ...update,
+    type: RelationType,
-                lastUpdated: Date.now()
+  ): void {
-            };
+    const index = this.relationships.findIndex(
-            this.resources.set(id, updatedResource);
+      (rel) =>
-            this.emit('resource_updated', updatedResource);
+        rel.sourceId === sourceId &&
-        }
+        rel.targetId === targetId &&
+        rel.type === type,
+    );
+    if (index !== -1) {
+      const removed = this.relationships.splice(index, 1)[0];
+      this.emit("relationship_removed", removed);
     }
+  }
 
-    public removeResource(id: string): void {
+  // History management
-        const resource = this.resources.get(id);
+  private addToHistory(state: ResourceState): void {
-        if (resource) {
+    const history = this.stateHistory.get(state.id) || [];
-            this.resources.delete(id);
+    history.push({ ...state });
-            // Remove related relationships
+    if (history.length > this.historyLimit) {
-            this.relationships = this.relationships.filter(
+      history.shift();
-                rel => rel.sourceId !== id && rel.targetId !== id
-            );
-            this.emit('resource_removed', resource);
-        }
     }
+    this.stateHistory.set(state.id, history);
+  }
 
-    // Relationship management
+  public getHistory(id: string): ResourceState[] {
-    public addRelationship(relationship: ResourceRelationship): void {
+    return this.stateHistory.get(id) || [];
-        this.relationships.push(relationship);
+  }
-        this.emit('relationship_added', relationship);
-    }
 
-    public removeRelationship(sourceId: string, targetId: string, type: RelationType): void {
+  // Context queries
-        const index = this.relationships.findIndex(
+  public getResource(id: string): ResourceState | undefined {
-            rel => rel.sourceId === sourceId && rel.targetId === targetId && rel.type === type
+    return this.resources.get(id);
-        );
+  }
-        if (index !== -1) {
-            const removed = this.relationships.splice(index, 1)[0];
-            this.emit('relationship_removed', removed);
-        }
-    }
 
-    // History management
+  public getResourcesByType(type: ResourceType): ResourceState[] {
-    private addToHistory(state: ResourceState): void {
+    return Array.from(this.resources.values()).filter(
-        const history = this.stateHistory.get(state.id) || [];
+      (resource) => resource.type === type,
-        history.push({ ...state });
+    );
-        if (history.length > this.historyLimit) {
+  }
-            history.shift();
-        }
-        this.stateHistory.set(state.id, history);
-    }
 
-    public getHistory(id: string): ResourceState[] {
+  public getRelatedResources(
-        return this.stateHistory.get(id) || [];
+    id: string,
-    }
+    type?: RelationType,
+    depth: number = 1,
+  ): ResourceState[] {
+    const related = new Set<ResourceState>();
+    const visited = new Set<string>();
 
-    // Context queries
+    const traverse = (currentId: string, currentDepth: number) => {
-    public getResource(id: string): ResourceState | undefined {
+      if (currentDepth > depth || visited.has(currentId)) return;
-        return this.resources.get(id);
+      visited.add(currentId);
-    }
 
-    public getResourcesByType(type: ResourceType): ResourceState[] {
+      this.relationships
-        return Array.from(this.resources.values()).filter(
+        .filter(
-            resource => resource.type === type
+          (rel) =>
-        );
+            (rel.sourceId === currentId || rel.targetId === currentId) &&
-    }
+            (!type || rel.type === type),
+        )
+        .forEach((rel) => {
+          const relatedId =
+            rel.sourceId === currentId ? rel.targetId : rel.sourceId;
+          const relatedResource = this.resources.get(relatedId);
+          if (relatedResource) {
+            related.add(relatedResource);
+            traverse(relatedId, currentDepth + 1);
+          }
+        });
+    };
 
-    public getRelatedResources(
+    traverse(id, 0);
-        id: string,
+    return Array.from(related);
-        type?: RelationType,
+  }
-        depth: number = 1
-    ): ResourceState[] {
-        const related = new Set<ResourceState>();
-        const visited = new Set<string>();
 
-        const traverse = (currentId: string, currentDepth: number) => {
+  // Context analysis
-            if (currentDepth > depth || visited.has(currentId)) return;
+  public analyzeResourceUsage(id: string): {
-            visited.add(currentId);
+    dependencies: string[];
+    dependents: string[];
+    groups: string[];
+    usage: {
+      triggerCount: number;
+      controlCount: number;
+      groupCount: number;
+    };
+  } {
+    const dependencies = this.relationships
+      .filter(
+        (rel) => rel.sourceId === id && rel.type === RelationType.DEPENDS_ON,
+      )
+      .map((rel) => rel.targetId);
 
-            this.relationships
+    const dependents = this.relationships
-                .filter(rel =>
+      .filter(
-                    (rel.sourceId === currentId || rel.targetId === currentId) &&
+        (rel) => rel.targetId === id && rel.type === RelationType.DEPENDS_ON,
-                    (!type || rel.type === type)
+      )
-                )
+      .map((rel) => rel.sourceId);
-                .forEach(rel => {
-                    const relatedId = rel.sourceId === currentId ? rel.targetId : rel.sourceId;
-                    const relatedResource = this.resources.get(relatedId);
-                    if (relatedResource) {
-                        related.add(relatedResource);
-                        traverse(relatedId, currentDepth + 1);
-                    }
-                });
-        };
 
-        traverse(id, 0);
+    const groups = this.relationships
-        return Array.from(related);
+      .filter((rel) => rel.targetId === id && rel.type === RelationType.GROUPS)
-    }
+      .map((rel) => rel.sourceId);
 
-    // Context analysis
+    const usage = {
-    public analyzeResourceUsage(id: string): {
+      triggerCount: this.relationships.filter(
-        dependencies: string[];
+        (rel) => rel.sourceId === id && rel.type === RelationType.TRIGGERS,
-        dependents: string[];
+      ).length,
-        groups: string[];
+      controlCount: this.relationships.filter(
-        usage: {
+        (rel) => rel.sourceId === id && rel.type === RelationType.CONTROLS,
-            triggerCount: number;
+      ).length,
-            controlCount: number;
+      groupCount: groups.length,
-            groupCount: number;
+    };
-        };
-    } {
-        const dependencies = this.relationships
-            .filter(rel => rel.sourceId === id && rel.type === RelationType.DEPENDS_ON)
-            .map(rel => rel.targetId);
 
-        const dependents = this.relationships
+    return { dependencies, dependents, groups, usage };
-            .filter(rel => rel.targetId === id && rel.type === RelationType.DEPENDS_ON)
+  }
-            .map(rel => rel.sourceId);
 
-        const groups = this.relationships
+  // Event subscriptions
-            .filter(rel => rel.targetId === id && rel.type === RelationType.GROUPS)
+  public subscribeToResource(
-            .map(rel => rel.sourceId);
+    id: string,
+    callback: (state: ResourceState) => void,
+  ): () => void {
+    const handler = (resource: ResourceState) => {
+      if (resource.id === id) {
+        callback(resource);
+      }
+    };
 
-        const usage = {
+    this.on("resource_updated", handler);
-            triggerCount: this.relationships.filter(
+    return () => this.off("resource_updated", handler);
-                rel => rel.sourceId === id && rel.type === RelationType.TRIGGERS
+  }
-            ).length,
-            controlCount: this.relationships.filter(
-                rel => rel.sourceId === id && rel.type === RelationType.CONTROLS
-            ).length,
-            groupCount: groups.length
-        };
 
-        return { dependencies, dependents, groups, usage };
+  public subscribeToType(
-    }
+    type: ResourceType,
+    callback: (state: ResourceState) => void,
+  ): () => void {
+    const handler = (resource: ResourceState) => {
+      if (resource.type === type) {
+        callback(resource);
+      }
+    };
 
-    // Event subscriptions
+    this.on("resource_updated", handler);
-    public subscribeToResource(
+    return () => this.off("resource_updated", handler);
-        id: string,
+  }
-        callback: (state: ResourceState) => void
-    ): () => void {
-        const handler = (resource: ResourceState) => {
-            if (resource.id === id) {
-                callback(resource);
-            }
-        };
-
-        this.on('resource_updated', handler);
-        return () => this.off('resource_updated', handler);
-    }
-
-    public subscribeToType(
-        type: ResourceType,
-        callback: (state: ResourceState) => void
-    ): () => void {
-        const handler = (resource: ResourceState) => {
-            if (resource.type === type) {
-                callback(resource);
-            }
-        };
-
-        this.on('resource_updated', handler);
-        return () => this.off('resource_updated', handler);
-    }
 }
 
 // Export context manager instance
-export const contextManager = new ContextManager(); 
+export const contextManager = new ContextManager();

src/hass/index.ts

@@ -1,687 +1,125 @@
-import { CreateApplication, TServiceParams, ServiceFunction, AlsExtension, GetApisResult, ILogger, InternalDefinition, TContext, TInjectedConfig, TLifecycleBase, TScheduler } from "@digital-alchemy/core";
+import type { HassEntity } from "../interfaces/hass.js";
-import { Area, Backup, CallProxy, Configure, Device, EntityManager, EventsService, FetchAPI, FetchInternals, Floor, IDByExtension, Label, LIB_HASS, ReferenceService, Registry, WebsocketAPI, Zone } from "@digital-alchemy/hass";
-import { DomainSchema } from "../schemas.js";
-import { HASS_CONFIG } from "../config/index.js";
-import WebSocket from 'ws';
-import { EventEmitter } from 'events';
-import * as HomeAssistant from '../types/hass.js';
-import { HassEntity, HassEvent, HassService } from '../interfaces/hass.js';
 
-type Environments = "development" | "production" | "test";
+class HomeAssistantAPI {
+  private baseUrl: string;
+  private token: string;
 
-// Define the type for Home Assistant services
+  constructor() {
-type HassServiceMethod = (data: Record<string, unknown>) => Promise<void>;
+    this.baseUrl = process.env.HASS_HOST || "http://localhost:8123";
+    this.token = process.env.HASS_TOKEN || "";
 
-type HassServices = {
+    if (!this.token || this.token === "your_hass_token_here") {
-  [K in keyof typeof DomainSchema.Values]: {
+      throw new Error("HASS_TOKEN is required but not set in environment variables");
-    [service: string]: HassServiceMethod;
-  };
-};
-
-// Define the type for Home Assistant instance
-interface HassInstance {
-  states: {
-    get: () => Promise<HassEntity[]>;
-    subscribe: (callback: (states: HassEntity[]) => void) => Promise<number>;
-    unsubscribe: (subscription: number) => void;
-  };
-  services: {
-    get: () => Promise<Record<string, Record<string, HassService>>>;
-    call: (domain: string, service: string, serviceData?: Record<string, any>) => Promise<void>;
-  };
-  connection: {
-    socket: WebSocket;
-    subscribeEvents: (callback: (event: HassEvent) => void, eventType?: string) => Promise<number>;
-    unsubscribeEvents: (subscription: number) => void;
-  };
-  subscribeEvents: (callback: (event: HassEvent) => void, eventType?: string) => Promise<number>;
-  unsubscribeEvents: (subscription: number) => void;
-}
-
-// Configuration type for application with more specific constraints
-type ApplicationConfiguration = {
-  NODE_ENV: ServiceFunction<Environments>;
-};
-
-// Strict configuration type for Home Assistant
-type HassConfiguration = {
-  BASE_URL: {
-    type: "string";
-    description: string;
-    required: true;
-    default: string;
-  };
-  TOKEN: {
-    type: "string";
-    description: string;
-    required: true;
-    default: string;
-  };
-  SOCKET_URL: {
-    type: "string";
-    description: string;
-    required: true;
-    default: string;
-  };
-  SOCKET_TOKEN: {
-    type: "string";
-    description: string;
-    required: true;
-    default: string;
-  };
-};
-
-// application
-const MY_APP = CreateApplication<ApplicationConfiguration, {}>({
-  configuration: {
-    NODE_ENV: {
-      type: "string",
-      default: "development",
-      enum: ["development", "production", "test"],
-      description: "Code runner addon can set with it's own NODE_ENV",
-    },
-  },
-  services: {
-    NODE_ENV: () => {
-      // Directly return the default value or use process.env
-      return (process.env.NODE_ENV as Environments) || "development";
-    }
-  },
-  libraries: [
-    {
-      ...LIB_HASS,
-      configuration: {
-        BASE_URL: {
-          type: "string",
-          description: "Home Assistant base URL",
-          required: true,
-          default: HASS_CONFIG.BASE_URL
-        },
-        TOKEN: {
-          type: "string",
-          description: "Home Assistant long-lived access token",
-          required: true,
-          default: HASS_CONFIG.TOKEN
-        },
-        SOCKET_URL: {
-          type: "string",
-          description: "Home Assistant WebSocket URL",
-          required: true,
-          default: HASS_CONFIG.SOCKET_URL
-        },
-        SOCKET_TOKEN: {
-          type: "string",
-          description: "Home Assistant WebSocket token",
-          required: true,
-          default: HASS_CONFIG.SOCKET_TOKEN
-        }
-      }
-    }
-  ],
-  name: 'hass' as const
-});
-
-export interface HassConfig {
-  host: string;
-  token: string;
-}
-
-const CONFIG: Record<string, HassConfig> = {
-  development: {
-    host: process.env.HASS_HOST || 'http://localhost:8123',
-    token: process.env.HASS_TOKEN || ''
-  },
-  production: {
-    host: process.env.HASS_HOST || '',
-    token: process.env.HASS_TOKEN || ''
-  },
-  test: {
-    host: 'http://localhost:8123',
-    token: 'test_token'
-  }
-};
-
-export class HassWebSocketClient extends EventEmitter {
-  private ws: WebSocket | null = null;
-  private messageId = 1;
-  private subscriptions = new Map<number, (data: any) => void>();
-  private reconnectAttempts = 0;
-  private options: {
-    autoReconnect: boolean;
-    maxReconnectAttempts: number;
-    reconnectDelay: number;
-  };
-
-  constructor(
-    private url: string,
-    private token: string,
-    options: Partial<typeof HassWebSocketClient.prototype.options> = {}
-  ) {
-    super();
-    this.options = {
-      autoReconnect: true,
-      maxReconnectAttempts: 3,
-      reconnectDelay: 1000,
-      ...options
-    };
-  }
-
-  async connect(): Promise<void> {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      return;
     }
 
-    return new Promise((resolve, reject) => {
+    console.log(`Initializing Home Assistant API with base URL: ${this.baseUrl}`);
-      this.ws = new WebSocket(this.url);
-
-      this.ws.on('open', () => {
-        this.emit('open');
-        const authMessage: HomeAssistant.AuthMessage = {
-          type: 'auth',
-          access_token: this.token
-        };
-        this.ws?.send(JSON.stringify(authMessage));
-      });
-
-      this.ws.on('message', (data: string) => {
-        try {
-          const message = JSON.parse(data);
-          this.handleMessage(message);
-        } catch (error) {
-          this.emit('error', new Error('Failed to parse message'));
-        }
-      });
-
-      this.ws.on('close', () => {
-        this.emit('disconnected');
-        if (this.options.autoReconnect && this.reconnectAttempts < this.options.maxReconnectAttempts) {
-          setTimeout(() => {
-            this.reconnectAttempts++;
-            this.connect();
-          }, this.options.reconnectDelay);
-        }
-      });
-
-      this.ws.on('error', (error) => {
-        this.emit('error', error);
-        reject(error);
-      });
-    });
   }
 
-  private handleMessage(message: any): void {
+  private async fetchApi(endpoint: string, options: RequestInit = {}) {
-    switch (message.type) {
+    const url = `${this.baseUrl}/api/${endpoint}`;
-      case 'auth_ok':
+    console.log(`Making request to: ${url}`);
-        this.emit('auth_ok');
+    console.log('Request options:', {
-        break;
+      method: options.method || 'GET',
-      case 'auth_invalid':
-        this.emit('auth_invalid');
-        break;
-      case 'result':
-        // Handle command results
-        break;
-      case 'event':
-        if (message.event) {
-          this.emit('event', message.event);
-          const subscription = this.subscriptions.get(message.id);
-          if (subscription) {
-            subscription(message.event.data);
-          }
-        }
-        break;
-      default:
-        this.emit('error', new Error(`Unknown message type: ${message.type}`));
-    }
-  }
-
-  async subscribeEvents(callback: (data: any) => void, eventType?: string): Promise<number> {
-    const id = this.messageId++;
-    const message = {
-      id,
-      type: 'subscribe_events',
-      event_type: eventType
-    };
-
-    return new Promise((resolve, reject) => {
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-        reject(new Error('WebSocket not connected'));
-        return;
-      }
-
-      this.subscriptions.set(id, callback);
-      this.ws.send(JSON.stringify(message));
-      resolve(id);
-    });
-  }
-
-  async unsubscribeEvents(subscriptionId: number): Promise<void> {
-    const message = {
-      id: this.messageId++,
-      type: 'unsubscribe_events',
-      subscription: subscriptionId
-    };
-
-    return new Promise((resolve, reject) => {
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-        reject(new Error('WebSocket not connected'));
-        return;
-      }
-
-      this.ws.send(JSON.stringify(message));
-      this.subscriptions.delete(subscriptionId);
-      resolve();
-    });
-  }
-
-  disconnect(): void {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-}
-
-export class HassInstanceImpl implements HassInstance {
-  public readonly baseUrl: string;
-  public readonly token: string;
-  public wsClient: HassWebSocketClient | undefined;
-
-  public readonly services: HassInstance['services'];
-  public readonly states: HassInstance['states'];
-  public readonly connection: HassInstance['connection'];
-
-  constructor(baseUrl: string, token: string) {
-    this.baseUrl = baseUrl;
-    this.token = token;
-
-    // Initialize services
-    this.services = {
-      get: async () => {
-        const response = await fetch(`${this.baseUrl}/api/services`, {
-          headers: {
-            Authorization: `Bearer ${this.token}`,
-            'Content-Type': 'application/json',
-          },
-        });
-        if (!response.ok) {
-          throw new Error(`Failed to fetch services: ${response.statusText}`);
-        }
-        return response.json();
-      },
-      call: async (domain: string, service: string, serviceData?: Record<string, any>) => {
-        const response = await fetch(`${this.baseUrl}/api/services/${domain}/${service}`, {
-          method: 'POST',
-          headers: {
-            Authorization: `Bearer ${this.token}`,
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify(serviceData),
-        });
-        if (!response.ok) {
-          throw new Error(`Service call failed: ${response.statusText}`);
-        }
-      }
-    };
-
-    // Initialize states
-    this.states = {
-      get: async () => {
-        const response = await fetch(`${this.baseUrl}/api/states`, {
-          headers: {
-            Authorization: `Bearer ${this.token}`,
-            'Content-Type': 'application/json',
-          },
-        });
-        if (!response.ok) {
-          throw new Error(`Failed to fetch states: ${response.statusText}`);
-        }
-        return response.json();
-      },
-      subscribe: async (callback: (states: HassEntity[]) => void) => {
-        return this.subscribeEvents((event: HassEvent) => {
-          if (event.event_type === 'state_changed') {
-            this.states.get().then(callback);
-          }
-        }, 'state_changed');
-      },
-      unsubscribe: (subscription: number) => {
-        this.unsubscribeEvents(subscription);
-      }
-    };
-
-    // Initialize connection
-    this.connection = {
-      socket: new WebSocket(this.baseUrl.replace(/^http/, 'ws') + '/api/websocket'),
-      subscribeEvents: this.subscribeEvents.bind(this),
-      unsubscribeEvents: this.unsubscribeEvents.bind(this)
-    };
-
-    this.initialize();
-  }
-
-  public als!: AlsExtension;
-  public context!: TContext;
-  public event!: EventEmitter<[never]>;
-  public internal!: InternalDefinition;
-  public lifecycle!: TLifecycleBase;
-  public logger!: ILogger;
-  public scheduler!: TScheduler;
-  public config!: TInjectedConfig;
-  public params!: TServiceParams;
-  public hass!: GetApisResult<{
-    area: typeof Area;
-    backup: typeof Backup;
-    call: typeof CallProxy;
-    configure: typeof Configure;
-    device: typeof Device;
-    entity: typeof EntityManager;
-    events: typeof EventsService;
-    fetch: typeof FetchAPI;
-    floor: typeof Floor;
-    idBy: typeof IDByExtension;
-    internals: typeof FetchInternals;
-    label: typeof Label;
-    refBy: typeof ReferenceService;
-    registry: typeof Registry;
-    socket: typeof WebsocketAPI;
-    zone: typeof Zone;
-  }>;
-
-  private initialize() {
-    // Initialize all required properties with proper type instantiation
-    this.als = {} as AlsExtension;
-    this.context = {} as TContext;
-    this.event = new EventEmitter();
-    this.internal = {} as InternalDefinition;
-    this.lifecycle = {} as TLifecycleBase;
-    this.logger = {} as ILogger;
-    this.scheduler = {} as TScheduler;
-    this.config = {} as TInjectedConfig;
-    this.params = {} as TServiceParams;
-    this.hass = {} as GetApisResult<any>;
-  }
-
-  async fetchStates(): Promise<HomeAssistant.Entity[]> {
-    const response = await fetch(`${this.baseUrl}/api/states`, {
       headers: {
-        Authorization: `Bearer ${this.token}`,
+        Authorization: 'Bearer [REDACTED]',
-        'Content-Type': 'application/json',
+        "Content-Type": "application/json",
+        ...options.headers,
       },
+      body: options.body ? JSON.parse(options.body as string) : undefined
     });
 
-    if (!response.ok) {
+    try {
-      throw new Error(`Failed to fetch states: ${response.statusText}`);
+      const response = await fetch(url, {
-    }
+        ...options,
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json",
+          ...options.headers,
+        },
+      });
 
-    const data = await response.json();
+      if (!response.ok) {
-    return data as HomeAssistant.Entity[];
+        const errorText = await response.text();
+        console.error('Home Assistant API error:', {
+          status: response.status,
+          statusText: response.statusText,
+          error: errorText
+        });
+        throw new Error(`Home Assistant API error: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+
+      const data = await response.json();
+      console.log('Response data:', data);
+      return data;
+    } catch (error) {
+      console.error('Failed to make request:', error);
+      throw error;
+    }
   }
 
-  async fetchState(entityId: string): Promise<HomeAssistant.Entity> {
+  async getStates(): Promise<HassEntity[]> {
-    const response = await fetch(`${this.baseUrl}/api/states/${entityId}`, {
+    return this.fetchApi("states");
-      headers: {
+  }
-        Authorization: `Bearer ${this.token}`,
-        'Content-Type': 'application/json',
-      },
-    });
 
-    if (!response.ok) {
+  async getState(entityId: string): Promise<HassEntity> {
-      throw new Error(`Failed to fetch state: ${response.statusText}`);
+    return this.fetchApi(`states/${entityId}`);
-    }
-
-    const data = await response.json();
-    return data as HomeAssistant.Entity;
   }
 
   async callService(domain: string, service: string, data: Record<string, any>): Promise<void> {
-    const response = await fetch(`${this.baseUrl}/api/services/${domain}/${service}`, {
+    await this.fetchApi(`services/${domain}/${service}`, {
-      method: 'POST',
+      method: "POST",
-      headers: {
-        Authorization: `Bearer ${this.token}`,
-        'Content-Type': 'application/json',
-      },
       body: JSON.stringify(data),
     });
-
-    if (!response.ok) {
-      throw new Error(`Service call failed: ${response.statusText}`);
-    }
-  }
-
-  async subscribeEvents(callback: (event: HassEvent) => void, eventType?: string): Promise<number> {
-    if (!this.wsClient) {
-      this.wsClient = new HassWebSocketClient(
-        this.baseUrl.replace(/^http/, 'ws') + '/api/websocket',
-        this.token
-      );
-      await this.wsClient.connect();
-    }
-
-    return this.wsClient.subscribeEvents((data: any) => {
-      const hassEvent: HassEvent = {
-        event_type: data.event_type,
-        data: data.data,
-        origin: data.origin,
-        time_fired: data.time_fired,
-        context: {
-          id: data.context.id,
-          parent_id: data.context.parent_id,
-          user_id: data.context.user_id
-        }
-      };
-      callback(hassEvent);
-    }, eventType);
-  }
-
-  async unsubscribeEvents(subscriptionId: number): Promise<void> {
-    if (this.wsClient) {
-      await this.wsClient.unsubscribeEvents(subscriptionId);
-    }
   }
 }
 
-class HomeAssistantInstance implements HassInstance {
+let instance: HomeAssistantAPI | null = null;
-  private messageId = 1;
-  private messageCallbacks = new Map<number, (result: any) => void>();
-  private eventCallbacks = new Map<number, (event: HassEvent) => void>();
-  private stateCallbacks = new Map<number, (states: HassEntity[]) => void>();
-  private _authenticated = false;
-  private socket: WebSocket;
-  private readonly _states: HassInstance['states'];
-  private readonly _services: HassInstance['services'];
-  private readonly _connection: HassInstance['connection'];
 
-  constructor() {
+export async function get_hass() {
-    if (!HASS_CONFIG.TOKEN) {
+  if (!instance) {
-      throw new Error('Home Assistant token is required');
+    try {
-    }
+      instance = new HomeAssistantAPI();
-
+      // Verify connection by trying to get states
-    this.socket = new WebSocket(HASS_CONFIG.SOCKET_URL);
+      await instance.getStates();
-
+      console.log('Successfully connected to Home Assistant');
-    this._states = {
+    } catch (error) {
-      get: async (): Promise<HassEntity[]> => {
+      console.error('Failed to initialize Home Assistant connection:', error);
-        const message = {
+      instance = null;
-          type: 'get_states'
+      throw error;
-        };
-        return this.sendMessage(message);
-      },
-
-      subscribe: async (callback: (states: HassEntity[]) => void): Promise<number> => {
-        const id = this.messageId++;
-        this.stateCallbacks.set(id, callback);
-
-        const message = {
-          type: 'subscribe_events',
-          event_type: 'state_changed'
-        };
-
-        await this.sendMessage(message);
-        return id;
-      },
-
-      unsubscribe: (subscription: number): void => {
-        this.stateCallbacks.delete(subscription);
-      }
-    };
-
-    this._services = {
-      get: async (): Promise<Record<string, Record<string, HassService>>> => {
-        const message = {
-          type: 'get_services'
-        };
-        return this.sendMessage(message);
-      },
-
-      call: async (domain: string, service: string, serviceData?: Record<string, any>): Promise<void> => {
-        const message = {
-          type: 'call_service',
-          domain,
-          service,
-          service_data: serviceData
-        };
-        await this.sendMessage(message);
-      }
-    };
-
-    this._connection = {
-      socket: this.socket,
-      subscribeEvents: this.subscribeEvents.bind(this),
-      unsubscribeEvents: this.unsubscribeEvents.bind(this)
-    };
-
-    this.setupWebSocket();
-  }
-
-  get authenticated(): boolean {
-    return this._authenticated;
-  }
-
-  get states(): HassInstance['states'] {
-    return this._states;
-  }
-
-  get services(): HassInstance['services'] {
-    return this._services;
-  }
-
-  get connection(): HassInstance['connection'] {
-    return this._connection;
-  }
-
-  private setupWebSocket() {
-    this.socket.on('open', () => {
-      this.authenticate();
-    });
-
-    this.socket.on('message', (data: WebSocket.Data) => {
-      if (typeof data === 'string') {
-        const message = JSON.parse(data);
-        this.handleMessage(message);
-      }
-    });
-
-    this.socket.on('close', () => {
-      console.log('WebSocket connection closed');
-      // Implement reconnection logic here
-    });
-
-    this.socket.on('error', (error) => {
-      console.error('WebSocket error:', error);
-    });
-  }
-
-  private authenticate() {
-    const auth = {
-      type: 'auth',
-      access_token: HASS_CONFIG.TOKEN
-    };
-    this.socket.send(JSON.stringify(auth));
-  }
-
-  private handleMessage(message: any) {
-    if (message.type === 'auth_ok') {
-      this._authenticated = true;
-      console.log('Authenticated with Home Assistant');
-      return;
-    }
-
-    if (message.type === 'auth_invalid') {
-      console.error('Authentication failed:', message.message);
-      return;
-    }
-
-    if (message.type === 'event') {
-      const callback = this.eventCallbacks.get(message.id);
-      if (callback) {
-        callback(message.event);
-      }
-      return;
-    }
-
-    if (message.type === 'result') {
-      const callback = this.messageCallbacks.get(message.id);
-      if (callback) {
-        callback(message.result);
-        this.messageCallbacks.delete(message.id);
-      }
-      return;
     }
   }
-
+  return instance;
-  private async sendMessage(message: any): Promise<any> {
-    if (!this._authenticated) {
-      throw new Error('Not authenticated with Home Assistant');
-    }
-
-    return new Promise((resolve, reject) => {
-      const id = this.messageId++;
-      message.id = id;
-
-      this.messageCallbacks.set(id, resolve);
-      this.socket.send(JSON.stringify(message));
-
-      // Add timeout
-      setTimeout(() => {
-        this.messageCallbacks.delete(id);
-        reject(new Error('Message timeout'));
-      }, 10000);
-    });
-  }
-
-  public async subscribeEvents(callback: (event: HassEvent) => void, eventType?: string): Promise<number> {
-    const id = this.messageId++;
-    this.eventCallbacks.set(id, callback);
-
-    const message = {
-      type: 'subscribe_events',
-      event_type: eventType
-    };
-
-    await this.sendMessage(message);
-    return id;
-  }
-
-  public unsubscribeEvents(subscription: number): void {
-    this.eventCallbacks.delete(subscription);
-  }
 }
 
-let hassInstance: HomeAssistantInstance | null = null;
+// Helper function to call Home Assistant services
+export async function call_service(
+  domain: string,
+  service: string,
+  data: Record<string, any>,
+) {
+  const hass = await get_hass();
+  return hass.callService(domain, service, data);
+}
 
-export async function get_hass(): Promise<HassInstance> {
+// Helper function to list devices
-  if (!hassInstance) {
+export async function list_devices() {
-    hassInstance = new HomeAssistantInstance();
+  const hass = await get_hass();
-    // Wait for authentication
+  const states = await hass.getStates();
-    await new Promise<void>((resolve) => {
+  return states.map((state: HassEntity) => ({
-      const checkAuth = () => {
+    entity_id: state.entity_id,
-        if (hassInstance?.authenticated) {
+    state: state.state,
-          resolve();
+    attributes: state.attributes
-        } else {
+  }));
-          setTimeout(checkAuth, 100);
+}
-        }
+
-      };
+// Helper function to get entity states
-      checkAuth();
+export async function get_states() {
-    });
+  const hass = await get_hass();
-  }
+  return hass.getStates();
-  return hassInstance;
+}
-}
+
+// Helper function to get a specific entity state
+export async function get_state(entity_id: string) {
+  const hass = await get_hass();
+  return hass.getState(entity_id);
+}

src/hass/types.ts

@@ -0,0 +1,74 @@
+import type { WebSocket } from 'ws';
+
+export interface HassInstanceImpl {
+    baseUrl: string;
+    token: string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getStates(): Promise<any[]>;
+    callService(domain: string, service: string, data?: any): Promise<void>;
+    fetchStates(): Promise<any[]>;
+    fetchState(entityId: string): Promise<any>;
+    subscribeEvents(callback: (event: any) => void, eventType?: string): Promise<number>;
+    unsubscribeEvents(subscriptionId: number): Promise<void>;
+}
+
+export interface HassWebSocketClient {
+    url: string;
+    token: string;
+    socket: WebSocket | null;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    send(message: any): Promise<void>;
+    subscribe(callback: (data: any) => void): () => void;
+}
+
+export interface HassState {
+    entity_id: string;
+    state: string;
+    attributes: Record<string, any>;
+    last_changed: string;
+    last_updated: string;
+    context: {
+        id: string;
+        parent_id: string | null;
+        user_id: string | null;
+    };
+}
+
+export interface HassServiceCall {
+    domain: string;
+    service: string;
+    target?: {
+        entity_id?: string | string[];
+        device_id?: string | string[];
+        area_id?: string | string[];
+    };
+    service_data?: Record<string, any>;
+}
+
+export interface HassEvent {
+    event_type: string;
+    data: any;
+    origin: string;
+    time_fired: string;
+    context: {
+        id: string;
+        parent_id: string | null;
+        user_id: string | null;
+    };
+}
+
+export type MockFunction<T extends (...args: any[]) => any> = {
+    (...args: Parameters<T>): ReturnType<T>;
+    mock: {
+        calls: Parameters<T>[];
+        results: { type: 'return' | 'throw'; value: any }[];
+        instances: any[];
+        mockImplementation(fn: T): MockFunction<T>;
+        mockReturnValue(value: ReturnType<T>): MockFunction<T>;
+        mockResolvedValue(value: Awaited<ReturnType<T>>): MockFunction<T>;
+        mockRejectedValue(value: any): MockFunction<T>;
+        mockReset(): void;
+    };
+}; 

src/health-check.ts

@@ -1,16 +1,16 @@
 const check = async () => {
-    try {
+  try {
-        const response = await fetch('http://localhost:3000/health');
+    const response = await fetch("http://localhost:3000/health");
-        if (!response.ok) {
+    if (!response.ok) {
-            console.error('Health check failed:', response.status);
+      console.error("Health check failed:", response.status);
-            process.exit(1);
+      process.exit(1);
-        }
-        console.log('Health check passed');
-        process.exit(0);
-    } catch (error) {
-        console.error('Health check failed:', error);
-        process.exit(1);
     }
+    console.log("Health check passed");
+    process.exit(0);
+  } catch (error) {
+    console.error("Health check failed:", error);
+    process.exit(1);
+  }
 };
 
-check(); 
+check();

src/index.ts

@@ -1,73 +1,184 @@
 /**
- * Home Assistant MCP (Master Control Program)
+ * Home Assistant Model Context Protocol (MCP) Server
- * Main application entry point
+ * A standardized protocol for AI tools to interact with Home Assistant
- * 
- * This file initializes the Express server and sets up necessary
- * middleware and routes for the application when not in Claude mode.
- * 
- * @module index
  */
 
 import express from 'express';
-import { APP_CONFIG } from './config/app.config.js';
+import cors from 'cors';
-import { apiRoutes } from './routes/index.js';
+import swaggerUi from 'swagger-ui-express';
-import { securityHeaders, rateLimiter, validateRequest, sanitizeInput, errorHandler } from './security/index.js';
+import { MCPServer } from './mcp/MCPServer.js';
-import { requestLogger, errorLogger } from './middleware/logging.middleware.js';
+import { loggingMiddleware, timeoutMiddleware } from './mcp/middleware/index.js';
-import { get_hass } from './hass/index.js';
+import { StdioTransport } from './mcp/transports/stdio.transport.js';
-import { LiteMCP } from 'litemcp';
+import { HttpTransport } from './mcp/transports/http.transport.js';
-import { logger } from './utils/logger.js';
+import { APP_CONFIG } from './config.js';
-import { initLogRotation } from './utils/log-rotation.js';
+import { logger } from "./utils/logger.js";
+import { openApiConfig } from './openapi.js';
+import { apiLimiter, authLimiter } from './middleware/rate-limit.middleware.js';
+import { SecurityMiddleware } from './security/enhanced-middleware.js';
 
-logger.info('Starting Home Assistant MCP...');
+// Home Assistant tools
-logger.info('Initializing Home Assistant connection...');
+import { LightsControlTool } from './tools/homeassistant/lights.tool.js';
+import { ClimateControlTool } from './tools/homeassistant/climate.tool.js';
 
-// Initialize log rotation
+// Home Assistant optional tools - these can be added as needed
-initLogRotation();
+// import { ControlTool } from './tools/control.tool.js';
+// import { SceneTool } from './tools/scene.tool.js';
+// import { AutomationTool } from './tools/automation.tool.js';
+// import { NotifyTool } from './tools/notify.tool.js';
+// import { ListDevicesTool } from './tools/list-devices.tool.js';
+// import { HistoryTool } from './tools/history.tool.js';
 
 /**
- * Initialize LiteMCP instance
+ * Check if running in stdio mode via command line args
- * This provides the core MCP functionality
  */
-const server = new LiteMCP('home-assistant', APP_CONFIG.VERSION);
+function isStdioMode(): boolean {
+  return process.argv.includes('--stdio');
+}
 
-// Only start Express server when not in Claude mode
+/**
-if (process.env.PROCESSOR_TYPE !== 'claude') {
+ * Main function to start the MCP server
-  /**
+ */
-   * Initialize Express application with security middleware
+async function main() {
-   * and route handlers
+  logger.info('Starting Home Assistant MCP Server...');
-   */
-  const app = express();
 
-  // Apply logging middleware first to catch all requests
+  // Check if we're in stdio mode from command line
-  app.use(requestLogger);
+  const useStdio = isStdioMode() || APP_CONFIG.useStdioTransport;
 
-  // Apply security middleware
+  // Configure server
-  app.use(securityHeaders);
+  const EXECUTION_TIMEOUT = APP_CONFIG.executionTimeout;
-  app.use(rateLimiter);
+  const STREAMING_ENABLED = APP_CONFIG.streamingEnabled;
-  app.use(express.json());
-  app.use(validateRequest);
-  app.use(sanitizeInput);
 
-  /**
+  // Get the server instance (singleton)
-   * Mount API routes under /api
+  const server = MCPServer.getInstance();
-   * All API endpoints are prefixed with /api
-   */
-  app.use('/api', apiRoutes);
 
-  /**
+  // Register Home Assistant tools
-   * Apply error handling middleware
+  server.registerTool(new LightsControlTool());
-   * This should be the last middleware in the chain
+  server.registerTool(new ClimateControlTool());
-   */
-  app.use(errorLogger);
-  app.use(errorHandler);
 
-  /**
+  // Add optional tools here as needed
-   * Start the server and listen for incoming connections
+  // server.registerTool(new ControlTool());
-   * The port is configured in the environment variables
+  // server.registerTool(new SceneTool());
-   */
+  // server.registerTool(new NotifyTool());
-  app.listen(APP_CONFIG.PORT, () => {
+  // server.registerTool(new ListDevicesTool());
-    logger.info(`Server is running on port ${APP_CONFIG.PORT}`);
+  // server.registerTool(new HistoryTool());
-  });
+
-} else {
+  // Add middlewares
-  logger.info('Running in Claude mode - Express server disabled');
+  server.use(loggingMiddleware);
-}
+  server.use(timeoutMiddleware(EXECUTION_TIMEOUT));
+
+  // Initialize transports
+  if (useStdio) {
+    logger.info('Using Standard I/O transport');
+
+    // Create and configure the stdio transport with debug enabled for stdio mode
+    const stdioTransport = new StdioTransport({
+      debug: true, // Always enable debug in stdio mode for better visibility
+      silent: false // Never be silent in stdio mode
+    });
+
+    // Explicitly set the server reference to ensure access to tools
+    stdioTransport.setServer(server);
+
+    // Register the transport
+    server.registerTransport(stdioTransport);
+
+    // Special handling for stdio mode - don't start other transports
+    if (isStdioMode()) {
+      logger.info('Running in pure stdio mode (from CLI)');
+      // Start the server
+      await server.start();
+      logger.info('MCP Server started successfully');
+
+      // Handle shutdown
+      const shutdown = async () => {
+        logger.info('Shutting down MCP Server...');
+        try {
+          await server.shutdown();
+          logger.info('MCP Server shutdown complete');
+          process.exit(0);
+        } catch (error) {
+          logger.error('Error during shutdown:', error);
+          process.exit(1);
+        }
+      };
+
+      // Register shutdown handlers
+      process.on('SIGINT', shutdown);
+      process.on('SIGTERM', shutdown);
+
+      // Exit the function early as we're in stdio-only mode
+      return;
+    }
+  }
+
+  // HTTP transport (only if not in pure stdio mode)
+  if (APP_CONFIG.useHttpTransport) {
+    logger.info('Using HTTP transport on port ' + APP_CONFIG.port);
+    const app = express();
+
+    // Apply enhanced security middleware
+    app.use(SecurityMiddleware.applySecurityHeaders);
+
+    // CORS configuration
+    app.use(cors({
+      origin: APP_CONFIG.corsOrigin,
+      methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+      allowedHeaders: ['Content-Type', 'Authorization'],
+      maxAge: 86400 // 24 hours
+    }));
+
+    // Apply rate limiting to all routes
+    app.use('/api', apiLimiter);
+    app.use('/auth', authLimiter);
+
+    // Swagger UI setup
+    app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(openApiConfig, {
+      explorer: true,
+      customCss: '.swagger-ui .topbar { display: none }',
+      customSiteTitle: 'Home Assistant MCP API Documentation'
+    }));
+
+    // Health check endpoint
+    app.get('/health', (req, res) => {
+      res.json({
+        status: 'ok',
+        version: process.env.npm_package_version || '1.0.0'
+      });
+    });
+
+    const httpTransport = new HttpTransport({
+      port: APP_CONFIG.port,
+      corsOrigin: APP_CONFIG.corsOrigin,
+      apiPrefix: "/api/mcp",
+      debug: APP_CONFIG.debugHttp
+    });
+    server.registerTransport(httpTransport);
+  }
+
+  // Start the server
+  await server.start();
+  logger.info('MCP Server started successfully');
+
+  // Handle shutdown
+  const shutdown = async () => {
+    logger.info('Shutting down MCP Server...');
+    try {
+      await server.shutdown();
+      logger.info('MCP Server shutdown complete');
+      process.exit(0);
+    } catch (error) {
+      logger.error('Error during shutdown:', error);
+      process.exit(1);
+    }
+  };
+
+  // Register shutdown handlers
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+// Run the main function
+main().catch(error => {
+  logger.error('Error starting MCP Server:', error);
+  process.exit(1);
+});

src/interfaces/hass.ts

@@ -2,79 +2,92 @@
 
 // Home Assistant entity types
 export interface HassEntity {
-    entity_id: string;
+  entity_id: string;
-    state: string;
+  state: string;
-    attributes: Record<string, any>;
+  attributes: Record<string, any>;
-    last_changed?: string;
+  last_changed?: string;
-    last_updated?: string;
+  last_updated?: string;
-    context?: {
+  context?: {
-        id: string;
+    id: string;
-        parent_id?: string;
+    parent_id?: string;
-        user_id?: string;
+    user_id?: string;
-    };
+  };
 }
 
 export interface HassState {
-    entity_id: string;
+  entity_id: string;
-    state: string;
+  state: string;
-    attributes: {
+  attributes: {
-        friendly_name?: string;
+    friendly_name?: string;
-        description?: string;
+    description?: string;
-        [key: string]: any;
+    [key: string]: any;
-    };
+  };
 }
 
 // Home Assistant instance types
 export interface HassInstance {
-    states: HassStates;
+  states: HassStates;
-    services: HassServices;
+  services: HassServices;
-    connection: HassConnection;
+  connection: HassConnection;
-    subscribeEvents: (callback: (event: HassEvent) => void, eventType?: string) => Promise<number>;
+  subscribeEvents: (
-    unsubscribeEvents: (subscription: number) => void;
+    callback: (event: HassEvent) => void,
+    eventType?: string,
+  ) => Promise<number>;
+  unsubscribeEvents: (subscription: number) => void;
 }
 
 export interface HassStates {
-    get: () => Promise<HassEntity[]>;
+  get: () => Promise<HassEntity[]>;
-    subscribe: (callback: (states: HassEntity[]) => void) => Promise<number>;
+  subscribe: (callback: (states: HassEntity[]) => void) => Promise<number>;
-    unsubscribe: (subscription: number) => void;
+  unsubscribe: (subscription: number) => void;
 }
 
 export interface HassServices {
-    get: () => Promise<Record<string, Record<string, HassService>>>;
+  get: () => Promise<Record<string, Record<string, HassService>>>;
-    call: (domain: string, service: string, serviceData?: Record<string, any>) => Promise<void>;
+  call: (
+    domain: string,
+    service: string,
+    serviceData?: Record<string, any>,
+  ) => Promise<void>;
 }
 
 export interface HassConnection {
-    socket: WebSocket;
+  socket: WebSocket;
-    subscribeEvents: (callback: (event: HassEvent) => void, eventType?: string) => Promise<number>;
+  subscribeEvents: (
-    unsubscribeEvents: (subscription: number) => void;
+    callback: (event: HassEvent) => void,
+    eventType?: string,
+  ) => Promise<number>;
+  unsubscribeEvents: (subscription: number) => void;
 }
 
 export interface HassService {
-    name: string;
+  name: string;
-    description: string;
+  description: string;
-    target?: {
+  target?: {
-        entity?: {
+    entity?: {
-            domain: string[];
+      domain: string[];
-        };
     };
-    fields: Record<string, {
+  };
-        name: string;
+  fields: Record<
-        description: string;
+    string,
-        required?: boolean;
+    {
-        example?: any;
+      name: string;
-        selector?: any;
+      description: string;
-    }>;
+      required?: boolean;
+      example?: any;
+      selector?: any;
+    }
+  >;
 }
 
 export interface HassEvent {
-    event_type: string;
+  event_type: string;
-    data: Record<string, any>;
+  data: Record<string, any>;
-    origin: string;
+  origin: string;
-    time_fired: string;
+  time_fired: string;
-    context: {
+  context: {
-        id: string;
+    id: string;
-        parent_id?: string;
+    parent_id?: string;
-        user_id?: string;
+    user_id?: string;
-    };
+  };
-} 
+}

src/interfaces/index.ts

@@ -1,170 +1,183 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 // Tool interfaces
 export interface Tool {
-    name: string;
+  name: string;
-    description: string;
+  description: string;
-    parameters: z.ZodType<any>;
+  parameters: z.ZodType<any>;
-    execute: (params: any) => Promise<any>;
+  execute: (params: any) => Promise<any>;
 }
 
 // Command interfaces
 export interface CommandParams {
-    command: string;
+  command: string;
-    entity_id: string;
+  entity_id: string;
-    // Common parameters
+  // Common parameters
-    state?: string;
+  state?: string;
-    // Light parameters
+  // Light parameters
-    brightness?: number;
+  brightness?: number;
-    color_temp?: number;
+  color_temp?: number;
-    rgb_color?: [number, number, number];
+  rgb_color?: [number, number, number];
-    // Cover parameters
+  // Cover parameters
-    position?: number;
+  position?: number;
-    tilt_position?: number;
+  tilt_position?: number;
-    // Climate parameters
+  // Climate parameters
-    temperature?: number;
+  temperature?: number;
-    target_temp_high?: number;
+  target_temp_high?: number;
-    target_temp_low?: number;
+  target_temp_low?: number;
-    hvac_mode?: string;
+  hvac_mode?: string;
-    fan_mode?: string;
+  fan_mode?: string;
-    humidity?: number;
+  humidity?: number;
 }
 
 // Re-export Home Assistant types
 export type {
-    HassInstance,
+  HassInstance,
-    HassStates,
+  HassStates,
-    HassServices,
+  HassServices,
-    HassConnection,
+  HassConnection,
-    HassService,
+  HassService,
-    HassEvent,
+  HassEvent,
-    HassEntity,
+  HassEntity,
-    HassState
+  HassState,
-} from './hass.js';
+} from "./hass.js";
 
 // Home Assistant interfaces
 export interface HassAddon {
+  name: string;
+  slug: string;
+  description: string;
+  version: string;
+  installed: boolean;
+  available: boolean;
+  state: string;
+}
+
+export interface HassAddonResponse {
+  data: {
+    addons: HassAddon[];
+  };
+}
+
+export interface HassAddonInfoResponse {
+  data: {
     name: string;
     slug: string;
     description: string;
     version: string;
-    installed: boolean;
-    available: boolean;
     state: string;
-}
+    status: string;
-
+    options: Record<string, any>;
-export interface HassAddonResponse {
+    [key: string]: any;
-    data: {
+  };
-        addons: HassAddon[];
-    };
-}
-
-export interface HassAddonInfoResponse {
-    data: {
-        name: string;
-        slug: string;
-        description: string;
-        version: string;
-        state: string;
-        status: string;
-        options: Record<string, any>;
-        [key: string]: any;
-    };
 }
 
 // HACS interfaces
 export interface HacsRepository {
-    name: string;
+  name: string;
-    description: string;
+  description: string;
-    category: string;
+  category: string;
-    installed: boolean;
+  installed: boolean;
-    version_installed: string;
+  version_installed: string;
-    available_version: string;
+  available_version: string;
-    authors: string[];
+  authors: string[];
-    domain: string;
+  domain: string;
 }
 
 export interface HacsResponse {
-    repositories: HacsRepository[];
+  repositories: HacsRepository[];
 }
 
 // Automation interfaces
 export interface AutomationConfig {
-    alias: string;
+  alias: string;
-    description?: string;
+  description?: string;
-    mode?: 'single' | 'parallel' | 'queued' | 'restart';
+  mode?: "single" | "parallel" | "queued" | "restart";
-    trigger: any[];
+  trigger: any[];
-    condition?: any[];
+  condition?: any[];
-    action: any[];
+  action: any[];
 }
 
 export interface AutomationResponse {
-    automation_id: string;
+  automation_id: string;
 }
 
 // SSE interfaces
 export interface SSEHeaders {
-    onAbort?: () => void;
+  onAbort?: () => void;
 }
 
 export interface SSEParams {
-    token: string;
+  token: string;
-    events?: string[];
+  events?: string[];
-    entity_id?: string;
+  entity_id?: string;
-    domain?: string;
+  domain?: string;
 }
 
 // History interfaces
 export interface HistoryParams {
-    entity_id: string;
+  entity_id: string;
-    start_time?: string;
+  start_time?: string;
-    end_time?: string;
+  end_time?: string;
-    minimal_response?: boolean;
+  minimal_response?: boolean;
-    significant_changes_only?: boolean;
+  significant_changes_only?: boolean;
 }
 
 // Scene interfaces
 export interface SceneParams {
-    action: 'list' | 'activate';
+  action: "list" | "activate";
-    scene_id?: string;
+  scene_id?: string;
 }
 
 // Notification interfaces
 export interface NotifyParams {
-    message: string;
+  message: string;
-    title?: string;
+  title?: string;
-    target?: string;
+  target?: string;
-    data?: Record<string, any>;
+  data?: Record<string, any>;
 }
 
 // Automation parameter interfaces
 export interface AutomationParams {
-    action: 'list' | 'toggle' | 'trigger';
+  action: "list" | "toggle" | "trigger";
-    automation_id?: string;
+  automation_id?: string;
 }
 
 export interface AddonParams {
-    action: 'list' | 'info' | 'install' | 'uninstall' | 'start' | 'stop' | 'restart';
+  action:
-    slug?: string;
+    | "list"
-    version?: string;
+    | "info"
+    | "install"
+    | "uninstall"
+    | "start"
+    | "stop"
+    | "restart";
+  slug?: string;
+  version?: string;
 }
 
 export interface PackageParams {
-    action: 'list' | 'install' | 'uninstall' | 'update';
+  action: "list" | "install" | "uninstall" | "update";
-    category: 'integration' | 'plugin' | 'theme' | 'python_script' | 'appdaemon' | 'netdaemon';
+  category:
-    repository?: string;
+    | "integration"
-    version?: string;
+    | "plugin"
+    | "theme"
+    | "python_script"
+    | "appdaemon"
+    | "netdaemon";
+  repository?: string;
+  version?: string;
 }
 
 export interface AutomationConfigParams {
-    action: 'create' | 'update' | 'delete' | 'duplicate';
+  action: "create" | "update" | "delete" | "duplicate";
-    automation_id?: string;
+  automation_id?: string;
-    config?: {
+  config?: {
-        alias: string;
+    alias: string;
-        description?: string;
+    description?: string;
-        mode?: 'single' | 'parallel' | 'queued' | 'restart';
+    mode?: "single" | "parallel" | "queued" | "restart";
-        trigger: any[];
+    trigger: any[];
-        condition?: any[];
+    condition?: any[];
-        action: any[];
+    action: any[];
-    };
+  };
-} 
+}

src/mcp/BaseTool.ts

@@ -0,0 +1,105 @@
+/**
+ * Base Tool Implementation for MCP
+ * 
+ * This base class provides the foundation for all tools in the MCP implementation,
+ * with typed parameters, validation, and error handling.
+ */
+
+import { z } from 'zod';
+import { ToolDefinition, ToolMetadata, MCPResponseStream } from './types.js';
+
+/**
+ * Configuration options for creating a tool
+ */
+export interface ToolOptions<P = unknown> {
+    name: string;
+    description: string;
+    version: string;
+    parameters?: z.ZodType<P>;
+    metadata?: ToolMetadata;
+}
+
+/**
+ * Base class for all MCP tools
+ * 
+ * Provides:
+ * - Parameter validation with Zod
+ * - Error handling
+ * - Streaming support
+ * - Type safety
+ */
+export abstract class BaseTool<P = unknown, R = unknown> implements ToolDefinition {
+    public readonly name: string;
+    public readonly description: string;
+    public readonly parameters?: z.ZodType<P>;
+    public readonly metadata: ToolMetadata;
+
+    /**
+     * Create a new tool
+     */
+    constructor(options: ToolOptions<P>) {
+        this.name = options.name;
+        this.description = options.description;
+        this.parameters = options.parameters;
+        this.metadata = {
+            version: options.version,
+            category: options.metadata?.category || 'general',
+            tags: options.metadata?.tags || [],
+            examples: options.metadata?.examples || [],
+        };
+    }
+
+    /**
+     * Execute the tool with the given parameters
+     * 
+     * @param params The validated parameters for the tool
+     * @param stream Optional stream for sending partial results
+     * @returns The result of the tool execution
+     */
+    abstract execute(params: P, stream?: MCPResponseStream): Promise<R>;
+
+    /**
+     * Get the parameter schema as JSON schema
+     */
+    public getParameterSchema(): Record<string, unknown> | undefined {
+        if (!this.parameters) return undefined;
+        return this.parameters.isOptional()
+            ? { type: 'object', properties: {} }
+            : this.parameters.shape;
+    }
+
+    /**
+     * Get tool definition for registration
+     */
+    public getDefinition(): ToolDefinition {
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: this.parameters,
+            metadata: this.metadata
+        };
+    }
+
+    /**
+     * Validate parameters against the schema
+     * 
+     * @param params Parameters to validate
+     * @returns Validated parameters
+     * @throws Error if validation fails
+     */
+    protected validateParams(params: unknown): P {
+        if (!this.parameters) {
+            return {} as P;
+        }
+
+        try {
+            return this.parameters.parse(params);
+        } catch (error) {
+            if (error instanceof z.ZodError) {
+                const issues = error.issues.map(issue => `${issue.path.join('.')}: ${issue.message}`).join(', ');
+                throw new Error(`Parameter validation failed: ${issues}`);
+            }
+            throw error;
+        }
+    }
+}