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

.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,43 +1,17 @@
+# 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
-# Port for the MCP server (default: 3000)
-PORT=3000
-
-# Environment (development/production/test)
-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_REGULAR=100
-
-# Requests per minute per IP for WebSocket connections
-RATE_LIMIT_WEBSOCKET=1000
-
 # Security Configuration
-# JWT Configuration
 JWT_SECRET=your_jwt_secret_key_min_32_chars
 JWT_EXPIRY=86400000
 JWT_MAX_AGE=2592000000
@@ -46,31 +20,18 @@ JWT_ALGORITHM=HS256
 # Rate Limiting
 RATE_LIMIT_WINDOW=900000
 RATE_LIMIT_MAX_REQUESTS=100
-
+RATE_LIMIT_MAX_AUTH_REQUESTS=5
-# Token Security
+RATE_LIMIT_REGULAR=100
-TOKEN_MIN_LENGTH=32
+RATE_LIMIT_WEBSOCKET=1000
-MAX_FAILED_ATTEMPTS=5
-LOCKOUT_DURATION=900000
 
 # CORS Configuration
-CORS_ORIGINS=http://localhost:3000,http://localhost:8123
+CORS_ORIGINS=http://localhost:3000,http://localhost:8123,http://homeassistant.local:8123
 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
 
-# Content Security Policy
-CSP_ENABLED=true
-CSP_REPORT_ONLY=false
-CSP_REPORT_URI=
-
-# SSL/TLS Configuration
-REQUIRE_HTTPS=true
-HSTS_MAX_AGE=31536000
-HSTS_INCLUDE_SUBDOMAINS=true
-HSTS_PRELOAD=true
-
 # Cookie Security
 COOKIE_SECRET=your_cookie_secret_key_min_32_chars
 COOKIE_SECURE=true
@@ -81,31 +42,57 @@ COOKIE_SAME_SITE=Strict
 MAX_REQUEST_SIZE=1048576
 MAX_REQUEST_FIELDS=1000
 
-# SSE Configuration
+# AI Configuration
-SSE_MAX_CLIENTS=1000
+PROCESSOR_TYPE=openai
-SSE_PING_INTERVAL=30000
+OPENAI_API_KEY=your_openai_api_key
+OPENAI_MODEL=gpt-3.5-turbo
+MAX_RETRIES=3
+ANALYSIS_TIMEOUT=30000
 
-# Logging Configuration
+# Speech Features Configuration
-LOG_LEVEL=info
+ENABLE_SPEECH_FEATURES=false
-LOG_DIR=logs
+ENABLE_WAKE_WORD=false
-LOG_MAX_SIZE=20m
+ENABLE_SPEECH_TO_TEXT=false
-LOG_MAX_DAYS=14d
+WHISPER_MODEL_PATH=/models
-LOG_COMPRESS=true
+WHISPER_MODEL_TYPE=base
-LOG_REQUESTS=true
+
+# 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=50
+SSE_RECONNECT_TIMEOUT=5000
+
+# Development Flags
+HOT_RELOAD=true
+
+# Test Configuration (only needed for running tests)
+TEST_HASS_HOST=http://homeassistant.local:8123
+TEST_HASS_TOKEN=test_token
+TEST_HASS_SOCKET_URL=ws://homeassistant.local:8123/api/websocket
+TEST_PORT=3001
 
 # Version
 VERSION=0.1.0
 
-# Test Configuration
+# Docker Configuration
-# Only needed if running tests
+COMPOSE_PROJECT_NAME=mcp
-TEST_HASS_HOST=http://localhost:8123
-TEST_HASS_TOKEN=test_token
-TEST_HASS_SOCKET_URL=ws://localhost:8123/api/websocket
-TEST_PORT=3001
 
-# Speech Features Configuration
+# Resource Limits
-ENABLE_SPEECH_FEATURES=false
+FAST_WHISPER_CPU_LIMIT=4.0
-ENABLE_WAKE_WORD=true
+FAST_WHISPER_MEMORY_LIMIT=2G
-ENABLE_SPEECH_TO_TEXT=true
+MCP_CPU_LIMIT=1.0
-WHISPER_MODEL_PATH=/models
+MCP_MEMORY_LIMIT=512M
-WHISPER_MODEL_TYPE=base

.github/workflows/deploy-docs.yml

@@ -1,4 +1,4 @@
-name: Deploy Documentation to GitHub Pages
+name: Deploy Documentation
 
 on:
   push:
@@ -6,57 +6,69 @@ on:
       - main
     paths:
       - 'docs/**'
-      - '.github/workflows/deploy-docs.yml'
+      - '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
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
 concurrency:
   group: "pages"
-  cancel-in-progress: true
+  cancel-in-progress: false
 
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout
+      - name: Checkout repository
         uses: actions/checkout@v4
-
-      - name: Setup Ruby
-        uses: ruby/setup-ruby@v1
         with:
-          ruby-version: '3.2'
+          fetch-depth: 0
-          bundler-cache: true
+
-          cache-version: 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: |
-          cd docs
+          python -m pip install --upgrade pip
-          bundle install
+          pip install -r docs/requirements.txt
 
-      - name: Build site
+      - name: List mkdocs configuration
         run: |
-          cd docs
+          echo "Current directory contents:"
-          bundle exec jekyll build
+          ls -la
-        env:
+          echo "MkDocs version:"
-          JEKYLL_ENV: production
+          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: docs/_site
+          path: ./site/advanced-homeassistant-mcp
 
   deploy:
-    needs: build
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
+    needs: build
     runs-on: ubuntu-latest
     steps:
       - name: Deploy to GitHub Pages

.github/workflows/docs-deploy.yml

@@ -1,32 +0,0 @@
-name: Deploy Documentation
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - 'docs/**'
-      - 'mkdocs.yml'
-
-permissions:
-  contents: write
-
-jobs:
-  deploy-docs:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.x
-
-      - name: Install dependencies
-        run: |
-          pip install mkdocs-material
-          pip install mkdocs
-
-      - name: Deploy documentation
-        run: mkdocs gh-deploy --force 

.gitignore

@@ -31,7 +31,7 @@ wheels/
 venv/
 ENV/
 env/
-
+.venv/
 # Logs
 logs
 *.log
@@ -71,7 +71,7 @@ coverage/
 # Environment files
 .env
 .env.*
-!.env.*.template
+!.env.example
 
 .cursor/
 .cursor/*
@@ -88,3 +88,14 @@ site/
 __pycache__/
 *.py[cod]
 *$py.class
+
+models/
+
+*.code-workspace
+*.ttf
+*.otf
+*.woff
+*.woff2
+*.eot
+*.svg
+*.png

Dockerfile

@@ -4,28 +4,31 @@ FROM node:20-slim as builder
 # Set working directory
 WORKDIR /app
 
-# Install bun
+# Install bun with the latest version
-RUN npm install -g bun@1.0.25
+RUN npm install -g bun@1.0.35
 
-# Install only the minimal dependencies needed and clean up in the same layer
+# Install Python and other dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    ca-certificates \
+    python3 \
-    curl \
+    python3-pip \
-    && rm -rf /var/lib/apt/lists/* \
+    python3-venv \
-    && apt-get clean \
+    build-essential \
-    && rm -rf /var/cache/apt/*
+    && rm -rf /var/lib/apt/lists/*
 
-# Set build-time environment variables
+# Create and activate virtual environment
-ENV NODE_ENV=production \
+RUN python3 -m venv /opt/venv
-    NODE_OPTIONS="--max-old-space-size=2048" \
+ENV PATH="/opt/venv/bin:$PATH"
-    BUN_INSTALL_CACHE=0
+ENV VIRTUAL_ENV="/opt/venv"
 
-# Copy only package files first
+# 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
+
+# Copy package.json and install dependencies
 COPY package.json ./
-
+RUN bun install --frozen-lockfile || bun install
-# Install dependencies with a clean slate
-RUN rm -rf node_modules .bun bun.lockb && \
-    bun install --no-save
 
 # Copy source files and build
 COPY src ./src
@@ -35,26 +38,55 @@ 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
+# Install bun in production image with the latest version
-RUN npm install -g bun@1.0.25
+RUN npm install -g bun@1.0.35
 
-# Set production environment variables
+# Install system dependencies
-ENV NODE_ENV=production \
+RUN apt-get update && apt-get install -y --no-install-recommends \
-    NODE_OPTIONS="--max-old-space-size=1024"
+    curl \
+    python3 \
+    python3-pip \
+    python3-venv \
+    alsa-utils \
+    pulseaudio \
+    && rm -rf /var/lib/apt/lists/*
 
-# Create a non-root user
+# 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 bunjs
+    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
-COPY --chown=bunjs:nodejs package.json ./
 
-# Create logs directory with proper permissions
+# Ensure audio setup script is executable
-RUN mkdir -p /app/logs && chown -R bunjs:nodejs /app/logs
+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
@@ -64,7 +96,7 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
     CMD curl -f http://localhost:4000/health || exit 1
 
 # Expose port
-EXPOSE 4000
+EXPOSE ${PORT:-4000}
 
-# Start the application with optimized flags
+# Start the application with audio setup
-CMD ["bun", "--smol", "run", "start"] 
+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,14 +1,13 @@
-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: {
                 action: 'turn_on',
                 target: 'light.living_room',
@@ -21,14 +20,13 @@ jest.mock('../../../src/ai/nlp/processor.js', () => {
                 context: 0.9
             }
         })),
-            validateIntent: jest.fn().mockImplementation(async () => true),
+        validateIntent: mock(async () => true),
-            suggestCorrections: jest.fn().mockImplementation(async () => [
+        suggestCorrections: mock(async () => [
             'Try using simpler commands',
             '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];
-            if (!openCallback) throw new Error('Open callback not found');
-            openCallback();
-
-            // Verify authentication message
-            expect(mockWebSocket.send).toHaveBeenCalledWith(
-                JSON.stringify({
                         type: 'auth',
                         access_token: mockToken
-                })
+                    }));
-            );
+                    resolve();
-
+                });
-            // 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) => {
-            // Get and call the open callback
+                    reject(error);
-            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
-            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 () => {
+            client.emit('message', JSON.stringify({ type: 'auth_invalid' }));
-            const connectPromise = client.connect();
 
-            // Get and call the error callback
+            await expect(failurePromise).rejects.toThrow();
-            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');
         });
 
-        it('should handle message parsing 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 open callback
+            client.emit('error', new Error('Connection failed'));
-            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
+            await expect(errorPromise).rejects.toThrow('Connection failed');
-            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');
             });
-
+            await expect(instance.getStates()).rejects.toThrow('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();
-            });
-
-            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,28 +165,21 @@ 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',
                 context: {
@@ -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,3 +1,4 @@
+import { describe, expect, test } from "bun:test";
 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';
@@ -17,7 +18,7 @@ describe('Security Module', () => {
         const testToken = 'test-token';
         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);
             expect(encrypted).toContain('aes-256-gcm:');
 
@@ -25,20 +26,20 @@ describe('Security Module', () => {
             expect(decrypted).toBe(testToken);
         });
 
-        it('should validate tokens correctly', () => {
+        test('should validate tokens correctly', () => {
             const validToken = jwt.sign({ data: 'test' }, TEST_SECRET, { expiresIn: '1h' });
             const result = TokenManager.validateToken(validToken);
             expect(result.valid).toBe(true);
             expect(result.error).toBeUndefined();
         });
 
-        it('should handle empty tokens', () => {
+        test('should handle empty tokens', () => {
             const result = TokenManager.validateToken('');
             expect(result.valid).toBe(false);
             expect(result.error).toBe('Invalid token format');
         });
 
-        it('should handle expired tokens', () => {
+        test('should handle expired tokens', () => {
             const now = Math.floor(Date.now() / 1000);
             const payload = {
                 data: 'test',
@@ -51,13 +52,13 @@ describe('Security Module', () => {
             expect(result.error).toBe('Token has expired');
         });
 
-        it('should handle invalid token format', () => {
+        test('should handle invalid token format', () => {
             const result = TokenManager.validateToken('invalid-token');
             expect(result.valid).toBe(false);
             expect(result.error).toBe('Invalid token format');
         });
 
-        it('should handle missing JWT secret', () => {
+        test('should handle missing JWT secret', () => {
             delete process.env.JWT_SECRET;
             const payload = { data: 'test' };
             const token = jwt.sign(payload, 'some-secret');
@@ -66,7 +67,7 @@ describe('Security Module', () => {
             expect(result.error).toBe('JWT secret not configured');
         });
 
-        it('should handle rate limiting for failed attempts', () => {
+        test('should handle rate limiting for failed attempts', () => {
             const invalidToken = 'x'.repeat(64);
             const testIp = '127.0.0.1';
 
@@ -111,7 +112,7 @@ describe('Security Module', () => {
             mockNext = mock(() => { });
         });
 
-        it('should pass valid requests', () => {
+        test('should pass valid requests', () => {
             if (mockRequest.headers) {
                 mockRequest.headers.authorization = 'Bearer valid-token';
             }
@@ -123,7 +124,7 @@ describe('Security Module', () => {
             expect(mockNext).toHaveBeenCalled();
         });
 
-        it('should reject invalid content type', () => {
+        test('should reject invalid content type', () => {
             if (mockRequest.headers) {
                 mockRequest.headers['content-type'] = 'text/plain';
             }
@@ -139,7 +140,7 @@ describe('Security Module', () => {
             });
         });
 
-        it('should reject missing token', () => {
+        test('should reject missing token', () => {
             if (mockRequest.headers) {
                 delete mockRequest.headers.authorization;
             }
@@ -155,7 +156,7 @@ describe('Security Module', () => {
             });
         });
 
-        it('should reject invalid request body', () => {
+        test('should reject invalid request body', () => {
             mockRequest.body = null;
 
             validateRequest(mockRequest, mockResponse, mockNext);
@@ -197,7 +198,7 @@ describe('Security Module', () => {
             mockNext = mock(() => { });
         });
 
-        it('should sanitize HTML tags from request body', () => {
+        test('should sanitize HTML tags from request body', () => {
             sanitizeInput(mockRequest, mockResponse, mockNext);
 
             expect(mockRequest.body).toEqual({
@@ -209,7 +210,7 @@ describe('Security Module', () => {
             expect(mockNext).toHaveBeenCalled();
         });
 
-        it('should handle non-object body', () => {
+        test('should handle non-object body', () => {
             mockRequest.body = 'string body';
             sanitizeInput(mockRequest, mockResponse, mockNext);
             expect(mockNext).toHaveBeenCalled();
@@ -235,7 +236,7 @@ describe('Security Module', () => {
             mockNext = mock(() => { });
         });
 
-        it('should handle errors in production mode', () => {
+        test('should handle errors in production mode', () => {
             process.env.NODE_ENV = 'production';
             const error = new Error('Test error');
             errorHandler(error, mockRequest, mockResponse, mockNext);
@@ -248,7 +249,7 @@ describe('Security Module', () => {
             });
         });
 
-        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);
@@ -265,7 +266,7 @@ describe('Security Module', () => {
     });
 
     describe('Rate Limiter', () => {
-        it('should limit requests after threshold', async () => {
+        test('should limit requests after threshold', async () => {
             const mockContext = {
                 request: new Request('http://localhost', {
                     headers: new Headers({
@@ -292,7 +293,7 @@ describe('Security Module', () => {
     });
 
     describe('Security Headers', () => {
-        it('should set security headers', async () => {
+        test('should set security headers', async () => {
             const mockHeaders = new Headers();
             const mockContext = {
                 request: new Request('http://localhost', {

__tests__/security/middleware.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "bun:test";
 import { describe, it, expect } from 'bun:test';
 import {
     checkRateLimit,
@@ -9,31 +10,31 @@ import {
 
 describe('Security Middleware Utilities', () => {
     describe('Rate Limiter', () => {
-        it('should allow requests under threshold', () => {
+        test('should allow requests under threshold', () => {
             const ip = '127.0.0.1';
-            expect(() => checkRateLimit(ip, 10)).not.toThrow();
+            expect(() => checkRateLimtest(ip, 10)).not.toThrow();
         });
 
-        it('should throw when requests exceed threshold', () => {
+        test('should throw when requests exceed threshold', () => {
             const ip = '127.0.0.2';
 
             // Simulate multiple requests
             for (let i = 0; i < 11; i++) {
                 if (i < 10) {
-                    expect(() => checkRateLimit(ip, 10)).not.toThrow();
+                    expect(() => checkRateLimtest(ip, 10)).not.toThrow();
                 } else {
-                    expect(() => checkRateLimit(ip, 10)).toThrow('Too many requests from this IP, please try again later');
+                    expect(() => checkRateLimtest(ip, 10)).toThrow('Too many requests from this IP, please try again later');
                 }
             }
         });
 
-        it('should reset rate limit after window expires', async () => {
+        test('should reset rate limit after window expires', async () => {
             const ip = '127.0.0.3';
 
             // Simulate multiple requests
             for (let i = 0; i < 11; i++) {
                 if (i < 10) {
-                    expect(() => checkRateLimit(ip, 10, 50)).not.toThrow();
+                    expect(() => checkRateLimtest(ip, 10, 50)).not.toThrow();
                 }
             }
 
@@ -41,12 +42,12 @@ describe('Security Middleware Utilities', () => {
             await new Promise(resolve => setTimeout(resolve, 100));
 
             // Should be able to make requests again
-            expect(() => checkRateLimit(ip, 10, 50)).not.toThrow();
+            expect(() => checkRateLimtest(ip, 10, 50)).not.toThrow();
         });
     });
 
     describe('Request Validation', () => {
-        it('should validate content type', () => {
+        test('should validate content type', () => {
             const mockRequest = new Request('http://localhost', {
                 method: 'POST',
                 headers: {
@@ -57,7 +58,7 @@ describe('Security Middleware Utilities', () => {
             expect(() => validateRequestHeaders(mockRequest)).not.toThrow();
         });
 
-        it('should reject invalid content type', () => {
+        test('should reject invalid content type', () => {
             const mockRequest = new Request('http://localhost', {
                 method: 'POST',
                 headers: {
@@ -68,7 +69,7 @@ describe('Security Middleware Utilities', () => {
             expect(() => validateRequestHeaders(mockRequest)).toThrow('Content-Type must be application/json');
         });
 
-        it('should reject large request bodies', () => {
+        test('should reject large request bodies', () => {
             const mockRequest = new Request('http://localhost', {
                 method: 'POST',
                 headers: {
@@ -82,13 +83,13 @@ describe('Security Middleware Utilities', () => {
     });
 
     describe('Input Sanitization', () => {
-        it('should sanitize HTML tags', () => {
+        test('should sanitize HTML tags', () => {
             const input = '<script>alert("xss")</script>Hello';
             const sanitized = sanitizeValue(input);
             expect(sanitized).toBe('&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;Hello');
         });
 
-        it('should sanitize nested objects', () => {
+        test('should sanitize nested objects', () => {
             const input = {
                 text: '<script>alert("xss")</script>Hello',
                 nested: {
@@ -104,7 +105,7 @@ describe('Security Middleware Utilities', () => {
             });
         });
 
-        it('should preserve non-string values', () => {
+        test('should preserve non-string values', () => {
             const input = {
                 number: 123,
                 boolean: true,
@@ -116,7 +117,7 @@ describe('Security Middleware Utilities', () => {
     });
 
     describe('Security Headers', () => {
-        it('should apply security headers', () => {
+        test('should apply security headers', () => {
             const mockRequest = new Request('http://localhost');
             const headers = applySecurityHeaders(mockRequest);
 
@@ -129,7 +130,7 @@ describe('Security Middleware Utilities', () => {
     });
 
     describe('Error Handling', () => {
-        it('should handle errors in production mode', () => {
+        test('should handle errors in production mode', () => {
             const error = new Error('Test error');
             const result = handleError(error, 'production');
 
@@ -140,7 +141,7 @@ describe('Security Middleware Utilities', () => {
             });
         });
 
-        it('should include error details in development mode', () => {
+        test('should include error details in development mode', () => {
             const error = new Error('Test error');
             const result = handleError(error, 'development');
 

__tests__/security/token-manager.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "bun:test";
 import { TokenManager } from '../../src/security/index.js';
 import jwt from 'jsonwebtoken';
 
@@ -16,36 +17,36 @@ describe('TokenManager', () => {
     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 payload = { sub: '123', name: 'Test User', iat: Math.floor(Date.now() / 1000), exp: Math.floor(Date.now() / 1000) + 3600 };
             const token = jwt.sign(payload, TEST_SECRET);
             const result = TokenManager.validateToken(token);
@@ -53,7 +54,7 @@ describe('TokenManager', () => {
             expect(result.error).toBeUndefined();
         });
 
-        it('should reject expired tokens', () => {
+        test('should reject expired tokens', () => {
             const payload = { sub: '123', name: 'Test User', iat: Math.floor(Date.now() / 1000) - 7200, exp: Math.floor(Date.now() / 1000) - 3600 };
             const token = jwt.sign(payload, TEST_SECRET);
             const result = TokenManager.validateToken(token);
@@ -61,13 +62,13 @@ describe('TokenManager', () => {
             expect(result.error).toBe('Token has expired');
         });
 
-        it('should reject malformed tokens', () => {
+        test('should reject malformed tokens', () => {
             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 payload = { sub: '123', name: 'Test User', iat: Math.floor(Date.now() / 1000), exp: Math.floor(Date.now() / 1000) + 3600 };
             const token = jwt.sign(payload, 'different-secret');
             const result = TokenManager.validateToken(token);
@@ -75,7 +76,7 @@ describe('TokenManager', () => {
             expect(result.error).toBe('Invalid token signature');
         });
 
-        it('should handle tokens with missing expiration', () => {
+        test('should handle tokens with missing expiration', () => {
             const payload = { sub: '123', name: 'Test User' };
             const token = jwt.sign(payload, TEST_SECRET);
             const result = TokenManager.validateToken(token);
@@ -83,7 +84,7 @@ describe('TokenManager', () => {
             expect(result.error).toBe('Token missing required claims');
         });
 
-        it('should handle undefined and null inputs', () => {
+        test('should handle undefined and null inputs', () => {
             const undefinedResult = TokenManager.validateToken(undefined);
             expect(undefinedResult.valid).toBe(false);
             expect(undefinedResult.error).toBe('Invalid token format');
@@ -95,26 +96,26 @@ describe('TokenManager', () => {
     });
 
     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);
@@ -123,19 +124,19 @@ 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();
         });
     });

__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;
     })
+};
+
+// Create mock constructors
+const MockElysia = mock(() => mockApp);
+const mockCors = mock(() => (app: any) => app);
+const mockSwagger = mock(() => (app: any) => app);
+const mockSpeechService = {
+    initialize: mock(() => Promise.resolve()),
+    shutdown: mock(() => Promise.resolve())
+};
+
+// Mock the modules
+const mockModules = {
+    Elysia: MockElysia,
+    cors: mockCors,
+    swagger: mockSwagger,
+    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 jest.fn(() => mockApp);
+        return mocks[specifier] || {};
-});
-
-// Mock LiteMCP
-jest.mock('litemcp', () => ({
-    LiteMCP: jest.fn(() => ({
-        addTool: jest.fn(),
-        start: jest.fn().mockImplementation(async () => { })
-    }))
-}));
-
-// Mock logger
-jest.mock('../src/utils/logger.js', () => ({
-    logger: {
-        info: jest.fn(),
-        error: jest.fn(),
-        debug: jest.fn()
     }
-}));
+};
 
 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(() => {
+        if (eventEmitter) {
             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'
+            })
         });
 
-    it('should handle auth failure', () => {
+        onMessageCallback({
-        // Simulate auth_invalid message
+            data: JSON.stringify({
-        eventEmitter.emit('message', JSON.stringify({
+                type: 'auth_ok'
+            })
+        });
+
+        await connectPromise;
+        expect(client.isAuthenticated()).toBe(true);
+    });
+
+    test('should handle auth failure', async () => {
+        const connectPromise = client.connect();
+        onOpenCallback();
+
+        onMessageCallback({
+            data: JSON.stringify({
+                type: 'auth_required'
+            })
+        });
+
+        onMessageCallback({
+            data: JSON.stringify({
                 type: 'auth_invalid',
-            message: 'Invalid token'
+                message: 'Invalid password'
-        }));
+            })
-
-        // Verify client attempts to close connection
-        expect(mockWebSocket.close).toHaveBeenCalled();
         });
 
-    it('should handle connection errors', () => {
+        await expect(connectPromise).rejects.toThrow('Authentication failed');
-        // Create error spy
+        expect(client.isAuthenticated()).toBe(false);
-        const errorSpy = jest.fn();
-        client.on('error', errorSpy);
-
-        // Simulate error
-        const testError = new Error('Test error');
-        eventEmitter.emit('error', testError);
-
-        // Verify error was handled
-        expect(errorSpy).toHaveBeenCalledWith(testError);
     });
 
-    it('should handle disconnection', () => {
+    test('should handle connection errors', async () => {
-        // Create close spy
+        const errorPromise = new Promise((resolve) => {
-        const closeSpy = jest.fn();
+            client.once('error', resolve);
-        client.on('close', closeSpy);
-
-        // Simulate close
-        eventEmitter.emit('close');
-
-        // Verify close was handled
-        expect(closeSpy).toHaveBeenCalled();
         });
 
-    it('should handle event messages', () => {
+        const connectPromise = client.connect().catch(() => { /* Expected error */ });
-        // Create event spy
+        onOpenCallback();
-        const eventSpy = jest.fn();
+
-        client.on('event', eventSpy);
+        const errorEvent = new Error('Connection failed');
+        onErrorCallback({ error: errorEvent });
+
+        const error = await errorPromise;
+        expect(error instanceof Error).toBe(true);
+        expect((error as Error).message).toBe('Connection failed');
+    });
+
+    test('should handle disconnection', async () => {
+        const connectPromise = client.connect();
+        onOpenCallback();
+        await connectPromise;
+
+        const disconnectPromise = new Promise((resolve) => {
+            client.on('disconnected', resolve);
+        });
+
+        onCloseCallback();
+
+        await disconnectPromise;
+        expect(client.isConnected()).toBe(false);
+    });
+
+    test('should handle event messages', async () => {
+        const connectPromise = client.connect();
+        onOpenCallback();
+
+        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)
         });
 
