Restructure Project Architecture with Modular Routes and Configuration

- Refactored main application entry point to use centralized configuration
- Created modular route structure with separate files for different API endpoints
- Introduced app.config.ts for centralized environment variable management
- Moved tools and route logic into dedicated files
- Simplified index.ts and improved overall project organization
- Added comprehensive type definitions for tools and API interactions

src/tools/automation-config.tool.ts

@@ -0,0 +1,150 @@
+import { z } from 'zod';
+import { Tool, AutomationConfigParams, AutomationConfig, AutomationResponse } from '../types/index.js';
+import { APP_CONFIG } from '../config/app.config.js';
+
+export const automationConfigTool: Tool = {
+    name: 'automation_config',
+    description: 'Advanced automation configuration and management',
+    parameters: z.object({
+        action: z.enum(['create', 'update', 'delete', 'duplicate'])
+            .describe('Action to perform with automation config'),
+        automation_id: z.string().optional()
+            .describe('Automation ID (required for update, delete, and duplicate)'),
+        config: z.object({
+            alias: z.string().describe('Friendly name for the automation'),
+            description: z.string().optional().describe('Description of what the automation does'),
+            mode: z.enum(['single', 'parallel', 'queued', 'restart']).optional()
+                .describe('How multiple triggerings are handled'),
+            trigger: z.array(z.any()).describe('List of triggers'),
+            condition: z.array(z.any()).optional().describe('List of conditions'),
+            action: z.array(z.any()).describe('List of actions'),
+        }).optional().describe('Automation configuration (required for create and update)'),
+    }),
+    execute: async (params: AutomationConfigParams) => {
+        try {
+            switch (params.action) {
+                case 'create': {
+                    if (!params.config) {
+                        throw new Error('Configuration is required for creating automation');
+                    }
+
+                    const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/config/automation/config`, {
+                        method: 'POST',
+                        headers: {
+                            Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify(params.config),
+                    });
+
+                    if (!response.ok) {
+                        throw new Error(`Failed to create automation: ${response.statusText}`);
+                    }
+
+                    const responseData = await response.json() as { automation_id: string };
+                    return {
+                        success: true,
+                        message: 'Successfully created automation',
+                        automation_id: responseData.automation_id,
+                    };
+                }
+
+                case 'update': {
+                    if (!params.automation_id || !params.config) {
+                        throw new Error('Automation ID and configuration are required for updating automation');
+                    }
+
+                    const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/config/automation/config/${params.automation_id}`, {
+                        method: 'PUT',
+                        headers: {
+                            Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify(params.config),
+                    });
+
+                    if (!response.ok) {
+                        throw new Error(`Failed to update automation: ${response.statusText}`);
+                    }
+
+                    const responseData = await response.json() as { automation_id: string };
+                    return {
+                        success: true,
+                        automation_id: responseData.automation_id,
+                        message: 'Automation updated successfully'
+                    };
+                }
+
+                case 'delete': {
+                    if (!params.automation_id) {
+                        throw new Error('Automation ID is required for deleting automation');
+                    }
+
+                    const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/config/automation/config/${params.automation_id}`, {
+                        method: 'DELETE',
+                        headers: {
+                            Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
+                            'Content-Type': 'application/json',
+                        },
+                    });
+
+                    if (!response.ok) {
+                        throw new Error(`Failed to delete automation: ${response.statusText}`);
+                    }
+
+                    return {
+                        success: true,
+                        message: `Successfully deleted automation ${params.automation_id}`,
+                    };
+                }
+
+                case 'duplicate': {
+                    if (!params.automation_id) {
+                        throw new Error('Automation ID is required for duplicating automation');
+                    }
+
+                    // First, get the existing automation config
+                    const getResponse = await fetch(`${APP_CONFIG.HASS_HOST}/api/config/automation/config/${params.automation_id}`, {
+                        headers: {
+                            Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
+                            'Content-Type': 'application/json',
+                        },
+                    });
+
+                    if (!getResponse.ok) {
+                        throw new Error(`Failed to get automation config: ${getResponse.statusText}`);
+                    }
+
+                    const config = await getResponse.json() as AutomationConfig;
+                    config.alias = `${config.alias} (Copy)`;
+
+                    // Create new automation with modified config
+                    const createResponse = await fetch(`${APP_CONFIG.HASS_HOST}/api/config/automation/config`, {
+                        method: 'POST',
+                        headers: {
+                            Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify(config),
+                    });
+
+                    if (!createResponse.ok) {
+                        throw new Error(`Failed to create duplicate automation: ${createResponse.statusText}`);
+                    }
+
+                    const newAutomation = await createResponse.json() as AutomationResponse;
+                    return {
+                        success: true,
+                        message: `Successfully duplicated automation ${params.automation_id}`,
+                        new_automation_id: newAutomation.automation_id,
+                    };
+                }
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    },
+};