# Task Engine AI Core Configuration

This directory contains comprehensive configuration files for the `task-engine-ai-core` package, supporting the complete transformation trilogy architecture.

## 📁 Configuration Files

### Core Configuration Files

- **`task-engine-config.json`** - Master configuration with package metadata and feature definitions
- **`default.json`** - Default configuration settings for all environments
- **`development.json`** - Development environment specific settings
- **`production.json`** - Production environment optimized settings
- **`schema.json`** - JSON schema for configuration validation

### Configuration Structure

```
config/
├── README.md                 # This file
├── task-engine-config.json   # Master package configuration
├── default.json              # Default settings
├── development.json          # Development environment
├── production.json           # Production environment
└── schema.json               # Configuration schema
```

## 🚀 Quick Start

### Basic Usage

```javascript
import { ConfigLoader, loadConfig } from 'task-engine-ai-core/src/utils/config-loader.js';

// Load configuration for current environment
const config = await loadConfig();

// Access configuration values
const port = config.architectures.backend.port;
const aiEnabled = config.ai.features.taskGeneration;
```

### Environment-Specific Loading

```javascript
// Load development configuration
const devConfig = await loadConfig({ environment: 'development' });

// Load production configuration
const prodConfig = await loadConfig({ environment: 'production' });
```

### Custom Configuration Directory

```javascript
const config = await loadConfig({
    configDir: '/path/to/custom/config',
    environment: 'staging'
});
```

## ⚙️ Configuration Hierarchy

Configurations are loaded and merged in the following order (later configs override earlier ones):

1. **Default Configuration** (`default.json`)
2. **Environment Configuration** (`{environment}.json`)
3. **User Configuration** (`user.json`) - Optional
4. **Local Configuration** (`local.json`) - Optional
5. **Environment Variables** - Highest priority

## 🌍 Environment Variables

Override configuration values using environment variables:

```bash
# Backend Configuration
export TASK_ENGINE_PORT=8080
export TASK_ENGINE_HOST=0.0.0.0
export TASK_ENGINE_DB_TYPE=postgresql
export TASK_ENGINE_DB_HOST=localhost
export TASK_ENGINE_DB_PORT=5432
export TASK_ENGINE_DB_NAME=taskengine

# Cache Configuration
export TASK_ENGINE_REDIS_HOST=localhost
export TASK_ENGINE_REDIS_PORT=6379

# Logging Configuration
export TASK_ENGINE_LOG_LEVEL=debug
export TASK_ENGINE_DEBUG=true

# AI Configuration
export ANTHROPIC_API_KEY=your-api-key
export OPENAI_API_KEY=your-api-key

# MCP Configuration
export MCP_PORT=9000
export MCP_HOST=localhost
```

## 🏗️ Architecture Configuration

### Frontend Architecture (v0.1.0)

```json
{
  "architectures": {
    "frontend": {
      "enabled": true,
      "port": 3000,
      "activeAgent": {
        "enabled": true,
        "intelligence": {
          "predictiveAnalytics": true,
          "naturalLanguageProcessing": true,
          "machineLearning": true
        }
      },
      "realTime": {
        "enabled": true,
        "websocket": {
          "port": 3001
        }
      }
    }
  }
}
```

### Backend Architecture (v0.2.0)

```json
{
  "architectures": {
    "backend": {
      "enabled": true,
      "port": 8000,
      "database": {
        "type": "sqlite",
        "path": "data/tasks.db"
      },
      "cache": {
        "enabled": true,
        "type": "memory",
        "ttl": 300
      },
      "performance": {
        "optimization": true,
        "dataEngine": {
          "batchSize": 100,
          "parallelProcessing": true
        }
      }
    }
  }
}
```

### CLI Architecture (v0.3.0)

```json
{
  "architectures": {
    "cli": {
      "enabled": true,
      "commands": {
        "aliases": ["task-master", "tm"],
        "autoComplete": true
      },
      "performance": {
        "enabled": true,
        "caching": true
      },
      "legacy": {
        "compatibility": true
      }
    }
  }
}
```