-    describe('Connection Events', () => {
+        const receivedEvent = await eventPromise;
-        it('should handle successful connection', (done) => {
+        expect(receivedEvent).toEqual(eventData.event.data);
-            client.on('open', () => {
+    });
+
+    test('should subscribe to specific events', async () => {
+        const connectPromise = client.connect();
+        onOpenCallback();
+
+        onMessageCallback({
+            data: JSON.stringify({
+                type: 'auth_required'
+            })
+        });
+
+        onMessageCallback({
+            data: JSON.stringify({
+                type: 'auth_ok'
+            })
+        });
+
+        await connectPromise;
+
+        const subscriptionId = await client.subscribeEvents('state_changed', (data) => {
+            // Empty callback for type satisfaction
+        });
         expect(mockWebSocket.send).toHaveBeenCalled();
-                done();
+        expect(subscriptionId).toBeDefined();
     });
 
-            eventEmitter.emit('open');
+    test('should unsubscribe from events', async () => {
+        const connectPromise = client.connect();
+        onOpenCallback();
+
+        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);
+        await connectPromise;
+
+        const subscriptionId = await client.subscribeEvents('state_changed', (data) => {
+            // Empty callback for type satisfaction
         });
+        await client.unsubscribeEvents(subscriptionId);
 
-        it('should handle connection close', (done) => {
+        expect(mockWebSocket.send).toHaveBeenCalled();
-            client.on('disconnected', () => {
-                expect(mockWebSocket.close).toHaveBeenCalled();
-                done();
-            });
-
-            eventEmitter.emit('close');
-        });
-    });
-
-    describe('Authentication', () => {
-        it('should send authentication message on connect', () => {
-            const authMessage: HomeAssistant.AuthMessage = {
-                type: 'auth',
-                access_token: 'test_token'
-            };
-
-            client.connect();
-            expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify(authMessage));
-        });
-
-        it('should handle successful authentication', (done) => {
-            client.on('auth_ok', () => {
-                done();
-            });
-
-            client.connect();
-            eventEmitter.emit('message', JSON.stringify({ type: 'auth_ok' }));
-        });
-
-        it('should handle authentication failure', (done) => {
-            client.on('auth_invalid', () => {
-                done();
-            });
-
-            client.connect();
-            eventEmitter.emit('message', JSON.stringify({ type: 'auth_invalid' }));
-        });
-    });
-
-    describe('Event Subscription', () => {
-        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

@@ -1,5 +1,5 @@
 [test]
-preload = ["./src/__tests__/setup.ts"]
+preload = ["./test/setup.ts"]
 coverage = true
 coverageThreshold = {
   statements = 80,
@@ -7,7 +7,7 @@ coverageThreshold = {
   functions = 80,
   lines = 80
 }
-timeout = 30000
+timeout = 10000
 testMatch = ["**/__tests__/**/*.test.ts"]
 testPathIgnorePatterns = ["/node_modules/", "/dist/"]
 collectCoverageFrom = [
@@ -19,10 +19,34 @@ collectCoverageFrom = [
 ]
 
 [build]
-target = "node"
+target = "bun"
 outdir = "./dist"
-minify = true
+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
@@ -48,3 +72,12 @@ 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

@@ -3,16 +3,52 @@
 # 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() {
-    echo "Cleaning up..."
+    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
-echo "Cleaning up Docker system..."
+print_message "$YELLOW" "Cleaning up Docker system..."
 docker system prune -f --volumes
 
 # Set build arguments for better performance
@@ -26,23 +62,47 @@ BUILD_MEM=$(( TOTAL_MEM / 2 ))  # Use half of available memory
 CPU_COUNT=$(nproc)
 CPU_QUOTA=$(( CPU_COUNT * 50000 ))  # Allow 50% CPU usage per core
 
-echo "Building with ${BUILD_MEM}MB memory limit and CPU quota ${CPU_QUOTA}"
+print_message "$YELLOW" "Building with ${BUILD_MEM}MB memory limit and CPU quota ${CPU_QUOTA}"
 
 # Remove any existing lockfile
 rm -f bun.lockb
 
-# Build with resource limits, optimizations, and timeout
+# Base build arguments
-echo "Building Docker image..."
+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 \
-    --memory="${BUILD_MEM}m" \
+    "${BUILD_ARGS[@]}" \
-    --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 \
     -t homeassistant-mcp:latest \
     -t homeassistant-mcp:$(date +%Y%m%d) \
     .
@@ -50,15 +110,39 @@ DOCKER_BUILDKIT=1 docker build \
 # Check if build was successful
 BUILD_EXIT_CODE=$?
 if [ $BUILD_EXIT_CODE -eq 124 ]; then
-    echo "Build timed out after 15 minutes!"
+    print_message "$RED" "Build timed out after 15 minutes!"
     exit 1
 elif [ $BUILD_EXIT_CODE -ne 0 ]; then
-    echo "Build failed with exit code ${BUILD_EXIT_CODE}!"
+    print_message "$RED" "Build failed with exit code ${BUILD_EXIT_CODE}!"
     exit 1
 else
-    echo "Build completed successfully!"
+    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/Dockerfile

@@ -1,68 +0,0 @@
-# Use Python slim image as builder
-FROM python:3.10-slim as builder
-
-# Install build dependencies
-RUN apt-get update && apt-get install -y \
-    git \
-    build-essential \
-    portaudio19-dev \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create and activate virtual environment
-RUN python -m venv /opt/venv
-ENV PATH="/opt/venv/bin:$PATH"
-
-# Install Python dependencies with specific versions and CPU-only variants
-RUN pip install --no-cache-dir "numpy>=1.24.3,<2.0.0" && \
-    pip install --no-cache-dir torch==2.1.2 torchaudio==2.1.2 --index-url https://download.pytorch.org/whl/cpu && \
-    pip install --no-cache-dir faster-whisper==0.10.0 openwakeword==0.4.0 pyaudio==0.2.14 sounddevice==0.4.6 requests==2.31.0 && \
-    pip freeze > /opt/venv/requirements.txt
-
-# Create final image
-FROM python:3.10-slim
-
-# Copy virtual environment from builder
-COPY --from=builder /opt/venv /opt/venv
-ENV PATH="/opt/venv/bin:$PATH"
-
-# Install audio dependencies
-RUN apt-get update && apt-get install -y \
-    portaudio19-dev \
-    python3-pyaudio \
-    alsa-utils \
-    libasound2 \
-    libasound2-plugins \
-    pulseaudio \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create necessary directories
-RUN mkdir -p /models/wake_word /audio
-
-# Set working directory
-WORKDIR /app
-
-# Copy the wake word detection script
-COPY wake_word_detector.py .
-
-# Set environment variables
-ENV WHISPER_MODEL_PATH=/models \
-    WAKEWORD_MODEL_PATH=/models/wake_word \
-    PYTHONUNBUFFERED=1 \
-    ASR_MODEL=base.en \
-    ASR_MODEL_PATH=/models
-
-# Add resource limits to Python
-ENV PYTHONMALLOC=malloc \
-    MALLOC_TRIM_THRESHOLD_=100000 \
-    PYTHONDEVMODE=1
-
-# Add healthcheck
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD ps aux | grep '[p]ython' || exit 1
-
-# Copy audio setup script
-COPY setup-audio.sh /setup-audio.sh
-RUN chmod +x /setup-audio.sh
-
-# Start command
-CMD ["/bin/bash", "-c", "/setup-audio.sh && python -u wake_word_detector.py"] 

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

@@ -1,7 +1,58 @@
 #!/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
 
-# Wait for PulseAudio to be ready
+echo "Starting audio setup script at $(date)"
-sleep 2
+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
@@ -12,5 +63,6 @@ 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%
 
-# Make the script executable
+# Keep the script running to prevent container exit
-chmod +x /setup-audio.sh 
+echo "Audio setup complete. Keeping container alive."
+tail -f /dev/null 

docker/speech/wake_word_detector.py

@@ -30,6 +30,9 @@ 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
@@ -44,7 +47,7 @@ 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 = ["alexa"]  # Using 'alexa' as temporary replacement for 'gaja'
+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
@@ -53,8 +56,8 @@ HASS_TOKEN = os.environ.get('HASS_TOKEN')
 
 def initialize_asr_model():
     """Initialize the ASR model with retries and timeout"""
-    model_path = os.environ.get('ASR_MODEL_PATH', '/models')
+    model_path = os.environ.get('WHISPER_MODEL_PATH', '/models')
-    model_name = os.environ.get('ASR_MODEL', 'large-v3')
+    model_name = os.environ.get('WHISPER_MODEL_TYPE', 'base')
     
     start_time = time.time()
     for attempt in range(MAX_MODEL_LOAD_RETRIES):
@@ -235,7 +238,22 @@ class AudioProcessor:
         self.buffer = np.zeros(SAMPLE_RATE * BUFFER_DURATION)
         self.buffer_lock = threading.Lock()
         self.last_transcription_time = 0
-        self.stream = None
+        
+        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
@@ -272,7 +290,7 @@ class AudioProcessor:
                     return True
         return False
 
-    def audio_callback(self, indata, frames, time, status):
+    def _audio_callback(self, indata, frames, time, status):
         """Callback for audio input"""
         if status:
             logger.warning(f"Audio callback status: {status}")
@@ -382,7 +400,7 @@ class AudioProcessor:
                     channels=CHANNELS,
                     samplerate=SAMPLE_RATE,
                     blocksize=CHUNK_SIZE,
-                    callback=self.audio_callback
+                    callback=self._audio_callback
                 ):
                     logger.info("Audio input stream started successfully")
                     logger.info("Listening for audio input...")

docs/Gemfile

@@ -1,23 +0,0 @@
-source "https://rubygems.org"
-
-gem "github-pages", group: :jekyll_plugins
-gem "jekyll-theme-minimal"
-gem "jekyll-relative-links"
-gem "jekyll-seo-tag"
-gem "jekyll-remote-theme"
-gem "jekyll-github-metadata"
-gem "faraday-retry"
-
-# Windows and JRuby does not include zoneinfo files, so bundle the tzinfo-data gem
-# and associated library.
-platforms :mingw, :x64_mingw, :mswin, :jruby do
-  gem "tzinfo", ">= 1"
-  gem "tzinfo-data"
-end
-
-# Lock `http_parser.rb` gem to `v0.6.x` on JRuby builds since newer versions of the gem
-# do not have a Java counterpart.
-gem "http_parser.rb", "~> 0.6.0", :platforms => [:jruby]
-
-# Add webrick for Ruby 3.0+
-gem "webrick", "~> 1.7" 

docs/_config.yml

@@ -1,78 +0,0 @@
-title: Model Context Protocol (MCP)
-description: A bridge between Home Assistant and Language Learning Models
-theme: jekyll-theme-minimal
-markdown: kramdown
-
-# Repository settings
-repository: jango-blockchained/advanced-homeassistant-mcp
-github: [metadata]
-
-# Add base URL and URL settings
-baseurl: "/advanced-homeassistant-mcp" # the subpath of your site
-url: "https://jango-blockchained.github.io" # the base hostname & protocol
-
-# Theme settings
-logo: /assets/img/logo.png # path to logo (create this if you want a logo)
-show_downloads: true # show download buttons for your repo
-
-plugins:
-  - jekyll-relative-links
-  - jekyll-seo-tag
-  - jekyll-remote-theme
-  - jekyll-github-metadata
-
-# Enable relative links
-relative_links:
-  enabled: true
-  collections: true
-
-# Navigation structure
-header_pages:
-  - index.md
-  - getting-started.md
-  - api.md
-  - usage.md
-  - tools/tools.md
-  - development/development.md
-  - troubleshooting.md
-  - contributing.md
-  - roadmap.md
-
-# Collections
-collections:
-  tools:
-    output: true
-    permalink: /:collection/:name
-  development:
-    output: true
-    permalink: /:collection/:name
-
-# Default layouts
-defaults:
-  - scope:
-      path: ""
-      type: "pages"
-    values:
-      layout: "default"
-  - scope:
-      path: "tools"
-      type: "tools"
-    values:
-      layout: "default"
-  - scope:
-      path: "development"
-      type: "development"
-    values:
-      layout: "default"
-
-# Exclude files from processing
-exclude:
-  - Gemfile
-  - Gemfile.lock
-  - node_modules
-  - vendor
-
-# Sass settings
-sass:
-  style: compressed
-  sass_dir: _sass 

docs/_layouts/default.html

@@ -1,52 +0,0 @@
-<!DOCTYPE html>
-<html lang="{{ site.lang | default: " en-US" }}">
-
-<head>
-    <meta charset="UTF-8">
-    <meta http-equiv="X-UA-Compatible" content="IE=edge">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    {% seo %}
-    <link rel="stylesheet" href="{{ " /assets/css/style.css?v=" | append: site.github.build_revision | relative_url }}">
-</head>
-
-<body>
-    <div class="wrapper">
-        <header>
-            <h1><a href="{{ " /" | absolute_url }}">{{ site.title | default: site.github.repository_name }}</a></h1>
-
-            {% if site.logo %}
-            <img src="{{site.logo | relative_url}}" alt="Logo" />
-            {% endif %}
-
-            <p>{{ site.description | default: site.github.project_tagline }}</p>
-
-            <p class="view"><a href="{{ site.github.repository_url }}">View the Project on GitHub <small>{{
-                        site.github.repository_nwo }}</small></a></p>
-
-            <nav class="main-nav">
-                <h3>Documentation</h3>
-                <ul>
-                    <li><a href="{{ '/getting-started' | relative_url }}">Getting Started</a></li>
-                    <li><a href="{{ '/api' | relative_url }}">API Reference</a></li>
-                    <li><a href="{{ '/sse-api' | relative_url }}">SSE API</a></li>
-                    <li><a href="{{ '/architecture' | relative_url }}">Architecture</a></li>
-                    <li><a href="{{ '/contributing' | relative_url }}">Contributing</a></li>
-                    <li><a href="{{ '/troubleshooting' | relative_url }}">Troubleshooting</a></li>
-                </ul>
-            </nav>
-        </header>
-        <section>
-            {{ content }}
-        </section>
-        <footer>
-            {% if site.github.is_project_page %}
-            <p>This project is maintained by <a href="{{ site.github.owner_url }}">{{ site.github.owner_name }}</a></p>
-            {% endif %}
-            <p><small>Hosted on GitHub Pages &mdash; Theme by <a
-                        href="https://github.com/orderedlist">orderedlist</a></small></p>
-        </footer>
-    </div>
-    <script src="{{ " /assets/js/scale.fix.js" | relative_url }}"></script>
-</body>
-
-</html>

docs/api.md

@@ -1,728 +0,0 @@
-# 🚀 Home Assistant MCP API Documentation
-
-![API Version](https://img.shields.io/badge/API-v2.1-blueviolet) ![Rate Limit](https://img.shields.io/badge/Rate%20Limit-100%2Fmin-brightgreen)
-
-## 🌟 Quick Start
-
-```bash
-# Get API schema with caching
-curl -X GET http://localhost:3000/mcp \
-  -H "Cache-Control: max-age=3600" # Cache for 1 hour
-```
-
-## 🔌 Core Functions ⚙️
-
-### State Management (`/api/state`)
-```http
-GET /api/state?cache=true  # Enable client-side caching
-POST /api/state
-```
-
-**Example Request:**
-```json
-{
-  "context": "living_room",
-  "state": {
-    "lights": "on",
-    "temperature": 22
-  },
-  "_cache": {  // Optional caching config
-    "ttl": 300,  // 5 minutes
-    "tags": ["lights", "climate"]
-  }
-}
-```
-
-## ⚡ Action Endpoints
-
-### Execute Action with Cache Validation
-```http
-POST /api/action
-If-None-Match: "etag_value"  // Prevent duplicate actions
-```
-
-**Batch Processing:**
-```json
-{
-  "actions": [
-    { "action": "🌞 Morning Routine", "params": { "brightness": 80 } },
-    { "action": "❄️ AC Control", "params": { "temp": 21 } }
-  ],
-  "_parallel": true  // Execute actions concurrently
-}
-```
-
-## 🔍 Query Functions
-
-### Available Actions with ETag
-```http
-GET /api/actions
-ETag: "a1b2c3d4"  // Client-side cache validation
-```
-
-**Response Headers:**
-```
-Cache-Control: public, max-age=86400  // 24-hour cache
-ETag: "a1b2c3d4"
-```
-
-## 🌐 WebSocket Events
-
-```javascript
-const ws = new WebSocket('wss://ha-mcp/ws');
-ws.onmessage = ({ data }) => {
-  const event = JSON.parse(data);
-  if(event.type === 'STATE_UPDATE') {
-    updateUI(event.payload);  // 🎨 Real-time UI sync
-  }
-};
-```
-
-## 🗃️ Caching Strategies
-
-### Client-Side Caching
-```http
-GET /api/devices
-Cache-Control: max-age=300, stale-while-revalidate=60
-```
-
-### Server-Side Cache-Control
-```typescript
-// Example middleware configuration
-app.use(
-  cacheMiddleware({
-    ttl: 60 * 5,  // 5 minutes
-    paths: ['/api/devices', '/mcp'],
-    vary: ['Authorization']  // User-specific caching
-  })
-);
-```
-
-## ❌ Error Handling
-
-**429 Too Many Requests:**
-```json
-{
-  "error": {
-    "code": "RATE_LIMITED",
-    "message": "Slow down! 🐢",
-    "retry_after": 30,
-    "docs": "https://ha-mcp/docs/rate-limits"
-  }
-}
-```
-
-## 🚦 Rate Limiting Tiers
-
-| Tier          | Requests/min | Features               |
-|---------------|--------------|------------------------|
-| Guest         | 10           | Basic read-only        |
-| User          | 100          | Full access            |
-| Power User    | 500          | Priority queue         |
-| Integration   | 1000         | Bulk operations        |
-
-## 🛠️ Example Usage
-
-### Smart Cache Refresh
-```javascript
-async function getDevices() {
-  const response = await fetch('/api/devices', {
-    headers: {
-      'If-None-Match': localStorage.getItem('devicesETag')
-    }
-  });
-  
-  if(response.status === 304) {  // Not Modified
-    return JSON.parse(localStorage.devicesCache);
-  }
-  
-  const data = await response.json();
-  localStorage.setItem('devicesETag', response.headers.get('ETag'));
-  localStorage.setItem('devicesCache', JSON.stringify(data));
-  return data;
-}
-```
-
-## 🔒 Security Middleware (Enhanced)
-
-### Cache-Aware Rate Limiting
-```typescript
-app.use(
-  rateLimit({
-    windowMs: 15 * 60 * 1000, // 15 minutes
-    max: 100, // Limit each IP to 100 requests per window
-    cache: new RedisStore(), // Distributed cache
-    keyGenerator: (req) => {
-      return `${req.ip}-${req.headers.authorization}`;
-    }
-  })
-);
-```
-
-### Security Headers
-```http
-Content-Security-Policy: default-src 'self';
-Strict-Transport-Security: max-age=31536000;
-X-Content-Type-Options: nosniff;
-Cache-Control: public, max-age=600;
-ETag: "abc123"
-```
-
-## 📘 Best Practices
-
-1. **Cache Wisely:** Use `ETag` and `Cache-Control` headers for state data
-2. **Batch Operations:** Combine requests using `/api/actions/batch`
-3. **WebSocket First:** Prefer real-time updates over polling
-4. **Error Recovery:** Implement exponential backoff with jitter
-5. **Cache Invalidation:** Use tags for bulk invalidation
-
-```mermaid
-graph LR
-A[Client] -->|Cached Request| B{CDN}
-B -->|Cache Hit| C[Return 304]
-B -->|Cache Miss| D[Origin Server]
-D -->|Response| B
-B -->|Response| A
-```
-
-> Pro Tip: Use `curl -I` to inspect cache headers! 🔍
-
-## Device Control
-
-### Common Entity Controls
-
-```json
-{
-  "tool": "control",
-  "command": "turn_on",  // Options: "turn_on", "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",  // Options: "start", "stop", "restart"
-  "slug": "core_configurator"
-}
-```
-
-## Package Management
-
-### List HACS Packages
-
-```json
-{
-  "tool": "package",
-  "action": "list",
-  "category": "integration"  // Options: "integration", "plugin", "theme", "python_script", "appdaemon", "netdaemon"
-}
-```
-
-### Install Package
-
-```json
-{
-  "tool": "package",
-  "action": "install",
-  "category": "integration",
-  "repository": "hacs/integration",
-  "version": "1.32.0"
-}
-```
-
-## Automation Management
-
-For automation management details and endpoints, please refer to the [Tools Documentation](tools/tools.md).
-
-## Security Considerations
-
-- Validate and sanitize all user inputs.
-- Enforce rate limiting to prevent abuse.
-- Apply proper security headers.
-- Gracefully handle errors based on the environment.
-
-## Troubleshooting
-
-If you experience issues with the API:
-- Verify the endpoint and request payload.
-- Check authentication tokens and required headers.
-- Consult the [Troubleshooting Guide](troubleshooting.md) for further guidance.
-
-## 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.
-
-## 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);
-}
-```
-
-## Security Middleware
-
-### Overview
-
-The security middleware provides a comprehensive set of utility functions to enhance the security of the Home Assistant MCP application. These functions cover various aspects of web security, including:
-
-- Rate limiting
-- Request validation
-- Input sanitization
-- Security headers
-- Error handling
-
-### Utility Functions
-
-#### `checkRateLimit(ip: string, maxRequests?: number, windowMs?: number)`
-
-Manages rate limiting for IP addresses to prevent abuse.
-
-**Parameters**:
-- `ip`: IP address to track
-- `maxRequests`: Maximum number of requests allowed (default: 100)
-- `windowMs`: Time window for rate limiting (default: 15 minutes)
-
-**Returns**: `boolean` or throws an error if limit is exceeded
-
-**Example**:
-```typescript
-try {
-  checkRateLimit('127.0.0.1'); // Checks rate limit with default settings
-} catch (error) {
-  // Handle rate limit exceeded
-}
-```
-
-#### `validateRequestHeaders(request: Request, requiredContentType?: string)`
-
-Validates incoming HTTP request headers for security and compliance.
-
-**Parameters**:
-- `request`: The incoming HTTP request
-- `requiredContentType`: Expected content type (default: 'application/json')
-
-**Checks**:
-- Content type
-- Request body size
-- Authorization header (optional)
-
-**Example**:
-```typescript
-try {
-  validateRequestHeaders(request);
-} catch (error) {
-  // Handle validation errors
-}
-```
-
-#### `sanitizeValue(value: unknown)`
-
-Sanitizes input values to prevent XSS attacks.
-
-**Features**:
-- Escapes HTML tags
-- Handles nested objects and arrays
-- Preserves non-string values
-
-**Example**:
-```typescript
-const sanitized = sanitizeValue('<script>alert("xss")</script>');
-// Returns: '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;'
-```
-
-#### `applySecurityHeaders(request: Request, helmetConfig?: HelmetOptions)`
-
-Applies security headers to HTTP requests using Helmet.
-
-**Security Headers**:
-- Content Security Policy
-- X-Frame-Options
-- X-Content-Type-Options
-- Referrer Policy
-- HSTS (in production)
-
-**Example**:
-```typescript
-const headers = applySecurityHeaders(request);
-```
-
-#### `handleError(error: Error, env?: string)`
-
-Handles error responses with environment-specific details.
-
-**Modes**:
-- Production: Generic error message
-- Development: Detailed error with stack trace
-
-**Example**:
-```typescript
-const errorResponse = handleError(error, process.env.NODE_ENV);
-```
-
-### Middleware Usage
-
-These utility functions are integrated into Elysia middleware:
-
-```typescript
-const app = new Elysia()
-  .use(rateLimiter)      // Rate limiting
-  .use(validateRequest)  // Request validation
-  .use(sanitizeInput)    // Input sanitization
-  .use(securityHeaders)  // Security headers
-  .use(errorHandler)     // Error handling
-```
-
-### Best Practices
-
-1. Always validate and sanitize user inputs
-2. Use rate limiting to prevent abuse
-3. Apply security headers
-4. Handle errors gracefully
-5. Keep environment-specific error handling
-
-### Security Considerations
-
-- Configurable rate limits
-- XSS protection
-- Content security policies
-- Token validation
-- Error information exposure control
-
-### Troubleshooting
-
-- Ensure `JWT_SECRET` is set in environment
-- Check content type in requests
-- Monitor rate limit errors
-- Review error handling in different environments 

docs/api/core.md

@@ -1,326 +0,0 @@
----
-layout: default
-title: Core Functions
-parent: API Reference
-nav_order: 3
----
-
-# Core Functions API 🔧
-
-The Core Functions API provides the fundamental operations for interacting with Home Assistant devices and services through MCP Server.
-
-## Device Control
-
-### Get Device State
-
-Retrieve the current state of devices.
-
-```http
-GET /api/state
-GET /api/state/{entity_id}
-```
-
-Parameters:
-- `entity_id` (optional): Specific device ID to query
-
-```bash
-# Get all states
-curl http://localhost:3000/api/state
-
-# Get specific device state
-curl http://localhost:3000/api/state/light.living_room
-```
-
-Response:
-```json
-{
-  "entity_id": "light.living_room",
-  "state": "on",
-  "attributes": {
-    "brightness": 255,
-    "color_temp": 370,
-    "friendly_name": "Living Room Light"
-  },
-  "last_changed": "2024-01-20T15:30:00Z"
-}
-```
-
-### Control Device
-
-Execute device commands.
-
-```http
-POST /api/device/control
-```
-
-Request body:
-```json
-{
-  "entity_id": "light.living_room",
-  "action": "turn_on",
-  "parameters": {
-    "brightness": 200,
-    "color_temp": 400
-  }
-}
-```
-
-Available actions:
-- `turn_on`
-- `turn_off`
-- `toggle`
-- `set_value`
-
-Example with curl:
-```bash
-curl -X POST http://localhost:3000/api/device/control \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
-  -d '{
-    "entity_id": "light.living_room",
-    "action": "turn_on",
-    "parameters": {
-      "brightness": 200
-    }
-  }'
-```
-
-## Natural Language Commands
-
-### Execute Command
-
-Process natural language commands.
-
-```http
-POST /api/command
-```
-
-Request body:
-```json
-{
-  "command": "Turn on the living room lights and set them to 50% brightness"
-}
-```
-
-Example usage:
-```bash
-curl -X POST http://localhost:3000/api/command \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
-  -d '{
-    "command": "Turn on the living room lights and set them to 50% brightness"
-  }'
-```
-
-Response:
-```json
-{
-  "success": true,
-  "actions": [
-    {
-      "entity_id": "light.living_room",
-      "action": "turn_on",
-      "parameters": {
-        "brightness": 127
-      },
-      "status": "completed"
-    }
-  ],
-  "message": "Command executed successfully"
-}
-```
-
-## Scene Management
-
-### Create Scene
-
-Define a new scene with multiple actions.
-
-```http
-POST /api/scene
-```
-
-Request body:
-```json
-{
-  "name": "Movie Night",
-  "description": "Perfect lighting for movie watching",
-  "actions": [
-    {
-      "entity_id": "light.living_room",
-      "action": "turn_on",
-      "parameters": {
-        "brightness": 50,
-        "color_temp": 500
-      }
-    },
-    {
-      "entity_id": "cover.living_room",
-      "action": "close"
-    }
-  ]
-}
-```
-
-### Activate Scene
-
-Trigger a predefined scene.
-
-```http
-POST /api/scene/{scene_name}/activate
-```
-
-Example:
-```bash
-curl -X POST http://localhost:3000/api/scene/movie_night/activate \
-  -H "Authorization: Bearer YOUR_JWT_TOKEN"
-```
-
-## Groups
-
-### Create Device Group
-
-Create a group of devices for collective control.
-
-```http
-POST /api/group
-```
-
-Request body:
-```json
-{
-  "name": "Living Room",
-  "entities": [
-    "light.living_room_main",
-    "light.living_room_accent",
-    "switch.living_room_fan"
-  ]
-}
-```
-
-### Control Group
-
-Control multiple devices in a group.
-
-```http
-POST /api/group/{group_name}/control
-```
-
-Request body:
-```json
-{
-  "action": "turn_off"
-}
-```
-
-## System Operations
-
-### Health Check
-
-Check server status and connectivity.
-
-```http
-GET /health
-```
-
-Response:
-```json
-{
-  "status": "healthy",
-  "version": "1.0.0",
-  "uptime": 3600,
-  "homeAssistant": {
-    "connected": true,
-    "version": "2024.1.0"
-  }
-}
-```
-
-### Configuration
-
-Get current server configuration.
-
-```http
-GET /api/config
-```
-
-Response:
-```json
-{
-  "server": {
-    "port": 3000,
-    "host": "0.0.0.0",
-    "version": "1.0.0"
-  },
-  "homeAssistant": {
-    "url": "http://homeassistant:8123",
-    "connected": true
-  },
-  "features": {
-    "nlp": true,
-    "scenes": true,
-    "groups": true
-  }
-}
-```
-
-## Error Handling
-
-All endpoints follow standard HTTP status codes and return detailed error messages:
-
-```json
-{
-  "error": true,
-  "code": "INVALID_ENTITY",
-  "message": "Device 'light.nonexistent' not found",
-  "details": {
-    "entity_id": "light.nonexistent",
-    "available_entities": [
-      "light.living_room",
-      "light.kitchen"
-    ]
-  }
-}
-```
-
-Common error codes:
-- `INVALID_ENTITY`: Device not found
-- `INVALID_ACTION`: Unsupported action
-- `INVALID_PARAMETERS`: Invalid command parameters
-- `AUTHENTICATION_ERROR`: Invalid or missing token
-- `CONNECTION_ERROR`: Home Assistant connection issue
-
-## TypeScript Interfaces
-
-```typescript
-interface DeviceState {
-  entity_id: string;
-  state: string;
-  attributes: Record<string, any>;
-  last_changed: string;
-}
-
-interface DeviceCommand {
-  entity_id: string;
-  action: 'turn_on' | 'turn_off' | 'toggle' | 'set_value';
-  parameters?: Record<string, any>;
-}
-
-interface Scene {
-  name: string;
-  description?: string;
-  actions: DeviceCommand[];
-}
-
-interface Group {
-  name: string;
-  entities: string[];
-}
-```
-
-## Related Resources
-
-- [API Overview](index.md)
-- [SSE API](sse.md)
-- [Architecture](../architecture.md)
-- [Examples](https://github.com/jango-blockchained/advanced-homeassistant-mcp/tree/main/examples) 

docs/api/index.md

@@ -1,234 +0,0 @@
----
-layout: default
-title: API Overview
-parent: API Reference
-nav_order: 1
-has_children: false
----
-
-# API Documentation 📚
-
-Welcome to the MCP Server API documentation. This guide covers all available endpoints, authentication methods, and integration patterns.
-
-## API Overview
-
-The MCP Server provides several API categories:
-
-1. **Core API** - Basic device control and state management
-2. **SSE API** - Real-time event subscriptions
-3. **Scene API** - Scene management and automation
-4. **Voice API** - Natural language command processing
-
-## Authentication
-
-All API endpoints require authentication using JWT tokens:
-
-```bash
-# Include the token in your requests
-curl -H "Authorization: Bearer YOUR_JWT_TOKEN" http://localhost:3000/api/state
-```
-
-To obtain a token:
-
-```bash
-curl -X POST http://localhost:3000/auth/token \
-  -H "Content-Type: application/json" \
-  -d '{"username": "your_username", "password": "your_password"}'
-```
-
-## Core Endpoints
-
-### Device State
-
-```http
-GET /api/state
-```
-
-Retrieve the current state of all devices:
-
-```bash
-curl http://localhost:3000/api/state
-```
-
-Response:
-```json
-{
-  "devices": [
-    {
-      "id": "light.living_room",
-      "state": "on",
-      "attributes": {
-        "brightness": 255,
-        "color_temp": 370
-      }
-    }
-  ]
-}
-```
-
-### Command Execution
-
-```http
-POST /api/command
-```
-
-Execute a natural language command:
-
-```bash
-curl -X POST http://localhost:3000/api/command \
-  -H "Content-Type: application/json" \
-  -d '{"command": "Turn on the kitchen lights"}'
-```
-
-Response:
-```json
-{
-  "success": true,
-  "action": "turn_on",
-  "device": "light.kitchen",
-  "message": "Kitchen lights turned on"
-}
-```
-
-## Real-Time Events
-
-### Event Subscription
-
-```http
-GET /subscribe_events
-```
-
-Subscribe to device state changes:
-
-```javascript
-const eventSource = new EventSource('http://localhost:3000/subscribe_events?token=YOUR_TOKEN');
-
-eventSource.onmessage = (event) => {
-    const data = JSON.parse(event.data);
-    console.log('State changed:', data);
-};
-```
-
-### Filtered Subscriptions
-
-Subscribe to specific device types:
-
-```http
-GET /subscribe_events?domain=light
-GET /subscribe_events?entity_id=light.living_room
-```
-
-## Scene Management
-
-### Create Scene
-
-```http
-POST /api/scene
-```
-
-Create a new scene:
-
-```bash
-curl -X POST http://localhost:3000/api/scene \
-  -H "Content-Type: application/json" \
-  -d '{
-    "name": "Movie Night",
-    "actions": [
-      {"device": "light.living_room", "action": "dim", "value": 20},
-      {"device": "media_player.tv", "action": "on"}
-    ]
-  }'
-```
-
-### Activate Scene
-
-```http
-POST /api/scene/activate
-```
-
-Activate an existing scene:
-
-```bash
-curl -X POST http://localhost:3000/api/scene/activate \
-  -H "Content-Type: application/json" \
-  -d '{"name": "Movie Night"}'
-```
-
-## Error Handling
-
-The API uses standard HTTP status codes:
-
-- `200` - Success
-- `400` - Bad Request
-- `401` - Unauthorized
-- `404` - Not Found
-- `500` - Server Error
-
-Error responses include detailed messages:
-
-```json
-{
-  "error": true,
-  "message": "Device not found",
-  "code": "DEVICE_NOT_FOUND",
-  "details": {
-    "device_id": "light.nonexistent"
-  }
-}
-```
-
-## Rate Limiting
-
-API requests are rate-limited to prevent abuse:
-
-```http
-X-RateLimit-Limit: 100
-X-RateLimit-Remaining: 99
-X-RateLimit-Reset: 1640995200
-```
-
-When exceeded, returns `429 Too Many Requests`:
-
-```json
-{
-  "error": true,
-  "message": "Rate limit exceeded",
-  "reset": 1640995200
-}
-```
-
-## WebSocket API
-
-For bi-directional communication:
-
-```javascript
-const ws = new WebSocket('ws://localhost:3000/ws');
-
-ws.onmessage = (event) => {
-    const data = JSON.parse(event.data);
-    console.log('Received:', data);
-};
-
-ws.send(JSON.stringify({
-    type: 'command',
-    payload: {
-        command: 'Turn on lights'
-    }
-}));
-```
-
-## API Versioning
-
-The current API version is v1. Include the version in the URL:
-
-```http
-/api/v1/state
-/api/v1/command
-```
-
-## Further Reading
-
-- [SSE API Details](sse.md) - In-depth SSE documentation
-- [Core Functions](core.md) - Detailed endpoint documentation
-- [Architecture Overview](../architecture.md) - System design details
-- [Troubleshooting](../troubleshooting.md) - Common issues and solutions 

docs/api/sse.md

@@ -1,266 +0,0 @@
----
-layout: default
-title: SSE API
-parent: API Reference
-nav_order: 2
----
-
-# Server-Sent Events (SSE) API 📡
-
-The SSE API provides real-time updates about device states and events from your Home Assistant setup. This guide covers how to use and implement SSE connections in your applications.
-
-## Overview
-
-Server-Sent Events (SSE) is a standard that enables servers to push real-time updates to clients over HTTP connections. MCP Server uses SSE to provide:
-
-- Real-time device state updates
-- Event notifications
-- System status changes
-- Command execution results
-
-## Basic Usage
-
-### Establishing a Connection
-
-Create an EventSource connection to receive updates:
-
-```javascript
-const eventSource = new EventSource('http://localhost:3000/subscribe_events?token=YOUR_JWT_TOKEN');
-
-eventSource.onmessage = (event) => {
-    const data = JSON.parse(event.data);
-    console.log('Received update:', data);
-};
-```
-
-### Connection States
-
-Handle different connection states:
-
-```javascript
-eventSource.onopen = () => {
-    console.log('Connection established');
-};
-
-eventSource.onerror = (error) => {
-    console.error('Connection error:', error);
-    // Implement reconnection logic if needed
-};
-```
-
-## Event Types
-
-### Device State Events
-
-Subscribe to all device state changes:
-
-```javascript
-const stateEvents = new EventSource('http://localhost:3000/subscribe_events?type=state');
-
-stateEvents.onmessage = (event) => {
-    const state = JSON.parse(event.data);
-    console.log('Device state changed:', state);
-};
-```
-
-Example state event:
-```json
-{
-  "type": "state_changed",
-  "entity_id": "light.living_room",
-  "state": "on",
-  "attributes": {
-    "brightness": 255,
-    "color_temp": 370
-  },
-  "timestamp": "2024-01-20T15:30:00Z"
-}
-```
-
-### Filtered Subscriptions
-
-#### By Domain
-Subscribe to specific device types:
-
-```javascript
-// Subscribe to only light events
-const lightEvents = new EventSource('http://localhost:3000/subscribe_events?domain=light');
-
-// Subscribe to multiple domains
-const multiEvents = new EventSource('http://localhost:3000/subscribe_events?domain=light,switch,sensor');
-```
-
-#### By Entity ID
-Subscribe to specific devices:
-
-```javascript
-// Single entity
-const livingRoomLight = new EventSource(
-    'http://localhost:3000/subscribe_events?entity_id=light.living_room'
-);
-
-// Multiple entities
-const kitchenDevices = new EventSource(
-    'http://localhost:3000/subscribe_events?entity_id=light.kitchen,switch.coffee_maker'
-);
-```
-
-## Advanced Usage
-
-### Connection Management
-
-Implement robust connection handling:
-
-```javascript
-class SSEManager {
-    constructor(url, options = {}) {
-        this.url = url;
-        this.options = {
-            maxRetries: 3,
-            retryDelay: 1000,
-            ...options
-        };
-        this.retryCount = 0;
-        this.connect();
-    }
-
-    connect() {
-        this.eventSource = new EventSource(this.url);
-        
-        this.eventSource.onopen = () => {
-            this.retryCount = 0;
-            console.log('Connected to SSE stream');
-        };
-
-        this.eventSource.onerror = (error) => {
-            this.handleError(error);
-        };
-
-        this.eventSource.onmessage = (event) => {
-            this.handleMessage(event);
-        };
-    }
-
-    handleError(error) {
-        console.error('SSE Error:', error);
-        this.eventSource.close();
-
-        if (this.retryCount < this.options.maxRetries) {
-            this.retryCount++;
-            setTimeout(() => {
-                console.log(`Retrying connection (${this.retryCount}/${this.options.maxRetries})`);
-                this.connect();
-            }, this.options.retryDelay * this.retryCount);
-        }
-    }
-
-    handleMessage(event) {
-        try {
-            const data = JSON.parse(event.data);
-            // Handle the event data
-            console.log('Received:', data);
-        } catch (error) {
-            console.error('Error parsing SSE data:', error);
-        }
-    }
-
-    disconnect() {
-        if (this.eventSource) {
-            this.eventSource.close();
-        }
-    }
-}
-
-// Usage
-const sseManager = new SSEManager('http://localhost:3000/subscribe_events?token=YOUR_TOKEN');
-```
-
-### Event Filtering
-
-Filter events on the client side:
-
-```javascript
-class EventFilter {
-    constructor(conditions) {
-        this.conditions = conditions;
-    }
-
-    matches(event) {
-        return Object.entries(this.conditions).every(([key, value]) => {
-            if (Array.isArray(value)) {
-                return value.includes(event[key]);
-            }
-            return event[key] === value;
-        });
-    }
-}
-
-// Usage
-const filter = new EventFilter({
-    domain: ['light', 'switch'],
-    state: 'on'
-});
-
-eventSource.onmessage = (event) => {
-    const data = JSON.parse(event.data);
-    if (filter.matches(data)) {
-        console.log('Matched event:', data);
-    }
-};
-```
-
-## Best Practices
-
-1. **Authentication**
-   - Always include authentication tokens
-   - Implement token refresh mechanisms
-   - Handle authentication errors gracefully
-
-2. **Error Handling**
-   - Implement progressive retry logic
-   - Log connection issues
-   - Notify users of connection status
-
-3. **Resource Management**
-   - Close EventSource connections when not needed
-   - Limit the number of concurrent connections
-   - Use filtered subscriptions when possible
-
-4. **Performance**
-   - Process events efficiently
-   - Batch UI updates
-   - Consider debouncing frequent updates
-
-## Common Issues
-
-### Connection Drops
-If the connection drops, the EventSource will automatically attempt to reconnect. You can customize this behavior:
-
-```javascript
-eventSource.addEventListener('error', (error) => {
-    if (eventSource.readyState === EventSource.CLOSED) {
-        // Connection closed, implement custom retry logic
-    }
-});
-```
-
-### Memory Leaks
-Always clean up EventSource connections:
-
-```javascript
-// In a React component
-useEffect(() => {
-    const eventSource = new EventSource('http://localhost:3000/subscribe_events');
-    
-    return () => {
-        eventSource.close(); // Cleanup on unmount
-    };
-}, []);
-```
-
-## Related Resources
-
-- [API Overview](index.md)
-- [Core Functions](core.md)
-- [WebSocket API](index.md#websocket-api)
-- [Troubleshooting](../troubleshooting.md) 

docs/architecture.md

@@ -1,283 +0,0 @@
----
-layout: default
-title: Architecture
-nav_order: 4
----
-
-# Architecture Overview 🏗️
-
-This document describes the architecture of the MCP Server, explaining how different components work together to provide a bridge between Home Assistant and Language Learning Models.
-
-## System Architecture
-
-```mermaid
-graph TD
-    subgraph "Client Layer"
-        WC[Web Clients]
-        MC[Mobile Clients]
-        VC[Voice Assistants]
-    end
-
-    subgraph "MCP Server"
-        API[API Gateway]
-        NLP[NLP Engine]
-        SSE[SSE Manager]
-        WS[WebSocket Server]
-        CM[Command Manager]
-        SC[Scene Controller]
-        Cache[Redis Cache]
-    end
-
-    subgraph "Home Assistant"
-        HA[Home Assistant Core]
-        Dev[Devices & Services]
-    end
-
-    subgraph "AI Layer"
-        LLM[Language Models]
-        IC[Intent Classifier]
-        NER[Named Entity Recognition]
-    end
-
-    WC --> |HTTP/WS| API
-    MC --> |HTTP/WS| API
-    VC --> |HTTP| API
-    
-    API --> |Events| SSE
-    API --> |Real-time| WS
-    API --> |Process| NLP
-    
-    NLP --> |Query| LLM
-    NLP --> |Extract| IC
-    NLP --> |Identify| NER
-    
-    CM --> |Execute| HA
-    HA --> |Control| Dev
-    
-    SSE --> |State Updates| WC
-    SSE --> |State Updates| MC
-    WS --> |Bi-directional| WC
-    
-    Cache --> |Fast Access| API
-    HA --> |Events| Cache
-```
-
-## Component Details
-
-### 1. Client Layer
-
-The client layer consists of various interfaces that interact with the MCP Server:
-
-- **Web Clients**: Browser-based dashboards and control panels
-- **Mobile Clients**: Native mobile applications
-- **Voice Assistants**: Voice-enabled devices and interfaces
-
-### 2. MCP Server Core
-
-#### API Gateway
-- Handles all incoming HTTP requests
-- Manages authentication and rate limiting
-- Routes requests to appropriate handlers
-
-```typescript
-interface APIGateway {
-    authenticate(): Promise<boolean>;
-    rateLimit(): Promise<boolean>;
-    route(request: Request): Promise<Response>;
-}
-```
-
-#### NLP Engine
-- Processes natural language commands
-- Integrates with Language Models
-- Extracts intents and entities
-
-```typescript
-interface NLPEngine {
-    processCommand(text: string): Promise<CommandIntent>;
-    extractEntities(text: string): Promise<Entity[]>;
-    validateIntent(intent: CommandIntent): boolean;
-}
-```
-
-#### Event Management
-- **SSE Manager**: Handles Server-Sent Events
-- **WebSocket Server**: Manages bi-directional communication
-- **Command Manager**: Processes and executes commands
-
-### 3. Home Assistant Integration
-
-The server maintains a robust connection to Home Assistant through:
-
-- REST API calls
-- WebSocket connections
-- Event subscriptions
-
-```typescript
-interface HomeAssistantClient {
-    connect(): Promise<void>;
-    getState(entityId: string): Promise<EntityState>;
-    executeCommand(command: Command): Promise<CommandResult>;
-    subscribeToEvents(callback: EventCallback): Subscription;
-}
-```
-
-### 4. AI Layer
-
-#### Language Model Integration
-- Processes natural language input
-- Understands context and user intent
-- Generates appropriate responses
-
-#### Intent Classification
-- Identifies command types
-- Extracts parameters
-- Validates requests
-
-## Data Flow
-
-### 1. Command Processing
-
-```mermaid
-sequenceDiagram
-    participant Client
-    participant API
-    participant NLP
-    participant LLM
-    participant HA
-    
-    Client->>API: Send command
-    API->>NLP: Process text
-    NLP->>LLM: Get intent
-    LLM-->>NLP: Return structured intent
-    NLP->>HA: Execute command
-    HA-->>API: Return result
-    API-->>Client: Send response
-```
-
-### 2. Real-time Updates
-
-```mermaid
-sequenceDiagram
-    participant HA
-    participant Cache
-    participant SSE
-    participant Client
-    
-    HA->>Cache: State change
-    Cache->>SSE: Notify change
-    SSE->>Client: Send update
-    Note over Client: Update UI
-```
-
-### 3. [SSE API](api/sse.md)
-- Event Subscriptions
-- Real-time Updates
-- Connection Management
-
-## Security Architecture
-
-### Authentication Flow
-
-1. **JWT-based Authentication**
-   ```typescript
-   interface AuthToken {
-       token: string;
-       expires: number;
-       scope: string[];
-   }
-   ```
-
-2. **Rate Limiting**
-   ```typescript
-   interface RateLimit {
-       window: number;
-       max: number;
-       current: number;
-   }
-   ```
-
-### Security Measures
-
-- TLS encryption for all communications
-- Input sanitization
-- Request validation
-- Token-based authentication
-- Rate limiting
-- IP filtering
-
-## Performance Optimizations
-
-### Caching Strategy
-
-```mermaid
-graph LR
-    Request --> Cache{Cache?}
-    Cache -->|Hit| Response
-    Cache -->|Miss| HA[Home Assistant]
-    HA --> Cache
-    Cache --> Response
-```
-
-### Connection Management
-
-- Connection pooling
-- Automatic reconnection
-- Load balancing
-- Request queuing
-
-## Configuration
-
-The system is highly configurable through environment variables and configuration files:
-
-```yaml
-server:
-  port: 3000
-  host: '0.0.0.0'
-  
-homeAssistant:
-  url: 'http://homeassistant:8123'
-  token: 'YOUR_TOKEN'
-  
-security:
-  jwtSecret: 'your-secret'
-  rateLimit: 100
-  
-ai:
-  model: 'gpt-4'
-  temperature: 0.7
-  
-cache:
-  ttl: 300
-  maxSize: '100mb'
-```
-
-## Deployment Architecture
-
-### Docker Deployment
-
-```mermaid
-graph TD
-    subgraph "Docker Compose"
-        MCP[MCP Server]
-        Redis[Redis Cache]
-        HA[Home Assistant]
-    end
-    
-    MCP --> Redis
-    MCP --> HA
-```
-
-### Scaling Considerations
-
-- Horizontal scaling capabilities
-- Load balancing support
-- Redis cluster support
-- Multiple HA instance support
-
-## Further Reading
-
-- [API Documentation](api/index.md)
-- [Installation Guide](getting-started/installation.md)
-- [Contributing Guidelines](contributing.md)
-- [Troubleshooting](troubleshooting.md) 

docs/assets/css/style.scss

@@ -1,54 +0,0 @@
-@import "{{ site.theme }}";
-
-// Custom styles
-.main-nav {
-    margin-top: 20px;
-
-    ul {
-        list-style: none;
-        padding: 0;
-        margin: 0;
-    }
-
-    li {
-        margin-bottom: 8px;
-    }
-
-    a {
-        color: #267CB9;
-        text-decoration: none;
-
-        &:hover {
-            text-decoration: underline;
-        }
-    }
-}
-
-h1,
-h2,
-h3 {
-    color: #333;
-}
-
-code {
-    background-color: #f8f8f8;
-    border: 1px solid #ddd;
-    border-radius: 3px;
-    padding: 2px 5px;
-}
-
-pre {
-    background-color: #f8f8f8;
-    border: 1px solid #ddd;
-    border-radius: 3px;
-    padding: 10px;
-    overflow-x: auto;
-}
-
-.wrapper {
-    max-width: 960px;
-}
-
-section {
-    max-width: 700px;
-}

docs/assets/stylesheets/extra.css

@@ -1,28 +0,0 @@
-:root {
-  --md-primary-fg-color: #1a73e8;
-  --md-primary-fg-color--light: #5195ee;
-  --md-primary-fg-color--dark: #0d47a1;
-}
-
-.md-header {
-  box-shadow: 0 0 0.2rem rgba(0,0,0,.1), 0 0.2rem 0.4rem rgba(0,0,0,.2);
-}
-
-.md-main__inner {
-  margin-top: 1.5rem;
-}
-
-.md-typeset h1 {
-  font-weight: 700;
-  color: var(--md-primary-fg-color);
-}
-
-.md-typeset .admonition {
-  font-size: .8rem;
-}
-
-code {
-  background-color: rgba(175,184,193,0.2);
-  padding: .2em .4em;
-  border-radius: 6px;
-} 

docs/claude_desktop_config.json

@@ -1,16 +0,0 @@
-{
-    "mcpServers": {
-        "homeassistant-mcp": {
-            "command": "bun",
-            "args": [
-                "run",
-                "start",
-                "--port",
-                "8080"
-            ],
-            "env": {
-                "NODE_ENV": "production"
-            }
-        }
-    }
-}

docs/cline_config.json

@@ -1,18 +0,0 @@
-{
-    "mcpServers": {
-        "homeassistant-mcp": {
-            "command": "bun",
-            "args": [
-                "run",
-                "start",
-                "--enable-cline",
-                "--config",
-                "${configDir}/.env"
-            ],
-            "env": {
-                "NODE_ENV": "production",
-                "CLINE_MODE": "true"
-            }
-        }
-    }
-}

docs/contributing.md

@@ -1,254 +0,0 @@
----
-layout: default
-title: Contributing
-nav_order: 5
----
-
-# Contributing Guide 🤝
-
-Thank you for your interest in contributing to the MCP Server project! This guide will help you get started with contributing to the project.
-
-## Getting Started
-
-### Prerequisites
-
-Before you begin, ensure you have:
-
-- [Bun](https://bun.sh) >= 1.0.26
-- [Node.js](https://nodejs.org) >= 18
-- [Docker](https://www.docker.com) (optional, for containerized development)
-- A running Home Assistant instance for testing
-
-### Development Setup
-
-1. Fork and clone the repository:
-   ```bash
-   git clone https://github.com/YOUR_USERNAME/advanced-homeassistant-mcp.git
-   cd advanced-homeassistant-mcp
-   ```
-
-2. Install dependencies:
-   ```bash
-   bun install
-   ```
-
-3. Set up your development environment:
-   ```bash
-   cp .env.example .env
-   # Edit .env with your Home Assistant details
-   ```
-
-4. Start the development server:
-   ```bash
-   bun run dev
-   ```
-
-## Development Workflow
-
-### Branch Naming Convention
-
-- `feature/` - New features
-- `fix/` - Bug fixes
-- `docs/` - Documentation updates
-- `refactor/` - Code refactoring
-- `test/` - Test improvements
-
-Example:
-```bash
-git checkout -b feature/voice-commands
-```
-
-### Commit Messages
-
-We follow the [Conventional Commits](https://www.conventionalcommits.org/) specification:
-
-```
-type(scope): description
-
-[optional body]
-
-[optional footer]
-```
-
-Types:
-- `feat:` - New features
-- `fix:` - Bug fixes
-- `docs:` - Documentation changes
-- `style:` - Code style changes (formatting, etc.)
-- `refactor:` - Code refactoring
-- `test:` - Test updates
-- `chore:` - Maintenance tasks
-
-Examples:
-```bash
-feat(api): add voice command endpoint
-fix(sse): resolve connection timeout issue
-docs(readme): update installation instructions
-```
-
-### Testing
-
-Run tests before submitting your changes:
-
-```bash
-# Run all tests
-bun test
-
-# Run specific test file
-bun test test/api/command.test.ts
-
-# Run tests with coverage
-bun test --coverage
-```
-
-### Code Style
-
-We use ESLint and Prettier for code formatting:
-
-```bash
-# Check code style
-bun run lint
-
-# Fix code style issues
-bun run lint:fix
-```
-
-## Pull Request Process
-
-1. **Update Documentation**
-   - Add/update relevant documentation
-   - Include inline code comments where necessary
-   - Update API documentation if endpoints change
-
-2. **Write Tests**
-   - Add tests for new features
-   - Update existing tests if needed
-   - Ensure all tests pass
-
-3. **Create Pull Request**
-   - Fill out the PR template
-   - Link related issues
-   - Provide clear description of changes
-
-4. **Code Review**
-   - Address review comments
-   - Keep discussions focused
-   - Be patient and respectful
-
-### PR Template
-
-```markdown
-## Description
-Brief description of the changes
-
-## Type of Change
-- [ ] Bug fix
-- [ ] New feature
-- [ ] Breaking change
-- [ ] Documentation update
-
-## How Has This Been Tested?
-Describe your test process
-
-## Checklist
-- [ ] Tests added/updated
-- [ ] Documentation updated
-- [ ] Code follows style guidelines
-- [ ] All tests passing
-```
-
-## Development Guidelines
-
-### Code Organization
-
-```
-src/
-├── api/          # API endpoints
-├── core/         # Core functionality
-├── models/       # Data models
-├── services/     # Business logic
-├── utils/        # Utility functions
-└── types/        # TypeScript types
-```
-
-### Best Practices
-
-1. **Type Safety**
-   ```typescript
-   // Use explicit types
-   interface CommandRequest {
-       command: string;
-       parameters?: Record<string, unknown>;
-   }
-   
-   function processCommand(request: CommandRequest): Promise<CommandResponse> {
-       // Implementation
-   }
-   ```
-
-2. **Error Handling**
-   ```typescript
-   try {
-       await processCommand(request);
-   } catch (error) {
-       if (error instanceof ValidationError) {
-           // Handle validation errors
-       }
-       throw error;
-   }
-   ```
-
-3. **Async/Await**
-   ```typescript
-   // Prefer async/await over promises
-   async function handleRequest() {
-       const result = await processData();
-       return result;
-   }
-   ```
-
-## Documentation
-
-### API Documentation
-
-Update API documentation when adding/modifying endpoints:
-
-```typescript
-/**
- * Process a voice command
- * @param command - The voice command to process
- * @returns Promise<CommandResult>
- * @throws {ValidationError} If command is invalid
- */
-async function processVoiceCommand(command: string): Promise<CommandResult> {
-    // Implementation
-}
-```
-
-### README Updates
-
-Keep the README up to date with:
-- New features
-- Changed requirements
-- Updated examples
-- Modified configuration
-
-## Getting Help
-
-- Check [Discussions](https://github.com/jango-blockchained/advanced-homeassistant-mcp/discussions)
-- Review existing [Issues](https://github.com/jango-blockchained/advanced-homeassistant-mcp/issues)
-
-## Community Guidelines
-
-We expect all contributors to:
-
-- Be respectful and inclusive
-- Focus on constructive feedback
-- Help maintain a positive environment
-- Follow our code style guidelines
-- Write clear documentation
-- Test their code thoroughly
-
-## License
-
-By contributing, you agree that your contributions will be licensed under the MIT License. 

docs/development/best-practices.md

@@ -1,310 +0,0 @@
-# Development Best Practices
-
-This guide outlines the best practices for developing tools and features for the Home Assistant MCP.
-
-## Code Style
-
-### TypeScript
-
-1. Use TypeScript for all new code
-2. Enable strict mode
-3. Use explicit types
-4. Avoid `any` type
-5. Use interfaces over types
-6. Document with JSDoc comments
-
-```typescript
-/** 
- * Represents a device in the system.
- * @interface
- */
-interface Device {
-    /** Unique device identifier */
-    id: string;
-    
-    /** Human-readable device name */
-    name: string;
-    
-    /** Device state */
-    state: DeviceState;
-}
-```
-
-### Naming Conventions
-
-1. Use PascalCase for:
-   - Classes
-   - Interfaces
-   - Types
-   - Enums
-
-2. Use camelCase for:
-   - Variables
-   - Functions
-   - Methods
-   - Properties
-
-3. Use UPPER_SNAKE_CASE for:
-   - Constants
-   - Enum values
-
-```typescript
-class DeviceManager {
-    private readonly DEFAULT_TIMEOUT = 5000;
-    
-    async getDeviceState(deviceId: string): Promise<DeviceState> {
-        // Implementation
-    }
-}
-```
-
-## Architecture
-
-### SOLID Principles
-
-1. Single Responsibility
-   - Each class/module has one job
-   - Split complex functionality
-
-2. Open/Closed
-   - Open for extension
-   - Closed for modification
-
-3. Liskov Substitution
-   - Subtypes must be substitutable
-   - Use interfaces properly
-
-4. Interface Segregation
-   - Keep interfaces focused
-   - Split large interfaces
-
-5. Dependency Inversion
-   - Depend on abstractions
-   - Use dependency injection
-
-### Example
-
-```typescript
-// Bad
-class DeviceManager {
-    async getState() { /* ... */ }
-    async setState() { /* ... */ }
-    async sendNotification() { /* ... */ }  // Wrong responsibility
-}
-
-// Good
-class DeviceManager {
-    constructor(
-        private notifier: NotificationService
-    ) {}
-
-    async getState() { /* ... */ }
-    async setState() { /* ... */ }
-}
-
-class NotificationService {
-    async send() { /* ... */ }
-}
-```
-
-## Error Handling
-
-### Best Practices
-
-1. Use custom error classes
-2. Include error codes
-3. Provide meaningful messages
-4. Include error context
-5. Handle async errors
-6. Log appropriately
-
-```typescript
-class DeviceError extends Error {
-    constructor(
-        message: string,
-        public code: string,
-        public context: Record<string, any>
-    ) {
-        super(message);
-        this.name = 'DeviceError';
-    }
-}
-
-try {
-    await device.connect();
-} catch (error) {
-    throw new DeviceError(
-        'Failed to connect to device',
-        'DEVICE_CONNECTION_ERROR',
-        { deviceId: device.id, attempt: 1 }
-    );
-}
-```
-
-## Testing
-
-### Guidelines
-
-1. Write unit tests first
-2. Use meaningful descriptions
-3. Test edge cases
-4. Mock external dependencies
-5. Keep tests focused
-6. Use test fixtures
-
-```typescript
-describe('DeviceManager', () => {
-    let manager: DeviceManager;
-    let mockDevice: jest.Mocked<Device>;
-
-    beforeEach(() => {
-        mockDevice = {
-            id: 'test_device',
-            getState: jest.fn()
-        };
-        manager = new DeviceManager(mockDevice);
-    });
-
-    it('should get device state', async () => {
-        mockDevice.getState.mockResolvedValue('on');
-        const state = await manager.getDeviceState();
-        expect(state).toBe('on');
-    });
-});
-```
-
-## Performance
-
-### Optimization
-
-1. Use caching
-2. Implement pagination
-3. Optimize database queries
-4. Use connection pooling
-5. Implement rate limiting
-6. Batch operations
-
-```typescript
-class DeviceCache {
-    private cache = new Map<string, CacheEntry>();
-    private readonly TTL = 60000;  // 1 minute
-
-    async getDevice(id: string): Promise<Device> {
-        const cached = this.cache.get(id);
-        if (cached && Date.now() - cached.timestamp < this.TTL) {
-            return cached.device;
-        }
-        
-        const device = await this.fetchDevice(id);
-        this.cache.set(id, {
-            device,
-            timestamp: Date.now()
-        });
-        
-        return device;
-    }
-}
-```
-
-## Security
-
-### Guidelines
-
-1. Validate all input
-2. Use parameterized queries
-3. Implement rate limiting
-4. Use proper authentication
-5. Follow OWASP guidelines
-6. Sanitize output
-
-```typescript
-class InputValidator {
-    static validateDeviceId(id: string): boolean {
-        return /^[a-zA-Z0-9_-]{1,64}$/.test(id);
-    }
-
-    static sanitizeOutput(data: any): any {
-        // Implement output sanitization
-        return data;
-    }
-}
-```
-
-## Documentation
-
-### Standards
-
-1. Use JSDoc comments
-2. Document interfaces
-3. Include examples
-4. Document errors
-5. Keep docs updated
-6. Use markdown
-
-```typescript
-/**
- * Manages device operations.
- * @class
- */
-class DeviceManager {
-    /**
-     * Gets the current state of a device.
-     * @param {string} deviceId - The device identifier.
-     * @returns {Promise<DeviceState>} The current device state.
-     * @throws {DeviceError} If device is not found or unavailable.
-     * @example
-     * const state = await deviceManager.getDeviceState('living_room_light');
-     */
-    async getDeviceState(deviceId: string): Promise<DeviceState> {
-        // Implementation
-    }
-}
-```
-
-## Logging
-
-### Best Practices
-
-1. Use appropriate levels
-2. Include context
-3. Structure log data
-4. Handle sensitive data
-5. Implement rotation
-6. Use correlation IDs
-
-```typescript
-class Logger {
-    info(message: string, context: Record<string, any>) {
-        console.log(JSON.stringify({
-            level: 'info',
-            message,
-            context,
-            timestamp: new Date().toISOString(),
-            correlationId: context.correlationId
-        }));
-    }
-}
-```
-
-## Version Control
-
-### Guidelines
-
-1. Use meaningful commits
-2. Follow branching strategy
-3. Write good PR descriptions
-4. Review code thoroughly
-5. Keep changes focused
-6. Use conventional commits
-
-```bash
-# Good commit messages
-git commit -m "feat(device): add support for zigbee devices"
-git commit -m "fix(api): handle timeout errors properly"
-```
-
-## See Also
-
-- [Tool Development Guide](tools.md)
-- [Interface Documentation](interfaces.md)
-- [Testing Guide](../testing.md) 

docs/development/development.md

@@ -1,190 +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/
-│   ├── __tests__/        # Test files
-│   ├── __mocks__/       # Mock files
-│   ├── 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/development/interfaces.md

@@ -1,296 +0,0 @@
-# Interface Documentation
-
-This document describes the core interfaces used throughout the Home Assistant MCP.
-
-## Core Interfaces
-
-### Tool Interface
-
-```typescript
-interface Tool {
-    /** Unique identifier for the tool */
-    id: string;
-    
-    /** Human-readable name */
-    name: string;
-    
-    /** Detailed description */
-    description: string;
-    
-    /** Semantic version */
-    version: string;
-    
-    /** Tool category */
-    category: ToolCategory;
-    
-    /** Execute tool functionality */
-    execute(params: any): Promise<ToolResult>;
-}
-```
-
-### Tool Result
-
-```typescript
-interface ToolResult {
-    /** Operation success status */
-    success: boolean;
-    
-    /** Response data */
-    data?: any;
-    
-    /** Error message if failed */
-    message?: string;
-    
-    /** Error code if failed */
-    error_code?: string;
-}
-```
-
-### Tool Category
-
-```typescript
-enum ToolCategory {
-    DeviceManagement = 'device_management',
-    HistoryState = 'history_state',
-    Automation = 'automation',
-    AddonsPackages = 'addons_packages',
-    Notifications = 'notifications',
-    Events = 'events',
-    Utility = 'utility'
-}
-```
-
-## Event Interfaces
-
-### Event Subscription
-
-```typescript
-interface EventSubscription {
-    /** Unique subscription ID */
-    id: string;
-    
-    /** Event type to subscribe to */
-    event_type: string;
-    
-    /** Optional entity ID filter */
-    entity_id?: string;
-    
-    /** Optional domain filter */
-    domain?: string;
-    
-    /** Subscription creation timestamp */
-    created_at: string;
-    
-    /** Last event timestamp */
-    last_event?: string;
-}
-```
-
-### Event Message
-
-```typescript
-interface EventMessage {
-    /** Event type */
-    event_type: string;
-    
-    /** Entity ID if applicable */
-    entity_id?: string;
-    
-    /** Event data */
-    data: any;
-    
-    /** Event origin */
-    origin: 'LOCAL' | 'REMOTE';
-    
-    /** Event timestamp */
-    time_fired: string;
-    
-    /** Event context */
-    context: EventContext;
-}
-```
-
-## Device Interfaces
-
-### Device
-
-```typescript
-interface Device {
-    /** Device ID */
-    id: string;
-    
-    /** Device name */
-    name: string;
-    
-    /** Device domain */
-    domain: string;
-    
-    /** Current state */
-    state: string;
-    
-    /** Device attributes */
-    attributes: Record<string, any>;
-    
-    /** Device capabilities */
-    capabilities: DeviceCapabilities;
-}
-```
-
-### Device Capabilities
-
-```typescript
-interface DeviceCapabilities {
-    /** Supported features */
-    features: string[];
-    
-    /** Supported commands */
-    commands: string[];
-    
-    /** State attributes */
-    attributes: {
-        /** Attribute name */
-        [key: string]: {
-            /** Attribute type */
-            type: 'string' | 'number' | 'boolean' | 'object';
-            /** Attribute description */
-            description: string;
-            /** Optional value constraints */
-            constraints?: {
-                min?: number;
-                max?: number;
-                enum?: any[];
-            };
-        };
-    };
-}
-```
-
-## Authentication Interfaces
-
-### Auth Token
-
-```typescript
-interface AuthToken {
-    /** Token value */
-    token: string;
-    
-    /** Token type */
-    type: 'bearer' | 'jwt';
-    
-    /** Expiration timestamp */
-    expires_at: string;
-    
-    /** Token refresh info */
-    refresh?: {
-        token: string;
-        expires_at: string;
-    };
-}
-```
-
-### User
-
-```typescript
-interface User {
-    /** User ID */
-    id: string;
-    
-    /** Username */
-    username: string;
-    
-    /** User type */
-    type: 'admin' | 'user' | 'service';
-    
-    /** User permissions */
-    permissions: string[];
-}
-```
-
-## Error Interfaces
-
-### Tool Error
-
-```typescript
-interface ToolError extends Error {
-    /** Error code */
-    code: string;
-    
-    /** HTTP status code */
-    status: number;
-    
-    /** Error details */
-    details?: Record<string, any>;
-}
-```
-
-### Validation Error
-
-```typescript
-interface ValidationError {
-    /** Error path */
-    path: string;
-    
-    /** Error message */
-    message: string;
-    
-    /** Error code */
-    code: string;
-}
-```
-
-## Configuration Interfaces
-
-### Tool Configuration
-
-```typescript
-interface ToolConfig {
-    /** Enable/disable tool */
-    enabled: boolean;
-    
-    /** Tool-specific settings */
-    settings: Record<string, any>;
-    
-    /** Rate limiting */
-    rate_limit?: {
-        /** Max requests */
-        max: number;
-        /** Time window in seconds */
-        window: number;
-    };
-}
-```
-
-### System Configuration
-
-```typescript
-interface SystemConfig {
-    /** System name */
-    name: string;
-    
-    /** Environment */
-    environment: 'development' | 'production';
-    
-    /** Log level */
-    log_level: 'debug' | 'info' | 'warn' | 'error';
-    
-    /** Tool configurations */
-    tools: Record<string, ToolConfig>;
-}
-```
-
-## Best Practices
-
-1. Use TypeScript for all interfaces
-2. Include JSDoc comments
-3. Use strict typing
-4. Keep interfaces focused
-5. Use consistent naming
-6. Document constraints
-7. Version interfaces
-8. Include examples
-
-## See Also
-
-- [Tool Development Guide](tools.md)
-- [Best Practices](best-practices.md)
-- [Testing Guide](../testing.md) 

docs/development/tools.md

@@ -1,226 +0,0 @@
-# Tool Development Guide
-
-This guide explains how to create new tools for the Home Assistant MCP.
-
-## Tool Structure
-
-Each tool should follow this basic structure:
-
-```typescript
-interface Tool {
-    id: string;
-    name: string;
-    description: string;
-    version: string;
-    category: ToolCategory;
-    execute(params: any): Promise<ToolResult>;
-}
-```
-
-## Creating a New Tool
-
-1. Create a new file in the appropriate category directory
-2. Implement the Tool interface
-3. Add API endpoints
-4. Add WebSocket handlers
-5. Add documentation
-6. Add tests
-
-### Example Tool Implementation
-
-```typescript
-import { Tool, ToolCategory, ToolResult } from '../interfaces';
-
-export class MyCustomTool implements Tool {
-    id = 'my_custom_tool';
-    name = 'My Custom Tool';
-    description = 'Description of what the tool does';
-    version = '1.0.0';
-    category = ToolCategory.Utility;
-
-    async execute(params: any): Promise<ToolResult> {
-        // Tool implementation
-        return {
-            success: true,
-            data: {
-                // Tool-specific response data
-            }
-        };
-    }
-}
-```
-
-## Tool Categories
-
-- Device Management
-- History & State
-- Automation
-- Add-ons & Packages
-- Notifications
-- Events
-- Utility
-
-## API Integration
-
-### REST Endpoint
-
-```typescript
-import { Router } from 'express';
-import { MyCustomTool } from './my-custom-tool';
-
-const router = Router();
-const tool = new MyCustomTool();
-
-router.post('/api/tools/custom', async (req, res) => {
-    try {
-        const result = await tool.execute(req.body);
-        res.json(result);
-    } catch (error) {
-        res.status(500).json({
-            success: false,
-            message: error.message
-        });
-    }
-});
-```
-
-### WebSocket Handler
-
-```typescript
-import { WebSocketServer } from 'ws';
-import { MyCustomTool } from './my-custom-tool';
-
-const tool = new MyCustomTool();
-
-wss.on('connection', (ws) => {
-    ws.on('message', async (message) => {
-        const { type, params } = JSON.parse(message);
-        if (type === 'my_custom_tool') {
-            const result = await tool.execute(params);
-            ws.send(JSON.stringify(result));
-        }
-    });
-});
-```
-
-## Error Handling
-
-```typescript
-class ToolError extends Error {
-    constructor(
-        message: string,
-        public code: string,
-        public status: number = 500
-    ) {
-        super(message);
-        this.name = 'ToolError';
-    }
-}
-
-// Usage in tool
-async execute(params: any): Promise<ToolResult> {
-    try {
-        // Tool implementation
-    } catch (error) {
-        throw new ToolError(
-            'Operation failed',
-            'TOOL_ERROR',
-            500
-        );
-    }
-}
-```
-
-## Testing
-
-```typescript
-import { MyCustomTool } from './my-custom-tool';
-
-describe('MyCustomTool', () => {
-    let tool: MyCustomTool;
-
-    beforeEach(() => {
-        tool = new MyCustomTool();
-    });
-
-    it('should execute successfully', async () => {
-        const result = await tool.execute({
-            // Test parameters
-        });
-        expect(result.success).toBe(true);
-    });
-
-    it('should handle errors', async () => {
-        // Error test cases
-    });
-});
-```
-
-## Documentation
-
-1. Create tool documentation in `docs/tools/category/tool-name.md`
-2. Update `tools/tools.md` with tool reference
-3. Add tool to navigation in `mkdocs.yml`
-
-### Documentation Template
-
-```markdown
-# Tool Name
-
-Description of the tool.
-
-## Features
-
-- Feature 1
-- Feature 2
-
-## Usage
-
-### REST API
-
-```typescript
-// API endpoints
-```
-
-### WebSocket
-
-```typescript
-// WebSocket usage
-```
-
-## Examples
-
-### Example 1
-
-```typescript
-// Usage example
-```
-
-## Response Format
-
-```json
-{
-    "success": true,
-    "data": {
-        // Response data structure
-    }
-}
-```
-```
-
-## Best Practices
-
-1. Follow consistent naming conventions
-2. Implement proper error handling
-3. Add comprehensive documentation
-4. Write thorough tests
-5. Use TypeScript for type safety
-6. Follow SOLID principles
-7. Implement rate limiting
-8. Add proper logging
-
-## See Also
-
-- [Interface Documentation](interfaces.md)
-- [Best Practices](best-practices.md)
-- [Testing Guide](../testing.md) 

docs/examples/index.md

@@ -1,22 +0,0 @@
----
-layout: default
-title: Examples
-nav_order: 7
-has_children: true
----
-
-# Example Projects 📚
-
-This section contains examples and tutorials for common MCP Server integrations.
-
-## Speech-to-Text Integration
-
-Example of integrating speech recognition with MCP Server:
-
-```typescript
-// From examples/speech-to-text-example.ts
-// Add example code and explanation
-```
-
-## More Examples Coming Soon
-... 

docs/getting-started.md

@@ -1,30 +0,0 @@
-# Getting Started
-
-Begin your journey with the Home Assistant MCP Server by following these steps:
-
-- **API Documentation:** Read the [API Documentation](api.md) for available endpoints.
-- **Real-Time Updates:** Learn about [Server-Sent Events](api/sse.md) for live communication.
-- **Tools:** Explore available [Tools](tools/tools.md) for device control and automation.
-- **Configuration:** Refer to the [Configuration Guide](getting-started/configuration.md) for setup and advanced settings.
-
-## Troubleshooting
-
-If you encounter any issues:
-1. Verify that your Home Assistant instance is accessible.
-2. Ensure that all required environment variables are properly set.
-3. Consult the [Troubleshooting Guide](troubleshooting.md) for additional solutions.
-
-## Development
-
-For contributors:
-1. Fork the repository.
-2. Create a feature branch.
-3. Follow the [Development Guide](development/development.md) for contribution guidelines.
-4. Submit a pull request with your enhancements.
-
-## Support
-
-Need help?
-- Visit our [GitHub Issues](https://github.com/jango-blockchained/homeassistant-mcp/issues).
-- Review the [Troubleshooting Guide](troubleshooting.md).
-- Check the [FAQ](troubleshooting.md#faq) for common questions. 

docs/getting-started/configuration.md

@@ -1,5 +0,0 @@
-# Configuration
-
-## Basic Configuration
-
-## Advanced Settings 

docs/getting-started/docker.md

@@ -1,10 +0,0 @@
----
-layout: default
-title: Docker Deployment
-parent: Getting Started
-nav_order: 3
----
-
-# Docker Deployment Guide 🐳
-
-Detailed guide for deploying MCP Server with Docker... 

docs/getting-started/installation.md

@@ -1,181 +0,0 @@
----
-layout: default
-title: Installation
-parent: Getting Started
-nav_order: 1
----
-
-# Installation Guide 🛠️
-
-This guide covers different methods to install and set up the MCP Server for Home Assistant. Choose the installation method that best suits your needs.
-
-## Prerequisites
-
-Before installing MCP Server, ensure you have:
-
-- Home Assistant instance running and accessible
-- Node.js 18+ or Docker installed
-- Home Assistant Long-Lived Access Token ([How to get one](https://developers.home-assistant.io/docs/auth_api/#long-lived-access-token))
-
-## Installation Methods
-
-### 1. 🔧 Smithery Installation (Recommended)
-
-The easiest way to install MCP Server is through Smithery:
-
-#### Smithery Configuration
-
-The project includes a `smithery.yaml` configuration:
-
-```yaml
-# Add smithery.yaml contents and explanation
-```
-
-#### Installation Steps
-
-```bash
-npx -y @smithery/cli install @jango-blockchained/advanced-homeassistant-mcp --client claude
-```
-
-### 2. 🐳 Docker Installation
-
-For a containerized deployment:
-
-```bash
-# Clone the repository
-git clone --depth 1 https://github.com/jango-blockchained/advanced-homeassistant-mcp.git
-cd advanced-homeassistant-mcp
-
-# Configure environment variables
-cp .env.example .env
-# Edit .env with your Home Assistant details:
-# - HA_URL: Your Home Assistant URL
-# - HA_TOKEN: Your Long-Lived Access Token
-# - Other configuration options
-
-# Build and start containers
-docker compose up -d --build
-
-# View logs (optional)
-docker compose logs -f --tail=50
-```
-
-### 3. 💻 Manual Installation
-
-For direct installation on your system:
-
-```bash
-# Install Bun runtime
-curl -fsSL https://bun.sh/install | bash
-
-# Clone and install
-git clone https://github.com/jango-blockchained/advanced-homeassistant-mcp.git
-cd advanced-homeassistant-mcp
-bun install --frozen-lockfile
-
-# Configure environment
-cp .env.example .env
-# Edit .env with your configuration
-
-# Start the server
-bun run dev --watch
-```
-
-## Configuration
-
-### Environment Variables
-
-Key configuration options in your `.env` file:
-
-```env
-# Home Assistant Configuration
-HA_URL=http://your-homeassistant:8123
-HA_TOKEN=your_long_lived_access_token
-
-# Server Configuration
-PORT=3000
-HOST=0.0.0.0
-NODE_ENV=production
-
-# Security Settings
-JWT_SECRET=your_secure_jwt_secret
-RATE_LIMIT=100
-```
-
-### Client Integration
-
-#### Cursor Integration
-
-Add to `.cursor/config/config.json`:
-
-```json
-{
-  "mcpServers": {
-    "homeassistant-mcp": {
-      "command": "bun",
-      "args": ["run", "start"],
-      "cwd": "${workspaceRoot}",
-      "env": {
-        "NODE_ENV": "development"
-      }
-    }
-  }
-}
-```
-
-#### Claude Desktop Integration
-
-Add to your Claude configuration:
-
-```json
-{
-  "mcpServers": {
-    "homeassistant-mcp": {
-      "command": "bun",
-      "args": ["run", "start", "--port", "8080"],
-      "env": {
-        "NODE_ENV": "production"
-      }
-    }
-  }
-}
-```
-
-## Verification
-
-To verify your installation:
-
-1. Check server status:
-   ```bash
-   curl http://localhost:3000/health
-   ```
-
-2. Test Home Assistant connection:
-   ```bash
-   curl http://localhost:3000/api/state
-   ```
-
-## Troubleshooting
-
-If you encounter issues:
-
-1. Check the [Troubleshooting Guide](../troubleshooting.md)
-2. Verify your environment variables
-3. Check server logs:
-   ```bash
-   # For Docker installation
-   docker compose logs -f
-   
-   # For manual installation
-   bun run dev
-   ```
-
-## Next Steps
-
-- Follow the [Quick Start Guide](quickstart.md) to begin using MCP Server
-- Read the [API Documentation](../api/index.md) for integration details
-- Check the [Architecture Overview](../architecture.md) to understand the system
-
-## Support
-
-Need help? Check our [Support Resources](../index.md#support) or [open an issue](https://github.com/jango-blockchained/advanced-homeassistant-mcp/issues). 

docs/getting-started/quickstart.md

@@ -1,219 +0,0 @@
----
-layout: default
-title: Quick Start
-parent: Getting Started
-nav_order: 2
----
-
-# Quick Start Guide 🚀
-
-This guide will help you get started with MCP Server after installation. We'll cover basic usage, common commands, and simple integrations.
-
-## First Steps
-
-### 1. Verify Connection
-
-After installation, verify your MCP Server is running and connected to Home Assistant:
-
-```bash
-# Check server health
-curl http://localhost:3000/health
-
-# Verify Home Assistant connection
-curl http://localhost:3000/api/state
-```
-
-### 2. Basic Voice Commands
-
-Try these basic voice commands to test your setup:
-
-```bash
-# Example using curl for testing
-curl -X POST http://localhost:3000/api/command \
-  -H "Content-Type: application/json" \
-  -d '{"command": "Turn on the living room lights"}'
-```
-
-Common voice commands:
-- "Turn on/off [device name]"
-- "Set [device] to [value]"
-- "What's the temperature in [room]?"
-- "Is [device] on or off?"
-
-## Real-World Examples
-
-### 1. Smart Lighting Control
-
-```javascript
-// Browser example using fetch
-const response = await fetch('http://localhost:3000/api/command', {
-  method: 'POST',
-  headers: {
-    'Content-Type': 'application/json',
-  },
-  body: JSON.stringify({
-    command: 'Set living room lights to 50% brightness and warm white color'
-  })
-});
-```
-
-### 2. Real-Time Updates
-
-Subscribe to device state changes using Server-Sent Events (SSE):
-
-```javascript
-const eventSource = new EventSource('http://localhost:3000/subscribe_events?token=YOUR_TOKEN&domain=light');
-
-eventSource.onmessage = (event) => {
-    const data = JSON.parse(event.data);
-    console.log('Device state changed:', data);
-    // Update your UI here
-};
-```
-
-### 3. Scene Automation
-
-Create and trigger scenes for different activities:
-
-```javascript
-// Create a "Movie Night" scene
-const createScene = async () => {
-  await fetch('http://localhost:3000/api/scene', {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      name: 'Movie Night',
-      actions: [
-        { device: 'living_room_lights', action: 'dim', value: 20 },
-        { device: 'tv', action: 'on' },
-        { device: 'soundbar', action: 'on' }
-      ]
-    })
-  });
-};
-
-// Trigger the scene with voice command:
-// "Hey MCP, activate movie night scene"
-```
-
-## Integration Examples
-
-### 1. Web Dashboard Integration
-
-```javascript
-// React component example
-function SmartHomeControl() {
-    const [devices, setDevices] = useState([]);
-    
-    useEffect(() => {
-        // Subscribe to device updates
-        const events = new EventSource('http://localhost:3000/subscribe_events');
-        events.onmessage = (event) => {
-            const data = JSON.parse(event.data);
-            setDevices(currentDevices => 
-                currentDevices.map(device => 
-                    device.id === data.id ? {...device, ...data} : device
-                )
-            );
-        };
-        
-        return () => events.close();
-    }, []);
-
-    return (
-        <div className="dashboard">
-            {devices.map(device => (
-                <DeviceCard key={device.id} device={device} />
-            ))}
-        </div>
-    );
-}
-```
-
-### 2. Voice Assistant Integration
-
-```typescript
-// Example using speech-to-text with MCP
-async function handleVoiceCommand(audioBlob: Blob) {
-    // First, convert speech to text
-    const text = await speechToText(audioBlob);
-    
-    // Then send command to MCP
-    const response = await fetch('http://localhost:3000/api/command', {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ command: text })
-    });
-    
-    return response.json();
-}
-```
-
-## Best Practices
-
-1. **Error Handling**
-   ```javascript
-   try {
-       const response = await fetch('http://localhost:3000/api/command', {
-           method: 'POST',
-           headers: {
-               'Content-Type': 'application/json',
-           },
-           body: JSON.stringify({ command: 'Turn on lights' })
-       });
-       
-       if (!response.ok) {
-           throw new Error(`HTTP error! status: ${response.status}`);
-       }
-       
-       const data = await response.json();
-   } catch (error) {
-       console.error('Error:', error);
-       // Handle error appropriately
-   }
-   ```
-
-2. **Connection Management**
-   ```javascript
-   class MCPConnection {
-       constructor() {
-           this.eventSource = null;
-           this.reconnectAttempts = 0;
-       }
-       
-       connect() {
-           this.eventSource = new EventSource('http://localhost:3000/subscribe_events');
-           this.eventSource.onerror = this.handleError.bind(this);
-       }
-       
-       handleError() {
-           if (this.reconnectAttempts < 3) {
-               setTimeout(() => {
-                   this.reconnectAttempts++;
-                   this.connect();
-               }, 1000 * this.reconnectAttempts);
-           }
-       }
-   }
-   ```
-
-## Next Steps
-
-- Explore the [API Documentation](../api/index.md) for advanced features
-- Learn about [SSE API](../api/sse.md) for real-time updates
-- Check out [Architecture](../architecture.md) for system design details
-- Read the [Contributing Guide](../contributing.md) to get involved
-
-## Troubleshooting
-
-If you encounter issues:
-- Verify your authentication token
-- Check server logs for errors
-- Ensure Home Assistant is accessible
-- Review the [Troubleshooting Guide](../troubleshooting.md)
-
-Need more help? Visit our [Support Resources](../index.md#support). 

docs/index.md

@@ -1,55 +0,0 @@
----
-layout: default
-title: Home
-nav_order: 1
----
-
-# 🚀 MCP Server for Home Assistant
-
-Welcome to the Model Context Protocol (MCP) Server documentation! This guide will help you get started with integrating AI-powered natural language processing into your Home Assistant setup.
-
-## What is MCP Server?
-
-MCP Server is a bridge between Home Assistant and Language Learning Models (LLMs), enabling natural language interactions and real-time automation of your smart devices. It allows you to control your home automation setup using natural language commands while maintaining high performance and security.
-
-## Key Features
-
-### 🎮 Device Control & Monitoring
-- Voice-controlled automation
-- Real-time updates via SSE/WebSocket
-- Scene-based automation rules
-
-### 🤖 AI-Powered Features
-- Natural Language Processing (NLP)
-- Predictive automation
-- Anomaly detection
-
-### 🛡️ Security & Performance
-- JWT authentication
-- Request sanitization
-- Sub-100ms latency
-- Rate limiting
-
-## Documentation Structure
-
-### Getting Started
-- [Installation Guide](getting-started/installation.md) - Set up MCP Server
-- [Quick Start Tutorial](getting-started/quickstart.md) - Basic usage examples
-
-### Core Documentation
-- [API Documentation](api/index.md) - Complete API reference
-- [Architecture Overview](architecture.md) - System design and components
-- [Contributing Guidelines](contributing.md) - How to contribute
-- [Troubleshooting Guide](troubleshooting.md) - Common issues and solutions
-
-## Support
-
-If you need help or want to report issues:
-
-- [GitHub Issues](https://github.com/jango-blockchained/advanced-homeassistant-mcp/issues)
-- [GitHub Discussions](https://github.com/jango-blockchained/advanced-homeassistant-mcp/discussions)
-- [Contributing Guidelines](contributing.md)
-
-## License
-
-This project is licensed under the MIT License. See the [LICENSE](https://github.com/jango-blockchained/advanced-homeassistant-mcp/blob/main/LICENSE) file for details. 

docs/roadmap.md

@@ -1,51 +0,0 @@
-# Roadmap for MCP Server
-
-The following roadmap outlines our planned enhancements and future directions for the Home Assistant MCP Server. This document is a living guide that will be updated as new features are planned and developed.
-
-## Near-Term Goals
-
-- **Advanced Automation Capabilities:**
-  - Integrate sophisticated automation rules with conditional logic and multi-step execution.
-  - Introduce a visual automation builder for simplified rule creation.
-
-- **Enhanced Security Features:**
-  - Implement multi-factor authentication for critical actions.
-  - Strengthen encryption methods and data handling practices.
-  - Expand monitoring and alerting for potential security breaches.
-
-- **Performance Optimizations:**
-  - Refine resource utilization to reduce latency.
-  - Optimize real-time data streaming via SSE.
-  - Introduce advanced caching mechanisms for frequently requested data.
-
-## Mid-Term Goals
-
-- **User Interface Improvements:**
-  - Develop an intuitive web-based dashboard for device management and monitoring.
-  - Provide real-time analytics and performance metrics.
-
-- **Expanded Integrations:**
-  - Support a broader range of smart home devices and brands.
-  - Integrate with additional home automation platforms and third-party services.
-
-- **Developer Experience Enhancements:**
-  - Improve documentation and developer tooling.
-  - Streamline contribution guidelines and testing setups.
-
-## Long-Term Vision
-
-- **Ecosystem Expansion:**
-  - Build a modular plugin system for community-driven extensions and integrations.
-  - Enable seamless integration with future technologies in smart home and AI domains.
-
-- **Scalability and Resilience:**
-  - Architect the system to support large-scale deployments.
-  - Incorporate advanced load balancing and failover mechanisms.
-
-## How to Follow the Roadmap
-
-- **Community Involvement:** We welcome and encourage feedback.
-- **Regular Updates:** This document is updated regularly with new goals and milestones.
-- **Transparency:** Check our GitHub repository and issue tracker for ongoing discussions.
-
-*This roadmap is intended as a guide and may evolve based on community needs, technological advancements, and strategic priorities.* 

docs/testing.md

@@ -1,422 +0,0 @@
-# Testing Documentation
-
-## Quick Reference
-
-```bash
-# Most Common Commands
-bun test                    # Run all tests
-bun test --watch           # Run tests in watch mode
-bun test --coverage        # Run tests with coverage
-bun test path/to/test.ts   # Run a specific test file
-
-# Additional Options
-DEBUG=true bun test        # Run with debug output
-bun test --pattern "auth"  # Run tests matching a pattern
-bun test --timeout 60000   # Run with a custom timeout
-```
-
-## Overview
-
-This document describes the testing setup and practices used in the Home Assistant MCP project. We use Bun's test runner for both unit and integration testing, ensuring comprehensive coverage across modules.
-
-## Test Structure
-
-Tests are organized in two main locations:
-
-1. **Root Level Integration Tests** (`/__tests__/`):
-
-```
-__tests__/
-├── ai/              # AI/ML component tests
-├── api/             # API integration tests
-├── context/         # Context management tests
-├── hass/            # Home Assistant integration tests
-├── schemas/         # Schema validation tests
-├── security/        # Security integration tests
-├── tools/           # Tools and utilities tests
-├── websocket/       # WebSocket integration tests
-├── helpers.test.ts  # Helper function tests
-├── index.test.ts    # Main application tests
-└── server.test.ts   # Server integration tests
-```
-
-2. **Component Level Unit Tests** (`src/**/`):
-
-```
-src/
-├── __tests__/   # Global test setup and utilities
-│   └── setup.ts # Global test configuration
-├── component/
-│   ├── __tests__/   # Component-specific unit tests
-│   └── component.ts
-```
-
-## Test Configuration
-
-### Bun Test Configuration (`bunfig.toml`)
-
-```toml
-[test]
-preload = ["./src/__tests__/setup.ts"]  # Global test setup
-coverage = true                         # Enable coverage by default
-timeout = 30000                         # Test timeout in milliseconds
-testMatch = ["**/__tests__/**/*.test.ts"] # Test file patterns
-```
-
-### Bun Scripts
-
-Available test commands in `package.json`:
-
-```bash
-# Run all tests
-bun test
-
-# Watch mode for development
-bun test --watch
-
-# Generate coverage report
-bun test --coverage
-
-# Run linting
-bun run lint
-
-# Format code
-bun run format
-```
-
-## Test Setup
-
-### Global Configuration
-
-A global test setup file (`src/__tests__/setup.ts`) provides:
-- Environment configuration
-- Mock utilities
-- Test helper functions
-- Global lifecycle hooks
-
-### Test Environment
-
-- Environment variables are loaded from `.env.test`.
-- Console output is minimized unless `DEBUG=true`.
-- JWT secrets and tokens are preconfigured for testing.
-- Rate limiting and security features are initialized appropriately.
-
-## Running Tests
-
-```bash
-# Basic test run
-bun test
-
-# Run tests with coverage
-bun test --coverage
-
-# Run a specific test file
-bun test path/to/test.test.ts
-
-# Run tests in watch mode
-bun test --watch
-
-# Run tests with debug output
-DEBUG=true bun test
-
-# Run tests with increased timeout
-bun test --timeout 60000
-
-# Run tests matching a pattern
-bun test --pattern "auth"
-```
-
-## Advanced Debugging
-
-### Using Node Inspector
-
-```bash
-# Start tests with inspector
-bun test --inspect
-
-# Start tests with inspector and break on first line
-bun test --inspect-brk
-```
-
-### Using VS Code
-
-Create a launch configuration in `.vscode/launch.json`:
-
-```json
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "type": "bun",
-      "request": "launch",
-      "name": "Debug Tests",
-      "program": "${workspaceFolder}/node_modules/bun/bin/bun",
-      "args": ["test", "${file}"],
-      "cwd": "${workspaceFolder}",
-      "env": { "DEBUG": "true" }
-    }
-  ]
-}
-```
-
-### Test Isolation
-
-To run a single test in isolation:
-
-```typescript
-describe.only("specific test suite", () => {
-  it.only("specific test case", () => {
-    // Only this test will run
-  });
-});
-```
-
-## Writing Tests
-
-### Test File Naming
-
-- Place test files in a `__tests__` directory adjacent to the code being tested.
-- Name files with the pattern `*.test.ts`.
-- Mirror the structure of the source code in your test organization.
-
-### Example Test Structure
-
-```typescript
-describe("Security Features", () => {
-  it("should validate tokens correctly", () => {
-    const payload = { userId: "123", role: "user" };
-    const token = jwt.sign(payload, validSecret, { expiresIn: "1h" });
-    const result = TokenManager.validateToken(token, testIp);
-    expect(result.valid).toBe(true);
-  });
-});
-```
-
-## Coverage
-
-The project maintains strict coverage:
-- Overall coverage: at least 80%
-- Critical paths: 90%+
-- New features: ≥85% coverage
-
-Generate a coverage report with:
-
-```bash
-bun test --coverage
-```
-
-## Security Middleware Testing
-
-### Utility Function Testing
-
-The security middleware now uses a utility-first approach, which allows for more granular and comprehensive testing. Each security function is now independently testable, improving code reliability and maintainability.
-
-#### Key Utility Functions
-
-1. **Rate Limiting (`checkRateLimit`)**
-   - Tests multiple scenarios:
-     - Requests under threshold
-     - Requests exceeding threshold
-     - Rate limit reset after window expiration
-   
-   ```typescript
-   // Example test
-   it('should throw when requests exceed threshold', () => {
-     const ip = '127.0.0.2';
-     for (let i = 0; i < 11; i++) {
-       if (i < 10) {
-         expect(() => checkRateLimit(ip, 10)).not.toThrow();
-       } else {
-         expect(() => checkRateLimit(ip, 10)).toThrow('Too many requests from this IP');
-       }
-     }
-   });
-   ```
-
-2. **Request Validation (`validateRequestHeaders`)**
-   - Tests content type validation
-   - Checks request size limits
-   - Validates authorization headers
-   
-   ```typescript
-   it('should reject invalid content type', () => {
-     const mockRequest = new Request('http://localhost', {
-       method: 'POST',
-       headers: { 'content-type': 'text/plain' }
-     });
-     expect(() => validateRequestHeaders(mockRequest)).toThrow('Content-Type must be application/json');
-   });
-   ```
-
-3. **Input Sanitization (`sanitizeValue`)**
-   - Sanitizes HTML tags
-   - Handles nested objects
-   - Preserves non-string values
-   
-   ```typescript
-   it('should sanitize HTML tags', () => {
-     const input = '<script>alert("xss")</script>Hello';
-     const sanitized = sanitizeValue(input);
-     expect(sanitized).toBe('&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;Hello');
-   });
-   ```
-
-4. **Security Headers (`applySecurityHeaders`)**
-   - Verifies correct security header application
-   - Checks CSP, frame options, and other security headers
-   
-   ```typescript
-   it('should apply security headers', () => {
-     const mockRequest = new Request('http://localhost');
-     const headers = applySecurityHeaders(mockRequest);
-     expect(headers['content-security-policy']).toBeDefined();
-     expect(headers['x-frame-options']).toBeDefined();
-   });
-   ```
-
-5. **Error Handling (`handleError`)**
-   - Tests error responses in production and development modes
-   - Verifies error message and stack trace inclusion
-   
-   ```typescript
-   it('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',
-       error: 'Test error',
-       stack: expect.any(String)
-     });
-   });
-   ```
-
-### Testing Philosophy
-
-- **Isolation**: Each utility function is tested independently
-- **Comprehensive Coverage**: Multiple scenarios for each function
-- **Predictable Behavior**: Clear expectations for input and output
-- **Error Handling**: Robust testing of error conditions
-
-### Best Practices
-
-1. Use minimal, focused test cases
-2. Test both successful and failure scenarios
-3. Verify input sanitization and security measures
-4. Mock external dependencies when necessary
-
-### Running Security Tests
-
-```bash
-# Run all tests
-bun test
-
-# Run specific security tests
-bun test __tests__/security/
-```
-
-### Continuous Improvement
-
-- Regularly update test cases
-- Add new test scenarios as security requirements evolve
-- Perform periodic security audits
-
-## Best Practices
-
-1. **Isolation**: Each test should be independent and not rely on the state of other tests.
-2. **Mocking**: Use the provided mock utilities for external dependencies.
-3. **Cleanup**: Clean up any resources or state modifications in `afterEach` or `afterAll` hooks.
-4. **Descriptive Names**: Use clear, descriptive test names that explain the expected behavior.
-5. **Assertions**: Make specific, meaningful assertions rather than general ones.
-6. **Setup**: Use `beforeEach` for common test setup to avoid repetition.
-7. **Error Cases**: Test both success and error cases for complete coverage.
-
-## Coverage
-
-The project aims for high test coverage, particularly focusing on:
-- Security-critical code paths
-- API endpoints
-- Data validation
-- Error handling
-- Event broadcasting
-
-Run coverage reports using:
-```bash
-bun test --coverage
-```
-
-## Debugging Tests
-
-To debug tests:
-1. Set `DEBUG=true` to enable console output during tests
-2. Use the `--watch` flag for development
-3. Add `console.log()` statements (they're only shown when DEBUG is true)
-4. Use the test utilities' debugging helpers
-
-### Advanced Debugging
-
-1. **Using Node Inspector**:
-   ```bash
-   # Start tests with inspector
-   bun test --inspect
-   
-   # Start tests with inspector and break on first line
-   bun test --inspect-brk
-   ```
-
-2. **Using VS Code**:
-   ```jsonc
-   // .vscode/launch.json
-   {
-     "version": "0.2.0",
-     "configurations": [
-       {
-         "type": "bun",
-         "request": "launch",
-         "name": "Debug Tests",
-         "program": "${workspaceFolder}/node_modules/bun/bin/bun",
-         "args": ["test", "${file}"],
-         "cwd": "${workspaceFolder}",
-         "env": { "DEBUG": "true" }
-       }
-     ]
-   }
-   ```
-
-3. **Test Isolation**:
-   To run a single test in isolation:
-   ```typescript
-   describe.only("specific test suite", () => {
-     it.only("specific test case", () => {
-       // Only this test will run
-     });
-   });
-   ```
-
-## Contributing
-
-When contributing new code:
-1. Add tests for new features
-2. Ensure existing tests pass
-3. Maintain or improve coverage
-4. Follow the existing test patterns and naming conventions
-5. Document any new test utilities or patterns 
-
-## Coverage Requirements
-
-The project maintains strict coverage requirements:
-
-- Minimum overall coverage: 80%
-- Critical paths (security, API, data validation): 90%
-- New features must include tests with >= 85% coverage
-
-Coverage reports are generated in multiple formats:
-- Console summary
-- HTML report (./coverage/index.html)
-- LCOV report (./coverage/lcov.info)
-
-To view detailed coverage:
-```bash
-# Generate and open coverage report
-bun test --coverage && open coverage/index.html
-``` 

docs/tools/addons-packages/addon.md

@@ -1,240 +0,0 @@
-# Add-on Management Tool
-
-The Add-on Management tool provides functionality to manage Home Assistant add-ons through the MCP interface.
-
-## Features
-
-- List available add-ons
-- Install/uninstall add-ons
-- Start/stop/restart add-ons
-- Get add-on information
-- Update add-ons
-- Configure add-ons
-- View add-on logs
-- Monitor add-on status
-
-## Usage
-
-### REST API
-
-```typescript
-GET /api/addons
-GET /api/addons/{addon_slug}
-POST /api/addons/{addon_slug}/install
-POST /api/addons/{addon_slug}/uninstall
-POST /api/addons/{addon_slug}/start
-POST /api/addons/{addon_slug}/stop
-POST /api/addons/{addon_slug}/restart
-GET /api/addons/{addon_slug}/logs
-PUT /api/addons/{addon_slug}/config
-GET /api/addons/{addon_slug}/stats
-```
-
-### WebSocket
-
-```typescript
-// List add-ons
-{
-    "type": "get_addons"
-}
-
-// Get add-on info
-{
-    "type": "get_addon_info",
-    "addon_slug": "required_addon_slug"
-}
-
-// Install add-on
-{
-    "type": "install_addon",
-    "addon_slug": "required_addon_slug",
-    "version": "optional_version"
-}
-
-// Control add-on
-{
-    "type": "control_addon",
-    "addon_slug": "required_addon_slug",
-    "action": "start|stop|restart"
-}
-```
-
-## Examples
-
-### List All Add-ons
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/addons', {
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-const addons = await response.json();
-```
-
-### Install Add-on
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/addons/mosquitto/install', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "version": "latest"
-    })
-});
-```
-
-### Configure Add-on
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/addons/mosquitto/config', {
-    method: 'PUT',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "logins": [
-            {
-                "username": "mqtt_user",
-                "password": "mqtt_password"
-            }
-        ],
-        "customize": {
-            "active": true,
-            "folder": "mosquitto"
-        }
-    })
-});
-```
-
-## Response Format
-
-### Add-on List Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "addons": [
-            {
-                "slug": "addon_slug",
-                "name": "Add-on Name",
-                "version": "1.0.0",
-                "state": "started",
-                "repository": "core",
-                "installed": true,
-                "update_available": false
-            }
-        ]
-    }
-}
-```
-
-### Add-on Info Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "addon": {
-            "slug": "addon_slug",
-            "name": "Add-on Name",
-            "version": "1.0.0",
-            "description": "Add-on description",
-            "long_description": "Detailed description",
-            "repository": "core",
-            "installed": true,
-            "state": "started",
-            "webui": "http://[HOST]:[PORT:80]",
-            "boot": "auto",
-            "options": {
-                // Add-on specific options
-            },
-            "schema": {
-                // Add-on options schema
-            },
-            "ports": {
-                "80/tcp": 8080
-            },
-            "ingress": true,
-            "ingress_port": 8099
-        }
-    }
-}
-```
-
-### Add-on Stats Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "stats": {
-            "cpu_percent": 2.5,
-            "memory_usage": 128974848,
-            "memory_limit": 536870912,
-            "network_rx": 1234,
-            "network_tx": 5678,
-            "blk_read": 12345,
-            "blk_write": 67890
-        }
-    }
-}
-```
-
-## Error Handling
-
-### Common Error Codes
-
-- `404`: Add-on not found
-- `401`: Unauthorized
-- `400`: Invalid request
-- `409`: Add-on operation failed
-- `422`: Invalid configuration
-
-### Error Response Format
-
-```json
-{
-    "success": false,
-    "message": "Error description",
-    "error_code": "ERROR_CODE"
-}
-```
-
-## Rate Limiting
-
-- Default limit: 50 requests per 15 minutes
-- Configurable through environment variables:
-  - `ADDON_RATE_LIMIT`
-  - `ADDON_RATE_WINDOW`
-
-## Best Practices
-
-1. Always check add-on compatibility
-2. Back up configurations before updates
-3. Monitor resource usage
-4. Use appropriate update strategies
-5. Implement proper error handling
-6. Test configurations in safe environment
-7. Handle rate limiting gracefully
-8. Keep add-ons updated
-
-## Add-on Security
-
-- Use secure passwords
-- Regularly update add-ons
-- Monitor add-on logs
-- Restrict network access
-- Use SSL/TLS when available
-- Follow principle of least privilege
-
-## See Also
-
-- [Package Management](package.md)
-- [Device Control](../device-management/control.md)
-- [Event Subscription](../events/subscribe-events.md) 

docs/tools/addons-packages/package.md

@@ -1,236 +0,0 @@
-# Package Management Tool
-
-The Package Management tool provides functionality to manage Home Assistant Community Store (HACS) packages through the MCP interface.
-
-## Features
-
-- List available packages
-- Install/update/remove packages
-- Search packages
-- Get package information
-- Manage package repositories
-- Track package updates
-- View package documentation
-- Monitor package status
-
-## Usage
-
-### REST API
-
-```typescript
-GET /api/packages
-GET /api/packages/{package_id}
-POST /api/packages/{package_id}/install
-POST /api/packages/{package_id}/uninstall
-POST /api/packages/{package_id}/update
-GET /api/packages/search
-GET /api/packages/categories
-GET /api/packages/repositories
-```
-
-### WebSocket
-
-```typescript
-// List packages
-{
-    "type": "get_packages",
-    "category": "optional_category"
-}
-
-// Search packages
-{
-    "type": "search_packages",
-    "query": "search_query",
-    "category": "optional_category"
-}
-
-// Install package
-{
-    "type": "install_package",
-    "package_id": "required_package_id",
-    "version": "optional_version"
-}
-```
-
-## Package Categories
-
-- Integrations
-- Frontend
-- Themes
-- AppDaemon Apps
-- NetDaemon Apps
-- Python Scripts
-- Plugins
-
-## Examples
-
-### List All Packages
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/packages', {
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-const packages = await response.json();
-```
-
-### Search Packages
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/packages/search?q=weather&category=integrations', {
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-const searchResults = await response.json();
-```
-
-### Install Package
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/packages/custom-weather-card/install', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "version": "latest"
-    })
-});
-```
-
-## Response Format
-
-### Package List Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "packages": [
-            {
-                "id": "package_id",
-                "name": "Package Name",
-                "category": "integrations",
-                "description": "Package description",
-                "version": "1.0.0",
-                "installed": true,
-                "update_available": false,
-                "stars": 150,
-                "downloads": 10000
-            }
-        ]
-    }
-}
-```
-
-### Package Info Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "package": {
-            "id": "package_id",
-            "name": "Package Name",
-            "category": "integrations",
-            "description": "Package description",
-            "long_description": "Detailed description",
-            "version": "1.0.0",
-            "installed_version": "0.9.0",
-            "available_version": "1.0.0",
-            "installed": true,
-            "update_available": true,
-            "stars": 150,
-            "downloads": 10000,
-            "repository": "https://github.com/author/repo",
-            "author": {
-                "name": "Author Name",
-                "url": "https://github.com/author"
-            },
-            "documentation": "https://github.com/author/repo/wiki",
-            "dependencies": [
-                "dependency1",
-                "dependency2"
-            ]
-        }
-    }
-}
-```
-
-### Search Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "results": [
-            {
-                "id": "package_id",
-                "name": "Package Name",
-                "category": "integrations",
-                "description": "Package description",
-                "version": "1.0.0",
-                "score": 0.95
-            }
-        ],
-        "total": 42
-    }
-}
-```
-
-## Error Handling
-
-### Common Error Codes
-
-- `404`: Package not found
-- `401`: Unauthorized
-- `400`: Invalid request
-- `409`: Package operation failed
-- `422`: Invalid configuration
-- `424`: Dependency error
-
-### Error Response Format
-
-```json
-{
-    "success": false,
-    "message": "Error description",
-    "error_code": "ERROR_CODE"
-}
-```
-
-## Rate Limiting
-
-- Default limit: 50 requests per 15 minutes
-- Configurable through environment variables:
-  - `PACKAGE_RATE_LIMIT`
-  - `PACKAGE_RATE_WINDOW`
-
-## Best Practices
-
-1. Check package compatibility
-2. Review package documentation
-3. Verify package dependencies
-4. Back up before updates
-5. Test in safe environment
-6. Monitor resource usage
-7. Keep packages updated
-8. Handle rate limiting gracefully
-
-## Package Security
-
-- Verify package sources
-- Review package permissions
-- Check package reputation
-- Monitor package activity
-- Keep dependencies updated
-- Follow security advisories
-
-## See Also
-
-- [Add-on Management](addon.md)
-- [Device Control](../device-management/control.md)
-- [Event Subscription](../events/subscribe-events.md) 

docs/tools/automation/automation-config.md

@@ -1,321 +0,0 @@
-# Automation Configuration Tool
-
-The Automation Configuration tool provides functionality to create, update, and manage Home Assistant automation configurations.
-
-## Features
-
-- Create new automations
-- Update existing automations
-- Delete automations
-- Duplicate automations
-- Import/Export automation configurations
-- Validate automation configurations
-
-## Usage
-
-### REST API
-
-```typescript
-POST /api/automations
-PUT /api/automations/{automation_id}
-DELETE /api/automations/{automation_id}
-POST /api/automations/{automation_id}/duplicate
-POST /api/automations/validate
-```
-
-### WebSocket
-
-```typescript
-// Create automation
-{
-    "type": "create_automation",
-    "automation": {
-        // Automation configuration
-    }
-}
-
-// Update automation
-{
-    "type": "update_automation",
-    "automation_id": "required_automation_id",
-    "automation": {
-        // Updated configuration
-    }
-}
-
-// Delete automation
-{
-    "type": "delete_automation",
-    "automation_id": "required_automation_id"
-}
-```
-
-## Automation Configuration
-
-### Basic Structure
-
-```json
-{
-    "id": "morning_routine",
-    "alias": "Morning Routine",
-    "description": "Turn on lights and adjust temperature in the morning",
-    "trigger": [
-        {
-            "platform": "time",
-            "at": "07:00:00"
-        }
-    ],
-    "condition": [
-        {
-            "condition": "time",
-            "weekday": ["mon", "tue", "wed", "thu", "fri"]
-        }
-    ],
-    "action": [
-        {
-            "service": "light.turn_on",
-            "target": {
-                "entity_id": "light.bedroom"
-            },
-            "data": {
-                "brightness": 255,
-                "transition": 300
-            }
-        }
-    ],
-    "mode": "single"
-}
-```
-
-### Trigger Types
-
-```json
-// Time-based trigger
-{
-    "platform": "time",
-    "at": "07:00:00"
-}
-
-// State-based trigger
-{
-    "platform": "state",
-    "entity_id": "binary_sensor.motion",
-    "to": "on"
-}
-
-// Event-based trigger
-{
-    "platform": "event",
-    "event_type": "custom_event"
-}
-
-// Numeric state trigger
-{
-    "platform": "numeric_state",
-    "entity_id": "sensor.temperature",
-    "above": 25
-}
-```
-
-### Condition Types
-
-```json
-// Time condition
-{
-    "condition": "time",
-    "after": "07:00:00",
-    "before": "22:00:00"
-}
-
-// State condition
-{
-    "condition": "state",
-    "entity_id": "device_tracker.phone",
-    "state": "home"
-}
-
-// Numeric state condition
-{
-    "condition": "numeric_state",
-    "entity_id": "sensor.temperature",
-    "below": 25
-}
-```
-
-### Action Types
-
-```json
-// Service call action
-{
-    "service": "light.turn_on",
-    "target": {
-        "entity_id": "light.bedroom"
-    }
-}
-
-// Delay action
-{
-    "delay": "00:00:30"
-}
-
-// Scene activation
-{
-    "scene": "scene.evening_mode"
-}
-
-// Conditional action
-{
-    "choose": [
-        {
-            "conditions": [
-                {
-                    "condition": "state",
-                    "entity_id": "sun.sun",
-                    "state": "below_horizon"
-                }
-            ],
-            "sequence": [
-                {
-                    "service": "light.turn_on",
-                    "target": {
-                        "entity_id": "light.living_room"
-                    }
-                }
-            ]
-        }
-    ]
-}
-```
-
-## Examples
-
-### Create New Automation
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/automations', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "alias": "Morning Routine",
-        "description": "Turn on lights in the morning",
-        "trigger": [
-            {
-                "platform": "time",
-                "at": "07:00:00"
-            }
-        ],
-        "action": [
-            {
-                "service": "light.turn_on",
-                "target": {
-                    "entity_id": "light.bedroom"
-                }
-            }
-        ]
-    })
-});
-```
-
-### Update Existing Automation
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/automations/morning_routine', {
-    method: 'PUT',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "alias": "Morning Routine",
-        "trigger": [
-            {
-                "platform": "time",
-                "at": "07:30:00"  // Updated time
-            }
-        ],
-        "action": [
-            {
-                "service": "light.turn_on",
-                "target": {
-                    "entity_id": "light.bedroom"
-                }
-            }
-        ]
-    })
-});
-```
-
-## Response Format
-
-### Success Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "automation": {
-            "id": "created_automation_id",
-            // Full automation configuration
-        }
-    }
-}
-```
-
-### Validation Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "valid": true,
-        "warnings": [
-            "No conditions specified"
-        ]
-    }
-}
-```
-
-## Error Handling
-
-### Common Error Codes
-
-- `404`: Automation not found
-- `401`: Unauthorized
-- `400`: Invalid configuration
-- `409`: Automation creation/update failed
-
-### Error Response Format
-
-```json
-{
-    "success": false,
-    "message": "Error description",
-    "error_code": "ERROR_CODE",
-    "validation_errors": [
-        {
-            "path": "trigger[0].platform",
-            "message": "Invalid trigger platform"
-        }
-    ]
-}
-```
-
-## Best Practices
-
-1. Always validate configurations before saving
-2. Use descriptive aliases and descriptions
-3. Group related automations
-4. Test automations in a safe environment
-5. Document automation dependencies
-6. Use variables for reusable values
-7. Implement proper error handling
-8. Consider automation modes carefully
-
-## See Also
-
-- [Automation Management](automation.md)
-- [Event Subscription](../events/subscribe-events.md)
-- [Scene Management](../history-state/scene.md) 

docs/tools/automation/automation.md

@@ -1,211 +0,0 @@
-# Automation Management Tool
-
-The Automation Management tool provides functionality to manage and control Home Assistant automations.
-
-## Features
-
-- List all automations
-- Get automation details
-- Toggle automation state (enable/disable)
-- Trigger automations manually
-- Monitor automation execution
-- View automation history
-
-## Usage
-
-### REST API
-
-```typescript
-GET /api/automations
-GET /api/automations/{automation_id}
-POST /api/automations/{automation_id}/toggle
-POST /api/automations/{automation_id}/trigger
-GET /api/automations/{automation_id}/history
-```
-
-### WebSocket
-
-```typescript
-// List automations
-{
-    "type": "get_automations"
-}
-
-// Toggle automation
-{
-    "type": "toggle_automation",
-    "automation_id": "required_automation_id"
-}
-
-// Trigger automation
-{
-    "type": "trigger_automation",
-    "automation_id": "required_automation_id",
-    "variables": {
-        // Optional variables
-    }
-}
-```
-
-## Examples
-
-### List All Automations
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/automations', {
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-const automations = await response.json();
-```
-
-### Toggle Automation State
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/automations/morning_routine/toggle', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-```
-
-### Trigger Automation Manually
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/automations/morning_routine/trigger', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "variables": {
-            "brightness": 100,
-            "temperature": 22
-        }
-    })
-});
-```
-
-## Response Format
-
-### Automation List Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "automations": [
-            {
-                "id": "automation_id",
-                "name": "Automation Name",
-                "enabled": true,
-                "last_triggered": "2024-02-05T12:00:00Z",
-                "trigger_count": 42
-            }
-        ]
-    }
-}
-```
-
-### Automation Details Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "automation": {
-            "id": "automation_id",
-            "name": "Automation Name",
-            "enabled": true,
-            "triggers": [
-                {
-                    "platform": "time",
-                    "at": "07:00:00"
-                }
-            ],
-            "conditions": [],
-            "actions": [
-                {
-                    "service": "light.turn_on",
-                    "target": {
-                        "entity_id": "light.bedroom"
-                    }
-                }
-            ],
-            "mode": "single",
-            "max": 10,
-            "last_triggered": "2024-02-05T12:00:00Z",
-            "trigger_count": 42
-        }
-    }
-}
-```
-
-### Automation History Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "history": [
-            {
-                "timestamp": "2024-02-05T12:00:00Z",
-                "trigger": {
-                    "platform": "time",
-                    "at": "07:00:00"
-                },
-                "context": {
-                    "user_id": "user_123",
-                    "variables": {}
-                },
-                "result": "success"
-            }
-        ]
-    }
-}
-```
-
-## Error Handling
-
-### Common Error Codes
-
-- `404`: Automation not found
-- `401`: Unauthorized
-- `400`: Invalid request
-- `409`: Automation execution failed
-
-### Error Response Format
-
-```json
-{
-    "success": false,
-    "message": "Error description",
-    "error_code": "ERROR_CODE"
-}
-```
-
-## Rate Limiting
-
-- Default limit: 50 requests per 15 minutes
-- Configurable through environment variables:
-  - `AUTOMATION_RATE_LIMIT`
-  - `AUTOMATION_RATE_WINDOW`
-
-## Best Practices
-
-1. Monitor automation execution history
-2. Use descriptive automation names
-3. Implement proper error handling
-4. Cache automation configurations when possible
-5. Handle rate limiting gracefully
-6. Test automations before enabling
-7. Use variables for flexible automation behavior
-
-## See Also
-
-- [Automation Configuration](automation-config.md)
-- [Event Subscription](../events/subscribe-events.md)
-- [Device Control](../device-management/control.md) 

docs/tools/device-management/control.md

@@ -1,195 +0,0 @@
-# Device Control Tool
-
-The Device Control tool provides functionality to control various types of devices in your Home Assistant instance.
-
-## Supported Device Types
-
-- Lights
-- Switches
-- Covers
-- Climate devices
-- Media players
-- And more...
-
-## Usage
-
-### REST API
-
-```typescript
-POST /api/devices/{device_id}/control
-```
-
-### WebSocket
-
-```typescript
-{
-    "type": "control_device",
-    "device_id": "required_device_id",
-    "domain": "required_domain",
-    "service": "required_service",
-    "data": {
-        // Service-specific data
-    }
-}
-```
-
-## Domain-Specific Commands
-
-### Lights
-
-```typescript
-// Turn on/off
-POST /api/devices/light/{device_id}/control
-{
-    "service": "turn_on",  // or "turn_off"
-}
-
-// Set brightness
-{
-    "service": "turn_on",
-    "data": {
-        "brightness": 255  // 0-255
-    }
-}
-
-// Set color
-{
-    "service": "turn_on",
-    "data": {
-        "rgb_color": [255, 0, 0]  // Red
-    }
-}
-```
-
-### Covers
-
-```typescript
-// Open/close
-POST /api/devices/cover/{device_id}/control
-{
-    "service": "open_cover",  // or "close_cover"
-}
-
-// Set position
-{
-    "service": "set_cover_position",
-    "data": {
-        "position": 50  // 0-100
-    }
-}
-```
-
-### Climate
-
-```typescript
-// Set temperature
-POST /api/devices/climate/{device_id}/control
-{
-    "service": "set_temperature",
-    "data": {
-        "temperature": 22.5
-    }
-}
-
-// Set mode
-{
-    "service": "set_hvac_mode",
-    "data": {
-        "hvac_mode": "heat"  // heat, cool, auto, off
-    }
-}
-```
-
-## Examples
-
-### Control Light Brightness
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/devices/light/living_room/control', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "service": "turn_on",
-        "data": {
-            "brightness": 128
-        }
-    })
-});
-```
-
-### Control Cover Position
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/devices/cover/bedroom/control', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "service": "set_cover_position",
-        "data": {
-            "position": 75
-        }
-    })
-});
-```
-
-## Response Format
-
-### Success Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "state": "on",
-        "attributes": {
-            // Updated device attributes
-        }
-    }
-}
-```
-
-### Error Response
-
-```json
-{
-    "success": false,
-    "message": "Error description",
-    "error_code": "ERROR_CODE"
-}
-```
-
-## Error Handling
-
-### Common Error Codes
-
-- `404`: Device not found
-- `401`: Unauthorized
-- `400`: Invalid service or parameters
-- `409`: Device unavailable or offline
-
-## Rate Limiting
-
-- Default limit: 100 requests per 15 minutes
-- Configurable through environment variables:
-  - `DEVICE_CONTROL_RATE_LIMIT`
-  - `DEVICE_CONTROL_RATE_WINDOW`
-
-## Best Practices
-
-1. Validate device availability before sending commands
-2. Implement proper error handling
-3. Use appropriate retry strategies for failed commands
-4. Cache device capabilities when possible
-5. Handle rate limiting gracefully
-
-## See Also
-
-- [List Devices](list-devices.md)
-- [Device History](../history-state/history.md)
-- [Event Subscription](../events/subscribe-events.md) 

docs/tools/device-management/list-devices.md

@@ -1,139 +0,0 @@
-# List Devices Tool
-
-The List Devices tool provides functionality to retrieve and manage device information from your Home Assistant instance.
-
-## Features
-
-- List all available Home Assistant devices
-- Group devices by domain
-- Get device states and attributes
-- Filter devices by various criteria
-
-## Usage
-
-### REST API
-
-```typescript
-GET /api/devices
-GET /api/devices/{domain}
-GET /api/devices/{device_id}/state
-```
-
-### WebSocket
-
-```typescript
-// List all devices
-{
-    "type": "list_devices",
-    "domain": "optional_domain"
-}
-
-// Get device state
-{
-    "type": "get_device_state",
-    "device_id": "required_device_id"
-}
-```
-
-### Examples
-
-#### List All Devices
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/devices', {
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-const devices = await response.json();
-```
-
-#### Get Devices by Domain
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/devices/light', {
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-const lightDevices = await response.json();
-```
-
-## Response Format
-
-### Device List Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "devices": [
-            {
-                "id": "device_id",
-                "name": "Device Name",
-                "domain": "light",
-                "state": "on",
-                "attributes": {
-                    "brightness": 255,
-                    "color_temp": 370
-                }
-            }
-        ]
-    }
-}
-```
-
-### Device State Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "state": "on",
-        "attributes": {
-            "brightness": 255,
-            "color_temp": 370
-        },
-        "last_changed": "2024-02-05T12:00:00Z",
-        "last_updated": "2024-02-05T12:00:00Z"
-    }
-}
-```
-
-## Error Handling
-
-### Common Error Codes
-
-- `404`: Device not found
-- `401`: Unauthorized
-- `400`: Invalid request parameters
-
-### Error Response Format
-
-```json
-{
-    "success": false,
-    "message": "Error description",
-    "error_code": "ERROR_CODE"
-}
-```
-
-## Rate Limiting
-
-- Default limit: 100 requests per 15 minutes
-- Configurable through environment variables:
-  - `DEVICE_LIST_RATE_LIMIT`
-  - `DEVICE_LIST_RATE_WINDOW`
-
-## Best Practices
-
-1. Cache device lists when possible
-2. Use domain filtering for better performance
-3. Implement proper error handling
-4. Handle rate limiting gracefully
-
-## See Also
-
-- [Device Control](control.md)
-- [Device History](../history-state/history.md)
-- [Event Subscription](../events/subscribe-events.md) 

docs/tools/events/sse-stats.md

@@ -1,251 +0,0 @@
-# SSE Statistics Tool
-
-The SSE Statistics tool provides functionality to monitor and analyze Server-Sent Events (SSE) connections and performance in your Home Assistant MCP instance.
-
-## Features
-
-- Monitor active SSE connections
-- Track connection statistics
-- Analyze event delivery
-- Monitor resource usage
-- Connection management
-- Performance metrics
-- Historical data
-- Alert configuration
-
-## Usage
-
-### REST API
-
-```typescript
-GET /api/sse/stats
-GET /api/sse/connections
-GET /api/sse/connections/{connection_id}
-GET /api/sse/metrics
-GET /api/sse/history
-```
-
-### WebSocket
-
-```typescript
-// Get SSE stats
-{
-    "type": "get_sse_stats"
-}
-
-// Get connection details
-{
-    "type": "get_sse_connection",
-    "connection_id": "required_connection_id"
-}
-
-// Get performance metrics
-{
-    "type": "get_sse_metrics",
-    "period": "1h|24h|7d|30d"
-}
-```
-
-## Examples
-
-### Get Current Statistics
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/sse/stats', {
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-const stats = await response.json();
-```
-
-### Get Connection Details
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/sse/connections/conn_123', {
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-const connection = await response.json();
-```
-
-### Get Performance Metrics
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/sse/metrics?period=24h', {
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-const metrics = await response.json();
-```
-
-## Response Format
-
-### Statistics Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "active_connections": 42,
-        "total_events_sent": 12345,
-        "events_per_second": 5.2,
-        "memory_usage": 128974848,
-        "cpu_usage": 2.5,
-        "uptime": "PT24H",
-        "event_backlog": 0
-    }
-}
-```
-
-### Connection Details Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "connection": {
-            "id": "conn_123",
-            "client_id": "client_456",
-            "user_id": "user_789",
-            "connected_at": "2024-02-05T12:00:00Z",
-            "last_event_at": "2024-02-05T12:05:00Z",
-            "events_sent": 150,
-            "subscriptions": [
-                {
-                    "event_type": "state_changed",
-                    "entity_id": "light.living_room"
-                }
-            ],
-            "state": "active",
-            "ip_address": "192.168.1.100",
-            "user_agent": "Mozilla/5.0 ..."
-        }
-    }
-}
-```
-
-### Performance Metrics Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "metrics": {
-            "connections": {
-                "current": 42,
-                "max": 100,
-                "average": 35.5
-            },
-            "events": {
-                "total": 12345,
-                "rate": {
-                    "current": 5.2,
-                    "max": 15.0,
-                    "average": 4.8
-                }
-            },
-            "latency": {
-                "p50": 15,
-                "p95": 45,
-                "p99": 100
-            },
-            "resources": {
-                "memory": {
-                    "current": 128974848,
-                    "max": 536870912
-                },
-                "cpu": {
-                    "current": 2.5,
-                    "max": 10.0,
-                    "average": 3.2
-                }
-            }
-        },
-        "period": "24h",
-        "timestamp": "2024-02-05T12:00:00Z"
-    }
-}
-```
-
-## Error Handling
-
-### Common Error Codes
-
-- `404`: Connection not found
-- `401`: Unauthorized
-- `400`: Invalid request parameters
-- `503`: Service overloaded
-
-### Error Response Format
-
-```json
-{
-    "success": false,
-    "message": "Error description",
-    "error_code": "ERROR_CODE"
-}
-```
-
-## Monitoring Metrics
-
-### Connection Metrics
-- Active connections
-- Connection duration
-- Connection state
-- Client information
-- Geographic distribution
-- Protocol version
-
-### Event Metrics
-- Events per second
-- Event types distribution
-- Delivery success rate
-- Event latency
-- Queue size
-- Backlog size
-
-### Resource Metrics
-- Memory usage
-- CPU usage
-- Network bandwidth
-- Disk I/O
-- Connection pool status
-- Thread pool status
-
-## Alert Thresholds
-
-- Connection limits
-- Event rate limits
-- Resource usage limits
-- Latency thresholds
-- Error rate thresholds
-- Backlog thresholds
-
-## Best Practices
-
-1. Monitor connection health
-2. Track resource usage
-3. Set up alerts
-4. Analyze usage patterns
-5. Optimize performance
-6. Plan capacity
-7. Implement failover
-8. Regular maintenance
-
-## Performance Optimization
-
-- Connection pooling
-- Event batching
-- Resource throttling
-- Load balancing
-- Cache optimization
-- Connection cleanup
-
-## See Also
-
-- [Event Subscription](subscribe-events.md)
-- [Device Control](../device-management/control.md)
-- [Automation Management](../automation/automation.md) 

docs/tools/events/subscribe-events.md

@@ -1,253 +0,0 @@
-# Event Subscription Tool
-
-The Event Subscription tool provides functionality to subscribe to and monitor real-time events from your Home Assistant instance.
-
-## Features
-
-- Subscribe to Home Assistant events
-- Monitor specific entities
-- Domain-based monitoring
-- Event filtering
-- Real-time updates
-- Event history
-- Custom event handling
-- Connection management
-
-## Usage
-
-### REST API
-
-```typescript
-POST /api/events/subscribe
-DELETE /api/events/unsubscribe
-GET /api/events/subscriptions
-GET /api/events/history
-```
-
-### WebSocket
-
-```typescript
-// Subscribe to events
-{
-    "type": "subscribe_events",
-    "event_type": "optional_event_type",
-    "entity_id": "optional_entity_id",
-    "domain": "optional_domain"
-}
-
-// Unsubscribe from events
-{
-    "type": "unsubscribe_events",
-    "subscription_id": "required_subscription_id"
-}
-```
-
-### Server-Sent Events (SSE)
-
-```typescript
-GET /api/events/stream?event_type=state_changed&entity_id=light.living_room
-```
-
-## Event Types
-
-- `state_changed`: Entity state changes
-- `automation_triggered`: Automation executions
-- `scene_activated`: Scene activations
-- `device_registered`: New device registrations
-- `service_registered`: New service registrations
-- `homeassistant_start`: System startup
-- `homeassistant_stop`: System shutdown
-- Custom events
-
-## Examples
-
-### Subscribe to All State Changes
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/events/subscribe', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "event_type": "state_changed"
-    })
-});
-```
-
-### Monitor Specific Entity
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/events/subscribe', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "event_type": "state_changed",
-        "entity_id": "light.living_room"
-    })
-});
-```
-
-### Domain-Based Monitoring
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/events/subscribe', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "event_type": "state_changed",
-        "domain": "light"
-    })
-});
-```
-
-### SSE Connection Example
-
-```typescript
-const eventSource = new EventSource(
-    'http://your-ha-mcp/api/events/stream?event_type=state_changed&entity_id=light.living_room',
-    {
-        headers: {
-            'Authorization': 'Bearer your_access_token'
-        }
-    }
-);
-
-eventSource.onmessage = (event) => {
-    const data = JSON.parse(event.data);
-    console.log('Event received:', data);
-};
-
-eventSource.onerror = (error) => {
-    console.error('SSE error:', error);
-    eventSource.close();
-};
-```
-
-## Response Format
-
-### Subscription Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "subscription_id": "sub_123",
-        "event_type": "state_changed",
-        "entity_id": "light.living_room",
-        "created_at": "2024-02-05T12:00:00Z"
-    }
-}
-```
-
-### Event Message Format
-
-```json
-{
-    "event_type": "state_changed",
-    "entity_id": "light.living_room",
-    "data": {
-        "old_state": {
-            "state": "off",
-            "attributes": {},
-            "last_changed": "2024-02-05T11:55:00Z"
-        },
-        "new_state": {
-            "state": "on",
-            "attributes": {
-                "brightness": 255
-            },
-            "last_changed": "2024-02-05T12:00:00Z"
-        }
-    },
-    "origin": "LOCAL",
-    "time_fired": "2024-02-05T12:00:00Z",
-    "context": {
-        "id": "context_123",
-        "parent_id": null,
-        "user_id": "user_123"
-    }
-}
-```
-
-### Subscriptions List Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "subscriptions": [
-            {
-                "id": "sub_123",
-                "event_type": "state_changed",
-                "entity_id": "light.living_room",
-                "created_at": "2024-02-05T12:00:00Z",
-                "last_event": "2024-02-05T12:05:00Z"
-            }
-        ]
-    }
-}
-```
-
-## Error Handling
-
-### Common Error Codes
-
-- `404`: Event type not found
-- `401`: Unauthorized
-- `400`: Invalid subscription parameters
-- `409`: Subscription already exists
-- `429`: Too many subscriptions
-
-### Error Response Format
-
-```json
-{
-    "success": false,
-    "message": "Error description",
-    "error_code": "ERROR_CODE"
-}
-```
-
-## Rate Limiting
-
-- Default limits:
-  - Maximum subscriptions: 100 per client
-  - Maximum event rate: 1000 events per minute
-- Configurable through environment variables:
-  - `EVENT_SUB_MAX_SUBSCRIPTIONS`
-  - `EVENT_SUB_RATE_LIMIT`
-  - `EVENT_SUB_RATE_WINDOW`
-
-## Best Practices
-
-1. Use specific event types when possible
-2. Implement proper error handling
-3. Handle connection interruptions
-4. Process events asynchronously
-5. Implement backoff strategies
-6. Monitor subscription health
-7. Clean up unused subscriptions
-8. Handle rate limiting gracefully
-
-## Connection Management
-
-- Implement heartbeat monitoring
-- Use reconnection strategies
-- Handle connection timeouts
-- Monitor connection quality
-- Implement fallback mechanisms
-- Clean up resources properly
-
-## See Also
-
-- [SSE Statistics](sse-stats.md)
-- [Device Control](../device-management/control.md)
-- [Automation Management](../automation/automation.md) 