## 🤖 AI Configuration

```json
{
  "ai": {
    "providers": {
      "default": "anthropic",
      "anthropic": {
        "enabled": true,
        "model": "claude-3-sonnet-20240229",
        "maxTokens": 4096,
        "temperature": 0.7
      }
    },
    "features": {
      "taskGeneration": true,
      "taskOptimization": true,
      "predictiveAnalytics": true,
      "naturalLanguageProcessing": true
    },
    "limits": {
      "requestsPerMinute": 60,
      "requestsPerHour": 1000
    }
  }
}
```

## 📊 Monitoring Configuration

```json
{
  "monitoring": {
    "enabled": true,
    "metrics": {
      "performance": true,
      "system": true,
      "business": true
    },
    "alerting": {
      "enabled": true,
      "thresholds": {
        "responseTime": 1000,
        "errorRate": 0.05,
        "memoryUsage": 0.8
      }
    }
  }
}
```

## 🔧 Development vs Production

### Development Settings
- Debug mode enabled
- Verbose logging
- Hot reload enabled
- Mock data available
- Relaxed security
- Lower performance limits

### Production Settings
- Debug mode disabled
- Error-level logging only
- SSL/TLS enabled
- Authentication required
- Enhanced security
- Optimized performance
- Clustering enabled
- Backup and monitoring

## 📝 Custom Configuration

Create custom configuration files for specific environments:

### `config/staging.json`
```json
{
  "taskEngine": {
    "environment": "staging",
    "debug": false
  },
  "architectures": {
    "backend": {
      "database": {
        "type": "postgresql",
        "host": "staging-db.example.com"
      }
    }
  }
}
```

### `config/user.json` (Optional)
```json
{
  "ai": {
    "providers": {
      "anthropic": {
        "temperature": 0.9
      }
    }
  },
  "development": {
    "mockData": {
      "enabled": true,
      "tasks": 50
    }
  }
}
```

## ✅ Configuration Validation

The configuration system includes automatic validation:

- **Schema Validation** - Validates against JSON schema
- **Type Checking** - Ensures correct data types
- **Range Validation** - Validates numeric ranges
- **Required Fields** - Checks for required configuration

### Manual Validation

```javascript
import { ConfigLoader } from 'task-engine-ai-core/src/utils/config-loader.js';

const loader = new ConfigLoader({ validateSchema: true });
try {
    const config = await loader.load();
    console.log('Configuration is valid');
} catch (error) {
    console.error('Configuration validation failed:', error.message);
}
```

## 🔍 Configuration Access

### Using ConfigLoader

```javascript
import { configLoader } from 'task-engine-ai-core/src/utils/config-loader.js';

// Load configuration
await configLoader.load();

// Get specific values
const port = configLoader.get('architectures.backend.port', 8000);
const aiEnabled = configLoader.get('ai.features.taskGeneration', false);

// Check if configuration exists
if (configLoader.has('monitoring.enabled')) {
    // Monitoring is configured
}
```

### Direct Access

```javascript
const config = await loadConfig();

// Access nested values
const dbConfig = config.architectures.backend.database;
const aiConfig = config.ai.providers.anthropic;
```

## 🚨 Common Issues

### Missing Configuration Files
- Ensure `default.json` exists in the config directory
- Check file permissions and paths

### Environment Variable Override
- Use exact environment variable names
- Check data type conversion (strings to numbers/booleans)

### Schema Validation Errors
- Verify configuration structure matches schema
- Check required fields are present
- Validate data types and ranges

## 📚 Examples

See the `examples/` directory for complete configuration examples:
- Basic setup
- Enterprise deployment
- Development environment
- Custom integrations

---

**Configuration Version:** 1.0.0  
**Compatible with:** task-engine-ai-core v0.3.0  
**Last Updated:** January 8, 2025