docs/tools/history-state/history.md

@@ -1,167 +0,0 @@
-# Device History Tool
-
-The Device History tool allows you to retrieve historical state information for devices in your Home Assistant instance.
-
-## Features
-
-- Fetch device state history
-- Filter by time range
-- Get significant changes
-- Aggregate data by time periods
-- Export historical data
-
-## Usage
-
-### REST API
-
-```typescript
-GET /api/history/{device_id}
-GET /api/history/{device_id}/period/{start_time}
-GET /api/history/{device_id}/period/{start_time}/{end_time}
-```
-
-### WebSocket
-
-```typescript
-{
-    "type": "get_history",
-    "device_id": "required_device_id",
-    "start_time": "optional_iso_timestamp",
-    "end_time": "optional_iso_timestamp",
-    "significant_changes_only": false
-}
-```
-
-## Query Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `start_time` | ISO timestamp | Start of the period to fetch history for |
-| `end_time` | ISO timestamp | End of the period to fetch history for |
-| `significant_changes_only` | boolean | Only return significant state changes |
-| `minimal_response` | boolean | Return minimal state information |
-| `no_attributes` | boolean | Exclude attribute data from response |
-
-## Examples
-
-### Get Recent History
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/history/light.living_room', {
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-const history = await response.json();
-```
-
-### Get History for Specific Period
-
-```typescript
-const startTime = '2024-02-01T00:00:00Z';
-const endTime = '2024-02-02T00:00:00Z';
-const response = await fetch(
-    `http://your-ha-mcp/api/history/light.living_room/period/${startTime}/${endTime}`, 
-    {
-        headers: {
-            'Authorization': 'Bearer your_access_token'
-        }
-    }
-);
-const history = await response.json();
-```
-
-## Response Format
-
-### History Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "history": [
-            {
-                "state": "on",
-                "attributes": {
-                    "brightness": 255
-                },
-                "last_changed": "2024-02-05T12:00:00Z",
-                "last_updated": "2024-02-05T12:00:00Z"
-            },
-            {
-                "state": "off",
-                "last_changed": "2024-02-05T13:00:00Z",
-                "last_updated": "2024-02-05T13:00:00Z"
-            }
-        ]
-    }
-}
-```
-
-### Aggregated History Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "aggregates": {
-            "daily": [
-                {
-                    "date": "2024-02-05",
-                    "on_time": "PT5H30M",
-                    "off_time": "PT18H30M",
-                    "changes": 10
-                }
-            ]
-        }
-    }
-}
-```
-
-## Error Handling
-
-### Common Error Codes
-
-- `404`: Device not found
-- `401`: Unauthorized
-- `400`: Invalid parameters
-- `416`: Time range too large
-
-### Error Response Format
-
-```json
-{
-    "success": false,
-    "message": "Error description",
-    "error_code": "ERROR_CODE"
-}
-```
-
-## Rate Limiting
-
-- Default limit: 50 requests per 15 minutes
-- Configurable through environment variables:
-  - `HISTORY_RATE_LIMIT`
-  - `HISTORY_RATE_WINDOW`
-
-## Data Retention
-
-- Default retention period: 30 days
-- Configurable through environment variables:
-  - `HISTORY_RETENTION_DAYS`
-- Older data may be automatically aggregated
-
-## Best Practices
-
-1. Use appropriate time ranges to avoid large responses
-2. Enable `significant_changes_only` for better performance
-3. Use `minimal_response` when full state data isn't needed
-4. Implement proper error handling
-5. Cache frequently accessed historical data
-6. Handle rate limiting gracefully
-
-## See Also
-
-- [List Devices](../device-management/list-devices.md)
-- [Device Control](../device-management/control.md)
-- [Scene Management](scene.md) 

docs/tools/history-state/scene.md

@@ -1,215 +0,0 @@
-# Scene Management Tool
-
-The Scene Management tool provides functionality to manage and control scenes in your Home Assistant instance.
-
-## Features
-
-- List available scenes
-- Activate scenes
-- Create new scenes
-- Update existing scenes
-- Delete scenes
-- Get scene state information
-
-## Usage
-
-### REST API
-
-```typescript
-GET /api/scenes
-GET /api/scenes/{scene_id}
-POST /api/scenes/{scene_id}/activate
-POST /api/scenes
-PUT /api/scenes/{scene_id}
-DELETE /api/scenes/{scene_id}
-```
-
-### WebSocket
-
-```typescript
-// List scenes
-{
-    "type": "get_scenes"
-}
-
-// Activate scene
-{
-    "type": "activate_scene",
-    "scene_id": "required_scene_id"
-}
-
-// Create/Update scene
-{
-    "type": "create_scene",
-    "scene": {
-        "name": "required_scene_name",
-        "entities": {
-            // Entity states
-        }
-    }
-}
-```
-
-## Scene Configuration
-
-### Scene Definition
-
-```json
-{
-    "name": "Movie Night",
-    "entities": {
-        "light.living_room": {
-            "state": "on",
-            "brightness": 50,
-            "color_temp": 2700
-        },
-        "cover.living_room": {
-            "state": "closed"
-        },
-        "media_player.tv": {
-            "state": "on",
-            "source": "HDMI 1"
-        }
-    }
-}
-```
-
-## Examples
-
-### List All Scenes
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/scenes', {
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-const scenes = await response.json();
-```
-
-### Activate a Scene
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/scenes/movie_night/activate', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token'
-    }
-});
-```
-
-### Create a New Scene
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/scenes', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "name": "Movie Night",
-        "entities": {
-            "light.living_room": {
-                "state": "on",
-                "brightness": 50
-            },
-            "cover.living_room": {
-                "state": "closed"
-            }
-        }
-    })
-});
-```
-
-## Response Format
-
-### Scene List Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "scenes": [
-            {
-                "id": "scene_id",
-                "name": "Scene Name",
-                "entities": {
-                    // Entity configurations
-                }
-            }
-        ]
-    }
-}
-```
-
-### Scene Activation Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "scene_id": "activated_scene_id",
-        "status": "activated",
-        "timestamp": "2024-02-05T12:00:00Z"
-    }
-}
-```
-
-## Error Handling
-
-### Common Error Codes
-
-- `404`: Scene not found
-- `401`: Unauthorized
-- `400`: Invalid scene configuration
-- `409`: Scene activation failed
-
-### Error Response Format
-
-```json
-{
-    "success": false,
-    "message": "Error description",
-    "error_code": "ERROR_CODE"
-}
-```
-
-## Rate Limiting
-
-- Default limit: 50 requests per 15 minutes
-- Configurable through environment variables:
-  - `SCENE_RATE_LIMIT`
-  - `SCENE_RATE_WINDOW`
-
-## Best Practices
-
-1. Validate entity availability before creating scenes
-2. Use meaningful scene names
-3. Group related entities in scenes
-4. Implement proper error handling
-5. Cache scene configurations when possible
-6. Handle rate limiting gracefully
-
-## Scene Transitions
-
-Scenes can include transition settings for smooth state changes:
-
-```json
-{
-    "name": "Sunset Mode",
-    "entities": {
-        "light.living_room": {
-            "state": "on",
-            "brightness": 128,
-            "transition": 5  // 5 seconds
-        }
-    }
-}
-```
-
-## See Also
-
-- [Device Control](../device-management/control.md)
-- [Device History](history.md)
-- [Automation Management](../automation/automation.md) 

docs/tools/notifications/notify.md

@@ -1,249 +0,0 @@
-# Notification Tool
-
-The Notification tool provides functionality to send notifications through various services in your Home Assistant instance.
-
-## Features
-
-- Send notifications
-- Support for multiple notification services
-- Custom notification data
-- Rich media support
-- Notification templates
-- Delivery tracking
-- Priority levels
-- Notification groups
-
-## Usage
-
-### REST API
-
-```typescript
-POST /api/notify
-POST /api/notify/{service_id}
-GET /api/notify/services
-GET /api/notify/history
-```
-
-### WebSocket
-
-```typescript
-// Send notification
-{
-    "type": "send_notification",
-    "service": "required_service_id",
-    "message": "required_message",
-    "title": "optional_title",
-    "data": {
-        // Service-specific data
-    }
-}
-
-// Get notification services
-{
-    "type": "get_notification_services"
-}
-```
-
-## Supported Services
-
-- Mobile App
-- Email
-- SMS
-- Telegram
-- Discord
-- Slack
-- Push Notifications
-- Custom Services
-
-## Examples
-
-### Basic Notification
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/notify/mobile_app', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "message": "Motion detected in living room",
-        "title": "Security Alert"
-    })
-});
-```
-
-### Rich Notification
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/notify/mobile_app', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "message": "Motion detected in living room",
-        "title": "Security Alert",
-        "data": {
-            "image": "https://your-camera-snapshot.jpg",
-            "actions": [
-                {
-                    "action": "view_camera",
-                    "title": "View Camera"
-                },
-                {
-                    "action": "dismiss",
-                    "title": "Dismiss"
-                }
-            ],
-            "priority": "high",
-            "ttl": 3600,
-            "group": "security"
-        }
-    })
-});
-```
-
-### Service-Specific Example (Telegram)
-
-```typescript
-const response = await fetch('http://your-ha-mcp/api/notify/telegram', {
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer your_access_token',
-        'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({
-        "message": "Temperature is too high!",
-        "title": "Climate Alert",
-        "data": {
-            "parse_mode": "markdown",
-            "inline_keyboard": [
-                [
-                    {
-                        "text": "Turn On AC",
-                        "callback_data": "turn_on_ac"
-                    }
-                ]
-            ]
-        }
-    })
-});
-```
-
-## Response Format
-
-### Success Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "notification_id": "notification_123",
-        "status": "sent",
-        "timestamp": "2024-02-05T12:00:00Z",
-        "service": "mobile_app"
-    }
-}
-```
-
-### Services List Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "services": [
-            {
-                "id": "mobile_app",
-                "name": "Mobile App",
-                "enabled": true,
-                "features": [
-                    "actions",
-                    "images",
-                    "sound"
-                ]
-            }
-        ]
-    }
-}
-```
-
-### Notification History Response
-
-```json
-{
-    "success": true,
-    "data": {
-        "history": [
-            {
-                "id": "notification_123",
-                "service": "mobile_app",
-                "message": "Motion detected",
-                "title": "Security Alert",
-                "timestamp": "2024-02-05T12:00:00Z",
-                "status": "delivered"
-            }
-        ]
-    }
-}
-```
-
-## Error Handling
-
-### Common Error Codes
-
-- `404`: Service not found
-- `401`: Unauthorized
-- `400`: Invalid request
-- `408`: Delivery timeout
-- `422`: Invalid notification data
-
-### Error Response Format
-
-```json
-{
-    "success": false,
-    "message": "Error description",
-    "error_code": "ERROR_CODE"
-}
-```
-
-## Rate Limiting
-
-- Default limit: 100 notifications per hour
-- Configurable through environment variables:
-  - `NOTIFY_RATE_LIMIT`
-  - `NOTIFY_RATE_WINDOW`
-
-## Best Practices
-
-1. Use appropriate priority levels
-2. Group related notifications
-3. Include relevant context
-4. Implement proper error handling
-5. Use templates for consistency
-6. Consider time zones
-7. Respect user preferences
-8. Handle rate limiting gracefully
-
-## Notification Templates
-
-```typescript
-// Template example
-{
-    "template": "security_alert",
-    "data": {
-        "location": "living_room",
-        "event_type": "motion",
-        "timestamp": "2024-02-05T12:00:00Z"
-    }
-}
-```
-
-## See Also
-
-- [Event Subscription](../events/subscribe-events.md)
-- [Device Control](../device-management/control.md)
-- [Automation Management](../automation/automation.md) 

docs/tools/tools.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](device-management/list-devices.md)
-   - List all available Home Assistant devices
-   - Group devices by domain
-   - Get device states and attributes
-
-2. [Device Control](device-management/control.md)
-   - Control various device types
-   - Support for lights, switches, covers, climate devices
-   - Domain-specific commands and parameters
-
-### History and State
-
-1. [History](history-state/history.md)
-   - Fetch device state history
-   - Filter by time range
-   - Get significant changes
-
-2. [Scene Management](history-state/scene.md)
-   - List available scenes
-   - Activate scenes
-   - Scene state information
-
-### Automation
-
-1. [Automation Management](automation/automation.md)
-   - List automations
-   - Toggle automation state
-   - Trigger automations manually
-
-2. [Automation Configuration](automation/automation-config.md)
-   - Create new automations
-   - Update existing automations
-   - Delete automations
-   - Duplicate automations
-
-### Add-ons and Packages
-
-1. [Add-on Management](addons-packages/addon.md)
-   - List available add-ons
-   - Install/uninstall add-ons
-   - Start/stop/restart add-ons
-   - Get add-on information
-
-2. [Package Management](addons-packages/package.md)
-   - Manage HACS packages
-   - Install/update/remove packages
-   - List available packages by category
-
-### Notifications
-
-1. [Notify](notifications/notify.md)
-   - Send notifications
-   - Support for multiple notification services
-   - Custom notification data
-
-### Real-time Events
-
-1. [Event Subscription](events/subscribe-events.md)
-   - Subscribe to Home Assistant events
-   - Monitor specific entities
-   - Domain-based monitoring
-
-2. [SSE Statistics](events/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,374 +0,0 @@
----
-layout: default
-title: Troubleshooting
-nav_order: 6
----
-
-# Troubleshooting Guide 🔧
-
-This guide helps you diagnose and resolve common issues with MCP Server.
-
-## Quick Diagnostics
-
-### Health Check
-
-First, verify the server's health:
-
-```bash
-curl http://localhost:3000/health
-```
-
-Expected response:
-```json
-{
-  "status": "healthy",
-  "version": "1.0.0",
-  "uptime": 3600,
-  "homeAssistant": {
-    "connected": true,
-    "version": "2024.1.0"
-  }
-}
-```
-
-## Common Issues
-
-### 1. Connection Issues
-
-#### Cannot Connect to MCP Server
-
-**Symptoms:**
-- Server not responding
-- Connection refused errors
-- Timeout errors
-
-**Solutions:**
-
-1. Check if the server is running:
-   ```bash
-   # For Docker installation
-   docker compose ps
-   
-   # For manual installation
-   ps aux | grep mcp
-   ```
-
-2. Verify port availability:
-   ```bash
-   # Check if port is in use
-   netstat -tuln | grep 3000
-   ```
-
-3. Check logs:
-   ```bash
-   # Docker logs
-   docker compose logs mcp
-   
-   # Manual installation logs
-   bun run dev
-   ```
-
-#### Home Assistant Connection Failed
-
-**Symptoms:**
-- "Connection Error" in health check
-- Cannot control devices
-- State updates not working
-
-**Solutions:**
-
-1. Verify Home Assistant URL and token in `.env`:
-   ```env
-   HA_URL=http://homeassistant:8123
-   HA_TOKEN=your_long_lived_access_token
-   ```
-
-2. Test Home Assistant connection:
-   ```bash
-   curl -H "Authorization: Bearer YOUR_HA_TOKEN" \
-        http://your-homeassistant:8123/api/
-   ```
-
-3. Check network connectivity:
-   ```bash
-   # For Docker setup
-   docker compose exec mcp ping homeassistant
-   ```
-
-### 2. Authentication Issues
-
-#### Invalid Token
-
-**Symptoms:**
-- 401 Unauthorized responses
-- "Invalid token" errors
-
-**Solutions:**
-
-1. Generate a new token:
-   ```bash
-   curl -X POST http://localhost:3000/auth/token \
-     -H "Content-Type: application/json" \
-     -d '{"username": "your_username", "password": "your_password"}'
-   ```
-
-2. Verify token format:
-   ```javascript
-   // Token should be in format:
-   Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
-   ```
-
-#### Rate Limiting
-
-**Symptoms:**
-- 429 Too Many Requests
-- "Rate limit exceeded" errors
-
-**Solutions:**
-
-1. Check current rate limit status:
-   ```bash
-   curl -I http://localhost:3000/api/state
-   ```
-
-2. Adjust rate limits in configuration:
-   ```yaml
-   security:
-     rateLimit: 100  # Increase if needed
-     rateLimitWindow: 60000  # Window in milliseconds
-   ```
-
-### 3. Real-time Updates Issues
-
-#### SSE Connection Drops
-
-**Symptoms:**
-- Frequent disconnections
-- Missing state updates
-- EventSource errors
-
-**Solutions:**
-
-1. Implement proper reconnection logic:
-   ```javascript
-   class SSEClient {
-       constructor() {
-           this.connect();
-       }
-   
-       connect() {
-           this.eventSource = new EventSource('/subscribe_events');
-           this.eventSource.onerror = this.handleError.bind(this);
-       }
-   
-       handleError(error) {
-           console.error('SSE Error:', error);
-           this.eventSource.close();
-           setTimeout(() => this.connect(), 1000);
-       }
-   }
-   ```
-
-2. Check network stability:
-   ```bash
-   # Monitor connection stability
-   ping -c 100 localhost
-   ```
-
-### 4. Performance Issues
-
-#### High Latency
-
-**Symptoms:**
-- Slow response times
-- Command execution delays
-- UI lag
-
-**Solutions:**
-
-1. Enable Redis caching:
-   ```env
-   REDIS_ENABLED=true
-   REDIS_URL=redis://localhost:6379
-   ```
-
-2. Monitor system resources:
-   ```bash
-   # Check CPU and memory usage
-   docker stats
-   
-   # Or for manual installation
-   top -p $(pgrep -f mcp)
-   ```
-
-3. Optimize database queries and caching:
-   ```typescript
-   // Use batch operations
-   const results = await Promise.all([
-       cache.get('key1'),
-       cache.get('key2')
-   ]);
-   ```
-
-### 5. Device Control Issues
-
-#### Commands Not Executing
-
-**Symptoms:**
-- Commands appear successful but no device response
-- Inconsistent device states
-- Error messages from Home Assistant
-
-**Solutions:**
-
-1. Verify device availability:
-   ```bash
-   curl http://localhost:3000/api/state/light.living_room
-   ```
-
-2. Check command syntax:
-   ```bash
-   # Test basic command
-   curl -X POST http://localhost:3000/api/command \
-     -H "Content-Type: application/json" \
-     -d '{"command": "Turn on living room lights"}'
-   ```
-
-3. Review Home Assistant logs:
-   ```bash
-   docker compose exec homeassistant journalctl -f
-   ```
-
-## Debugging Tools
-
-### Log Analysis
-
-Enable debug logging:
-
-```env
-LOG_LEVEL=debug
-DEBUG=mcp:*
-```
-
-### Network Debugging
-
-Monitor network traffic:
-
-```bash
-# TCP dump for API traffic
-tcpdump -i any port 3000 -w debug.pcap
-```
-
-### Performance Profiling
-
-Enable performance monitoring:
-
-```env
-ENABLE_METRICS=true
-METRICS_PORT=9090
-```
-
-## Getting Help
-
-If you're still experiencing issues:
-
-1. Check the [GitHub Issues](https://github.com/jango-blockchained/advanced-homeassistant-mcp/issues)
-2. Search [Discussions](https://github.com/jango-blockchained/advanced-homeassistant-mcp/discussions)
-3. Create a new issue with:
-   - Detailed description
-   - Logs
-   - Configuration (sanitized)
-   - Steps to reproduce
-
-## Maintenance
-
-### Regular Health Checks
-
-Run periodic health checks:
-
-```bash
-# Create a cron job
-*/5 * * * * curl -f http://localhost:3000/health || notify-admin
-```
-
-### Log Rotation
-
-Configure log rotation:
-
-```yaml
-logging:
-  maxSize: "100m"
-  maxFiles: "7d"
-  compress: true
-```
-
-### Backup Configuration
-
-Regularly backup your configuration:
-
-```bash
-# Backup script
-tar -czf mcp-backup-$(date +%Y%m%d).tar.gz \
-    .env \
-    config/ \
-    data/
-```
-
-## FAQ
-
-### General Questions
-
-#### Q: What is MCP Server?
-A: MCP Server is a bridge between Home Assistant and Language Learning Models, enabling natural language control and automation of your smart home devices.
-
-#### Q: What are the system requirements?
-A: MCP Server requires:
-- Node.js 16 or higher
-- Home Assistant instance
-- 1GB RAM minimum
-- 1GB disk space
-
-#### Q: How do I update MCP Server?
-A: For Docker installation:
-```bash
-docker compose pull
-docker compose up -d
-```
-For manual installation:
-```bash
-git pull
-bun install
-bun run build
-```
-
-### Integration Questions
-
-#### Q: Can I use MCP Server with any Home Assistant instance?
-A: Yes, MCP Server works with any Home Assistant instance that has the REST API enabled and a valid long-lived access token.
-
-#### Q: Does MCP Server support all Home Assistant integrations?
-A: MCP Server supports all Home Assistant devices and services that are accessible via the REST API.
-
-### Security Questions
-
-#### Q: Is my Home Assistant token secure?
-A: Yes, your Home Assistant token is stored securely and only used for authenticated communication between MCP Server and your Home Assistant instance.
-
-#### Q: Can I use MCP Server remotely?
-A: Yes, but we recommend using a secure connection (HTTPS) and proper authentication when exposing MCP Server to the internet.
-
-### Troubleshooting Questions
-
-#### Q: Why are my device states not updating?
-A: Check:
-1. Home Assistant connection
-2. WebSocket connection status
-3. Device availability in Home Assistant
-4. Network connectivity
-
-#### Q: Why are my commands not working?
-A: Verify:
-1. Command syntax
-2. Device availability
-3. User permissions
-4. Home Assistant API access 

docs/usage.md

@@ -1,34 +0,0 @@
-# Usage Guide
-
-This guide explains how to use the Home Assistant MCP Server for smart home device management and integration with language learning systems.
-
-## Basic Usage
-
-1. **Starting the Server:**
-   - For development: run `npm run dev`.
-   - For production: run `npm run build` followed by `npm start`.
-
-2. **Accessing the Web Interface:**
-   - Open [http://localhost:3000](http://localhost:3000) in your browser.
-
-3. **Real-Time Updates:**
-   - Connect to the SSE endpoint at `/subscribe_events?token=YOUR_TOKEN&domain=light` to receive live updates.
-
-## Advanced Features
-
-1. **API Interactions:**
-   - Use the REST API for operations such as device control, automation, and add-on management.
-   - See [API Documentation](api.md) for details.
-
-2. **Tool Integrations:**
-   - Multiple tools are available (see [Tools Documentation](tools/tools.md)), for tasks like automation management and notifications.
-
-3. **Security Settings:**
-   - Configure token-based authentication and environment variables as per the [Configuration Guide](getting-started/configuration.md).
-
-4. **Customization and Extensions:**
-   - Extend server functionality by developing new tools as outlined in the [Development Guide](development/development.md).
-
-## Troubleshooting
-
-If you experience issues, review the [Troubleshooting Guide](troubleshooting.md). 

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
+    try {
-    const schemaResponse = await fetch(`${config.mcpServer}/mcp`, {
+        // Check if we're in test mode
+        if (process.env.HA_TEST_MODE === '1') {
+            logger.info("Running in test mode with mock data");
+            return MOCK_HA_INFO;
+        }
+
+        // Get states from Home Assistant directly
+        const statesResponse = await fetch(`${hassHost}/api/states`, {
             headers: {
                 'Authorization': `Bearer ${hassToken}`,
-            'Accept': 'application/json'
+                'Content-Type': 'application/json'
             }
         });
 
-    if (!schemaResponse.ok) {
+        if (!statesResponse.ok) {
-        console.error(`Failed to fetch MCP schema: ${schemaResponse.status}`);
+            throw new Error(`Failed to fetch states: ${statesResponse.status}`);
-        return info;
         }
 
-    const schema = await schemaResponse.json() as McpSchema;
+        const states = await statesResponse.json() as HassState[];
-    console.log("Available tools:", schema.tools.map(t => t.name));
 
-    // Execute list_devices to get basic device information
+        // Group devices by domain
-    console.log("Fetching device information...");
+        const devices: Record<string, HassState[]> = {};
-    try {
+        for (const state of states) {
-        const deviceInfo = await executeMcpTool('list_devices');
+            const [domain] = state.entity_id.split('.');
-        if (deviceInfo && deviceInfo.success && deviceInfo.devices) {
+            if (!devices[domain]) {
-            info.devices = deviceInfo.devices;
+                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 {
-            console.warn(`Failed to list devices: ${deviceInfo?.message || 'Unknown error'}`);
+            logger.warn('No devices found in Home Assistant');
-        }
-    } catch (error) {
-        console.warn("Error fetching devices:", error);
         }
 
         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);
+
+        // Get automation information
+        const automations = haInfo.devices?.automation || [];
+        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
+            })) || []
+        }));
+
+        const automationSummary = {
+            total: automations.length,
+            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()
+        };
+
+        // Create a summary of the devices
+        const deviceSummary = Object.entries(deviceStates)
+            .map(([domain, count]) => `${domain}: ${count}`)
+            .join(', ');
+
+        if (process.env.HA_TEST_MODE === '1') {
+            console.log("\nTest Mode Analysis Results:\n");
+            console.log("Based on your Home Assistant setup with:");
+            console.log(`- ${totalDevices} total devices`);
+            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;
+        }
+
+        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,
         });
 
-    const maxOption = AVAILABLE_MODELS.length;
+        console.log("\nAnalysis Results:\n");
-    const choice = await getUserInput(`\nSelect model (1-${maxOption}): `);
+        console.log(completion.content[0]?.type === 'text' ? completion.content[0].text : "No response generated");
-    const selectedIndex = parseInt(choice) - 1;
 
-    if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= AVAILABLE_MODELS.length) {
-        console.log(chalk.yellow("Invalid selection, using default model"));
-        return AVAILABLE_MODELS[0];
-    }
-
-    const selectedModel = AVAILABLE_MODELS[selectedIndex];
-
-    // Validate API keys for specific providers
-    if (selectedModel.name.startsWith('deepseek')) {
-        if (!process.env.DEEPSEEK_API_KEY) {
-            logger.error("DeepSeek models require DEEPSEEK_API_KEY in .env");
-            process.exit(1);
-        }
-
-        // Verify DeepSeek connection
-        try {
-            await getOpenAIClient().models.list();
     } catch (error) {
-            logger.error(`DeepSeek connection failed: ${error.message}`);
+        console.error("Error processing custom prompt:", error);
-            process.exit(1);
+
-        }
+        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;
         }
 
-    if (selectedModel.name.startsWith('gpt-4-o') && !process.env.OPENAI_API_KEY) {
+        // Retry with simplified prompt if there's an error
-        logger.error("OpenAI models require OPENAI_API_KEY in .env");
+        try {
-        process.exit(1);
+            const retryPrompt = "Please provide a simpler analysis of the Home Assistant system.";
-    }
+            const anthropic = getAnthropicClient();
+            const config = loadConfig();
 
-    return selectedModel;
+            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);
+        }
+    }
 }
 
 // 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

@@ -1,9 +1,15 @@
 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('fast-whisper');
+    const speech = new SpeechToText({
+        modelPath: 'base.en',
+        modelType: 'whisper',
+        containerName: 'fast-whisper'
+    });
 
     // Check if the service is available
     const isHealthy = await speech.checkHealth();
@@ -45,12 +51,51 @@ async function main() {
         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',  // You can change this to tiny.en, small.en, medium.en, or large-v2
+                model: 'base.en',
                 language: 'en',
                 temperature: 0,
                 beamSize: 5
@@ -63,22 +108,13 @@ async function main() {
         }
     }
 
-    // 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 wake word detection
     speech.startWakeWordDetection(audioDir);
 
-    // Example: You can also manually transcribe files
+    // Handle cleanup on exit
-    // Uncomment the following line and replace with your audio file:
-    // await transcribeFile('/path/to/your/audio.wav');
-
-    // Keep the process running
     process.on('SIGINT', () => {
         console.log('\nStopping speech service...');
+        recording.stop();
         speech.stopWakeWordDetection();
         process.exit(0);
     });

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';

mkdocs.yml

@@ -1,141 +0,0 @@
-site_name: Home Assistant MCP
-site_description: A bridge between Home Assistant and Language Learning Models
-site_url: https://jango-blockchained.github.io/advanced-homeassistant-mcp/
-repo_url: https://github.com/jango-blockchained/advanced-homeassistant-mcp
-repo_name: jango-blockchained/advanced-homeassistant-mcp
-
-theme:
-  name: material
-  logo: assets/images/logo.png
-  favicon: assets/images/favicon.ico
-  palette:
-    - media: "(prefers-color-scheme: light)"
-      scheme: default
-      primary: indigo
-      accent: indigo
-      toggle:
-        icon: material/brightness-7
-        name: Switch to dark mode
-    - media: "(prefers-color-scheme: dark)"
-      scheme: slate
-      primary: indigo
-      accent: indigo
-      toggle:
-        icon: material/brightness-4
-        name: Switch to light mode
-  features:
-    - navigation.instant
-    - navigation.tracking
-    - navigation.sections
-    - navigation.expand
-    - navigation.top
-    - search.suggest
-    - search.highlight
-    - content.code.copy
-
-markdown_extensions:
-  - admonition
-  - attr_list
-  - def_list
-  - footnotes
-  - meta
-  - toc:
-      permalink: true
-  - pymdownx.arithmatex:
-      generic: true
-  - pymdownx.betterem:
-      smart_enable: all
-  - pymdownx.caret
-  - pymdownx.details
-  - pymdownx.emoji:
-      emoji_index: !!python/name:material.extensions.emoji.twemoji
-      emoji_generator: !!python/name:material.extensions.emoji.to_svg
-  - pymdownx.highlight:
-      anchor_linenums: true
-  - pymdownx.inlinehilite
-  - pymdownx.keys
-  - pymdownx.magiclink
-  - pymdownx.mark
-  - pymdownx.smartsymbols
-  - pymdownx.superfences:
-      custom_fences:
-        - name: mermaid
-          class: mermaid
-          format: !!python/name:pymdownx.superfences.fence_code_format
-  - pymdownx.tabbed:
-      alternate_style: true
-  - pymdownx.tasklist:
-      custom_checkbox: true
-  - pymdownx.tilde
-
-plugins:
-  - search
-  - git-revision-date-localized:
-      type: date
-  - mkdocstrings:
-      default_handler: python
-      handlers:
-        python:
-          options:
-            show_source: true
-
-nav:
-  - Home: index.md
-  - Getting Started:
-    - Overview: getting-started.md
-    - Installation: getting-started/installation.md
-    - Configuration: getting-started/configuration.md
-    - Docker Setup: getting-started/docker.md
-    - Quick Start: getting-started/quickstart.md
-    - Usage: usage.md
-  - API Reference:
-    - Overview: api/index.md
-    - Core API: api.md
-    - SSE API: api/sse.md
-    - Core Functions: api/core.md
-  - Tools:
-    - Overview: tools/tools.md
-    - Device Management:
-      - List Devices: tools/device-management/list-devices.md
-      - Device Control: tools/device-management/control.md
-    - History & State:
-      - History: tools/history-state/history.md
-      - Scene Management: tools/history-state/scene.md
-    - Automation:
-      - Automation Management: tools/automation/automation.md
-      - Automation Configuration: tools/automation/automation-config.md
-    - Add-ons & Packages:
-      - Add-on Management: tools/addons-packages/addon.md
-      - Package Management: tools/addons-packages/package.md
-    - Notifications:
-      - Notify: tools/notifications/notify.md
-    - Events:
-      - Event Subscription: tools/events/subscribe-events.md
-      - SSE Statistics: tools/events/sse-stats.md
-  - Development:
-    - Overview: development/development.md
-    - Best Practices: development/best-practices.md
-    - Interfaces: development/interfaces.md
-    - Tool Development: development/tools.md
-    - Testing Guide: testing.md
-  - Architecture: architecture.md
-  - Contributing: contributing.md
-  - Troubleshooting: troubleshooting.md
-  - Examples:
-    - Overview: examples/index.md
-  - Roadmap: roadmap.md
-
-extra:
-  social:
-    - icon: fontawesome/brands/github
-      link: https://github.com/jango-blockchained/homeassistant-mcp
-    - icon: fontawesome/brands/docker
-      link: https://hub.docker.com/r/jangoblockchained/homeassistant-mcp
-  analytics:
-    provider: google
-    property: !ENV GOOGLE_ANALYTICS_KEY
-
-extra_css:
-  - assets/stylesheets/extra.css
-
-copyright: Copyright © 2024 Jango Blockchained 

package.json

@@ -4,10 +4,20 @@
   "description": "Home Assistant Model Context Protocol",
   "main": "dist/index.js",
   "type": "module",
+  "bin": {
+    "homeassistant-mcp": "./bin/npx-entry.cjs",
+    "mcp-stdio": "./bin/npx-entry.cjs"
+  },
   "scripts": {
     "start": "bun run dist/index.js",
+    "start:stdio": "bun run dist/stdio-server.js",
     "dev": "bun --hot --watch src/index.ts",
-    "build": "bun build ./src/index.ts --outdir ./dist --target node --minify",
+    "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:watch": "bun test --watch",
     "test:coverage": "bun test --coverage",
@@ -17,25 +27,36 @@
     "test:staged": "bun test --findRelatedTests",
     "lint": "eslint . --ext .ts",
     "format": "prettier --write \"src/**/*.ts\"",
-    "prepare": "husky install",
     "profile": "bun --inspect src/index.ts",
     "clean": "rm -rf dist .bun coverage",
     "typecheck": "bun x tsc --noEmit",
-    "example:speech": "bun run examples/speech-to-text-example.ts"
+    "example:speech": "bun run extra/speech-to-text-example.ts"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
     "@elysiajs/cors": "^1.2.0",
     "@elysiajs/swagger": "^1.2.0",
+    "@types/express-rate-limit": "^5.1.3",
     "@types/jsonwebtoken": "^9.0.5",
     "@types/node": "^20.11.24",
-    "@types/sanitize-html": "^2.9.5",
+    "@types/sanitize-html": "^2.13.0",
+    "@types/swagger-ui-express": "^4.1.8",
     "@types/ws": "^8.5.10",
-    "dotenv": "^16.4.5",
+    "@xmldom/xmldom": "^0.9.7",
+    "chalk": "^5.4.1",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
     "elysia": "^1.2.11",
+    "express": "^4.21.2",
+    "express-rate-limit": "^7.5.0",
     "helmet": "^7.1.0",
     "jsonwebtoken": "^9.0.2",
     "node-fetch": "^3.3.2",
-    "sanitize-html": "^2.11.0",
+    "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",
@@ -43,19 +64,36 @@
     "zod": "^3.22.4"
   },
   "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/bun": "latest",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "@types/jest": "^29.5.14",
+    "@types/supertest": "^6.0.2",
     "@types/uuid": "^10.0.0",
     "@typescript-eslint/eslint-plugin": "^7.1.0",
     "@typescript-eslint/parser": "^7.1.0",
+    "ajv": "^8.17.1",
     "bun-types": "^1.2.2",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.1.3",
     "husky": "^9.0.11",
     "prettier": "^3.2.5",
-    "supertest": "^6.3.3",
+    "supertest": "^7.1.0",
-    "uuid": "^11.0.5"
+    "uuid": "^11.1.0"
   },
   "engines": {
-    "bun": ">=1.0.0"
+    "bun": ">=1.0.0",
-  }
+    "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" 

smithery.yaml

@@ -11,10 +11,21 @@ startCommand:
       hassToken:
         type: string
         description: The token for connecting to Home Assistant API.
-      port:
+      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: 4000
+        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.
     |-
@@ -23,6 +34,228 @@ startCommand:
       args: ['--smol', 'run', 'start'], 
       env: { 
         HASS_TOKEN: config.hassToken,
-        PORT: config.port.toString()
+        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/__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);
+    });
+});