simple test

.env

@@ -0,0 +1,164 @@
+# ===========================================
+# STOCK BOT PLATFORM - ENVIRONMENT VARIABLES
+# ===========================================
+
+# Core Application Settings
+NODE_ENV=development
+LOG_LEVEL=info
+
+# Data Service Configuration
+DATA_SERVICE_PORT=2001
+
+# Queue and Worker Configuration
+WORKER_COUNT=4
+WORKER_CONCURRENCY=20
+
+WEBSHARE_API_KEY=y8ay534rcbybdkk3evnzmt640xxfhy7252ce2t98
+
+# ===========================================
+# DATABASE CONFIGURATIONS
+# ===========================================
+
+# Dragonfly/Redis Configuration
+DRAGONFLY_HOST=localhost
+DRAGONFLY_PORT=6379
+DRAGONFLY_PASSWORD=
+
+# PostgreSQL Configuration
+POSTGRES_HOST=localhost
+POSTGRES_PORT=5432
+POSTGRES_DB=stockbot
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=postgres
+POSTGRES_SSL=false
+
+# QuestDB Configuration
+QUESTDB_HOST=localhost
+QUESTDB_PORT=9000
+QUESTDB_DB=qdb
+QUESTDB_USER=admin
+QUESTDB_PASSWORD=quest
+
+# MongoDB Configuration
+MONGODB_HOST=localhost
+MONGODB_PORT=27017
+MONGODB_DB=stockbot
+MONGODB_USER=
+MONGODB_PASSWORD=
+MONGODB_URI=mongodb://localhost:27017/stockbot
+
+# ===========================================
+# DATA PROVIDER CONFIGURATIONS
+# ===========================================
+
+# Proxy Configuration
+PROXY_VALIDATION_HOURS=24
+PROXY_BATCH_SIZE=100
+PROXY_DIRECT_MODE=false
+
+# Yahoo Finance (if using API keys)
+YAHOO_API_KEY=
+YAHOO_API_SECRET=
+
+# QuoteMedia Configuration
+QUOTEMEDIA_API_KEY=
+QUOTEMEDIA_BASE_URL=https://api.quotemedia.com
+
+# ===========================================
+# TRADING PLATFORM INTEGRATIONS
+# ===========================================
+
+# Alpaca Trading
+ALPACA_API_KEY=
+ALPACA_SECRET_KEY=
+ALPACA_BASE_URL=https://paper-api.alpaca.markets
+ALPACA_PAPER_TRADING=true
+
+# Polygon.io
+POLYGON_API_KEY=
+POLYGON_BASE_URL=https://api.polygon.io
+
+# ===========================================
+# RISK MANAGEMENT
+# ===========================================
+
+# Risk Management Settings
+MAX_POSITION_SIZE=10000
+MAX_DAILY_LOSS=1000
+MAX_PORTFOLIO_EXPOSURE=0.8
+STOP_LOSS_PERCENTAGE=0.02
+TAKE_PROFIT_PERCENTAGE=0.05
+
+# ===========================================
+# MONITORING AND OBSERVABILITY
+# ===========================================
+
+# Prometheus Configuration
+PROMETHEUS_HOST=localhost
+PROMETHEUS_PORT=9090
+PROMETHEUS_METRICS_PORT=9091
+PROMETHEUS_PUSHGATEWAY_URL=http://localhost:9091
+
+# Grafana Configuration
+GRAFANA_HOST=localhost
+GRAFANA_PORT=3000
+GRAFANA_ADMIN_USER=admin
+GRAFANA_ADMIN_PASSWORD=admin
+
+# Loki Logging
+LOKI_HOST=localhost
+LOKI_PORT=3100
+LOKI_URL=http://localhost:3100
+
+# ===========================================
+# CACHE CONFIGURATION
+# ===========================================
+
+# Cache Settings
+CACHE_TTL=300
+CACHE_MAX_ITEMS=10000
+CACHE_ENABLED=true
+
+# ===========================================
+# SECURITY SETTINGS
+# ===========================================
+
+# JWT Configuration
+JWT_SECRET=your-super-secret-jwt-key-change-this-in-production
+JWT_EXPIRES_IN=24h
+
+# API Rate Limiting
+RATE_LIMIT_WINDOW=15
+RATE_LIMIT_MAX_REQUESTS=100
+
+# ===========================================
+# DEVELOPMENT SETTINGS
+# ===========================================
+
+# Debug Settings
+DEBUG_MODE=false
+VERBOSE_LOGGING=false
+
+# Development Tools
+HOT_RELOAD=true
+SOURCE_MAPS=true
+
+# ===========================================
+# DOCKER CONFIGURATION
+# ===========================================
+
+# Docker-specific settings (used in docker-compose)
+COMPOSE_PROJECT_NAME=stock-bot
+DOCKER_BUILDKIT=1
+
+# ===========================================
+# MISCELLANEOUS
+# ===========================================
+
+# Timezone
+TZ=UTC
+
+# Application Metadata
+APP_NAME=Stock Bot Platform
+APP_VERSION=1.0.0
+APP_DESCRIPTION=Advanced Stock Trading and Analysis Platform

.eslintignore

@@ -0,0 +1,81 @@
+# Dependencies
+node_modules/
+**/node_modules/
+
+# Build outputs
+dist/
+build/
+**/dist/
+**/build/
+.next/
+**/.next/
+
+# Cache directories
+.turbo/
+**/.turbo/
+.cache/
+**/.cache/
+
+# Environment files
+.env
+.env.local
+.env.production
+.env.staging
+**/.env*
+
+# Lock files
+package-lock.json
+yarn.lock
+bun.lockb
+pnpm-lock.yaml
+
+# Logs
+*.log
+logs/
+**/logs/
+
+# Database files
+*.db
+*.sqlite
+*.sqlite3
+
+# Temporary files
+*.tmp
+*.temp
+.DS_Store
+Thumbs.db
+
+# Generated files
+*.d.ts
+**/*.d.ts
+
+# JavaScript files (we're focusing on TypeScript)
+*.js
+*.mjs
+!.eslintrc.js
+!eslint.config.js
+
+# Scripts and config directories
+scripts/
+monitoring/
+database/
+docker-compose*.yml
+Dockerfile*
+
+# Documentation
+*.md
+docs/
+
+# Test coverage
+coverage/
+**/coverage/
+
+# IDE/Editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Angular specific
+**/.angular/
+**/src/polyfills.ts

.githooks/pre-commit

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Pre-commit hook to run Prettier
+echo "Running Prettier format check..."
+
+# Check if prettier is available
+if ! command -v prettier &> /dev/null; then
+    echo "Prettier not found. Please install it with: bun add -d prettier"
+    exit 1
+fi
+
+# Run prettier check on staged files
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(ts|js|json)$')
+
+if [[ -n "$STAGED_FILES" ]]; then
+    echo "Checking format for staged files..."
+    
+    # Check if files are formatted
+    npx prettier --check $STAGED_FILES
+    
+    if [[ $? -ne 0 ]]; then
+        echo ""
+        echo "❌ Some files are not formatted correctly."
+        echo "Please run 'npm run format' or 'bun run format' to fix formatting issues."
+        echo "Or run 'npx prettier --write $STAGED_FILES' to format just the staged files."
+        exit 1
+    fi
+    
+    echo "✅ All staged files are properly formatted."
+fi
+
+exit 0

.gitignore

@@ -11,13 +11,6 @@ build/
 *.d.ts
 
 
-# Environment variables
-.env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
 # Logs
 npm-debug.log*
 yarn-debug.log*

.prettierignore

@@ -0,0 +1,105 @@
+# Dependencies
+node_modules/
+**/node_modules/
+
+# Build outputs
+dist/
+build/
+**/dist/
+**/build/
+.next/
+**/.next/
+
+# Cache directories
+.turbo/
+**/.turbo/
+.cache/
+**/.cache/
+
+# Environment files
+.env
+.env.local
+.env.production
+.env.staging
+**/.env*
+
+# Lock files
+package-lock.json
+yarn.lock
+bun.lockb
+pnpm-lock.yaml
+bun.lock
+
+# Logs
+*.log
+logs/
+**/logs/
+
+# Database files
+*.db
+*.sqlite
+*.sqlite3
+
+# Temporary files
+*.tmp
+*.temp
+.DS_Store
+Thumbs.db
+
+# IDE/Editor files
+.vscode/settings.json
+.idea/
+*.swp
+*.swo
+
+# Angular specific
+**/.angular/
+
+# Test coverage
+coverage/
+**/coverage/
+
+# Generated documentation
+docs/generated/
+**/docs/generated/
+
+# Docker
+Dockerfile*
+docker-compose*.yml
+
+# Scripts (might have different formatting requirements)
+scripts/
+**/scripts/
+
+# Configuration files that should maintain their format
+*.md
+*.yml
+*.yaml
+*.toml
+!package.json
+!tsconfig*.json
+!.prettierrc
+
+# Git files
+.gitignore
+.dockerignore
+
+# Binary and special files
+*.ico
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.svg
+*.woff
+*.woff2
+*.ttf
+*.eot
+
+# SQL files
+*.sql
+
+# Shell scripts
+*.sh
+*.bat
+*.ps1

.prettierrc

@@ -0,0 +1,26 @@
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": true,
+  "printWidth": 100,
+  "tabWidth": 2,
+  "useTabs": false,
+  "arrowParens": "avoid",
+  "endOfLine": "lf",
+  "bracketSpacing": true,
+  "bracketSameLine": false,
+  "quoteProps": "as-needed",
+  "plugins": ["@ianvs/prettier-plugin-sort-imports"],
+  "importOrder": [
+    "^(node:.*|fs|path|crypto|url|os|util|events|stream|buffer|child_process|cluster|http|https|net|tls|dgram|dns|readline|repl|vm|zlib|querystring|punycode|assert|timers|constants)$",
+    "<THIRD_PARTY_MODULES>",
+    "^@stock-bot/(.*)$",
+    "^@/(.*)$",
+    "^\\.\\.(?!/?$)",
+    "^\\.\\./?$",
+    "^\\./(?=.*/)(?!/?$)",
+    "^\\.(?!/?$)",
+    "^\\./?$"
+  ],
+  "importOrderParserPlugins": ["typescript", "decorators-legacy"]
+}

.vscode/settings.json

@@ -20,5 +20,42 @@
   "yaml.validate": true,
   "yaml.completion": true,
   "yaml.hover": true,
-  "yaml.format.enable": true
+  "yaml.format.enable": true,
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.formatOnSave": true,
+  "editor.formatOnPaste": true,
+  "editor.codeActionsOnSave": {
+    "source.fixAll": "explicit",
+    "source.fixAll.eslint": "explicit",
+    "source.organizeImports": "explicit"
+  },
+  "eslint.enable": true,
+  "eslint.validate": [
+    "typescript",
+    "javascript"
+  ],
+  "eslint.run": "onType",
+  "eslint.workingDirectories": [
+    {
+      "mode": "auto"
+    }
+  ],
+  "[typescript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "editor.codeActionsOnSave": {
+      "source.fixAll.eslint": "explicit"
+    }
+  },
+  "[javascript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "editor.codeActionsOnSave": {
+      "source.fixAll.eslint": "explicit"
+    }
+  },
+  "[json]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[jsonc]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  }
 }

apps/dashboard/angular.json

@@ -7,7 +7,8 @@
   "newProjectRoot": "projects",
   "projects": {
     "trading-dashboard": {
-      "projectType": "application",      "schematics": {
+      "projectType": "application",
+      "schematics": {
         "@schematics/angular:component": {
           "style": "css"
         }
@@ -15,7 +16,8 @@
       "root": "",
       "sourceRoot": "src",
       "prefix": "app",
-      "architect": {        "build": {
+      "architect": {
+        "build": {
           "builder": "@angular/build:application",
           "options": {
             "browser": "src/main.ts",
@@ -27,9 +29,7 @@
                 "input": "public"
               }
             ],
-            "styles": [
-              "src/styles.css"
-            ]
+            "styles": ["src/styles.css"]
           },
           "configurations": {
             "production": {
@@ -69,7 +69,8 @@
         },
         "extract-i18n": {
           "builder": "@angular/build:extract-i18n"
-        },        "test": {
+        },
+        "test": {
           "builder": "@angular/build:karma",
           "options": {
             "tsConfig": "tsconfig.spec.json",
@@ -80,9 +81,7 @@
                 "input": "public"
               }
             ],
-            "styles": [
-              "src/styles.css"
-            ]
+            "styles": ["src/styles.css"]
           }
         }
       }

apps/dashboard/src/app/app.config.ts

@@ -1,8 +1,11 @@
-import { ApplicationConfig, provideBrowserGlobalErrorListeners, provideZonelessChangeDetection } from '@angular/core';
-import { provideRouter } from '@angular/router';
 import { provideHttpClient } from '@angular/common/http';
+import {
+  ApplicationConfig,
+  provideBrowserGlobalErrorListeners,
+  provideZonelessChangeDetection,
+} from '@angular/core';
 import { provideAnimationsAsync } from '@angular/platform-browser/animations/async';
-
+import { provideRouter } from '@angular/router';
 import { routes } from './app.routes';
 
 export const appConfig: ApplicationConfig = {
@@ -11,6 +14,6 @@ export const appConfig: ApplicationConfig = {
     provideZonelessChangeDetection(),
     provideRouter(routes),
     provideHttpClient(),
-    provideAnimationsAsync()
-  ]
+    provideAnimationsAsync(),
+  ],
 };

apps/dashboard/src/app/app.routes.ts

@@ -2,9 +2,9 @@ import { Routes } from '@angular/router';
 import { DashboardComponent } from './pages/dashboard/dashboard.component';
 import { MarketDataComponent } from './pages/market-data/market-data.component';
 import { PortfolioComponent } from './pages/portfolio/portfolio.component';
-import { StrategiesComponent } from './pages/strategies/strategies.component';
 import { RiskManagementComponent } from './pages/risk-management/risk-management.component';
 import { SettingsComponent } from './pages/settings/settings.component';
+import { StrategiesComponent } from './pages/strategies/strategies.component';
 
 export const routes: Routes = [
   { path: '', redirectTo: '/dashboard', pathMatch: 'full' },
@@ -14,5 +14,5 @@ export const routes: Routes = [
   { path: 'strategies', component: StrategiesComponent },
   { path: 'risk-management', component: RiskManagementComponent },
   { path: 'settings', component: SettingsComponent },
-  { path: '**', redirectTo: '/dashboard' }
+  { path: '**', redirectTo: '/dashboard' },
 ];

apps/dashboard/src/app/app.spec.ts

@@ -6,7 +6,7 @@ describe('App', () => {
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       imports: [App],
-      providers: [provideZonelessChangeDetection()]
+      providers: [provideZonelessChangeDetection()],
     }).compileComponents();
   });
 

apps/dashboard/src/app/app.ts

@@ -1,13 +1,13 @@
-import { Component, signal } from '@angular/core';
-import { RouterOutlet } from '@angular/router';
 import { CommonModule } from '@angular/common';
+import { Component, signal } from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatIconModule } from '@angular/material/icon';
 import { MatSidenavModule } from '@angular/material/sidenav';
 import { MatToolbarModule } from '@angular/material/toolbar';
-import { MatButtonModule } from '@angular/material/button';
-import { MatIconModule } from '@angular/material/icon';
-import { MatChipsModule } from '@angular/material/chips';
-import { SidebarComponent } from './components/sidebar/sidebar.component';
+import { RouterOutlet } from '@angular/router';
 import { NotificationsComponent } from './components/notifications/notifications';
+import { SidebarComponent } from './components/sidebar/sidebar.component';
 
 @Component({
   selector: 'app-root',
@@ -20,10 +20,10 @@ import { NotificationsComponent } from './components/notifications/notifications
     MatIconModule,
     MatChipsModule,
     SidebarComponent,
-    NotificationsComponent
+    NotificationsComponent,
   ],
   templateUrl: './app.html',
-  styleUrl: './app.css'
+  styleUrl: './app.css',
 })
 export class App {
   protected title = 'Trading Dashboard';

apps/dashboard/src/app/components/notifications/notifications.ts

@@ -1,12 +1,12 @@
-import { Component, inject } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { MatIconModule } from '@angular/material/icon';
-import { MatButtonModule } from '@angular/material/button';
+import { Component, inject } from '@angular/core';
 import { MatBadgeModule } from '@angular/material/badge';
-import { MatMenuModule } from '@angular/material/menu';
-import { MatListModule } from '@angular/material/list';
+import { MatButtonModule } from '@angular/material/button';
 import { MatDividerModule } from '@angular/material/divider';
-import { NotificationService, Notification } from '../../services/notification.service';
+import { MatIconModule } from '@angular/material/icon';
+import { MatListModule } from '@angular/material/list';
+import { MatMenuModule } from '@angular/material/menu';
+import { Notification, NotificationService } from '../../services/notification.service';
 
 @Component({
   selector: 'app-notifications',
@@ -17,10 +17,10 @@ import { NotificationService, Notification } from '../../services/notification.s
     MatBadgeModule,
     MatMenuModule,
     MatListModule,
-    MatDividerModule
+    MatDividerModule,
   ],
   templateUrl: './notifications.html',
-  styleUrl: './notifications.css'
+  styleUrl: './notifications.css',
 })
 export class NotificationsComponent {
   private notificationService = inject(NotificationService);
@@ -51,21 +51,29 @@ export class NotificationsComponent {
 
   getNotificationIcon(type: string): string {
     switch (type) {
-      case 'error': return 'error';
-      case 'warning': return 'warning';
-      case 'success': return 'check_circle';
+      case 'error':
+        return 'error';
+      case 'warning':
+        return 'warning';
+      case 'success':
+        return 'check_circle';
       case 'info':
-      default: return 'info';
+      default:
+        return 'info';
     }
   }
 
   getNotificationColor(type: string): string {
     switch (type) {
-      case 'error': return 'text-red-600';
-      case 'warning': return 'text-yellow-600';
-      case 'success': return 'text-green-600';
+      case 'error':
+        return 'text-red-600';
+      case 'warning':
+        return 'text-yellow-600';
+      case 'success':
+        return 'text-green-600';
       case 'info':
-      default: return 'text-blue-600';
+      default:
+        return 'text-blue-600';
     }
   }
 
@@ -74,11 +82,17 @@ export class NotificationsComponent {
     const diff = now.getTime() - timestamp.getTime();
     const minutes = Math.floor(diff / 60000);
 
-    if (minutes < 1) return 'Just now';
-    if (minutes < 60) return `${minutes}m ago`;
+    if (minutes < 1) {
+      return 'Just now';
+    }
+    if (minutes < 60) {
+      return `${minutes}m ago`;
+    }
 
     const hours = Math.floor(minutes / 60);
-    if (hours < 24) return `${hours}h ago`;
+    if (hours < 24) {
+      return `${hours}h ago`;
+    }
 
     const days = Math.floor(hours / 24);
     return `${days}d ago`;

apps/dashboard/src/app/components/sidebar/sidebar.component.ts

@@ -1,9 +1,9 @@
-import { Component, input, output } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { MatSidenavModule } from '@angular/material/sidenav';
+import { Component, input, output } from '@angular/core';
 import { MatButtonModule } from '@angular/material/button';
 import { MatIconModule } from '@angular/material/icon';
-import { Router, NavigationEnd } from '@angular/router';
+import { MatSidenavModule } from '@angular/material/sidenav';
+import { NavigationEnd, Router } from '@angular/router';
 import { filter } from 'rxjs/operators';
 
 export interface NavigationItem {
@@ -16,14 +16,9 @@ export interface NavigationItem {
 @Component({
   selector: 'app-sidebar',
   standalone: true,
-  imports: [
-    CommonModule,
-    MatSidenavModule,
-    MatButtonModule,
-    MatIconModule
-  ],
+  imports: [CommonModule, MatSidenavModule, MatButtonModule, MatIconModule],
   templateUrl: './sidebar.component.html',
-  styleUrl: './sidebar.component.css'
+  styleUrl: './sidebar.component.css',
 })
 export class SidebarComponent {
   opened = input<boolean>(true);
@@ -35,16 +30,16 @@ export class SidebarComponent {
     { label: 'Portfolio', icon: 'account_balance_wallet', route: '/portfolio' },
     { label: 'Strategies', icon: 'psychology', route: '/strategies' },
     { label: 'Risk Management', icon: 'security', route: '/risk-management' },
-    { label: 'Settings', icon: 'settings', route: '/settings' }
+    { label: 'Settings', icon: 'settings', route: '/settings' },
   ];
 
   constructor(private router: Router) {
     // Listen to route changes to update active state
-    this.router.events.pipe(
-      filter(event => event instanceof NavigationEnd)
-    ).subscribe((event: NavigationEnd) => {
-      this.updateActiveRoute(event.urlAfterRedirects);
-    });
+    this.router.events
+      .pipe(filter(event => event instanceof NavigationEnd))
+      .subscribe((event: NavigationEnd) => {
+        this.updateActiveRoute(event.urlAfterRedirects);
+      });
   }
 
   onNavigationClick(route: string) {

apps/dashboard/src/app/pages/dashboard/dashboard.component.ts

@@ -1,10 +1,10 @@
-import { Component, signal } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { MatCardModule } from '@angular/material/card';
-import { MatTabsModule } from '@angular/material/tabs';
+import { Component, signal } from '@angular/core';
 import { MatButtonModule } from '@angular/material/button';
+import { MatCardModule } from '@angular/material/card';
 import { MatIconModule } from '@angular/material/icon';
 import { MatTableModule } from '@angular/material/table';
+import { MatTabsModule } from '@angular/material/tabs';
 
 export interface MarketDataItem {
   symbol: string;
@@ -22,23 +22,23 @@ export interface MarketDataItem {
     MatTabsModule,
     MatButtonModule,
     MatIconModule,
-    MatTableModule
+    MatTableModule,
   ],
   templateUrl: './dashboard.component.html',
-  styleUrl: './dashboard.component.css'
+  styleUrl: './dashboard.component.css',
 })
 export class DashboardComponent {
   // Mock data for the dashboard
   protected marketData = signal<MarketDataItem[]>([
     { symbol: 'AAPL', price: 192.53, change: 2.41, changePercent: 1.27 },
-    { symbol: 'GOOGL', price: 138.21, change: -1.82, changePercent: -1.30 },
-    { symbol: 'MSFT', price: 378.85, change: 4.12, changePercent: 1.10 },
+    { symbol: 'GOOGL', price: 138.21, change: -1.82, changePercent: -1.3 },
+    { symbol: 'MSFT', price: 378.85, change: 4.12, changePercent: 1.1 },
     { symbol: 'TSLA', price: 248.42, change: -3.21, changePercent: -1.28 },
   ]);
 
-  protected portfolioValue = signal(125420.50);
-  protected dayChange = signal(2341.20);
-  protected dayChangePercent = signal(1.90);
+  protected portfolioValue = signal(125420.5);
+  protected dayChange = signal(2341.2);
+  protected dayChangePercent = signal(1.9);
 
   protected displayedColumns: string[] = ['symbol', 'price', 'change', 'changePercent'];
 }

apps/dashboard/src/app/pages/market-data/market-data.component.ts

@@ -1,15 +1,15 @@
-import { Component, signal, OnInit, OnDestroy, inject } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { MatCardModule } from '@angular/material/card';
+import { Component, inject, OnDestroy, OnInit, signal } from '@angular/core';
 import { MatButtonModule } from '@angular/material/button';
+import { MatCardModule } from '@angular/material/card';
 import { MatIconModule } from '@angular/material/icon';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { MatSnackBar, MatSnackBarModule } from '@angular/material/snack-bar';
 import { MatTableModule } from '@angular/material/table';
 import { MatTabsModule } from '@angular/material/tabs';
-import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
-import { MatSnackBarModule, MatSnackBar } from '@angular/material/snack-bar';
+import { interval, Subscription } from 'rxjs';
 import { ApiService } from '../../services/api.service';
 import { WebSocketService } from '../../services/websocket.service';
-import { interval, Subscription } from 'rxjs';
 
 export interface ExtendedMarketData {
   symbol: string;
@@ -33,10 +33,10 @@ export interface ExtendedMarketData {
     MatTableModule,
     MatTabsModule,
     MatProgressSpinnerModule,
-    MatSnackBarModule
+    MatSnackBarModule,
   ],
   templateUrl: './market-data.component.html',
-  styleUrl: './market-data.component.css'
+  styleUrl: './market-data.component.css',
 })
 export class MarketDataComponent implements OnInit, OnDestroy {
   private apiService = inject(ApiService);
@@ -48,7 +48,14 @@ export class MarketDataComponent implements OnInit, OnDestroy {
   protected currentTime = signal<string>(new Date().toLocaleTimeString());
   protected isLoading = signal<boolean>(true);
   protected error = signal<string | null>(null);
-  protected displayedColumns: string[] = ['symbol', 'price', 'change', 'changePercent', 'volume', 'marketCap'];
+  protected displayedColumns: string[] = [
+    'symbol',
+    'price',
+    'change',
+    'changePercent',
+    'volume',
+    'marketCap',
+  ];
   ngOnInit() {
     // Update time every second
     const timeSubscription = interval(1000).subscribe(() => {
@@ -61,12 +68,12 @@ export class MarketDataComponent implements OnInit, OnDestroy {
 
     // Subscribe to real-time market data updates
     const wsSubscription = this.webSocketService.getMarketDataUpdates().subscribe({
-      next: (update) => {
+      next: update => {
         this.updateMarketData(update);
       },
-      error: (err) => {
+      error: err => {
         console.error('WebSocket market data error:', err);
-      }
+      },
     });
     this.subscriptions.push(wsSubscription);
 
@@ -84,20 +91,20 @@ export class MarketDataComponent implements OnInit, OnDestroy {
   }
   private loadMarketData() {
     this.apiService.getMarketData().subscribe({
-      next: (response) => {
+      next: response => {
         // Convert MarketData to ExtendedMarketData with mock extended properties
         const extendedData: ExtendedMarketData[] = response.data.map(item => ({
           ...item,
           marketCap: this.getMockMarketCap(item.symbol),
           high52Week: item.price * 1.3, // Mock 52-week high (30% above current)
-          low52Week: item.price * 0.7   // Mock 52-week low (30% below current)
+          low52Week: item.price * 0.7, // Mock 52-week low (30% below current)
         }));
 
         this.marketData.set(extendedData);
         this.isLoading.set(false);
         this.error.set(null);
       },
-      error: (err) => {
+      error: err => {
         console.error('Failed to load market data:', err);
         this.error.set('Failed to load market data');
         this.isLoading.set(false);
@@ -105,17 +112,17 @@ export class MarketDataComponent implements OnInit, OnDestroy {
 
         // Use mock data as fallback
         this.marketData.set(this.getMockData());
-      }
+      },
     });
   }
 
   private getMockMarketCap(symbol: string): string {
     const marketCaps: { [key: string]: string } = {
-      'AAPL': '2.98T',
-      'GOOGL': '1.78T',
-      'MSFT': '3.08T',
-      'TSLA': '789.2B',
-      'AMZN': '1.59T'
+      AAPL: '2.98T',
+      GOOGL: '1.78T',
+      MSFT: '3.08T',
+      TSLA: '789.2B',
+      AMZN: '1.59T',
     };
     return marketCaps[symbol] || '1.00T';
   }
@@ -130,7 +137,7 @@ export class MarketDataComponent implements OnInit, OnDestroy {
         volume: 45230000,
         marketCap: '2.98T',
         high52Week: 199.62,
-        low52Week: 164.08
+        low52Week: 164.08,
       },
       {
         symbol: 'GOOGL',
@@ -140,7 +147,7 @@ export class MarketDataComponent implements OnInit, OnDestroy {
         volume: 12450000,
         marketCap: '1.78T',
         high52Week: 3030.93,
-        low52Week: 2193.62
+        low52Week: 2193.62,
       },
       {
         symbol: 'MSFT',
@@ -150,17 +157,17 @@ export class MarketDataComponent implements OnInit, OnDestroy {
         volume: 23180000,
         marketCap: '3.08T',
         high52Week: 468.35,
-        low52Week: 309.45
+        low52Week: 309.45,
       },
       {
         symbol: 'TSLA',
-        price: 248.50, 
+        price: 248.5,
         change: -5.21,
         changePercent: -2.05,
         volume: 89760000,
         marketCap: '789.2B',
         high52Week: 299.29,
-        low52Week: 152.37
+        low52Week: 152.37,
       },
       {
         symbol: 'AMZN',
@@ -170,8 +177,8 @@ export class MarketDataComponent implements OnInit, OnDestroy {
         volume: 34520000,
         marketCap: '1.59T',
         high52Week: 170.17,
-        low52Week: 118.35
-      }
+        low52Week: 118.35,
+      },
     ];
   }
   refreshData() {
@@ -188,7 +195,7 @@ export class MarketDataComponent implements OnInit, OnDestroy {
           price: update.price,
           change: update.change,
           changePercent: update.changePercent,
-          volume: update.volume
+          volume: update.volume,
         };
       }
       return item;

apps/dashboard/src/app/pages/portfolio/portfolio.component.ts

@@ -1,14 +1,14 @@
-import { Component, signal, OnInit, OnDestroy, inject } from '@angular/core';
 import { CommonModule } from '@angular/common';
+import { Component, inject, OnDestroy, OnInit, signal } from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
 import { MatCardModule } from '@angular/material/card';
 import { MatIconModule } from '@angular/material/icon';
-import { MatButtonModule } from '@angular/material/button';
-import { MatTableModule } from '@angular/material/table';
 import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
-import { MatSnackBarModule, MatSnackBar } from '@angular/material/snack-bar';
+import { MatSnackBar, MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatTableModule } from '@angular/material/table';
 import { MatTabsModule } from '@angular/material/tabs';
-import { ApiService } from '../../services/api.service';
 import { interval, Subscription } from 'rxjs';
+import { ApiService } from '../../services/api.service';
 
 export interface Position {
   symbol: string;
@@ -44,10 +44,10 @@ export interface PortfolioSummary {
     MatTableModule,
     MatProgressSpinnerModule,
     MatSnackBarModule,
-    MatTabsModule
+    MatTabsModule,
   ],
   templateUrl: './portfolio.component.html',
-  styleUrl: './portfolio.component.css'
+  styleUrl: './portfolio.component.css',
 })
 export class PortfolioComponent implements OnInit, OnDestroy {
   private apiService = inject(ApiService);
@@ -62,13 +62,21 @@ export class PortfolioComponent implements OnInit, OnDestroy {
     dayChange: 0,
     dayChangePercent: 0,
     cash: 0,
-    positionsCount: 0
+    positionsCount: 0,
   });
 
   protected positions = signal<Position[]>([]);
   protected isLoading = signal<boolean>(true);
   protected error = signal<string | null>(null);
-  protected displayedColumns = ['symbol', 'quantity', 'avgPrice', 'currentPrice', 'marketValue', 'unrealizedPnL', 'dayChange'];
+  protected displayedColumns = [
+    'symbol',
+    'quantity',
+    'avgPrice',
+    'currentPrice',
+    'marketValue',
+    'unrealizedPnL',
+    'dayChange',
+  ];
 
   ngOnInit() {
     this.loadPortfolioData();
@@ -93,51 +101,52 @@ export class PortfolioComponent implements OnInit, OnDestroy {
         {
           symbol: 'AAPL',
           quantity: 100,
-          avgPrice: 180.50,
+          avgPrice: 180.5,
           currentPrice: 192.53,
           marketValue: 19253,
           unrealizedPnL: 1203,
           unrealizedPnLPercent: 6.67,
           dayChange: 241,
-          dayChangePercent: 1.27
+          dayChangePercent: 1.27,
         },
         {
           symbol: 'MSFT',
           quantity: 50,
-          avgPrice: 400.00,
+          avgPrice: 400.0,
           currentPrice: 415.26,
           marketValue: 20763,
           unrealizedPnL: 763,
           unrealizedPnLPercent: 3.82,
-          dayChange: 436.50,
-          dayChangePercent: 2.15
+          dayChange: 436.5,
+          dayChangePercent: 2.15,
         },
         {
           symbol: 'GOOGL',
           quantity: 10,
-          avgPrice: 2900.00,
+          avgPrice: 2900.0,
           currentPrice: 2847.56,
-          marketValue: 28475.60,
-          unrealizedPnL: -524.40,
+          marketValue: 28475.6,
+          unrealizedPnL: -524.4,
           unrealizedPnLPercent: -1.81,
-          dayChange: -123.40,
-          dayChangePercent: -0.43
-        }
+          dayChange: -123.4,
+          dayChangePercent: -0.43,
+        },
       ];
 
       const summary: PortfolioSummary = {
         totalValue: mockPositions.reduce((sum, pos) => sum + pos.marketValue, 0) + 25000, // + cash
-        totalCost: mockPositions.reduce((sum, pos) => sum + (pos.avgPrice * pos.quantity), 0),
+        totalCost: mockPositions.reduce((sum, pos) => sum + pos.avgPrice * pos.quantity, 0),
         totalPnL: mockPositions.reduce((sum, pos) => sum + pos.unrealizedPnL, 0),
         totalPnLPercent: 0,
         dayChange: mockPositions.reduce((sum, pos) => sum + pos.dayChange, 0),
         dayChangePercent: 0,
         cash: 25000,
-        positionsCount: mockPositions.length
+        positionsCount: mockPositions.length,
       };
 
       summary.totalPnLPercent = (summary.totalPnL / summary.totalCost) * 100;
-      summary.dayChangePercent = (summary.dayChange / (summary.totalValue - summary.dayChange)) * 100;
+      summary.dayChangePercent =
+        (summary.dayChange / (summary.totalValue - summary.dayChange)) * 100;
 
       this.positions.set(mockPositions);
       this.portfolioSummary.set(summary);
@@ -152,8 +161,12 @@ export class PortfolioComponent implements OnInit, OnDestroy {
   }
 
   getPnLColor(value: number): string {
-    if (value > 0) return 'text-green-600';
-    if (value < 0) return 'text-red-600';
+    if (value > 0) {
+      return 'text-green-600';
+    }
+    if (value < 0) {
+      return 'text-red-600';
+    }
     return 'text-gray-600';
   }
 }

apps/dashboard/src/app/pages/risk-management/risk-management.component.ts

@@ -1,16 +1,16 @@
-import { Component, signal, OnInit, OnDestroy, inject } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { MatCardModule } from '@angular/material/card';
-import { MatIconModule } from '@angular/material/icon';
+import { Component, inject, OnDestroy, OnInit, signal } from '@angular/core';
+import { FormBuilder, FormGroup, ReactiveFormsModule, Validators } from '@angular/forms';
 import { MatButtonModule } from '@angular/material/button';
-import { MatTableModule } from '@angular/material/table';
+import { MatCardModule } from '@angular/material/card';
 import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
 import { MatInputModule } from '@angular/material/input';
-import { MatSnackBarModule, MatSnackBar } from '@angular/material/snack-bar';
 import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
-import { ReactiveFormsModule, FormBuilder, FormGroup, Validators } from '@angular/forms';
-import { ApiService, RiskThresholds, RiskEvaluation } from '../../services/api.service';
+import { MatSnackBar, MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatTableModule } from '@angular/material/table';
 import { interval, Subscription } from 'rxjs';
+import { ApiService, RiskEvaluation, RiskThresholds } from '../../services/api.service';
 
 @Component({
   selector: 'app-risk-management',
@@ -25,10 +25,10 @@ import { interval, Subscription } from 'rxjs';
     MatInputModule,
     MatSnackBarModule,
     MatProgressSpinnerModule,
-    ReactiveFormsModule
+    ReactiveFormsModule,
   ],
   templateUrl: './risk-management.component.html',
-  styleUrl: './risk-management.component.css'
+  styleUrl: './risk-management.component.css',
 })
 export class RiskManagementComponent implements OnInit, OnDestroy {
   private apiService = inject(ApiService);
@@ -50,7 +50,7 @@ export class RiskManagementComponent implements OnInit, OnDestroy {
       maxPositionSize: [0, [Validators.required, Validators.min(0)]],
       maxDailyLoss: [0, [Validators.required, Validators.min(0)]],
       maxPortfolioRisk: [0, [Validators.required, Validators.min(0), Validators.max(1)]],
-      volatilityLimit: [0, [Validators.required, Validators.min(0), Validators.max(1)]]
+      volatilityLimit: [0, [Validators.required, Validators.min(0), Validators.max(1)]],
     });
   }
 
@@ -71,30 +71,30 @@ export class RiskManagementComponent implements OnInit, OnDestroy {
 
   private loadRiskThresholds() {
     this.apiService.getRiskThresholds().subscribe({
-      next: (response) => {
+      next: response => {
         this.riskThresholds.set(response.data);
         this.thresholdsForm.patchValue(response.data);
         this.isLoading.set(false);
         this.error.set(null);
       },
-      error: (err) => {
+      error: err => {
         console.error('Failed to load risk thresholds:', err);
         this.error.set('Failed to load risk thresholds');
         this.isLoading.set(false);
         this.snackBar.open('Failed to load risk thresholds', 'Dismiss', { duration: 5000 });
-      }
+      },
     });
   }
 
   private loadRiskHistory() {
     this.apiService.getRiskHistory().subscribe({
-      next: (response) => {
+      next: response => {
         this.riskHistory.set(response.data);
       },
-      error: (err) => {
+      error: err => {
         console.error('Failed to load risk history:', err);
         this.snackBar.open('Failed to load risk history', 'Dismiss', { duration: 3000 });
-      }
+      },
     });
   }
 
@@ -104,16 +104,16 @@ export class RiskManagementComponent implements OnInit, OnDestroy {
       const thresholds = this.thresholdsForm.value as RiskThresholds;
 
       this.apiService.updateRiskThresholds(thresholds).subscribe({
-        next: (response) => {
+        next: response => {
           this.riskThresholds.set(response.data);
           this.isSaving.set(false);
           this.snackBar.open('Risk thresholds updated successfully', 'Dismiss', { duration: 3000 });
         },
-        error: (err) => {
+        error: err => {
           console.error('Failed to save risk thresholds:', err);
           this.isSaving.set(false);
           this.snackBar.open('Failed to save risk thresholds', 'Dismiss', { duration: 5000 });
-        }
+        },
       });
     }
   }
@@ -126,10 +126,14 @@ export class RiskManagementComponent implements OnInit, OnDestroy {
 
   getRiskLevelColor(level: string): string {
     switch (level) {
-      case 'LOW': return 'text-green-600';
-      case 'MEDIUM': return 'text-yellow-600';
-      case 'HIGH': return 'text-red-600';
-      default: return 'text-gray-600';
+      case 'LOW':
+        return 'text-green-600';
+      case 'MEDIUM':
+        return 'text-yellow-600';
+      case 'HIGH':
+        return 'text-red-600';
+      default:
+        return 'text-gray-600';
     }
   }
 }

apps/dashboard/src/app/pages/settings/settings.component.ts

@@ -1,5 +1,5 @@
-import { Component } from '@angular/core';
 import { CommonModule } from '@angular/common';
+import { Component } from '@angular/core';
 import { MatCardModule } from '@angular/material/card';
 import { MatIconModule } from '@angular/material/icon';
 
@@ -8,6 +8,6 @@ import { MatIconModule } from '@angular/material/icon';
   standalone: true,
   imports: [CommonModule, MatCardModule, MatIconModule],
   templateUrl: './settings.component.html',
-  styleUrl: './settings.component.css'
+  styleUrl: './settings.component.css',
 })
 export class SettingsComponent {}

apps/dashboard/src/app/pages/strategies/components/drawdown-chart.component.ts

@@ -1,7 +1,7 @@
-import { Component, Input, OnChanges, SimpleChanges } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { BacktestResult } from '../../../services/strategy.service';
+import { Component, Input, OnChanges, SimpleChanges } from '@angular/core';
 import { Chart, ChartOptions } from 'chart.js/auto';
+import { BacktestResult } from '../../../services/strategy.service';
 
 @Component({
   selector: 'app-drawdown-chart',
@@ -18,7 +18,7 @@ import { Chart, ChartOptions } from 'chart.js/auto';
       height: 300px;
       margin-bottom: 20px;
     }
-  `
+  `,
 })
 export class DrawdownChartComponent implements OnChanges {
   @Input() backtestResult?: BacktestResult;
@@ -40,7 +40,9 @@ export class DrawdownChartComponent implements OnChanges {
   }
 
   private renderChart(): void {
-    if (!this.chartElement || !this.backtestResult) return;
+    if (!this.chartElement || !this.backtestResult) {
+      return;
+    }
 
     // Clean up previous chart if it exists
     if (this.chart) {
@@ -63,9 +65,9 @@ export class DrawdownChartComponent implements OnChanges {
             backgroundColor: 'rgba(255, 99, 132, 0.2)',
             fill: true,
             tension: 0.3,
-            borderWidth: 2
-          }
-        ]
+            borderWidth: 2,
+          },
+        ],
       },
       options: {
         responsive: true,
@@ -75,31 +77,31 @@ export class DrawdownChartComponent implements OnChanges {
             ticks: {
               maxTicksLimit: 12,
               maxRotation: 0,
-              minRotation: 0
+              minRotation: 0,
             },
             grid: {
-              display: false
-            }
+              display: false,
+            },
           },
           y: {
             ticks: {
-              callback: function(value) {
+              callback: function (value) {
                 return (value * 100).toFixed(1) + '%';
-              }
+              },
             },
             grid: {
-              color: 'rgba(200, 200, 200, 0.2)'
+              color: 'rgba(200, 200, 200, 0.2)',
             },
             min: -0.05, // Show at least 5% drawdown for context
-            suggestedMax: 0.01
-          }
+            suggestedMax: 0.01,
+          },
         },
         plugins: {
           tooltip: {
             mode: 'index',
             intersect: false,
             callbacks: {
-              label: function(context) {
+              label: function (context) {
                 let label = context.dataset.label || '';
                 if (label) {
                   label += ': ';
@@ -108,14 +110,14 @@ export class DrawdownChartComponent implements OnChanges {
                   label += (context.parsed.y * 100).toFixed(2) + '%';
                 }
                 return label;
-              }
-            }
+              },
+            },
           },
           legend: {
             position: 'top',
-          }
-        }
-      } as ChartOptions
+          },
+        },
+      } as ChartOptions,
     });
   }
 
@@ -136,7 +138,7 @@ export class DrawdownChartComponent implements OnChanges {
     const equityCurve: number[] = [];
 
     for (const daily of sortedReturns) {
-      equity *= (1 + daily.return);
+      equity *= 1 + daily.return;
       equityCurve.push(equity);
       dates.push(new Date(daily.date));
     }
@@ -148,7 +150,7 @@ export class DrawdownChartComponent implements OnChanges {
       // Update high water mark
       hwm = Math.max(hwm, equityCurve[i]);
       // Calculate drawdown as percentage from high water mark
-      const drawdown = (equityCurve[i] / hwm) - 1;
+      const drawdown = equityCurve[i] / hwm - 1;
       drawdowns.push(drawdown);
     }
 
@@ -159,7 +161,7 @@ export class DrawdownChartComponent implements OnChanges {
     return new Date(date).toLocaleDateString('en-US', {
       month: 'short',
       day: 'numeric',
-      year: 'numeric'
+      year: 'numeric',
     });
   }
 }

apps/dashboard/src/app/pages/strategies/components/equity-chart.component.ts

@@ -1,7 +1,7 @@
-import { Component, Input, OnChanges, SimpleChanges } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { BacktestResult } from '../../../services/strategy.service';
+import { Component, Input, OnChanges, SimpleChanges } from '@angular/core';
 import { Chart, ChartOptions } from 'chart.js/auto';
+import { BacktestResult } from '../../../services/strategy.service';
 
 @Component({
   selector: 'app-equity-chart',
@@ -18,7 +18,7 @@ import { Chart, ChartOptions } from 'chart.js/auto';
       height: 400px;
       margin-bottom: 20px;
     }
-  `
+  `,
 })
 export class EquityChartComponent implements OnChanges {
   @Input() backtestResult?: BacktestResult;
@@ -40,7 +40,9 @@ export class EquityChartComponent implements OnChanges {
   }
 
   private renderChart(): void {
-    if (!this.chartElement || !this.backtestResult) return;
+    if (!this.chartElement || !this.backtestResult) {
+      return;
+    }
 
     // Clean up previous chart if it exists
     if (this.chart) {
@@ -63,7 +65,7 @@ export class EquityChartComponent implements OnChanges {
             backgroundColor: 'rgba(75, 192, 192, 0.2)',
             tension: 0.3,
             borderWidth: 2,
-            fill: true
+            fill: true,
           },
           {
             label: 'Benchmark',
@@ -73,9 +75,9 @@ export class EquityChartComponent implements OnChanges {
             borderDash: [5, 5],
             tension: 0.3,
             borderWidth: 1,
-            fill: false
-          }
-        ]
+            fill: false,
+          },
+        ],
       },
       options: {
         responsive: true,
@@ -85,46 +87,48 @@ export class EquityChartComponent implements OnChanges {
             ticks: {
               maxTicksLimit: 12,
               maxRotation: 0,
-              minRotation: 0
+              minRotation: 0,
             },
             grid: {
-              display: false
-            }
+              display: false,
+            },
           },
           y: {
             ticks: {
-              callback: function(value) {
+              callback: function (value) {
                 return '$' + value.toLocaleString();
-              }
+              },
             },
             grid: {
-              color: 'rgba(200, 200, 200, 0.2)'
-            }
-          }
+              color: 'rgba(200, 200, 200, 0.2)',
+            },
+          },
         },
         plugins: {
           tooltip: {
             mode: 'index',
             intersect: false,
             callbacks: {
-              label: function(context) {
+              label: function (context) {
                 let label = context.dataset.label || '';
                 if (label) {
                   label += ': ';
                 }
                 if (context.parsed.y !== null) {
-                  label += new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' })
-                    .format(context.parsed.y);
+                  label += new Intl.NumberFormat('en-US', {
+                    style: 'currency',
+                    currency: 'USD',
+                  }).format(context.parsed.y);
                 }
                 return label;
-              }
-            }
+              },
+            },
           },
           legend: {
             position: 'top',
-          }
-        }
-      } as ChartOptions
+          },
+        },
+      } as ChartOptions,
     });
   }
 
@@ -165,7 +169,7 @@ export class EquityChartComponent implements OnChanges {
     return new Date(date).toLocaleDateString('en-US', {
       month: 'short',
       day: 'numeric',
-      year: 'numeric'
+      year: 'numeric',
     });
   }
 }

apps/dashboard/src/app/pages/strategies/components/performance-metrics.component.ts

@@ -1,21 +1,15 @@
-import { Component, Input } from '@angular/core';
 import { CommonModule } from '@angular/common';
+import { Component, Input } from '@angular/core';
 import { MatCardModule } from '@angular/material/card';
-import { MatGridListModule } from '@angular/material/grid-list';
 import { MatDividerModule } from '@angular/material/divider';
+import { MatGridListModule } from '@angular/material/grid-list';
 import { MatTooltipModule } from '@angular/material/tooltip';
 import { BacktestResult } from '../../../services/strategy.service';
 
 @Component({
   selector: 'app-performance-metrics',
   standalone: true,
-  imports: [
-    CommonModule,
-    MatCardModule,
-    MatGridListModule,
-    MatDividerModule,
-    MatTooltipModule
-  ],
+  imports: [CommonModule, MatCardModule, MatGridListModule, MatDividerModule, MatTooltipModule],
   template: `
     <mat-card class="metrics-card">
       <mat-card-header>
@@ -27,21 +21,34 @@ import { BacktestResult } from '../../../services/strategy.service';
             <h3>Returns</h3>
             <div class="metrics-row">
               <div class="metric">
-                <div class="metric-name" matTooltip="Total return over the backtest period">Total Return</div>
-                <div class="metric-value" [ngClass]="getReturnClass(backtestResult?.totalReturn || 0)">
-                  {{formatPercent(backtestResult?.totalReturn || 0)}}
+                <div class="metric-name" matTooltip="Total return over the backtest period">
+                  Total Return
+                </div>
+                <div
+                  class="metric-value"
+                  [ngClass]="getReturnClass(backtestResult?.totalReturn || 0)"
+                >
+                  {{ formatPercent(backtestResult?.totalReturn || 0) }}
                 </div>
               </div>
               <div class="metric">
-                <div class="metric-name" matTooltip="Annualized return (adjusted for the backtest duration)">Annualized Return</div>
-                <div class="metric-value" [ngClass]="getReturnClass(backtestResult?.annualizedReturn || 0)">
-                  {{formatPercent(backtestResult?.annualizedReturn || 0)}}
+                <div
+                  class="metric-name"
+                  matTooltip="Annualized return (adjusted for the backtest duration)"
+                >
+                  Annualized Return
+                </div>
+                <div
+                  class="metric-value"
+                  [ngClass]="getReturnClass(backtestResult?.annualizedReturn || 0)"
+                >
+                  {{ formatPercent(backtestResult?.annualizedReturn || 0) }}
                 </div>
               </div>
               <div class="metric">
                 <div class="metric-name" matTooltip="Compound Annual Growth Rate">CAGR</div>
                 <div class="metric-value" [ngClass]="getReturnClass(backtestResult?.cagr || 0)">
-                  {{formatPercent(backtestResult?.cagr || 0)}}
+                  {{ formatPercent(backtestResult?.cagr || 0) }}
                 </div>
               </div>
             </div>
@@ -53,27 +60,38 @@ import { BacktestResult } from '../../../services/strategy.service';
             <h3>Risk Metrics</h3>
             <div class="metrics-row">
               <div class="metric">
-                <div class="metric-name" matTooltip="Maximum peak-to-valley drawdown">Max Drawdown</div>
+                <div class="metric-name" matTooltip="Maximum peak-to-valley drawdown">
+                  Max Drawdown
+                </div>
                 <div class="metric-value negative">
-                  {{formatPercent(backtestResult?.maxDrawdown || 0)}}
+                  {{ formatPercent(backtestResult?.maxDrawdown || 0) }}
                 </div>
               </div>
               <div class="metric">
-                <div class="metric-name" matTooltip="Number of days in the worst drawdown">Max DD Duration</div>
+                <div class="metric-name" matTooltip="Number of days in the worst drawdown">
+                  Max DD Duration
+                </div>
                 <div class="metric-value">
-                  {{formatDays(backtestResult?.maxDrawdownDuration || 0)}}
+                  {{ formatDays(backtestResult?.maxDrawdownDuration || 0) }}
                 </div>
               </div>
               <div class="metric">
-                <div class="metric-name" matTooltip="Annualized standard deviation of returns">Volatility</div>
+                <div class="metric-name" matTooltip="Annualized standard deviation of returns">
+                  Volatility
+                </div>
                 <div class="metric-value">
-                  {{formatPercent(backtestResult?.volatility || 0)}}
+                  {{ formatPercent(backtestResult?.volatility || 0) }}
                 </div>
               </div>
               <div class="metric">
-                <div class="metric-name" matTooltip="Square root of the sum of the squares of drawdowns">Ulcer Index</div>
+                <div
+                  class="metric-name"
+                  matTooltip="Square root of the sum of the squares of drawdowns"
+                >
+                  Ulcer Index
+                </div>
                 <div class="metric-value">
-                  {{(backtestResult?.ulcerIndex || 0).toFixed(4)}}
+                  {{ (backtestResult?.ulcerIndex || 0).toFixed(4) }}
                 </div>
               </div>
             </div>
@@ -85,27 +103,50 @@ import { BacktestResult } from '../../../services/strategy.service';
             <h3>Risk-Adjusted Returns</h3>
             <div class="metrics-row">
               <div class="metric">
-                <div class="metric-name" matTooltip="Excess return per unit of risk">Sharpe Ratio</div>
-                <div class="metric-value" [ngClass]="getRatioClass(backtestResult?.sharpeRatio || 0)">
-                  {{(backtestResult?.sharpeRatio || 0).toFixed(2)}}
+                <div class="metric-name" matTooltip="Excess return per unit of risk">
+                  Sharpe Ratio
+                </div>
+                <div
+                  class="metric-value"
+                  [ngClass]="getRatioClass(backtestResult?.sharpeRatio || 0)"
+                >
+                  {{ (backtestResult?.sharpeRatio || 0).toFixed(2) }}
                 </div>
               </div>
               <div class="metric">
-                <div class="metric-name" matTooltip="Return per unit of downside risk">Sortino Ratio</div>
-                <div class="metric-value" [ngClass]="getRatioClass(backtestResult?.sortinoRatio || 0)">
-                  {{(backtestResult?.sortinoRatio || 0).toFixed(2)}}
+                <div class="metric-name" matTooltip="Return per unit of downside risk">
+                  Sortino Ratio
+                </div>
+                <div
+                  class="metric-value"
+                  [ngClass]="getRatioClass(backtestResult?.sortinoRatio || 0)"
+                >
+                  {{ (backtestResult?.sortinoRatio || 0).toFixed(2) }}
                 </div>
               </div>
               <div class="metric">
-                <div class="metric-name" matTooltip="Return per unit of max drawdown">Calmar Ratio</div>
-                <div class="metric-value" [ngClass]="getRatioClass(backtestResult?.calmarRatio || 0)">
-                  {{(backtestResult?.calmarRatio || 0).toFixed(2)}}
+                <div class="metric-name" matTooltip="Return per unit of max drawdown">
+                  Calmar Ratio
+                </div>
+                <div
+                  class="metric-value"
+                  [ngClass]="getRatioClass(backtestResult?.calmarRatio || 0)"
+                >
+                  {{ (backtestResult?.calmarRatio || 0).toFixed(2) }}
                 </div>
               </div>
               <div class="metric">
-                <div class="metric-name" matTooltip="Probability-weighted ratio of gains vs. losses">Omega Ratio</div>
-                <div class="metric-value" [ngClass]="getRatioClass(backtestResult?.omegaRatio || 0)">
-                  {{(backtestResult?.omegaRatio || 0).toFixed(2)}}
+                <div
+                  class="metric-name"
+                  matTooltip="Probability-weighted ratio of gains vs. losses"
+                >
+                  Omega Ratio
+                </div>
+                <div
+                  class="metric-value"
+                  [ngClass]="getRatioClass(backtestResult?.omegaRatio || 0)"
+                >
+                  {{ (backtestResult?.omegaRatio || 0).toFixed(2) }}
                 </div>
               </div>
             </div>
@@ -119,31 +160,36 @@ import { BacktestResult } from '../../../services/strategy.service';
               <div class="metric">
                 <div class="metric-name" matTooltip="Total number of trades">Total Trades</div>
                 <div class="metric-value">
-                  {{backtestResult?.totalTrades || 0}}
+                  {{ backtestResult?.totalTrades || 0 }}
                 </div>
               </div>
               <div class="metric">
                 <div class="metric-name" matTooltip="Percentage of winning trades">Win Rate</div>
                 <div class="metric-value" [ngClass]="getWinRateClass(backtestResult?.winRate || 0)">
-                  {{formatPercent(backtestResult?.winRate || 0)}}
+                  {{ formatPercent(backtestResult?.winRate || 0) }}
                 </div>
               </div>
               <div class="metric">
                 <div class="metric-name" matTooltip="Average profit of winning trades">Avg Win</div>
                 <div class="metric-value positive">
-                  {{formatPercent(backtestResult?.averageWinningTrade || 0)}}
+                  {{ formatPercent(backtestResult?.averageWinningTrade || 0) }}
                 </div>
               </div>
               <div class="metric">
                 <div class="metric-name" matTooltip="Average loss of losing trades">Avg Loss</div>
                 <div class="metric-value negative">
-                  {{formatPercent(backtestResult?.averageLosingTrade || 0)}}
+                  {{ formatPercent(backtestResult?.averageLosingTrade || 0) }}
                 </div>
               </div>
               <div class="metric">
-                <div class="metric-name" matTooltip="Ratio of total gains to total losses">Profit Factor</div>
-                <div class="metric-value" [ngClass]="getProfitFactorClass(backtestResult?.profitFactor || 0)">
-                  {{(backtestResult?.profitFactor || 0).toFixed(2)}}
+                <div class="metric-name" matTooltip="Ratio of total gains to total losses">
+                  Profit Factor
+                </div>
+                <div
+                  class="metric-value"
+                  [ngClass]="getProfitFactorClass(backtestResult?.profitFactor || 0)"
+                >
+                  {{ (backtestResult?.profitFactor || 0).toFixed(2) }}
                 </div>
               </div>
             </div>
@@ -198,21 +244,21 @@ import { BacktestResult } from '../../../services/strategy.service';
     }
 
     .positive {
-      color: #4CAF50;
+      color: #4caf50;
     }
 
     .negative {
-      color: #F44336;
+      color: #f44336;
     }
 
     .neutral {
-      color: #FFA000;
+      color: #ffa000;
     }
 
     mat-divider {
       margin: 8px 0;
     }
-  `
+  `,
 })
 export class PerformanceMetricsComponent {
   @Input() backtestResult?: BacktestResult;
@@ -222,7 +268,7 @@ export class PerformanceMetricsComponent {
     return new Intl.NumberFormat('en-US', {
       style: 'percent',
       minimumFractionDigits: 2,
-      maximumFractionDigits: 2
+      maximumFractionDigits: 2,
     }).format(value);
   }
 
@@ -232,27 +278,45 @@ export class PerformanceMetricsComponent {
 
   // Conditional classes
   getReturnClass(value: number): string {
-    if (value > 0) return 'positive';
-    if (value < 0) return 'negative';
+    if (value > 0) {
+      return 'positive';
+    }
+    if (value < 0) {
+      return 'negative';
+    }
     return '';
   }
 
   getRatioClass(value: number): string {
-    if (value >= 1.5) return 'positive';
-    if (value >= 1) return 'neutral';
-    if (value < 0) return 'negative';
+    if (value >= 1.5) {
+      return 'positive';
+    }
+    if (value >= 1) {
+      return 'neutral';
+    }
+    if (value < 0) {
+      return 'negative';
+    }
     return '';
   }
 
   getWinRateClass(value: number): string {
-    if (value >= 0.55) return 'positive';
-    if (value >= 0.45) return 'neutral';
+    if (value >= 0.55) {
+      return 'positive';
+    }
+    if (value >= 0.45) {
+      return 'neutral';
+    }
     return 'negative';
   }
 
   getProfitFactorClass(value: number): string {
-    if (value >= 1.5) return 'positive';
-    if (value >= 1) return 'neutral';
+    if (value >= 1.5) {
+      return 'positive';
+    }
+    if (value >= 1) {
+      return 'neutral';
+    }
     return 'negative';
   }
 }

apps/dashboard/src/app/pages/strategies/components/trades-table.component.ts

@@ -1,10 +1,10 @@
-import { Component, Input } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { MatTableModule } from '@angular/material/table';
-import { MatSortModule, Sort } from '@angular/material/sort';
-import { MatPaginatorModule, PageEvent } from '@angular/material/paginator';
+import { Component, Input } from '@angular/core';
 import { MatCardModule } from '@angular/material/card';
 import { MatIconModule } from '@angular/material/icon';
+import { MatPaginatorModule, PageEvent } from '@angular/material/paginator';
+import { MatSortModule, Sort } from '@angular/material/sort';
+import { MatTableModule } from '@angular/material/table';
 import { BacktestResult } from '../../../services/strategy.service';
 
 @Component({
@@ -16,7 +16,7 @@ import { BacktestResult } from '../../../services/strategy.service';
     MatSortModule,
     MatPaginatorModule,
     MatCardModule,
-    MatIconModule
+    MatIconModule,
   ],
   template: `
     <mat-card class="trades-card">
@@ -24,64 +24,75 @@ import { BacktestResult } from '../../../services/strategy.service';
         <mat-card-title>Trades</mat-card-title>
       </mat-card-header>
       <mat-card-content>
-        <table mat-table [dataSource]="displayedTrades" matSort (matSortChange)="sortData($event)" class="trades-table">
-          
+        <table
+          mat-table
+          [dataSource]="displayedTrades"
+          matSort
+          (matSortChange)="sortData($event)"
+          class="trades-table"
+        >
           <!-- Symbol Column -->
           <ng-container matColumnDef="symbol">
-            <th mat-header-cell *matHeaderCellDef mat-sort-header> Symbol </th>
-            <td mat-cell *matCellDef="let trade"> {{trade.symbol}} </td>
+            <th mat-header-cell *matHeaderCellDef mat-sort-header>Symbol</th>
+            <td mat-cell *matCellDef="let trade">{{ trade.symbol }}</td>
           </ng-container>
 
           <!-- Entry Date Column -->
           <ng-container matColumnDef="entryTime">
-            <th mat-header-cell *matHeaderCellDef mat-sort-header> Entry Time </th>
-            <td mat-cell *matCellDef="let trade"> {{formatDate(trade.entryTime)}} </td>
+            <th mat-header-cell *matHeaderCellDef mat-sort-header>Entry Time</th>
+            <td mat-cell *matCellDef="let trade">{{ formatDate(trade.entryTime) }}</td>
           </ng-container>
 
           <!-- Entry Price Column -->
           <ng-container matColumnDef="entryPrice">
-            <th mat-header-cell *matHeaderCellDef mat-sort-header> Entry Price </th>
-            <td mat-cell *matCellDef="let trade"> {{formatCurrency(trade.entryPrice)}} </td>
+            <th mat-header-cell *matHeaderCellDef mat-sort-header>Entry Price</th>
+            <td mat-cell *matCellDef="let trade">{{ formatCurrency(trade.entryPrice) }}</td>
           </ng-container>
 
           <!-- Exit Date Column -->
           <ng-container matColumnDef="exitTime">
-            <th mat-header-cell *matHeaderCellDef mat-sort-header> Exit Time </th>
-            <td mat-cell *matCellDef="let trade"> {{formatDate(trade.exitTime)}} </td>
+            <th mat-header-cell *matHeaderCellDef mat-sort-header>Exit Time</th>
+            <td mat-cell *matCellDef="let trade">{{ formatDate(trade.exitTime) }}</td>
           </ng-container>
 
           <!-- Exit Price Column -->
           <ng-container matColumnDef="exitPrice">
-            <th mat-header-cell *matHeaderCellDef mat-sort-header> Exit Price </th>
-            <td mat-cell *matCellDef="let trade"> {{formatCurrency(trade.exitPrice)}} </td>
+            <th mat-header-cell *matHeaderCellDef mat-sort-header>Exit Price</th>
+            <td mat-cell *matCellDef="let trade">{{ formatCurrency(trade.exitPrice) }}</td>
           </ng-container>
 
           <!-- Quantity Column -->
           <ng-container matColumnDef="quantity">
-            <th mat-header-cell *matHeaderCellDef mat-sort-header> Quantity </th>
-            <td mat-cell *matCellDef="let trade"> {{trade.quantity}} </td>
+            <th mat-header-cell *matHeaderCellDef mat-sort-header>Quantity</th>
+            <td mat-cell *matCellDef="let trade">{{ trade.quantity }}</td>
           </ng-container>
 
           <!-- P&L Column -->
           <ng-container matColumnDef="pnl">
-            <th mat-header-cell *matHeaderCellDef mat-sort-header> P&L </th>
-            <td mat-cell *matCellDef="let trade" 
-                [ngClass]="{'positive': trade.pnl > 0, 'negative': trade.pnl < 0}"> 
-                {{formatCurrency(trade.pnl)}} 
+            <th mat-header-cell *matHeaderCellDef mat-sort-header>P&L</th>
+            <td
+              mat-cell
+              *matCellDef="let trade"
+              [ngClass]="{ positive: trade.pnl > 0, negative: trade.pnl < 0 }"
+            >
+              {{ formatCurrency(trade.pnl) }}
             </td>
           </ng-container>
 
           <!-- P&L Percent Column -->
           <ng-container matColumnDef="pnlPercent">
-            <th mat-header-cell *matHeaderCellDef mat-sort-header> P&L % </th>
-            <td mat-cell *matCellDef="let trade" 
-                [ngClass]="{'positive': trade.pnlPercent > 0, 'negative': trade.pnlPercent < 0}">
-                {{formatPercent(trade.pnlPercent)}}
+            <th mat-header-cell *matHeaderCellDef mat-sort-header>P&L %</th>
+            <td
+              mat-cell
+              *matCellDef="let trade"
+              [ngClass]="{ positive: trade.pnlPercent > 0, negative: trade.pnlPercent < 0 }"
+            >
+              {{ formatPercent(trade.pnlPercent) }}
             </td>
           </ng-container>
 
           <tr mat-header-row *matHeaderRowDef="displayedColumns"></tr>
-          <tr mat-row *matRowDef="let row; columns: displayedColumns;"></tr>
+          <tr mat-row *matRowDef="let row; columns: displayedColumns"></tr>
         </table>
 
         <mat-paginator
@@ -89,7 +100,8 @@ import { BacktestResult } from '../../../services/strategy.service';
           [pageSize]="pageSize"
           [pageSizeOptions]="[5, 10, 25, 50]"
           (page)="pageChange($event)"
-          aria-label="Select page">
+          aria-label="Select page"
+        >
         </mat-paginator>
       </mat-card-content>
     </mat-card>
@@ -104,23 +116,24 @@ import { BacktestResult } from '../../../services/strategy.service';
       border-collapse: collapse;
     }
 
-    .mat-column-pnl, .mat-column-pnlPercent {
+    .mat-column-pnl,
+    .mat-column-pnlPercent {
       text-align: right;
       font-weight: 500;
     }
 
     .positive {
-      color: #4CAF50;
+      color: #4caf50;
     }
 
     .negative {
-      color: #F44336;
+      color: #f44336;
     }
 
     .mat-mdc-row:hover {
       background-color: rgba(0, 0, 0, 0.04);
     }
-  `
+  `,
 })
 export class TradesTableComponent {
   @Input() set backtestResult(value: BacktestResult | undefined) {
@@ -138,8 +151,14 @@ export class TradesTableComponent {
 
   // Table configuration
   displayedColumns: string[] = [
-    'symbol', 'entryTime', 'entryPrice', 'exitTime', 
-    'exitPrice', 'quantity', 'pnl', 'pnlPercent'
+    'symbol',
+    'entryTime',
+    'entryPrice',
+    'exitTime',
+    'exitPrice',
+    'quantity',
+    'pnl',
+    'pnlPercent',
   ];
 
   // Pagination
@@ -160,20 +179,39 @@ export class TradesTableComponent {
 
     const data = this._backtestResult?.trades.slice() || [];
 
-    this.displayedTrades = data.sort((a, b) => {
-      const isAsc = sort.direction === 'asc';
-      switch (sort.active) {
-        case 'symbol': return this.compare(a.symbol, b.symbol, isAsc);
-        case 'entryTime': return this.compare(new Date(a.entryTime).getTime(), new Date(b.entryTime).getTime(), isAsc);
-        case 'entryPrice': return this.compare(a.entryPrice, b.entryPrice, isAsc);
-        case 'exitTime': return this.compare(new Date(a.exitTime).getTime(), new Date(b.exitTime).getTime(), isAsc);
-        case 'exitPrice': return this.compare(a.exitPrice, b.exitPrice, isAsc);
-        case 'quantity': return this.compare(a.quantity, b.quantity, isAsc);
-        case 'pnl': return this.compare(a.pnl, b.pnl, isAsc);
-        case 'pnlPercent': return this.compare(a.pnlPercent, b.pnlPercent, isAsc);
-        default: return 0;
-      }
-    }).slice(this.currentPage * this.pageSize, (this.currentPage + 1) * this.pageSize);
+    this.displayedTrades = data
+      .sort((a, b) => {
+        const isAsc = sort.direction === 'asc';
+        switch (sort.active) {
+          case 'symbol':
+            return this.compare(a.symbol, b.symbol, isAsc);
+          case 'entryTime':
+            return this.compare(
+              new Date(a.entryTime).getTime(),
+              new Date(b.entryTime).getTime(),
+              isAsc
+            );
+          case 'entryPrice':
+            return this.compare(a.entryPrice, b.entryPrice, isAsc);
+          case 'exitTime':
+            return this.compare(
+              new Date(a.exitTime).getTime(),
+              new Date(b.exitTime).getTime(),
+              isAsc
+            );
+          case 'exitPrice':
+            return this.compare(a.exitPrice, b.exitPrice, isAsc);
+          case 'quantity':
+            return this.compare(a.quantity, b.quantity, isAsc);
+          case 'pnl':
+            return this.compare(a.pnl, b.pnl, isAsc);
+          case 'pnlPercent':
+            return this.compare(a.pnlPercent, b.pnlPercent, isAsc);
+          default:
+            return 0;
+        }
+      })
+      .slice(this.currentPage * this.pageSize, (this.currentPage + 1) * this.pageSize);
   }
 
   // Handle page changes
@@ -211,7 +249,7 @@ export class TradesTableComponent {
     return new Intl.NumberFormat('en-US', {
       style: 'percent',
       minimumFractionDigits: 2,
-      maximumFractionDigits: 2
+      maximumFractionDigits: 2,
     }).format(value);
   }
 

apps/dashboard/src/app/pages/strategies/dialogs/backtest-dialog.component.ts

@@ -1,28 +1,23 @@
-import { Component, Inject, OnInit } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { 
-  FormBuilder, 
-  FormGroup, 
-  ReactiveFormsModule, 
-  Validators 
-} from '@angular/forms';
+import { Component, Inject, OnInit } from '@angular/core';
+import { FormBuilder, FormGroup, ReactiveFormsModule, Validators } from '@angular/forms';
 import { MatButtonModule } from '@angular/material/button';
-import { MatDialogModule, MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';
-import { MatFormFieldModule } from '@angular/material/form-field';
-import { MatInputModule } from '@angular/material/input';
-import { MatSelectModule } from '@angular/material/select';
-import { MatDatepickerModule } from '@angular/material/datepicker';
-import { MatNativeDateModule } from '@angular/material/core';
-import { MatProgressBarModule } from '@angular/material/progress-bar';
-import { MatTabsModule } from '@angular/material/tabs';
 import { MatChipsModule } from '@angular/material/chips';
+import { MatNativeDateModule } from '@angular/material/core';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MAT_DIALOG_DATA, MatDialogModule, MatDialogRef } from '@angular/material/dialog';
+import { MatFormFieldModule } from '@angular/material/form-field';
 import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatSelectModule } from '@angular/material/select';
 import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatTabsModule } from '@angular/material/tabs';
 import {
   BacktestRequest,
   BacktestResult,
   StrategyService,
-  TradingStrategy 
+  TradingStrategy,
 } from '../../../services/strategy.service';
 
 @Component({
@@ -42,15 +37,25 @@ import {
     MatTabsModule,
     MatChipsModule,
     MatIconModule,
-    MatSlideToggleModule
+    MatSlideToggleModule,
   ],
   templateUrl: './backtest-dialog.component.html',
-  styleUrl: './backtest-dialog.component.css'
+  styleUrl: './backtest-dialog.component.css',
 })
 export class BacktestDialogComponent implements OnInit {
   backtestForm: FormGroup;
   strategyTypes: string[] = [];
-  availableSymbols: string[] = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'META', 'NVDA', 'SPY', 'QQQ'];
+  availableSymbols: string[] = [
+    'AAPL',
+    'MSFT',
+    'GOOGL',
+    'AMZN',
+    'TSLA',
+    'META',
+    'NVDA',
+    'SPY',
+    'QQQ',
+  ];
   selectedSymbols: string[] = [];
   parameters: Record<string, any> = {};
   isRunning: boolean = false;
@@ -65,22 +70,25 @@ export class BacktestDialogComponent implements OnInit {
     // Initialize form with defaults
     this.backtestForm = this.fb.group({
       strategyType: ['', [Validators.required]],
-      startDate: [new Date(new Date().setFullYear(new Date().getFullYear() - 1)), [Validators.required]],
+      startDate: [
+        new Date(new Date().setFullYear(new Date().getFullYear() - 1)),
+        [Validators.required],
+      ],
       endDate: [new Date(), [Validators.required]],
       initialCapital: [100000, [Validators.required, Validators.min(1000)]],
       dataResolution: ['1d', [Validators.required]],
       commission: [0.001, [Validators.required, Validators.min(0), Validators.max(0.1)]],
       slippage: [0.0005, [Validators.required, Validators.min(0), Validators.max(0.1)]],
-      mode: ['event', [Validators.required]]
+      mode: ['event', [Validators.required]],
     });
 
     // If strategy is provided, pre-populate the form
     if (data) {
       this.selectedSymbols = [...data.symbols];
       this.backtestForm.patchValue({
-        strategyType: data.type
+        strategyType: data.type,
       });
-      this.parameters = {...data.parameters};
+      this.parameters = { ...data.parameters };
     }
   }
 
@@ -90,7 +98,7 @@ export class BacktestDialogComponent implements OnInit {
 
   loadStrategyTypes(): void {
     this.strategyService.getStrategyTypes().subscribe({
-      next: (response) => {
+      next: response => {
         if (response.success) {
           this.strategyTypes = response.data;
 
@@ -100,38 +108,40 @@ export class BacktestDialogComponent implements OnInit {
           }
         }
       },
-      error: (error) => {
+      error: error => {
         console.error('Error loading strategy types:', error);
         this.strategyTypes = ['MOVING_AVERAGE_CROSSOVER', 'MEAN_REVERSION', 'CUSTOM'];
-      }
+      },
     });
   }
 
   onStrategyTypeChange(type: string): void {
     // Get default parameters for this strategy type
     this.strategyService.getStrategyParameters(type).subscribe({
-      next: (response) => {
+      next: response => {
         if (response.success) {
           // If strategy is provided, merge default with existing
           if (this.data) {
             this.parameters = {
               ...response.data,
-              ...this.data.parameters
+              ...this.data.parameters,
             };
           } else {
             this.parameters = response.data;
           }
         }
       },
-      error: (error) => {
+      error: error => {
         console.error('Error loading parameters:', error);
         this.parameters = {};
-      }
+      },
     });
   }
 
   addSymbol(symbol: string): void {
-    if (!symbol || this.selectedSymbols.includes(symbol)) return;
+    if (!symbol || this.selectedSymbols.includes(symbol)) {
+      return;
+    }
     this.selectedSymbols.push(symbol);
   }
 
@@ -160,22 +170,22 @@ export class BacktestDialogComponent implements OnInit {
       dataResolution: formValue.dataResolution,
       commission: formValue.commission,
       slippage: formValue.slippage,
-      mode: formValue.mode
+      mode: formValue.mode,
     };
 
     this.isRunning = true;
 
     this.strategyService.runBacktest(backtestRequest).subscribe({
-      next: (response) => {
+      next: response => {
         this.isRunning = false;
         if (response.success) {
           this.backtestResult = response.data;
         }
       },
-      error: (error) => {
+      error: error => {
         this.isRunning = false;
         console.error('Backtest error:', error);
-      }
+      },
     });
   }
 

apps/dashboard/src/app/pages/strategies/dialogs/strategy-dialog.component.ts

@@ -1,24 +1,16 @@
-import { Component, Inject, OnInit } from '@angular/core';
+import { COMMA, ENTER } from '@angular/cdk/keycodes';
 import { CommonModule } from '@angular/common';
-import { 
-  FormBuilder, 
-  FormGroup, 
-  ReactiveFormsModule, 
-  Validators 
-} from '@angular/forms';
+import { Component, Inject, OnInit } from '@angular/core';
+import { FormBuilder, FormGroup, ReactiveFormsModule, Validators } from '@angular/forms';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
 import { MatButtonModule } from '@angular/material/button';
-import { MatDialogModule, MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';
+import { MatChipsModule } from '@angular/material/chips';
+import { MAT_DIALOG_DATA, MatDialogModule, MatDialogRef } from '@angular/material/dialog';
 import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
 import { MatInputModule } from '@angular/material/input';
 import { MatSelectModule } from '@angular/material/select';
-import { MatChipsModule } from '@angular/material/chips';
-import { MatIconModule } from '@angular/material/icon';
-import { COMMA, ENTER } from '@angular/cdk/keycodes';
-import { MatAutocompleteModule } from '@angular/material/autocomplete';
-import { 
-  StrategyService, 
-  TradingStrategy 
-} from '../../../services/strategy.service';
+import { StrategyService, TradingStrategy } from '../../../services/strategy.service';
 
 @Component({
   selector: 'app-strategy-dialog',
@@ -33,16 +25,26 @@ import {
     MatSelectModule,
     MatChipsModule,
     MatIconModule,
-    MatAutocompleteModule
+    MatAutocompleteModule,
   ],
   templateUrl: './strategy-dialog.component.html',
-  styleUrl: './strategy-dialog.component.css'
+  styleUrl: './strategy-dialog.component.css',
 })
 export class StrategyDialogComponent implements OnInit {
   strategyForm: FormGroup;
   isEditMode: boolean = false;
   strategyTypes: string[] = [];
-  availableSymbols: string[] = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'META', 'NVDA', 'SPY', 'QQQ'];
+  availableSymbols: string[] = [
+    'AAPL',
+    'MSFT',
+    'GOOGL',
+    'AMZN',
+    'TSLA',
+    'META',
+    'NVDA',
+    'SPY',
+    'QQQ',
+  ];
   selectedSymbols: string[] = [];
   separatorKeysCodes: number[] = [ENTER, COMMA];
   parameters: Record<string, any> = {};
@@ -67,9 +69,9 @@ export class StrategyDialogComponent implements OnInit {
       this.strategyForm.patchValue({
         name: data.name,
         description: data.description,
-        type: data.type
+        type: data.type,
       });
-      this.parameters = {...data.parameters};
+      this.parameters = { ...data.parameters };
     }
   }
 
@@ -81,7 +83,7 @@ export class StrategyDialogComponent implements OnInit {
   loadStrategyTypes(): void {
     // In a real implementation, this would call the API
     this.strategyService.getStrategyTypes().subscribe({
-      next: (response) => {
+      next: response => {
         if (response.success) {
           this.strategyTypes = response.data;
 
@@ -91,40 +93,42 @@ export class StrategyDialogComponent implements OnInit {
           }
         }
       },
-      error: (error) => {
+      error: error => {
         console.error('Error loading strategy types:', error);
         // Fallback to hardcoded types
         this.strategyTypes = ['MOVING_AVERAGE_CROSSOVER', 'MEAN_REVERSION', 'CUSTOM'];
-      }
+      },
     });
   }
 
   onStrategyTypeChange(type: string): void {
     // Get default parameters for this strategy type
     this.strategyService.getStrategyParameters(type).subscribe({
-      next: (response) => {
+      next: response => {
         if (response.success) {
           // If editing, merge default with existing
           if (this.isEditMode && this.data) {
             this.parameters = {
               ...response.data,
-              ...this.data.parameters
+              ...this.data.parameters,
             };
           } else {
             this.parameters = response.data;
           }
         }
       },
-      error: (error) => {
+      error: error => {
         console.error('Error loading parameters:', error);
         // Fallback to empty parameters
         this.parameters = {};
-      }
+      },
     });
   }
 
   addSymbol(symbol: string): void {
-    if (!symbol || this.selectedSymbols.includes(symbol)) return;
+    if (!symbol || this.selectedSymbols.includes(symbol)) {
+      return;
+    }
     this.selectedSymbols.push(symbol);
   }
 
@@ -149,25 +153,25 @@ export class StrategyDialogComponent implements OnInit {
 
     if (this.isEditMode && this.data) {
       this.strategyService.updateStrategy(this.data.id, strategy).subscribe({
-        next: (response) => {
+        next: response => {
           if (response.success) {
             this.dialogRef.close(true);
           }
         },
-        error: (error) => {
+        error: error => {
           console.error('Error updating strategy:', error);
-        }
+        },
       });
     } else {
       this.strategyService.createStrategy(strategy).subscribe({
-        next: (response) => {
+        next: response => {
           if (response.success) {
             this.dialogRef.close(true);
           }
         },
-        error: (error) => {
+        error: error => {
           console.error('Error creating strategy:', error);
-        }
+        },
       });
     }
   }

apps/dashboard/src/app/pages/strategies/strategies.component.ts

@@ -1,21 +1,21 @@
-import { Component, OnInit } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { MatCardModule } from '@angular/material/card';
-import { MatIconModule } from '@angular/material/icon';
-import { MatButtonModule } from '@angular/material/button';
-import { MatTabsModule } from '@angular/material/tabs';
-import { MatTableModule } from '@angular/material/table';
-import { MatSortModule } from '@angular/material/sort';
-import { MatPaginatorModule } from '@angular/material/paginator';
-import { MatDialogModule, MatDialog } from '@angular/material/dialog';
-import { MatMenuModule } from '@angular/material/menu';
-import { MatChipsModule } from '@angular/material/chips';
-import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { Component, OnInit } from '@angular/core';
 import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatCardModule } from '@angular/material/card';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatDialog, MatDialogModule } from '@angular/material/dialog';
+import { MatIconModule } from '@angular/material/icon';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatPaginatorModule } from '@angular/material/paginator';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatSortModule } from '@angular/material/sort';
+import { MatTableModule } from '@angular/material/table';
+import { MatTabsModule } from '@angular/material/tabs';
 import { StrategyService, TradingStrategy } from '../../services/strategy.service';
 import { WebSocketService } from '../../services/websocket.service';
-import { StrategyDialogComponent } from './dialogs/strategy-dialog.component';
 import { BacktestDialogComponent } from './dialogs/backtest-dialog.component';
+import { StrategyDialogComponent } from './dialogs/strategy-dialog.component';
 import { StrategyDetailsComponent } from './strategy-details/strategy-details.component';
 
 @Component({
@@ -36,10 +36,10 @@ import { StrategyDetailsComponent } from './strategy-details/strategy-details.co
     MatProgressBarModule,
     FormsModule,
     ReactiveFormsModule,
-    StrategyDetailsComponent
+    StrategyDetailsComponent,
   ],
   templateUrl: './strategies.component.html',
-  styleUrl: './strategies.component.css'
+  styleUrl: './strategies.component.css',
 })
 export class StrategiesComponent implements OnInit {
   strategies: TradingStrategy[] = [];
@@ -61,24 +61,26 @@ export class StrategiesComponent implements OnInit {
   loadStrategies(): void {
     this.isLoading = true;
     this.strategyService.getStrategies().subscribe({
-      next: (response) => {
+      next: response => {
         if (response.success) {
           this.strategies = response.data;
         }
         this.isLoading = false;
       },
-      error: (error) => {
+      error: error => {
         console.error('Error loading strategies:', error);
         this.isLoading = false;
-      }
+      },
     });
   }
 
   listenForStrategyUpdates(): void {
     this.webSocketService.messages.subscribe(message => {
-      if (message.type === 'STRATEGY_CREATED' || 
-          message.type === 'STRATEGY_UPDATED' || 
-          message.type === 'STRATEGY_STATUS_CHANGED') {
+      if (
+        message.type === 'STRATEGY_CREATED' ||
+        message.type === 'STRATEGY_UPDATED' ||
+        message.type === 'STRATEGY_STATUS_CHANGED'
+      ) {
         // Refresh the strategy list when changes occur
         this.loadStrategies();
       }
@@ -87,17 +89,21 @@ export class StrategiesComponent implements OnInit {
 
   getStatusColor(status: string): string {
     switch (status) {
-      case 'ACTIVE': return 'green';
-      case 'PAUSED': return 'orange';
-      case 'ERROR': return 'red';
-      default: return 'gray';
+      case 'ACTIVE':
+        return 'green';
+      case 'PAUSED':
+        return 'orange';
+      case 'ERROR':
+        return 'red';
+      default:
+        return 'gray';
     }
   }
 
   openStrategyDialog(strategy?: TradingStrategy): void {
     const dialogRef = this.dialog.open(StrategyDialogComponent, {
       width: '600px',
-      data: strategy || null
+      data: strategy || null,
     });
 
     dialogRef.afterClosed().subscribe(result => {
@@ -110,7 +116,7 @@ export class StrategiesComponent implements OnInit {
   openBacktestDialog(strategy?: TradingStrategy): void {
     const dialogRef = this.dialog.open(BacktestDialogComponent, {
       width: '800px',
-      data: strategy || null
+      data: strategy || null,
     });
 
     dialogRef.afterClosed().subscribe(result => {
@@ -126,18 +132,18 @@ export class StrategiesComponent implements OnInit {
     if (strategy.status === 'ACTIVE') {
       this.strategyService.pauseStrategy(strategy.id).subscribe({
         next: () => this.loadStrategies(),
-        error: (error) => {
+        error: error => {
           console.error('Error pausing strategy:', error);
           this.isLoading = false;
-        }
+        },
       });
     } else {
       this.strategyService.startStrategy(strategy.id).subscribe({
         next: () => this.loadStrategies(),
-        error: (error) => {
+        error: error => {
           console.error('Error starting strategy:', error);
           this.isLoading = false;
-        }
+        },
       });
     }
   }

apps/dashboard/src/app/pages/strategies/strategy-details/strategy-details.component.html

@@ -4,17 +4,19 @@
     <mat-card class="flex-1 p-4">
       <div class="flex items-start justify-between">
         <div>
-          <h2 class="text-xl font-bold">{{strategy.name}}</h2>
-          <p class="text-gray-600 text-sm">{{strategy.description}}</p>
+          <h2 class="text-xl font-bold">{{ strategy.name }}</h2>
+          <p class="text-gray-600 text-sm">{{ strategy.description }}</p>
         </div>
         <div class="flex items-center gap-2">
           <button mat-raised-button color="primary" class="mr-2" (click)="openBacktestDialog()">
             Run Backtest
           </button>
-          <span class="px-3 py-1 rounded-full text-xs font-semibold" 
-                [style.background-color]="getStatusColor(strategy.status)" 
-                style="color: white;">
-            {{strategy.status}}
+          <span
+            class="px-3 py-1 rounded-full text-xs font-semibold"
+            [style.background-color]="getStatusColor(strategy.status)"
+            style="color: white"
+          >
+            {{ strategy.status }}
           </span>
         </div>
       </div>
@@ -22,20 +24,20 @@
       <div class="mt-4 grid grid-cols-1 md:grid-cols-2 gap-4">
         <div>
           <h3 class="font-semibold text-sm text-gray-600">Type</h3>
-          <p>{{strategy.type}}</p>
+          <p>{{ strategy.type }}</p>
         </div>
         <div>
           <h3 class="font-semibold text-sm text-gray-600">Created</h3>
-          <p>{{strategy.createdAt | date:'medium'}}</p>
+          <p>{{ strategy.createdAt | date: 'medium' }}</p>
         </div>
         <div>
           <h3 class="font-semibold text-sm text-gray-600">Last Updated</h3>
-          <p>{{strategy.updatedAt | date:'medium'}}</p>
+          <p>{{ strategy.updatedAt | date: 'medium' }}</p>
         </div>
         <div>
           <h3 class="font-semibold text-sm text-gray-600">Symbols</h3>
           <div class="flex flex-wrap gap-1 mt-1">
-            <mat-chip *ngFor="let symbol of strategy.symbols">{{symbol}}</mat-chip>
+            <mat-chip *ngFor="let symbol of strategy.symbols">{{ symbol }}</mat-chip>
           </div>
         </div>
       </div>
@@ -47,48 +49,68 @@
       <div class="grid grid-cols-2 gap-3">
         <div>
           <p class="text-sm text-gray-600">Return</p>
-          <p class="text-xl font-semibold" 
-             [ngClass]="{'text-green-600': performance.totalReturn >= 0, 'text-red-600': performance.totalReturn < 0}">
-            {{performance.totalReturn | percent:'1.2-2'}}
+          <p
+            class="text-xl font-semibold"
+            [ngClass]="{
+              'text-green-600': performance.totalReturn >= 0,
+              'text-red-600': performance.totalReturn < 0,
+            }"
+          >
+            {{ performance.totalReturn | percent: '1.2-2' }}
           </p>
         </div>
         <div>
           <p class="text-sm text-gray-600">Win Rate</p>
-          <p class="text-xl font-semibold">{{performance.winRate | percent:'1.0-0'}}</p>
+          <p class="text-xl font-semibold">{{ performance.winRate | percent: '1.0-0' }}</p>
         </div>
         <div>
           <p class="text-sm text-gray-600">Sharpe Ratio</p>
-          <p class="text-xl font-semibold">{{performance.sharpeRatio | number:'1.2-2'}}</p>
+          <p class="text-xl font-semibold">{{ performance.sharpeRatio | number: '1.2-2' }}</p>
         </div>
         <div>
           <p class="text-sm text-gray-600">Max Drawdown</p>
-          <p class="text-xl font-semibold text-red-600">{{performance.maxDrawdown | percent:'1.2-2'}}</p>
+          <p class="text-xl font-semibold text-red-600">
+            {{ performance.maxDrawdown | percent: '1.2-2' }}
+          </p>
         </div>
         <div>
           <p class="text-sm text-gray-600">Total Trades</p>
-          <p class="text-xl font-semibold">{{performance.totalTrades}}</p>
+          <p class="text-xl font-semibold">{{ performance.totalTrades }}</p>
         </div>
         <div>
           <p class="text-sm text-gray-600">Sortino Ratio</p>
-          <p class="text-xl font-semibold">{{performance.sortinoRatio | number:'1.2-2'}}</p>
+          <p class="text-xl font-semibold">{{ performance.sortinoRatio | number: '1.2-2' }}</p>
         </div>
       </div>
 
       <mat-divider class="my-4"></mat-divider>
 
       <div class="flex justify-between mt-2">
-        <button mat-button color="primary" *ngIf="strategy.status !== 'ACTIVE'" (click)="activateStrategy()">
+        <button
+          mat-button
+          color="primary"
+          *ngIf="strategy.status !== 'ACTIVE'"
+          (click)="activateStrategy()"
+        >
           <mat-icon>play_arrow</mat-icon> Start
         </button>
-        <button mat-button color="accent" *ngIf="strategy.status === 'ACTIVE'" (click)="pauseStrategy()">
+        <button
+          mat-button
+          color="accent"
+          *ngIf="strategy.status === 'ACTIVE'"
+          (click)="pauseStrategy()"
+        >
           <mat-icon>pause</mat-icon> Pause
         </button>
-        <button mat-button color="warn" *ngIf="strategy.status === 'ACTIVE'" (click)="stopStrategy()">
+        <button
+          mat-button
+          color="warn"
+          *ngIf="strategy.status === 'ACTIVE'"
+          (click)="stopStrategy()"
+        >
           <mat-icon>stop</mat-icon> Stop
         </button>
-        <button mat-button (click)="openEditDialog()">
-          <mat-icon>edit</mat-icon> Edit
-        </button>
+        <button mat-button (click)="openEditDialog()"><mat-icon>edit</mat-icon> Edit</button>
       </div>
     </mat-card>
   </div>
@@ -98,12 +120,12 @@
     <h3 class="text-lg font-bold mb-3">Strategy Parameters</h3>
     <div class="grid grid-cols-2 md:grid-cols-4 gap-4">
       <div *ngFor="let param of strategy.parameters | keyvalue">
-        <p class="text-sm text-gray-600">{{param.key}}</p>
-        <p class="font-semibold">{{param.value}}</p>
+        <p class="text-sm text-gray-600">{{ param.key }}</p>
+        <p class="font-semibold">{{ param.value }}</p>
       </div>
     </div>
   </mat-card>
-    <!-- Backtest Results Section (only shown when a backtest has been run) -->
+  <!-- Backtest Results Section (only shown when a backtest has been run) -->
   <div *ngIf="backtestResult" class="backtest-results space-y-6">
     <h2 class="text-xl font-bold">Backtest Results</h2>
 
@@ -140,18 +162,20 @@
               </thead>
               <tbody>
                 <tr *ngFor="let signal of signals">
-                  <td class="py-2">{{signal.timestamp | date:'short'}}</td>
-                  <td class="py-2">{{signal.symbol}}</td>
+                  <td class="py-2">{{ signal.timestamp | date: 'short' }}</td>
+                  <td class="py-2">{{ signal.symbol }}</td>
                   <td class="py-2">
-                    <span class="px-2 py-1 rounded text-xs font-semibold"
-                          [style.background-color]="getSignalColor(signal.action)" 
-                          style="color: white;">
-                      {{signal.action}}
+                    <span
+                      class="px-2 py-1 rounded text-xs font-semibold"
+                      [style.background-color]="getSignalColor(signal.action)"
+                      style="color: white"
+                    >
+                      {{ signal.action }}
                     </span>
                   </td>
-                  <td class="py-2">${{signal.price | number:'1.2-2'}}</td>
-                  <td class="py-2">{{signal.quantity}}</td>
-                  <td class="py-2">{{signal.confidence | percent:'1.0-0'}}</td>
+                  <td class="py-2">${{ signal.price | number: '1.2-2' }}</td>
+                  <td class="py-2">{{ signal.quantity }}</td>
+                  <td class="py-2">{{ signal.confidence | percent: '1.0-0' }}</td>
                 </tr>
               </tbody>
             </table>
@@ -179,19 +203,30 @@
               </thead>
               <tbody>
                 <tr *ngFor="let trade of trades">
-                  <td class="py-2">{{trade.symbol}}</td>
+                  <td class="py-2">{{ trade.symbol }}</td>
                   <td class="py-2">
-                    ${{trade.entryPrice | number:'1.2-2'}} @ {{trade.entryTime | date:'short'}}
+                    ${{ trade.entryPrice | number: '1.2-2' }} &#64;
+                    {{ trade.entryTime | date: 'short' }}
                   </td>
                   <td class="py-2">
-                    ${{trade.exitPrice | number:'1.2-2'}} @ {{trade.exitTime | date:'short'}}
+                    ${{ trade.exitPrice | number: '1.2-2' }} &#64;
+                    {{ trade.exitTime | date: 'short' }}
                   </td>
-                  <td class="py-2">{{trade.quantity}}</td>
-                  <td class="py-2" [ngClass]="{'text-green-600': trade.pnl >= 0, 'text-red-600': trade.pnl < 0}">
-                    ${{trade.pnl | number:'1.2-2'}}
+                  <td class="py-2">{{ trade.quantity }}</td>
+                  <td
+                    class="py-2"
+                    [ngClass]="{ 'text-green-600': trade.pnl >= 0, 'text-red-600': trade.pnl < 0 }"
+                  >
+                    ${{ trade.pnl | number: '1.2-2' }}
                   </td>
-                  <td class="py-2" [ngClass]="{'text-green-600': trade.pnlPercent >= 0, 'text-red-600': trade.pnlPercent < 0}">
-                    {{trade.pnlPercent | number:'1.2-2'}}%
+                  <td
+                    class="py-2"
+                    [ngClass]="{
+                      'text-green-600': trade.pnlPercent >= 0,
+                      'text-red-600': trade.pnlPercent < 0,
+                    }"
+                  >
+                    {{ trade.pnlPercent | number: '1.2-2' }}%
                   </td>
                 </tr>
               </tbody>
@@ -208,7 +243,7 @@
 
 <mat-card class="p-6 flex items-center" *ngIf="!strategy">
   <div class="text-center text-gray-500 w-full">
-    <mat-icon style="font-size: 4rem; width: 4rem; height: 4rem;">psychology</mat-icon>
+    <mat-icon style="font-size: 4rem; width: 4rem; height: 4rem">psychology</mat-icon>
     <p class="mb-4">No strategy selected</p>
   </div>
 </mat-card>

apps/dashboard/src/app/pages/strategies/strategy-details/strategy-details.component.ts

@@ -1,22 +1,26 @@
-import { Component, Input, OnChanges, SimpleChanges } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { MatCardModule } from '@angular/material/card';
-import { MatTabsModule } from '@angular/material/tabs';
-import { MatIconModule } from '@angular/material/icon';
+import { Component, Input, OnChanges, SimpleChanges } from '@angular/core';
 import { MatButtonModule } from '@angular/material/button';
-import { MatTableModule } from '@angular/material/table';
+import { MatCardModule } from '@angular/material/card';
 import { MatChipsModule } from '@angular/material/chips';
-import { MatProgressBarModule } from '@angular/material/progress-bar';
-import { MatDividerModule } from '@angular/material/divider';
 import { MatDialog } from '@angular/material/dialog';
-import { BacktestResult, TradingStrategy, StrategyService } from '../../../services/strategy.service';
+import { MatDividerModule } from '@angular/material/divider';
+import { MatIconModule } from '@angular/material/icon';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatTableModule } from '@angular/material/table';
+import { MatTabsModule } from '@angular/material/tabs';
+import {
+  BacktestResult,
+  StrategyService,
+  TradingStrategy,
+} from '../../../services/strategy.service';
 import { WebSocketService } from '../../../services/websocket.service';
-import { EquityChartComponent } from '../components/equity-chart.component';
 import { DrawdownChartComponent } from '../components/drawdown-chart.component';
-import { TradesTableComponent } from '../components/trades-table.component';
+import { EquityChartComponent } from '../components/equity-chart.component';
 import { PerformanceMetricsComponent } from '../components/performance-metrics.component';
-import { StrategyDialogComponent } from '../dialogs/strategy-dialog.component';
+import { TradesTableComponent } from '../components/trades-table.component';
 import { BacktestDialogComponent } from '../dialogs/backtest-dialog.component';
+import { StrategyDialogComponent } from '../dialogs/strategy-dialog.component';
 
 @Component({
   selector: 'app-strategy-details',
@@ -34,10 +38,10 @@ import { BacktestDialogComponent } from '../dialogs/backtest-dialog.component';
     EquityChartComponent,
     DrawdownChartComponent,
     TradesTableComponent,
-    PerformanceMetricsComponent
+    PerformanceMetricsComponent,
   ],
   templateUrl: './strategy-details.component.html',
-  styleUrl: './strategy-details.component.css'
+  styleUrl: './strategy-details.component.css',
 })
 export class StrategyDetailsComponent implements OnChanges {
   @Input() strategy: TradingStrategy | null = null;
@@ -63,63 +67,67 @@ export class StrategyDetailsComponent implements OnChanges {
   }
 
   loadStrategyData(): void {
-    if (!this.strategy) return;
+    if (!this.strategy) {
+      return;
+    }
 
     // In a real implementation, these would call API methods to fetch the data
     this.loadSignals();
     this.loadTrades();
     this.loadPerformance();
   }
-    loadSignals(): void {
-    if (!this.strategy) return;
+  loadSignals(): void {
+    if (!this.strategy) {
+      return;
+    }
 
     this.isLoadingSignals = true;
 
     // First check if we can get real signals from the API
-    this.strategyService.getStrategySignals(this.strategy.id)
-      .subscribe({
-        next: (response) => {
-          if (response.success && response.data && response.data.length > 0) {
-            this.signals = response.data;
-          } else {
-            // Fallback to mock data if no real signals available
-            this.signals = this.generateMockSignals();
-          }
-          this.isLoadingSignals = false;
-        },
-        error: (error) => {
-          console.error('Error loading signals', error);
-          // Fallback to mock data on error
+    this.strategyService.getStrategySignals(this.strategy.id).subscribe({
+      next: response => {
+        if (response.success && response.data && response.data.length > 0) {
+          this.signals = response.data;
+        } else {
+          // Fallback to mock data if no real signals available
           this.signals = this.generateMockSignals();
-          this.isLoadingSignals = false;
         }
-      });
+        this.isLoadingSignals = false;
+      },
+      error: error => {
+        console.error('Error loading signals', error);
+        // Fallback to mock data on error
+        this.signals = this.generateMockSignals();
+        this.isLoadingSignals = false;
+      },
+    });
   }
 
   loadTrades(): void {
-    if (!this.strategy) return;
+    if (!this.strategy) {
+      return;
+    }
 
     this.isLoadingTrades = true;
 
     // First check if we can get real trades from the API
-    this.strategyService.getStrategyTrades(this.strategy.id)
-      .subscribe({
-        next: (response) => {
-          if (response.success && response.data && response.data.length > 0) {
-            this.trades = response.data;
-          } else {
-            // Fallback to mock data if no real trades available
-            this.trades = this.generateMockTrades();
-          }
-          this.isLoadingTrades = false;
-        },
-        error: (error) => {
-          console.error('Error loading trades', error);
-          // Fallback to mock data on error
+    this.strategyService.getStrategyTrades(this.strategy.id).subscribe({
+      next: response => {
+        if (response.success && response.data && response.data.length > 0) {
+          this.trades = response.data;
+        } else {
+          // Fallback to mock data if no real trades available
           this.trades = this.generateMockTrades();
-          this.isLoadingTrades = false;
         }
-      });
+        this.isLoadingTrades = false;
+      },
+      error: error => {
+        console.error('Error loading trades', error);
+        // Fallback to mock data on error
+        this.trades = this.generateMockTrades();
+        this.isLoadingTrades = false;
+      },
+    });
   }
 
   loadPerformance(): void {
@@ -134,51 +142,50 @@ export class StrategyDetailsComponent implements OnChanges {
       dailyReturn: 0.0012,
       volatility: 0.008,
       sortinoRatio: 1.2,
-      calmarRatio: 0.7
+      calmarRatio: 0.7,
     };
   }
   listenForUpdates(): void {
-    if (!this.strategy) return;
+    if (!this.strategy) {
+      return;
+    }
 
     // Subscribe to strategy signals
-    this.webSocketService.getStrategySignals(this.strategy.id)
-      .subscribe((signal: any) => {
-        // Add the new signal to the top of the list
-        this.signals = [signal, ...this.signals.slice(0, 9)]; // Keep only the latest 10 signals
-      });
+    this.webSocketService.getStrategySignals(this.strategy.id).subscribe((signal: any) => {
+      // Add the new signal to the top of the list
+      this.signals = [signal, ...this.signals.slice(0, 9)]; // Keep only the latest 10 signals
+    });
 
     // Subscribe to strategy trades
-    this.webSocketService.getStrategyTrades(this.strategy.id)
-      .subscribe((trade: any) => {
-        // Add the new trade to the top of the list
-        this.trades = [trade, ...this.trades.slice(0, 9)]; // Keep only the latest 10 trades
+    this.webSocketService.getStrategyTrades(this.strategy.id).subscribe((trade: any) => {
+      // Add the new trade to the top of the list
+      this.trades = [trade, ...this.trades.slice(0, 9)]; // Keep only the latest 10 trades
 
-        // Update performance metrics
-        this.updatePerformanceMetrics();
-      });
+      // Update performance metrics
+      this.updatePerformanceMetrics();
+    });
 
     // Subscribe to strategy status updates
-    this.webSocketService.getStrategyUpdates()
-      .subscribe((update: any) => {
-        if (update.strategyId === this.strategy?.id) {
-          // Update strategy status if changed
-          if (update.status && this.strategy && this.strategy.status !== update.status) {
-            this.strategy.status = update.status;
-          }
-          
-          // Update other fields if present
-          if (update.performance && this.strategy) {
-            this.strategy.performance = { 
-              ...this.strategy.performance, 
-              ...update.performance 
-            };
-            this.performance = { 
-              ...this.performance, 
-              ...update.performance 
-            };
-          }
+    this.webSocketService.getStrategyUpdates().subscribe((update: any) => {
+      if (update.strategyId === this.strategy?.id) {
+        // Update strategy status if changed
+        if (update.status && this.strategy && this.strategy.status !== update.status) {
+          this.strategy.status = update.status;
         }
-      });
+
+        // Update other fields if present
+        if (update.performance && this.strategy) {
+          this.strategy.performance = {
+            ...this.strategy.performance,
+            ...update.performance,
+          };
+          this.performance = {
+            ...this.performance,
+            ...update.performance,
+          };
+        }
+      }
+    });
 
     console.log('WebSocket listeners for strategy updates initialized');
   }
@@ -187,7 +194,9 @@ export class StrategyDetailsComponent implements OnChanges {
    * Update performance metrics when new trades come in
    */
   private updatePerformanceMetrics(): void {
-    if (!this.strategy || this.trades.length === 0) return;
+    if (!this.strategy || this.trades.length === 0) {
+      return;
+    }
 
     // Calculate basic metrics
     const winningTrades = this.trades.filter(t => t.pnl > 0);
@@ -202,7 +211,9 @@ export class StrategyDetailsComponent implements OnChanges {
       ...currentPerformance,
       totalTrades: this.trades.length,
       winRate: winRate,
-      totalReturn: (currentPerformance.totalReturn || 0) + (totalPnl / 10000) // Approximate
+      winningTrades,
+      losingTrades,
+      totalReturn: (currentPerformance.totalReturn || 0) + totalPnl / 10000, // Approximate
     };
 
     // Update strategy performance as well
@@ -210,25 +221,32 @@ export class StrategyDetailsComponent implements OnChanges {
       this.strategy.performance = {
         ...this.strategy.performance,
         totalTrades: this.trades.length,
-        winRate: winRate
+        winRate: winRate,
       };
     }
   }
 
   getStatusColor(status: string): string {
     switch (status) {
-      case 'ACTIVE': return 'green';
-      case 'PAUSED': return 'orange';
-      case 'ERROR': return 'red';
-      default: return 'gray';
+      case 'ACTIVE':
+        return 'green';
+      case 'PAUSED':
+        return 'orange';
+      case 'ERROR':
+        return 'red';
+      default:
+        return 'gray';
     }
   }
 
   getSignalColor(action: string): string {
     switch (action) {
-      case 'BUY': return 'green';
-      case 'SELL': return 'red';
-      default: return 'gray';
+      case 'BUY':
+        return 'green';
+      case 'SELL':
+        return 'red';
+      default:
+        return 'gray';
     }
   }
 
@@ -236,11 +254,13 @@ export class StrategyDetailsComponent implements OnChanges {
    * Open the backtest dialog to run a backtest for this strategy
    */
   openBacktestDialog(): void {
-    if (!this.strategy) return;
+    if (!this.strategy) {
+      return;
+    }
 
     const dialogRef = this.dialog.open(BacktestDialogComponent, {
       width: '800px',
-      data: this.strategy
+      data: this.strategy,
     });
 
     dialogRef.afterClosed().subscribe(result => {
@@ -255,11 +275,13 @@ export class StrategyDetailsComponent implements OnChanges {
    * Open the strategy edit dialog
    */
   openEditDialog(): void {
-    if (!this.strategy) return;
+    if (!this.strategy) {
+      return;
+    }
 
     const dialogRef = this.dialog.open(StrategyDialogComponent, {
       width: '600px',
-      data: this.strategy
+      data: this.strategy,
     });
 
     dialogRef.afterClosed().subscribe(result => {
@@ -274,17 +296,19 @@ export class StrategyDetailsComponent implements OnChanges {
    * Start the strategy
    */
   activateStrategy(): void {
-    if (!this.strategy) return;
+    if (!this.strategy) {
+      return;
+    }
 
     this.strategyService.startStrategy(this.strategy.id).subscribe({
-      next: (response) => {
+      next: response => {
         if (response.success) {
           this.strategy!.status = 'ACTIVE';
         }
       },
-      error: (error) => {
+      error: error => {
         console.error('Error starting strategy:', error);
-      }
+      },
     });
   }
 
@@ -292,17 +316,19 @@ export class StrategyDetailsComponent implements OnChanges {
    * Pause the strategy
    */
   pauseStrategy(): void {
-    if (!this.strategy) return;
+    if (!this.strategy) {
+      return;
+    }
 
     this.strategyService.pauseStrategy(this.strategy.id).subscribe({
-      next: (response) => {
+      next: response => {
         if (response.success) {
           this.strategy!.status = 'PAUSED';
         }
       },
-      error: (error) => {
+      error: error => {
         console.error('Error pausing strategy:', error);
-      }
+      },
     });
   }
 
@@ -310,30 +336,35 @@ export class StrategyDetailsComponent implements OnChanges {
    * Stop the strategy
    */
   stopStrategy(): void {
-    if (!this.strategy) return;
+    if (!this.strategy) {
+      return;
+    }
 
     this.strategyService.stopStrategy(this.strategy.id).subscribe({
-      next: (response) => {
+      next: response => {
         if (response.success) {
           this.strategy!.status = 'INACTIVE';
         }
       },
-      error: (error) => {
+      error: error => {
         console.error('Error stopping strategy:', error);
-      }
+      },
     });
   }
 
   // Methods to generate mock data
   private generateMockSignals(): any[] {
-    if (!this.strategy) return [];
+    if (!this.strategy) {
+      return [];
+    }
 
     const signals = [];
     const actions = ['BUY', 'SELL', 'HOLD'];
     const now = new Date();
 
     for (let i = 0; i < 10; i++) {
-      const symbol = this.strategy.symbols[Math.floor(Math.random() * this.strategy.symbols.length)];
+      const symbol =
+        this.strategy.symbols[Math.floor(Math.random() * this.strategy.symbols.length)];
       const action = actions[Math.floor(Math.random() * actions.length)];
 
       signals.push({
@@ -343,7 +374,7 @@ export class StrategyDetailsComponent implements OnChanges {
         confidence: 0.7 + Math.random() * 0.3,
         price: 100 + Math.random() * 50,
         timestamp: new Date(now.getTime() - i * 1000 * 60 * 30), // 30 min intervals
-        quantity: Math.floor(10 + Math.random() * 90)
+        quantity: Math.floor(10 + Math.random() * 90),
       });
     }
 
@@ -351,13 +382,16 @@ export class StrategyDetailsComponent implements OnChanges {
   }
 
   private generateMockTrades(): any[] {
-    if (!this.strategy) return [];
+    if (!this.strategy) {
+      return [];
+    }
 
     const trades = [];
     const now = new Date();
 
     for (let i = 0; i < 10; i++) {
-      const symbol = this.strategy.symbols[Math.floor(Math.random() * this.strategy.symbols.length)];
+      const symbol =
+        this.strategy.symbols[Math.floor(Math.random() * this.strategy.symbols.length)];
       const entryPrice = 100 + Math.random() * 50;
       const exitPrice = entryPrice * (1 + (Math.random() * 0.1 - 0.05)); // -5% to +5%
       const quantity = Math.floor(10 + Math.random() * 90);
@@ -372,7 +406,7 @@ export class StrategyDetailsComponent implements OnChanges {
         exitTime: new Date(now.getTime() - i * 1000 * 60 * 60),
         quantity,
         pnl,
-        pnlPercent: ((exitPrice - entryPrice) / entryPrice) * 100
+        pnlPercent: ((exitPrice - entryPrice) / entryPrice) * 100,
       });
     }
 

apps/dashboard/src/app/services/api.service.ts

@@ -1,5 +1,5 @@
-import { Injectable } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
 
 export interface RiskThresholds {
@@ -27,13 +27,13 @@ export interface MarketData {
 }
 
 @Injectable({
-  providedIn: 'root'
+  providedIn: 'root',
 })
 export class ApiService {
   private readonly baseUrls = {
     riskGuardian: 'http://localhost:3002',
     strategyOrchestrator: 'http://localhost:3003',
-    marketDataGateway: 'http://localhost:3001'
+    marketDataGateway: 'http://localhost:3001',
   };
 
   constructor(private http: HttpClient) {}
@@ -45,7 +45,9 @@ export class ApiService {
     );
   }
 
-  updateRiskThresholds(thresholds: RiskThresholds): Observable<{ success: boolean; data: RiskThresholds }> {
+  updateRiskThresholds(
+    thresholds: RiskThresholds
+  ): Observable<{ success: boolean; data: RiskThresholds }> {
     return this.http.put<{ success: boolean; data: RiskThresholds }>(
       `${this.baseUrls.riskGuardian}/api/risk/thresholds`,
       thresholds
@@ -84,7 +86,9 @@ export class ApiService {
     );
   }
   // Market Data Gateway API
-  getMarketData(symbols: string[] = ['AAPL', 'GOOGL', 'MSFT', 'TSLA', 'AMZN']): Observable<{ success: boolean; data: MarketData[] }> {
+  getMarketData(
+    symbols: string[] = ['AAPL', 'GOOGL', 'MSFT', 'TSLA', 'AMZN']
+  ): Observable<{ success: boolean; data: MarketData[] }> {
     const symbolsParam = symbols.join(',');
     return this.http.get<{ success: boolean; data: MarketData[] }>(
       `${this.baseUrls.marketDataGateway}/api/market-data?symbols=${symbolsParam}`
@@ -92,7 +96,9 @@ export class ApiService {
   }
 
   // Health checks
-  checkServiceHealth(service: 'riskGuardian' | 'strategyOrchestrator' | 'marketDataGateway'): Observable<any> {
+  checkServiceHealth(
+    service: 'riskGuardian' | 'strategyOrchestrator' | 'marketDataGateway'
+  ): Observable<any> {
     return this.http.get(`${this.baseUrls[service]}/health`);
   }
 }

apps/dashboard/src/app/services/notification.service.ts

@@ -1,7 +1,7 @@
-import { Injectable, signal, inject } from '@angular/core';
+import { inject, Injectable, signal } from '@angular/core';
 import { MatSnackBar } from '@angular/material/snack-bar';
-import { WebSocketService, RiskAlert } from './websocket.service';
 import { Subscription } from 'rxjs';
+import { RiskAlert, WebSocketService } from './websocket.service';
 
 export interface Notification {
   id: string;
@@ -13,7 +13,7 @@ export interface Notification {
 }
 
 @Injectable({
-  providedIn: 'root'
+  providedIn: 'root',
 })
 export class NotificationService {
   private snackBar = inject(MatSnackBar);
@@ -34,9 +34,9 @@ export class NotificationService {
       next: (alert: RiskAlert) => {
         this.handleRiskAlert(alert);
       },
-      error: (err) => {
+      error: err => {
         console.error('Risk alert subscription error:', err);
-      }
+      },
     });
   }
 
@@ -47,7 +47,7 @@ export class NotificationService {
       title: `Risk Alert: ${alert.symbol}`,
       message: alert.message,
       timestamp: new Date(alert.timestamp),
-      read: false
+      read: false,
     };
 
     this.addNotification(notification);
@@ -56,10 +56,14 @@ export class NotificationService {
 
   private mapSeverityToType(severity: string): 'info' | 'warning' | 'error' | 'success' {
     switch (severity) {
-      case 'HIGH': return 'error';
-      case 'MEDIUM': return 'warning';
-      case 'LOW': return 'info';
-      default: return 'info';
+      case 'HIGH':
+        return 'error';
+      case 'MEDIUM':
+        return 'warning';
+      case 'LOW':
+        return 'info';
+      default:
+        return 'info';
     }
   }
 
@@ -67,14 +71,10 @@ export class NotificationService {
     const actionText = notification.type === 'error' ? 'Review' : 'Dismiss';
     const duration = notification.type === 'error' ? 10000 : 5000;
 
-    this.snackBar.open(
-      `${notification.title}: ${notification.message}`,
-      actionText,
-      {
-        duration,
-        panelClass: [`snack-${notification.type}`]
-      }
-    );
+    this.snackBar.open(`${notification.title}: ${notification.message}`, actionText, {
+      duration,
+      panelClass: [`snack-${notification.type}`],
+    });
   }
 
   // Public methods
@@ -87,9 +87,7 @@ export class NotificationService {
 
   markAsRead(notificationId: string) {
     const current = this.notifications();
-    const updated = current.map(n => 
-      n.id === notificationId ? { ...n, read: true } : n
-    );
+    const updated = current.map(n => (n.id === notificationId ? { ...n, read: true } : n));
     this.notifications.set(updated);
     this.updateUnreadCount();
   }
@@ -126,12 +124,12 @@ export class NotificationService {
       title,
       message,
       timestamp: new Date(),
-      read: false
+      read: false,
     };
     this.addNotification(notification);
     this.snackBar.open(`${title}: ${message}`, 'Dismiss', {
       duration: 3000,
-      panelClass: ['snack-success']
+      panelClass: ['snack-success'],
     });
   }
 
@@ -142,12 +140,12 @@ export class NotificationService {
       title,
       message,
       timestamp: new Date(),
-      read: false
+      read: false,
     };
     this.addNotification(notification);
     this.snackBar.open(`${title}: ${message}`, 'Dismiss', {
       duration: 8000,
-      panelClass: ['snack-error']
+      panelClass: ['snack-error'],
     });
   }
 
@@ -158,12 +156,12 @@ export class NotificationService {
       title,
       message,
       timestamp: new Date(),
-      read: false
+      read: false,
     };
     this.addNotification(notification);
     this.snackBar.open(`${title}: ${message}`, 'Dismiss', {
       duration: 5000,
-      panelClass: ['snack-warning']
+      panelClass: ['snack-warning'],
     });
   }
 
@@ -174,12 +172,12 @@ export class NotificationService {
       title,
       message,
       timestamp: new Date(),
-      read: false
+      read: false,
     };
     this.addNotification(notification);
     this.snackBar.open(`${title}: ${message}`, 'Dismiss', {
       duration: 4000,
-      panelClass: ['snack-info']
+      panelClass: ['snack-info'],
     });
   }
 

apps/dashboard/src/app/services/strategy.service.ts

@@ -1,5 +1,5 @@
-import { Injectable } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
 
 export interface TradingStrategy {
@@ -80,12 +80,12 @@ interface ApiResponse<T> {
 }
 
 @Injectable({
-  providedIn: 'root'
+  providedIn: 'root',
 })
 export class StrategyService {
   private apiBaseUrl = '/api'; // Will be proxied to the correct backend endpoint
 
-  constructor(private http: HttpClient) { }
+  constructor(private http: HttpClient) {}
 
   // Strategy Management
   getStrategies(): Observable<ApiResponse<TradingStrategy[]>> {
@@ -100,20 +100,35 @@ export class StrategyService {
     return this.http.post<ApiResponse<TradingStrategy>>(`${this.apiBaseUrl}/strategies`, strategy);
   }
 
-  updateStrategy(id: string, updates: Partial<TradingStrategy>): Observable<ApiResponse<TradingStrategy>> {
-    return this.http.put<ApiResponse<TradingStrategy>>(`${this.apiBaseUrl}/strategies/${id}`, updates);
+  updateStrategy(
+    id: string,
+    updates: Partial<TradingStrategy>
+  ): Observable<ApiResponse<TradingStrategy>> {
+    return this.http.put<ApiResponse<TradingStrategy>>(
+      `${this.apiBaseUrl}/strategies/${id}`,
+      updates
+    );
   }
 
   startStrategy(id: string): Observable<ApiResponse<TradingStrategy>> {
-    return this.http.post<ApiResponse<TradingStrategy>>(`${this.apiBaseUrl}/strategies/${id}/start`, {});
+    return this.http.post<ApiResponse<TradingStrategy>>(
+      `${this.apiBaseUrl}/strategies/${id}/start`,
+      {}
+    );
   }
 
   stopStrategy(id: string): Observable<ApiResponse<TradingStrategy>> {
-    return this.http.post<ApiResponse<TradingStrategy>>(`${this.apiBaseUrl}/strategies/${id}/stop`, {});
+    return this.http.post<ApiResponse<TradingStrategy>>(
+      `${this.apiBaseUrl}/strategies/${id}/stop`,
+      {}
+    );
   }
 
   pauseStrategy(id: string): Observable<ApiResponse<TradingStrategy>> {
-    return this.http.post<ApiResponse<TradingStrategy>>(`${this.apiBaseUrl}/strategies/${id}/pause`, {});
+    return this.http.post<ApiResponse<TradingStrategy>>(
+      `${this.apiBaseUrl}/strategies/${id}/pause`,
+      {}
+    );
   }
 
   // Backtest Management
@@ -122,7 +137,9 @@ export class StrategyService {
   }
 
   getStrategyParameters(type: string): Observable<ApiResponse<Record<string, any>>> {
-    return this.http.get<ApiResponse<Record<string, any>>>(`${this.apiBaseUrl}/strategy-parameters/${type}`);
+    return this.http.get<ApiResponse<Record<string, any>>>(
+      `${this.apiBaseUrl}/strategy-parameters/${type}`
+    );
   }
 
   runBacktest(request: BacktestRequest): Observable<ApiResponse<BacktestResult>> {
@@ -143,32 +160,40 @@ export class StrategyService {
   }
 
   // Strategy Signals and Trades
-  getStrategySignals(strategyId: string): Observable<ApiResponse<Array<{
-    id: string;
-    strategyId: string;
-    symbol: string;
-    action: string;
-    price: number;
-    quantity: number;
-    timestamp: Date;
-    confidence: number;
-    metadata?: any;
-  }>>> {
+  getStrategySignals(strategyId: string): Observable<
+    ApiResponse<
+      Array<{
+        id: string;
+        strategyId: string;
+        symbol: string;
+        action: string;
+        price: number;
+        quantity: number;
+        timestamp: Date;
+        confidence: number;
+        metadata?: any;
+      }>
+    >
+  > {
     return this.http.get<ApiResponse<any[]>>(`${this.apiBaseUrl}/strategies/${strategyId}/signals`);
   }
 
-  getStrategyTrades(strategyId: string): Observable<ApiResponse<Array<{
-    id: string;
-    strategyId: string;
-    symbol: string;
-    entryPrice: number;
-    entryTime: Date;
-    exitPrice: number;
-    exitTime: Date;
-    quantity: number;
-    pnl: number;
-    pnlPercent: number;
-  }>>> {
+  getStrategyTrades(strategyId: string): Observable<
+    ApiResponse<
+      Array<{
+        id: string;
+        strategyId: string;
+        symbol: string;
+        entryPrice: number;
+        entryTime: Date;
+        exitPrice: number;
+        exitTime: Date;
+        quantity: number;
+        pnl: number;
+        pnlPercent: number;
+      }>
+    >
+  > {
     return this.http.get<ApiResponse<any[]>>(`${this.apiBaseUrl}/strategies/${strategyId}/trades`);
   }
 
@@ -177,13 +202,17 @@ export class StrategyService {
     // Handle date formatting and parameter conversion
     return {
       ...formData,
-      startDate: formData.startDate instanceof Date ? formData.startDate.toISOString() : formData.startDate,
+      startDate:
+        formData.startDate instanceof Date ? formData.startDate.toISOString() : formData.startDate,
       endDate: formData.endDate instanceof Date ? formData.endDate.toISOString() : formData.endDate,
-      strategyParams: this.convertParameterTypes(formData.strategyType, formData.strategyParams)
+      strategyParams: this.convertParameterTypes(formData.strategyType, formData.strategyParams),
     };
   }
 
-  private convertParameterTypes(strategyType: string, params: Record<string, any>): Record<string, any> {
+  private convertParameterTypes(
+    strategyType: string,
+    params: Record<string, any>
+  ): Record<string, any> {
     // Convert string parameters to correct types based on strategy requirements
     const result: Record<string, any> = {};
 

apps/dashboard/src/app/services/websocket.service.ts

@@ -1,5 +1,5 @@
 import { Injectable, signal } from '@angular/core';
-import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { Observable, Subject } from 'rxjs';
 import { filter, map } from 'rxjs/operators';
 
 export interface WebSocketMessage {
@@ -27,13 +27,13 @@ export interface RiskAlert {
 }
 
 @Injectable({
-  providedIn: 'root'
+  providedIn: 'root',
 })
 export class WebSocketService {
   private readonly WS_ENDPOINTS = {
     marketData: 'ws://localhost:3001/ws',
     riskGuardian: 'ws://localhost:3002/ws',
-    strategyOrchestrator: 'ws://localhost:3003/ws'
+    strategyOrchestrator: 'ws://localhost:3003/ws',
   };
 
   private connections = new Map<string, WebSocket>();
@@ -44,7 +44,7 @@ export class WebSocketService {
   public connectionStatus = signal<{ [key: string]: boolean }>({
     marketData: false,
     riskGuardian: false,
-    strategyOrchestrator: false
+    strategyOrchestrator: false,
   });
 
   constructor() {
@@ -68,7 +68,7 @@ export class WebSocketService {
         this.updateConnectionStatus(serviceName, true);
       };
 
-      ws.onmessage = (event) => {
+      ws.onmessage = event => {
         try {
           const message: WebSocketMessage = JSON.parse(event.data);
           messageSubject.next(message);
@@ -87,14 +87,13 @@ export class WebSocketService {
         }, 5000);
       };
 
-      ws.onerror = (error) => {
+      ws.onerror = error => {
         console.error(`WebSocket error for ${serviceName}:`, error);
         this.updateConnectionStatus(serviceName, false);
       };
 
       this.connections.set(serviceName, ws);
       this.messageSubjects.set(serviceName, messageSubject);
-
     } catch (error) {
       console.error(`Failed to connect to ${serviceName} WebSocket:`, error);
       this.updateConnectionStatus(serviceName, false);
@@ -157,9 +156,10 @@ export class WebSocketService {
     }
 
     return subject.asObservable().pipe(
-      filter(message => 
-        message.type === 'strategy_signal' && 
-        (!strategyId || message.data.strategyId === strategyId)
+      filter(
+        message =>
+          message.type === 'strategy_signal' &&
+          (!strategyId || message.data.strategyId === strategyId)
       ),
       map(message => message.data)
     );
@@ -173,9 +173,10 @@ export class WebSocketService {
     }
 
     return subject.asObservable().pipe(
-      filter(message => 
-        message.type === 'strategy_trade' && 
-        (!strategyId || message.data.strategyId === strategyId)
+      filter(
+        message =>
+          message.type === 'strategy_trade' &&
+          (!strategyId || message.data.strategyId === strategyId)
       ),
       map(message => message.data)
     );
@@ -188,11 +189,7 @@ export class WebSocketService {
       throw new Error('Strategy Orchestrator WebSocket not initialized');
     }
 
-    return subject.asObservable().pipe(
-      filter(message => 
-        message.type.startsWith('strategy_')
-      )
-    );
+    return subject.asObservable().pipe(filter(message => message.type.startsWith('strategy_')));
   }
 
   // Send messages
@@ -207,7 +204,7 @@ export class WebSocketService {
 
   // Cleanup
   disconnect() {
-    this.connections.forEach((ws, serviceName) => {
+    this.connections.forEach((ws, _serviceName) => {
       if (ws.readyState === WebSocket.OPEN) {
         ws.close();
       }

apps/dashboard/src/main.ts

@@ -1,6 +1,5 @@
 import { bootstrapApplication } from '@angular/platform-browser';
-import { appConfig } from './app/app.config';
 import { App } from './app/app';
+import { appConfig } from './app/app.config';
 
-bootstrapApplication(App, appConfig)
-  .catch((err) => console.error(err));
+bootstrapApplication(App, appConfig).catch(err => console.error(err));

apps/dashboard/tsconfig.app.json

@@ -6,10 +6,6 @@
     "outDir": "./out-tsc/app",
     "types": []
   },
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "src/**/*.spec.ts"
-  ]
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.spec.ts"]
 }

apps/dashboard/tsconfig.spec.json

@@ -4,11 +4,7 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "outDir": "./out-tsc/spec",
-    "types": [
-      "jasmine"
-    ]
+    "types": ["jasmine"]
   },
-  "include": [
-    "src/**/*.ts"
-  ]
+  "include": ["src/**/*.ts"]
 }

apps/data-service/src/index.ts

@@ -1,213 +1,60 @@
 /**
  * Data Service - Combined live and historical data ingestion with queue-based architecture
  */
-import { getLogger } from '@stock-bot/logger';
-import { loadEnvVariables } from '@stock-bot/config';
 import { Hono } from 'hono';
-import { serve } from '@hono/node-server';
+import { Browser } from '@stock-bot/browser';
+import { loadEnvVariables } from '@stock-bot/config';
+import { getLogger } from '@stock-bot/logger';
+import { Shutdown } from '@stock-bot/shutdown';
+import { initializeIBResources } from './providers/ib.tasks';
+import { initializeProxyResources } from './providers/proxy.tasks';
 import { queueManager } from './services/queue.service';
+import { initializeBatchCache } from './utils/batch-helpers';
+import { healthRoutes, marketDataRoutes, proxyRoutes, queueRoutes, testRoutes } from './routes';
 
 // Load environment variables
 loadEnvVariables();
 
 const app = new Hono();
 const logger = getLogger('data-service');
-
 const PORT = parseInt(process.env.DATA_SERVICE_PORT || '3002');
-// Health check endpoint
-app.get('/health', (c) => {
-  return c.json({ 
-    service: 'data-service', 
-    status: 'healthy',
-    timestamp: new Date().toISOString(),
-    queue: {
-      status: 'running',
-      workers: queueManager.getWorkerCount()
-    }
-  });
-});
+let server: any = null;
 
-// Queue management endpoints
-app.get('/api/queue/status', async (c) => {
-  try {
-    const status = await queueManager.getQueueStatus();
-    return c.json({ status: 'success', data: status });
-  } catch (error) {
-    logger.error('Failed to get queue status', { error });
-    return c.json({ status: 'error', message: 'Failed to get queue status' }, 500);
-  }
-});
+// Initialize shutdown manager with 15 second timeout
+const shutdown = Shutdown.getInstance({ timeout: 15000 });
 
-app.post('/api/queue/job', async (c) => {
-  try {
-    const jobData = await c.req.json();
-    const job = await queueManager.addJob(jobData);
-    return c.json({ status: 'success', jobId: job.id });
-  } catch (error) {
-    logger.error('Failed to add job', { error });
-    return c.json({ status: 'error', message: 'Failed to add job' }, 500);
-  }
-});
-
-// Market data endpoints
-app.get('/api/live/:symbol', async (c) => {
-  const symbol = c.req.param('symbol');
-  logger.info('Live data request', { symbol });
-  
-  try {    // Queue job for live data using Yahoo provider
-    const job = await queueManager.addJob({
-      type: 'market-data-live',
-      service: 'market-data',
-      provider: 'yahoo-finance',
-      operation: 'live-data',
-      payload: { symbol }
-    });
-    return c.json({ 
-      status: 'success', 
-      message: 'Live data job queued',
-      jobId: job.id,
-      symbol 
-    });
-  } catch (error) {
-    logger.error('Failed to queue live data job', { symbol, error });
-    return c.json({ status: 'error', message: 'Failed to queue live data job' }, 500);
-  }
-});
-
-app.get('/api/historical/:symbol', async (c) => {
-  const symbol = c.req.param('symbol');
-  const from = c.req.query('from');
-  const to = c.req.query('to');
-  
-  logger.info('Historical data request', { symbol, from, to });
-  
-  try {
-    const fromDate = from ? new Date(from) : new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); // 30 days ago
-    const toDate = to ? new Date(to) : new Date(); // Now
-      // Queue job for historical data using Yahoo provider
-    const job = await queueManager.addJob({
-      type: 'market-data-historical',
-      service: 'market-data',
-      provider: 'yahoo-finance',
-      operation: 'historical-data',
-      payload: { 
-        symbol, 
-        from: fromDate.toISOString(), 
-        to: toDate.toISOString() 
-      }
-    });    return c.json({ 
-      status: 'success', 
-      message: 'Historical data job queued',
-      jobId: job.id,
-      symbol, 
-      from: fromDate, 
-      to: toDate 
-    });
-  } catch (error) {
-    logger.error('Failed to queue historical data job', { symbol, from, to, error });
-    return c.json({ status: 'error', message: 'Failed to queue historical data job' }, 500);  }
-});
-
-// Proxy management endpoints
-app.post('/api/proxy/fetch', async (c) => {
-  try {
-    const job = await queueManager.addJob({
-      type: 'proxy-fetch',
-      service: 'proxy',
-      provider: 'proxy-service',
-      operation: 'fetch-and-check',
-      payload: {},
-      priority: 5
-    });
-    
-    return c.json({ 
-      status: 'success', 
-      jobId: job.id, 
-      message: 'Proxy fetch job queued' 
-    });
-  } catch (error) {
-    logger.error('Failed to queue proxy fetch', { error });
-    return c.json({ status: 'error', message: 'Failed to queue proxy fetch' }, 500);
-  }
-});
-
-app.post('/api/proxy/check', async (c) => {
-  try {
-    const { proxies } = await c.req.json();
-    const job = await queueManager.addJob({
-      type: 'proxy-check',
-      service: 'proxy',
-      provider: 'proxy-service',
-      operation: 'check-specific',
-      payload: { proxies },
-      priority: 8
-    });
-    
-    return c.json({ 
-      status: 'success', 
-      jobId: job.id, 
-      message: `Proxy check job queued for ${proxies.length} proxies` 
-    });
-  } catch (error) {
-    logger.error('Failed to queue proxy check', { error });
-    return c.json({ status: 'error', message: 'Failed to queue proxy check' }, 500);
-  }
-});
-
-// Get proxy stats via queue
-app.get('/api/proxy/stats', async (c) => {
-  try {
-    const job = await queueManager.addJob({
-      type: 'proxy-stats',
-      service: 'proxy',
-      provider: 'proxy-service',
-      operation: 'get-stats',
-      payload: {},
-      priority: 3
-    });
-    
-    return c.json({ 
-      status: 'success', 
-      jobId: job.id, 
-      message: 'Proxy stats job queued' 
-    });
-  } catch (error) {
-    logger.error('Failed to queue proxy stats', { error });
-    return c.json({ status: 'error', message: 'Failed to queue proxy stats' }, 500);
-  }
-});
-
-// Provider registry endpoints
-app.get('/api/providers', async (c) => {
-  try {
-    const providers = queueManager.getRegisteredProviders();
-    return c.json({ status: 'success', providers });
-  } catch (error) {
-    logger.error('Failed to get providers', { error });
-    return c.json({ status: 'error', message: 'Failed to get providers' }, 500);
-  }
-});
-
-// Add new endpoint to see scheduled jobs
-app.get('/api/scheduled-jobs', async (c) => {
-  try {
-    const jobs = queueManager.getScheduledJobsInfo();
-    return c.json({ 
-      status: 'success', 
-      count: jobs.length,
-      jobs 
-    });
-  } catch (error) {
-    logger.error('Failed to get scheduled jobs info', { error });
-    return c.json({ status: 'error', message: 'Failed to get scheduled jobs' }, 500);
-  }
-});
+// Register all routes
+app.route('', healthRoutes);
+app.route('', queueRoutes);
+app.route('', marketDataRoutes);
+app.route('', proxyRoutes);
+app.route('', testRoutes);
 
 // Initialize services
 async function initializeServices() {
   logger.info('Initializing data service...');
 
   try {
+    // Initialize browser resources
+    logger.info('Starting browser resources initialization...');
+    await Browser.initialize();
+    logger.info('Browser resources initialized');
+
+    // Initialize batch cache FIRST - before queue service
+    logger.info('Starting batch cache initialization...');
+    await initializeBatchCache();
+    logger.info('Batch cache initialized');
+
+    // Initialize proxy cache - before queue service
+    logger.info('Starting proxy cache initialization...');
+    await initializeProxyResources(true); // Wait for cache during startup
+    logger.info('Proxy cache initialized');
+
+    // Initialize proxy cache - before queue service
+    logger.info('Starting proxy cache initialization...');
+    await initializeIBResources(true); // Wait for cache during startup
+    logger.info('Proxy cache initialized');
+
     // Initialize queue service (Redis connections should be ready now)
     logger.info('Starting queue service initialization...');
     await queueManager.initialize();
@@ -223,22 +70,43 @@ async function initializeServices() {
 // Start server
 async function startServer() {
   await initializeServices();
+  // Start the HTTP server using Bun's native serve
+  server = Bun.serve({
+    port: PORT,
+    fetch: app.fetch,
+    development: process.env.NODE_ENV === 'development',
+  });
+  logger.info(`Data Service started on port ${PORT}`);
 }
 
-// Graceful shutdown
-process.on('SIGINT', async () => {
-  logger.info('Received SIGINT, shutting down gracefully...');
-  await queueManager.shutdown();
-  process.exit(0);
+// Register shutdown handlers
+shutdown.onShutdown(async () => {
+  if (server) {
+    logger.info('Stopping HTTP server...');
+    try {
+      server.stop();
+      logger.info('HTTP server stopped successfully');
+    } catch (error) {
+      logger.error('Error stopping HTTP server', { error });
+    }
+  }
 });
 
-process.on('SIGTERM', async () => {
-  logger.info('Received SIGTERM, shutting down gracefully...');
-  await queueManager.shutdown();
-  process.exit(0);
+shutdown.onShutdown(async () => {
+  logger.info('Shutting down queue manager...');
+  try {
+    await queueManager.shutdown();
+    logger.info('Queue manager shut down successfully');
+  } catch (error) {
+    logger.error('Error shutting down queue manager', { error });
+    throw error; // Re-throw to mark shutdown as failed
+  }
 });
 
+// Start the application
 startServer().catch(error => {
   logger.error('Failed to start server', { error });
   process.exit(1);
 });
+
+logger.info('Data service startup initiated with graceful shutdown handlers');

apps/data-service/src/providers/ib.provider.ts

@@ -0,0 +1,32 @@
+import { getLogger } from '@stock-bot/logger';
+import { ProviderConfig } from '../services/provider-registry.service';
+
+const logger = getLogger('ib-provider');
+
+export const ibProvider: ProviderConfig = {
+  name: 'ib',
+  operations: {
+    'ib-symbol-summary': async () => {
+      const { ibTasks } = await import('./ib.tasks');
+      logger.info('Fetching symbol summary from IB');
+      const total = await ibTasks.fetchSymbolSummary();
+      logger.info('Fetched symbol summary from IB', {
+        count: total,
+      });
+      return total;
+    },
+  },
+
+  scheduledJobs: [
+    {
+      type: 'ib-symbol-summary',
+      operation: 'ib-symbol-summary',
+      payload: {},
+      // should remove and just run at the same time so app restarts dont keeping adding same jobs
+      cronPattern: '*/2 * * * *',
+      priority: 5,
+      immediately: true, // Don't run immediately during startup to avoid conflicts
+      description: 'Fetch and validate proxy list from sources',
+    },
+  ],
+};

apps/data-service/src/providers/ib.tasks.ts

@@ -0,0 +1,152 @@
+import { Browser } from '@stock-bot/browser';
+import { getLogger } from '@stock-bot/logger';
+
+// Shared instances (module-scoped, not global)
+let isInitialized = false; // Track if resources are initialized
+let logger: ReturnType<typeof getLogger>;
+// let cache: CacheProvider;
+
+export async function initializeIBResources(waitForCache = false): Promise<void> {
+  // Skip if already initialized
+  if (isInitialized) {
+    return;
+  }
+
+  logger = getLogger('proxy-tasks');
+  // cache = createCache({
+  //   keyPrefix: 'proxy:',
+  //   ttl: PROXY_CONFIG.CACHE_TTL,
+  //   enableMetrics: true,
+  // });
+
+  // httpClient = new HttpClient({ timeout: 15000 }, logger);
+
+  // if (waitForCache) {
+  //   // logger.info('Initializing proxy cache...');
+  //   // await cache.waitForReady(10000);
+  //   // logger.info('Proxy cache initialized successfully');
+  //   logger.info('Proxy tasks initialized');
+  // } else {
+  //   logger.info('Proxy tasks initialized (fallback mode)');
+  // }
+  isInitialized = true;
+}
+
+export async function fetchSymbolSummary(): Promise<number> {
+  try {
+    await Browser.initialize({ headless: true, timeout: 10000, blockResources: false });
+    logger.info('✅ Browser initialized');
+
+    const { page, contextId } = await Browser.createPageWithProxy(
+      'https://www.interactivebrokers.com/en/trading/products-exchanges.php#/',
+      'http://doimvbnb-US-rotate:w5fpiwrb9895@p.webshare.io:80'
+    );
+    logger.info('✅ Page created with proxy');
+    let summaryData: any = null; // Initialize summaryData to store API response
+    let eventCount = 0;
+    page.onNetworkEvent(event => {
+      if (event.url.includes('/webrest/search/product-types/summary')) {
+        console.log(`🎯 Found summary API call: ${event.type} ${event.url}`);
+
+        if (event.type === 'response' && event.responseData) {
+          console.log(`📊 Summary API Response Data: ${event.responseData}`);
+          try {
+            summaryData = JSON.parse(event.responseData) as any;
+            const totalCount = summaryData[0].totalCount;
+            console.log('📊 Summary API Response:', JSON.stringify(summaryData, null, 2));
+            console.log(`🔢 Total symbols found: ${totalCount || 'Unknown'}`);
+          } catch (e) {
+            console.log('📊 Raw Summary Response:', event.responseData);
+          }
+        }
+      }
+      eventCount++;
+      logger.info(`📡 Event ${eventCount}: ${event.type} ${event.url}`);
+    });
+
+    logger.info('⏳ Waiting for page load...');
+    await page.waitForLoadState('domcontentloaded', { timeout: 20000 });
+    logger.info('✅ Page loaded');
+
+    // RIGHT HERE - Interact with the page to find Stocks checkbox and Apply button
+    logger.info('🔍 Looking for Products tab...');
+
+    // Wait for the page to fully load
+    await page.waitForTimeout(20000);
+
+    // First, click on the Products tab
+    const productsTab = page.locator('#productSearchTab[role="tab"][href="#products"]');
+    await productsTab.waitFor({ timeout: 20000 });
+    logger.info('✅ Found Products tab');
+
+    logger.info('🖱️ Clicking Products tab...');
+    await productsTab.click();
+    logger.info('✅ Products tab clicked');
+
+    // Wait for the tab content to load
+    await page.waitForTimeout(5000);
+
+    // Click on the Asset Classes accordion to expand it
+    logger.info('🔍 Looking for Asset Classes accordion...');
+    const assetClassesAccordion = page.locator(
+      '#products .accordion-item #acc-products .accordion_btn:has-text("Asset Classes")'
+    );
+    await assetClassesAccordion.waitFor({ timeout: 10000 });
+    logger.info('✅ Found Asset Classes accordion');
+
+    logger.info('🖱️ Clicking Asset Classes accordion...');
+    await assetClassesAccordion.click();
+    logger.info('✅ Asset Classes accordion clicked');
+
+    // Wait for the accordion content to expand
+    await page.waitForTimeout(2000);
+
+    logger.info('🔍 Looking for Stocks checkbox...');
+
+    // Find the span with class "fs-7 checkbox-text" and inner text containing "Stocks"
+    const stocksSpan = page.locator('span.fs-7.checkbox-text:has-text("Stocks")');
+    await stocksSpan.waitFor({ timeout: 10000 });
+    logger.info('✅ Found Stocks span');
+
+    // Find the checkbox by looking in the same parent container
+    const parentContainer = stocksSpan.locator('..');
+    const checkbox = parentContainer.locator('input[type="checkbox"]');
+
+    if ((await checkbox.count()) > 0) {
+      logger.info('📋 Clicking Stocks checkbox...');
+      await checkbox.first().check();
+      logger.info('✅ Stocks checkbox checked');
+    } else {
+      logger.info('⚠️ Could not find checkbox near Stocks text');
+    }
+
+    // Wait a moment for any UI updates
+    await page.waitForTimeout(1000);
+
+    // Find and click the nearest Apply button
+    logger.info('🔍 Looking for Apply button...');
+    const applyButton = page.locator(
+      'button:has-text("Apply"), input[type="submit"][value*="Apply"], input[type="button"][value*="Apply"]'
+    );
+
+    if ((await applyButton.count()) > 0) {
+      logger.info('🎯 Clicking Apply button...');
+      await applyButton.first().click();
+      logger.info('✅ Apply button clicked');
+
+      // Wait for any network requests triggered by the Apply button
+      await page.waitForTimeout(2000);
+    } else {
+      logger.info('⚠️ Could not find Apply button');
+    }
+
+    return 0;
+  } catch (error) {
+    logger.error('Failed to fetch IB symbol summary', { error });
+    return 0;
+  }
+}
+// Optional: Export a convenience object that groups related tasks
+export const ibTasks = {
+  fetchSymbolSummary,
+};

apps/data-service/src/providers/proxy.provider.ts

@@ -1,7 +1,6 @@
 import { ProxyInfo } from 'libs/http/src/types';
-import { ProviderConfig } from '../services/provider-registry.service';
 import { getLogger } from '@stock-bot/logger';
-import { BatchProcessor } from '../utils/batch-processor';
+import { ProviderConfig } from '../services/provider-registry.service';
 
 // Create logger for this provider
 const logger = getLogger('proxy-provider');
@@ -15,12 +14,12 @@ const getEvery24HourCron = (): string => {
 };
 
 export const proxyProvider: ProviderConfig = {
-  name: 'proxy-service',
-  service: 'proxy',
+  name: 'proxy-provider',
   operations: {
-    'fetch-and-check': async (payload: { sources?: string[] }) => {
+    'fetch-and-check': async (_payload: { sources?: string[] }) => {
       const { proxyService } = await import('./proxy.tasks');
       const { queueManager } = await import('../services/queue.service');
+      const { processItems } = await import('../utils/batch-helpers');
 
       const proxies = await proxyService.fetchProxiesFromSources();
 
@@ -28,52 +27,39 @@ export const proxyProvider: ProviderConfig = {
         return { proxiesFetched: 0, jobsCreated: 0 };
       }
 
-      const batchProcessor = new BatchProcessor(queueManager);
-      
-      // Simplified configuration
-      const result = await batchProcessor.processItems({
-        items: proxies,
-        batchSize: parseInt(process.env.PROXY_BATCH_SIZE || '200'),
-        totalDelayMs: parseInt(process.env.PROXY_VALIDATION_HOURS || '4') * 60 * 60 * 1000 ,
-        jobNamePrefix: 'proxy',
-        operation: 'check-proxy',
-        service: 'proxy',
-        provider: 'proxy-service',
-        priority: 2,
-        useBatching: process.env.PROXY_DIRECT_MODE !== 'true', // Simple boolean flag
-        createJobData: (proxy: ProxyInfo) => ({ 
+      // Use generic function with routing parameters
+      const result = await processItems(
+        proxies,
+        (proxy, index) => ({
           proxy,
-          source: 'fetch-and-check' 
+          index,
+          source: 'batch-processing',
         }),
-        removeOnComplete: 5,
-        removeOnFail: 3
-      });
-
-      return {
-        proxiesFetched: result.totalItems,
-        ...result
-      };
-    },
-
-    'process-proxy-batch': async (payload: any) => {
-      // Process a batch of proxies - uses the fetch-and-check JobNamePrefix process-(proxy)-batch
-      const { queueManager } = await import('../services/queue.service');
-      const batchProcessor = new BatchProcessor(queueManager);
-      return await batchProcessor.processBatch(
-        payload,
-        (proxy: ProxyInfo) => ({
-          proxy,
-          source: payload.config?.source || 'batch-processing'
-        })
+        queueManager,
+        {
+          totalDelayHours: 12, //parseFloat(process.env.PROXY_VALIDATION_HOURS || '1'),
+          batchSize: parseInt(process.env.PROXY_BATCH_SIZE || '200'),
+          useBatching: process.env.PROXY_DIRECT_MODE !== 'true',
+          provider: 'proxy-provider',
+          operation: 'check-proxy',
+        }
       );
+      return result;
+    },
+    'process-batch-items': async (payload: any) => {
+      // Process a batch using the simplified batch helpers
+      const { processBatchJob } = await import('../utils/batch-helpers');
+      const { queueManager } = await import('../services/queue.service');
+
+      return await processBatchJob(payload, queueManager);
     },
 
     'check-proxy': async (payload: {
-      proxy: ProxyInfo, 
-      source?: string,
-      batchIndex?: number,
-      itemIndex?: number,
-      total?: number
+      proxy: ProxyInfo;
+      source?: string;
+      batchIndex?: number;
+      itemIndex?: number;
+      total?: number;
     }) => {
       const { checkProxy } = await import('./proxy.tasks');
 
@@ -84,57 +70,29 @@ export const proxyProvider: ProviderConfig = {
           proxy: `${payload.proxy.host}:${payload.proxy.port}`,
           isWorking: result.isWorking,
           responseTime: result.responseTime,
-          batchIndex: payload.batchIndex
         });
 
-        return { 
-          result, 
-          proxy: payload.proxy,
-          // Only include batch info if it exists (for batch mode)
-          ...(payload.batchIndex !== undefined && {
-            batchInfo: {
-              batchIndex: payload.batchIndex,
-              itemIndex: payload.itemIndex,
-              total: payload.total,
-              source: payload.source
-            }
-          })
-        };
+        return { result, proxy: payload.proxy };
       } catch (error) {
         logger.warn('Proxy validation failed', {
           proxy: `${payload.proxy.host}:${payload.proxy.port}`,
           error: error instanceof Error ? error.message : String(error),
-          batchIndex: payload.batchIndex
         });
 
-        return { 
-          result: { isWorking: false, error: String(error) }, 
-          proxy: payload.proxy,
-          // Only include batch info if it exists (for batch mode)
-          ...(payload.batchIndex !== undefined && {
-            batchInfo: {
-              batchIndex: payload.batchIndex,
-              itemIndex: payload.itemIndex,
-              total: payload.total,
-              source: payload.source
-            }
-          })
-        };
+        return { result: { isWorking: false, error: String(error) }, proxy: payload.proxy };
       }
-    }
+    },
   },
   scheduledJobs: [
-    {
-      type: 'proxy-maintenance',
-      operation: 'fetch-and-check',
-      payload: {},
-      // should remove and just run at the same time so app restarts dont keeping adding same jobs
-      cronPattern: getEvery24HourCron(),
-      priority: 5,
-      immediately: true, // Don't run immediately during startup to avoid conflicts
-      description: 'Fetch and validate proxy list from sources'
-    }
-  ]
+    // {
+    //   type: 'proxy-maintenance',
+    //   operation: 'fetch-and-check',
+    //   payload: {},
+    //   // should remove and just run at the same time so app restarts dont keeping adding same jobs
+    //   cronPattern: getEvery24HourCron(),
+    //   priority: 5,
+    //   immediately: true, // Don't run immediately during startup to avoid conflicts
+    //   description: 'Fetch and validate proxy list from sources',
+    // },
+  ],
 };
-
-

apps/data-service/src/providers/proxy.tasks.ts

@@ -1,7 +1,6 @@
-import { getLogger } from '@stock-bot/logger';
 import { createCache, type CacheProvider } from '@stock-bot/cache';
 import { HttpClient, ProxyInfo } from '@stock-bot/http';
-import pLimit from 'p-limit';
+import { getLogger } from '@stock-bot/logger';
 
 // Type definitions
 export interface ProxySource {
@@ -22,65 +21,196 @@ const PROXY_CONFIG = {
   CHECK_TIMEOUT: 7000,
   CHECK_IP: '99.246.102.205',
   CHECK_URL: 'https://proxy-detection.stare.gg/?api_key=bd406bf53ddc6abe1d9de5907830a955',
-  CONCURRENCY_LIMIT: 100,
   PROXY_SOURCES: [
-    {id: 'prxchk', url: 'https://raw.githubusercontent.com/prxchk/proxy-list/main/http.txt', protocol: 'http'},
-    {id: 'casals', url: 'https://raw.githubusercontent.com/casals-ar/proxy-list/main/http', protocol: 'http'},
-    {id: 'murong', url: 'https://raw.githubusercontent.com/MuRongPIG/Proxy-Master/main/http.txt', protocol: 'http'},
-    {id: 'vakhov-fresh', url: 'https://raw.githubusercontent.com/vakhov/fresh-proxy-list/master/http.txt', protocol: 'http'},
-    {id: 'sunny9577', url: 'https://raw.githubusercontent.com/sunny9577/proxy-scraper/master/proxies.txt', protocol: 'http'},
-    {id: 'kangproxy', url: 'https://raw.githubusercontent.com/officialputuid/KangProxy/refs/heads/KangProxy/http/http.txt', protocol: 'http'},
-    {id: 'gfpcom', url: 'https://raw.githubusercontent.com/gfpcom/free-proxy-list/refs/heads/main/list/http.txt', protocol: 'http'},
-    {id: 'dpangestuw', url: 'https://raw.githubusercontent.com/dpangestuw/Free-Proxy/refs/heads/main/http_proxies.txt', protocol: 'http'},
-    {id: 'gitrecon', url: 'https://raw.githubusercontent.com/gitrecon1455/fresh-proxy-list/refs/heads/main/proxylist.txt', protocol: 'http'},
-    {id: 'themiralay', url: 'https://raw.githubusercontent.com/themiralay/Proxy-List-World/refs/heads/master/data.txt', protocol: 'http'},
-    {id: 'vakhov-master', url: 'https://raw.githubusercontent.com/vakhov/fresh-proxy-list/refs/heads/master/http.txt', protocol: 'http'},
-    {id: 'casa-ls', url: 'https://raw.githubusercontent.com/casa-ls/proxy-list/refs/heads/main/http', protocol: 'http'},
-    {id: 'databay', url: 'https://raw.githubusercontent.com/databay-labs/free-proxy-list/refs/heads/master/http.txt', protocol: 'http'},
-    {id: 'breaking-tech', url: 'https://raw.githubusercontent.com/BreakingTechFr/Proxy_Free/refs/heads/main/proxies/http.txt', protocol: 'http'},
-    {id: 'speedx', url: 'https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt', protocol: 'http'},
-    {id: 'ercindedeoglu', url: 'https://raw.githubusercontent.com/ErcinDedeoglu/proxies/main/proxies/http.txt', protocol: 'http'},
-    {id: 'monosans', url: 'https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/http.txt', protocol: 'http'},
-    {id: 'tuanminpay', url: 'https://raw.githubusercontent.com/TuanMinPay/live-proxy/master/http.txt', protocol: 'http'},
+    {
+      id: 'prxchk',
+      url: 'https://raw.githubusercontent.com/prxchk/proxy-list/main/http.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'casals',
+      url: 'https://raw.githubusercontent.com/casals-ar/proxy-list/main/http',
+      protocol: 'http',
+    },
+    {
+      id: 'sunny9577',
+      url: 'https://raw.githubusercontent.com/sunny9577/proxy-scraper/master/proxies.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'themiralay',
+      url: 'https://raw.githubusercontent.com/themiralay/Proxy-List-World/refs/heads/master/data.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'casa-ls',
+      url: 'https://raw.githubusercontent.com/casa-ls/proxy-list/refs/heads/main/http',
+      protocol: 'http',
+    },
+    {
+      id: 'databay',
+      url: 'https://raw.githubusercontent.com/databay-labs/free-proxy-list/refs/heads/master/http.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'speedx',
+      url: 'https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'monosans',
+      url: 'https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/http.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'murong',
+      url: 'https://raw.githubusercontent.com/MuRongPIG/Proxy-Master/main/http.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'vakhov-fresh',
+      url: 'https://raw.githubusercontent.com/vakhov/fresh-proxy-list/master/http.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'kangproxy',
+      url: 'https://raw.githubusercontent.com/officialputuid/KangProxy/refs/heads/KangProxy/http/http.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'gfpcom',
+      url: 'https://raw.githubusercontent.com/gfpcom/free-proxy-list/refs/heads/main/list/http.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'dpangestuw',
+      url: 'https://raw.githubusercontent.com/dpangestuw/Free-Proxy/refs/heads/main/http_proxies.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'gitrecon',
+      url: 'https://raw.githubusercontent.com/gitrecon1455/fresh-proxy-list/refs/heads/main/proxylist.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'vakhov-master',
+      url: 'https://raw.githubusercontent.com/vakhov/fresh-proxy-list/refs/heads/master/http.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'breaking-tech',
+      url: 'https://raw.githubusercontent.com/BreakingTechFr/Proxy_Free/refs/heads/main/proxies/http.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'ercindedeoglu',
+      url: 'https://raw.githubusercontent.com/ErcinDedeoglu/proxies/main/proxies/http.txt',
+      protocol: 'http',
+    },
+    {
+      id: 'tuanminpay',
+      url: 'https://raw.githubusercontent.com/TuanMinPay/live-proxy/master/http.txt',
+      protocol: 'http',
+    },
 
-    // {url: 'https://raw.githubusercontent.com/r00tee/Proxy-List/refs/heads/main/Https.txt',protocol: 'https', },
-    // {url: 'https://raw.githubusercontent.com/ErcinDedeoglu/proxies/main/proxies/https.txt',protocol: 'https', },
-    // {url: 'https://raw.githubusercontent.com/vakhov/fresh-proxy-list/refs/heads/master/https.txt', protocol: 'https' },
-    // {url: 'https://raw.githubusercontent.com/databay-labs/free-proxy-list/refs/heads/master/https.txt',protocol: 'https', },
-    // {url: 'https://raw.githubusercontent.com/officialputuid/KangProxy/refs/heads/KangProxy/https/https.txt',protocol: 'https', },
-    // {url: 'https://raw.githubusercontent.com/zloi-user/hideip.me/refs/heads/master/https.txt',protocol: 'https', },
-    // {url: 'https://raw.githubusercontent.com/gfpcom/free-proxy-list/refs/heads/main/list/https.txt',protocol: 'https', },
-  ]
+    {
+      id: 'r00tee-https',
+      url: 'https://raw.githubusercontent.com/r00tee/Proxy-List/refs/heads/main/Https.txt',
+      protocol: 'https',
+    },
+    {
+      id: 'ercindedeoglu-https',
+      url: 'https://raw.githubusercontent.com/ErcinDedeoglu/proxies/main/proxies/https.txt',
+      protocol: 'https',
+    },
+    {
+      id: 'vakhov-fresh-https',
+      url: 'https://raw.githubusercontent.com/vakhov/fresh-proxy-list/refs/heads/master/https.txt',
+      protocol: 'https',
+    },
+    {
+      id: 'databay-https',
+      url: 'https://raw.githubusercontent.com/databay-labs/free-proxy-list/refs/heads/master/https.txt',
+      protocol: 'https',
+    },
+    {
+      id: 'kangproxy-https',
+      url: 'https://raw.githubusercontent.com/officialputuid/KangProxy/refs/heads/KangProxy/https/https.txt',
+      protocol: 'https',
+    },
+    {
+      id: 'zloi-user-https',
+      url: 'https://raw.githubusercontent.com/zloi-user/hideip.me/refs/heads/master/https.txt',
+      protocol: 'https',
+    },
+    {
+      id: 'gfpcom-https',
+      url: 'https://raw.githubusercontent.com/gfpcom/free-proxy-list/refs/heads/main/list/https.txt',
+      protocol: 'https',
+    },
+  ],
 };
 
 // Shared instances (module-scoped, not global)
+let isInitialized = false; // Track if resources are initialized
 let logger: ReturnType<typeof getLogger>;
 let cache: CacheProvider;
 let httpClient: HttpClient;
-let concurrencyLimit: ReturnType<typeof pLimit>;
 let proxyStats: ProxySource[] = PROXY_CONFIG.PROXY_SOURCES.map(source => ({
-      id: source.id,
-      total: 0,
-      working: 0,
-      lastChecked: new Date(),
-      protocol: source.protocol,
-      url: source.url,
-    }));
+  id: source.id,
+  total: 0,
+  working: 0,
+  lastChecked: new Date(),
+  protocol: source.protocol,
+  url: source.url,
+}));
 
+/**
+ * Initialize proxy resources (cache and shared dependencies)
+ * This should be called before any proxy operations
+ * @param waitForCache - Whether to wait for cache readiness (default: false for fallback mode)
+ */
+export async function initializeProxyResources(waitForCache = false): Promise<void> {
+  // Skip if already initialized
+  if (isInitialized) {
+    return;
+  }
+
+  logger = getLogger('proxy-tasks');
+  cache = createCache({
+    keyPrefix: 'proxy:',
+    ttl: PROXY_CONFIG.CACHE_TTL,
+    enableMetrics: true,
+  });
+
+  httpClient = new HttpClient({ timeout: 10000 }, logger);
+
+  if (waitForCache) {
+    logger.info('Initializing proxy cache...');
+    await cache.waitForReady(10000);
+    logger.info('Proxy cache initialized successfully');
+    logger.info('Proxy tasks initialized');
+  } else {
+    logger.info('Proxy tasks initialized (fallback mode)');
+  }
+  isInitialized = true;
+}
 
 // make a function that takes in source id and a boolean success and updates the proxyStats array
 async function updateProxyStats(sourceId: string, success: boolean) {
   const source = proxyStats.find(s => s.id === sourceId);
   if (source !== undefined) {
-    if(typeof source.working !== 'number')
+    if (typeof source.working !== 'number') {
       source.working = 0;
-    if(typeof source.total !== 'number')
+    }
+    if (typeof source.total !== 'number') {
       source.total = 0;
+    }
     source.total += 1;
     if (success) {
       source.working += 1;
     }
-    source.percentWorking = source.working / source.total * 100;
+    source.percentWorking = (source.working / source.total) * 100;
     source.lastChecked = new Date();
     await cache.set(`${PROXY_CONFIG.CACHE_STATS_KEY}:${source.id}`, source, PROXY_CONFIG.CACHE_TTL);
     return source;
@@ -91,64 +221,101 @@ async function updateProxyStats(sourceId: string, success: boolean) {
 
 // make a function that resets proxyStats
 async function resetProxyStats(): Promise<void> {
-    proxyStats = PROXY_CONFIG.PROXY_SOURCES.map(source => ({
-      id: source.id,
-      total: 0,
-      working: 0,
-      lastChecked: new Date(),
-      protocol: source.protocol,
-      url: source.url,
-    }));
-    for (const source of proxyStats) {
-      await cache.set(`${PROXY_CONFIG.CACHE_STATS_KEY}:${source.id}`, source, PROXY_CONFIG.CACHE_TTL);
-    }
-    return Promise.resolve();
+  proxyStats = PROXY_CONFIG.PROXY_SOURCES.map(source => ({
+    id: source.id,
+    total: 0,
+    working: 0,
+    lastChecked: new Date(),
+    protocol: source.protocol,
+    url: source.url,
+  }));
+  for (const source of proxyStats) {
+    await cache.set(`${PROXY_CONFIG.CACHE_STATS_KEY}:${source.id}`, source, PROXY_CONFIG.CACHE_TTL);
+  }
+  return Promise.resolve();
 }
 
+/**
+ * Update proxy data in cache with working/total stats and average response time
+ * @param proxy - The proxy to update
+ * @param isWorking - Whether the proxy is currently working
+ */
+async function updateProxyInCache(proxy: ProxyInfo, isWorking: boolean): Promise<void> {
+  const cacheKey = `${PROXY_CONFIG.CACHE_KEY}:${proxy.protocol}://${proxy.host}:${proxy.port}`;
 
-// Initialize shared resources
-async function initializeSharedResources() {
-  if (!logger) {
-    logger = getLogger('proxy-tasks');
-    cache = createCache({ 
-      keyPrefix: 'proxy:',
-      ttl: PROXY_CONFIG.CACHE_TTL,
-      enableMetrics: true
-    });
+  try {
+    const existing: any = await cache.get(cacheKey);
 
-    // Always initialize httpClient and concurrencyLimit first
-    httpClient = new HttpClient({ timeout: 10000 }, logger);
-    concurrencyLimit = pLimit(PROXY_CONFIG.CONCURRENCY_LIMIT);
-    
-    // Check if cache is ready, but don't block initialization
-    if (cache.isReady()) {
-      logger.info('Cache already ready');
-    } else {
-      logger.info('Cache not ready yet, tasks will use fallback mode');
-      // Try to wait briefly for cache to be ready, but don't block
-      cache.waitForReady(5000).then(() => {
-        logger.info('Cache became ready after initialization');
-      }).catch(error => {
-        logger.warn('Cache connection timeout, continuing with fallback mode:', {error: error.message});
+    // For failed proxies, only update if they already exist
+    if (!isWorking && !existing) {
+      logger.debug('Proxy not in cache, skipping failed update', {
+        proxy: `${proxy.host}:${proxy.port}`,
       });
+      return;
     }
 
-    logger.info('Proxy tasks initialized');
+    // Calculate new average response time if we have a response time
+    let newAverageResponseTime = existing?.averageResponseTime;
+    if (proxy.responseTime !== undefined) {
+      const existingAvg = existing?.averageResponseTime || 0;
+      const existingTotal = existing?.total || 0;
+
+      // Calculate weighted average: (existing_avg * existing_count + new_response) / (existing_count + 1)
+      newAverageResponseTime =
+        existingTotal > 0
+          ? (existingAvg * existingTotal + proxy.responseTime) / (existingTotal + 1)
+          : proxy.responseTime;
+    }
+
+    // Build updated proxy data
+    const updated = {
+      ...existing,
+      ...proxy, // Keep latest proxy info
+      total: (existing?.total || 0) + 1,
+      working: isWorking ? (existing?.working || 0) + 1 : existing?.working || 0,
+      isWorking,
+      lastChecked: new Date(),
+      // Add firstSeen only for new entries
+      ...(existing ? {} : { firstSeen: new Date() }),
+      // Update average response time if we calculated a new one
+      ...(newAverageResponseTime !== undefined
+        ? { averageResponseTime: newAverageResponseTime }
+        : {}),
+    };
+
+    // Calculate success rate
+    updated.successRate = updated.total > 0 ? (updated.working / updated.total) * 100 : 0;
+
+    // Save to cache: reset TTL for working proxies, keep existing TTL for failed ones
+    const cacheOptions = isWorking ? PROXY_CONFIG.CACHE_TTL : undefined;
+    await cache.set(cacheKey, updated, cacheOptions);
+
+    logger.debug(`Updated ${isWorking ? 'working' : 'failed'} proxy in cache`, {
+      proxy: `${proxy.host}:${proxy.port}`,
+      working: updated.working,
+      total: updated.total,
+      successRate: updated.successRate.toFixed(1) + '%',
+      avgResponseTime: updated.averageResponseTime
+        ? `${updated.averageResponseTime.toFixed(0)}ms`
+        : 'N/A',
+    });
+  } catch (error) {
+    logger.error('Failed to update proxy in cache', {
+      proxy: `${proxy.host}:${proxy.port}`,
+      error: error instanceof Error ? error.message : String(error),
+    });
   }
 }
 
 // Individual task functions
 export async function queueProxyFetch(): Promise<string> {
-  await initializeSharedResources();
-  
   const { queueManager } = await import('../services/queue.service');
   const job = await queueManager.addJob({
     type: 'proxy-fetch',
-    service: 'proxy',
     provider: 'proxy-service',
     operation: 'fetch-and-check',
     payload: {},
-    priority: 5
+    priority: 5,
   });
 
   const jobId = job.id || 'unknown';
@@ -157,16 +324,13 @@ export async function queueProxyFetch(): Promise<string> {
 }
 
 export async function queueProxyCheck(proxies: ProxyInfo[]): Promise<string> {
-  await initializeSharedResources();
-  
   const { queueManager } = await import('../services/queue.service');
   const job = await queueManager.addJob({
     type: 'proxy-check',
-    service: 'proxy',
     provider: 'proxy-service',
     operation: 'check-specific',
     payload: { proxies },
-    priority: 3
+    priority: 3,
   });
 
   const jobId = job.id || 'unknown';
@@ -175,42 +339,22 @@ export async function queueProxyCheck(proxies: ProxyInfo[]): Promise<string> {
 }
 
 export async function fetchProxiesFromSources(): Promise<ProxyInfo[]> {
-  await initializeSharedResources();
   await resetProxyStats();
-  
-  // Ensure concurrencyLimit is available before using it
-  if (!concurrencyLimit) {
-    logger.error('concurrencyLimit not initialized, using sequential processing');
-    const result = [];
-    for (const source of PROXY_CONFIG.PROXY_SOURCES) {
-      const proxies = await fetchProxiesFromSource(source);
-      result.push(...proxies);
-    }
-    let allProxies: ProxyInfo[] = result;
-    allProxies = removeDuplicateProxies(allProxies);
-    return allProxies;
-  }
-  
-  const sources = PROXY_CONFIG.PROXY_SOURCES.map(source => 
-    concurrencyLimit(() => fetchProxiesFromSource(source))
-  );
-  const result = await Promise.all(sources);
-  let allProxies: ProxyInfo[] = result.flat();
+  const fetchPromises = PROXY_CONFIG.PROXY_SOURCES.map(source => fetchProxiesFromSource(source));
+  const results = await Promise.all(fetchPromises);
+  let allProxies: ProxyInfo[] = results.flat();
   allProxies = removeDuplicateProxies(allProxies);
-  // await checkProxies(allProxies);
   return allProxies;
 }
 
 export async function fetchProxiesFromSource(source: ProxySource): Promise<ProxyInfo[]> {
-  await initializeSharedResources();
-  
   const allProxies: ProxyInfo[] = [];
 
   try {
     logger.info(`Fetching proxies from ${source.url}`);
 
     const response = await httpClient.get(source.url, {
-      timeout: 10000
+      timeout: 10000,
     });
 
     if (response.status !== 200) {
@@ -224,7 +368,9 @@ export async function fetchProxiesFromSource(source: ProxySource): Promise<Proxy
     for (const line of lines) {
       let trimmed = line.trim();
       trimmed = cleanProxyUrl(trimmed);
-      if (!trimmed || trimmed.startsWith('#')) continue;
+      if (!trimmed || trimmed.startsWith('#')) {
+        continue;
+      }
 
       // Parse formats like "host:port" or "host:port:user:pass"
       const parts = trimmed.split(':');
@@ -233,7 +379,7 @@ export async function fetchProxiesFromSource(source: ProxySource): Promise<Proxy
           source: source.id,
           protocol: source.protocol as 'http' | 'https' | 'socks4' | 'socks5',
           host: parts[0],
-          port: parseInt(parts[1])
+          port: parseInt(parts[1]),
         };
 
         if (!isNaN(proxy.port) && proxy.host) {
@@ -243,7 +389,6 @@ export async function fetchProxiesFromSource(source: ProxySource): Promise<Proxy
     }
 
     logger.info(`Parsed ${allProxies.length} proxies from ${source.url}`);
-    
   } catch (error) {
     logger.error(`Error fetching proxies from ${source.url}`, error);
     return [];
@@ -256,8 +401,6 @@ export async function fetchProxiesFromSource(source: ProxySource): Promise<Proxy
  * Check if a proxy is working
  */
 export async function checkProxy(proxy: ProxyInfo): Promise<ProxyInfo> {
-  await initializeSharedResources();
-  
   let success = false;
   logger.debug(`Checking Proxy:`, {
     protocol: proxy.protocol,
@@ -269,26 +412,25 @@ export async function checkProxy(proxy: ProxyInfo): Promise<ProxyInfo> {
     // Test the proxy
     const response = await httpClient.get(PROXY_CONFIG.CHECK_URL, {
       proxy,
-      timeout: PROXY_CONFIG.CHECK_TIMEOUT
+      timeout: PROXY_CONFIG.CHECK_TIMEOUT,
     });
 
     const isWorking = response.status >= 200 && response.status < 300;
-
     const result: ProxyInfo = {
       ...proxy,
       isWorking,
-      checkedAt: new Date(),
+      lastChecked: new Date(),
       responseTime: response.responseTime,
     };
 
     if (isWorking && !JSON.stringify(response.data).includes(PROXY_CONFIG.CHECK_IP)) {
       success = true;
-      await cache.set(`${PROXY_CONFIG.CACHE_KEY}:${proxy.protocol}://${proxy.host}:${proxy.port}`, result, PROXY_CONFIG.CACHE_TTL);
+      await updateProxyInCache(result, true);
     } else {
-      await cache.del(`${PROXY_CONFIG.CACHE_KEY}:${proxy.protocol}://${proxy.host}:${proxy.port}`);
+      await updateProxyInCache(result, false);
     }
 
-    if( proxy.source ){
+    if (proxy.source) {
       await updateProxyStats(proxy.source, success);
     }
 
@@ -299,35 +441,102 @@ export async function checkProxy(proxy: ProxyInfo): Promise<ProxyInfo> {
     });
 
     return result;
-
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-
     const result: ProxyInfo = {
       ...proxy,
       isWorking: false,
       error: errorMessage,
-      checkedAt: new Date()
+      lastChecked: new Date(),
     };
 
-    // If the proxy check failed, remove it from cache - success is here cause i think abort signal fails sometimes
-    // if (!success) {
-    //   await cache.set(`${PROXY_CONFIG.CACHE_KEY}:${proxy.protocol}://${proxy.host}:${proxy.port}`, result);
-    // }
-    if( proxy.source ){
+    // Update cache for failed proxy (increment total, don't update TTL)
+    await updateProxyInCache(result, false);
+
+    if (proxy.source) {
       await updateProxyStats(proxy.source, success);
     }
 
     logger.debug('Proxy check failed', {
       host: proxy.host,
       port: proxy.port,
-      error: errorMessage
+      error: errorMessage,
     });
 
     return result;
   }
 }
 
+/**
+ * Get a random active proxy from the cache
+ * @param protocol - Optional protocol filter ('http' | 'https' | 'socks4' | 'socks5')
+ * @param minSuccessRate - Minimum success rate percentage (default: 50)
+ * @returns A random working proxy or null if none found
+ */
+export async function getRandomActiveProxy(
+  protocol?: 'http' | 'https' | 'socks4' | 'socks5',
+  minSuccessRate: number = 50
+): Promise<ProxyInfo | null> {
+  try {
+    // Get all active proxy keys from cache
+    const pattern = protocol
+      ? `${PROXY_CONFIG.CACHE_KEY}:${protocol}://*`
+      : `${PROXY_CONFIG.CACHE_KEY}:*`;
+
+    const keys = await cache.keys(pattern);
+
+    if (keys.length === 0) {
+      logger.debug('No active proxies found in cache', { pattern });
+      return null;
+    }
+
+    // Shuffle the keys for randomness
+    const shuffledKeys = keys.sort(() => Math.random() - 0.5);
+
+    // Find a working proxy that meets the criteria
+    for (const key of shuffledKeys) {
+      try {
+        const proxyData: ProxyInfo | null = await cache.get(key);
+
+        if (
+          proxyData &&
+          proxyData.isWorking &&
+          (!proxyData.successRate || proxyData.successRate >= minSuccessRate)
+        ) {
+          logger.debug('Random active proxy selected', {
+            proxy: `${proxyData.host}:${proxyData.port}`,
+            protocol: proxyData.protocol,
+            successRate: proxyData.successRate?.toFixed(1) + '%',
+            avgResponseTime: proxyData.averageResponseTime
+              ? `${proxyData.averageResponseTime.toFixed(0)}ms`
+              : 'N/A',
+          });
+
+          return proxyData;
+        }
+      } catch (error) {
+        logger.debug('Error reading proxy from cache', { key, error: (error as Error).message });
+        continue;
+      }
+    }
+
+    logger.debug('No working proxies found meeting criteria', {
+      protocol,
+      minSuccessRate,
+      keysChecked: shuffledKeys.length,
+    });
+
+    return null;
+  } catch (error) {
+    logger.error('Error getting random active proxy', {
+      error: error instanceof Error ? error.message : String(error),
+      protocol,
+      minSuccessRate,
+    });
+    return null;
+  }
+}
+
 // Utility functions
 function cleanProxyUrl(url: string): string {
   return url

apps/data-service/src/providers/qm.provider.ts

@@ -1,15 +1,15 @@
-import { ProviderConfig } from '../services/provider-registry.service';
 import { getLogger } from '@stock-bot/logger';
+import { ProviderConfig } from '../services/provider-registry.service';
 
-const logger = getLogger('quotemedia-provider');
+const logger = getLogger('qm-provider');
 
-export const quotemediaProvider: ProviderConfig = {
-  name: 'quotemedia',
-  service: 'market-data',
-  operations: {    'live-data': async (payload: { symbol: string; fields?: string[] }) => {
-      logger.info('Fetching live data from QuoteMedia', { symbol: payload.symbol });
+export const qmProvider: ProviderConfig = {
+  name: 'qm',
+  operations: {
+    'live-data': async (payload: { symbol: string; fields?: string[] }) => {
+      logger.info('Fetching live data from qm', { symbol: payload.symbol });
 
-      // Simulate QuoteMedia API call
+      // Simulate qm API call
       const mockData = {
         symbol: payload.symbol,
         price: Math.random() * 1000 + 100,
@@ -17,8 +17,8 @@ export const quotemediaProvider: ProviderConfig = {
         change: (Math.random() - 0.5) * 20,
         changePercent: (Math.random() - 0.5) * 5,
         timestamp: new Date().toISOString(),
-        source: 'quotemedia',
-        fields: payload.fields || ['price', 'volume', 'change']
+        source: 'qm',
+        fields: payload.fields || ['price', 'volume', 'change'],
       };
 
       // Simulate network delay
@@ -32,16 +32,19 @@ export const quotemediaProvider: ProviderConfig = {
       from: Date;
       to: Date;
       interval?: string;
-      fields?: string[];    }) => {
-      logger.info('Fetching historical data from QuoteMedia', {
+      fields?: string[];
+    }) => {
+      logger.info('Fetching historical data from qm', {
         symbol: payload.symbol,
         from: payload.from,
         to: payload.to,
-        interval: payload.interval || '1d'
+        interval: payload.interval || '1d',
       });
 
       // Generate mock historical data
-      const days = Math.ceil((payload.to.getTime() - payload.from.getTime()) / (1000 * 60 * 60 * 24));
+      const days = Math.ceil(
+        (payload.to.getTime() - payload.from.getTime()) / (1000 * 60 * 60 * 24)
+      );
       const data = [];
 
       for (let i = 0; i < Math.min(days, 100); i++) {
@@ -53,7 +56,7 @@ export const quotemediaProvider: ProviderConfig = {
           low: Math.random() * 1000 + 100,
           close: Math.random() * 1000 + 100,
           volume: Math.floor(Math.random() * 1000000),
-          source: 'quotemedia'
+          source: 'qm',
         });
       }
 
@@ -64,14 +67,14 @@ export const quotemediaProvider: ProviderConfig = {
         symbol: payload.symbol,
         interval: payload.interval || '1d',
         data,
-        source: 'quotemedia',
-        totalRecords: data.length
+        source: 'qm',
+        totalRecords: data.length,
       };
     },
-      'batch-quotes': async (payload: { symbols: string[]; fields?: string[] }) => {
-      logger.info('Fetching batch quotes from QuoteMedia', {
+    'batch-quotes': async (payload: { symbols: string[]; fields?: string[] }) => {
+      logger.info('Fetching batch quotes from qm', {
         symbols: payload.symbols,
-        count: payload.symbols.length 
+        count: payload.symbols.length,
       });
 
       const quotes = payload.symbols.map(symbol => ({
@@ -80,7 +83,7 @@ export const quotemediaProvider: ProviderConfig = {
         volume: Math.floor(Math.random() * 1000000),
         change: (Math.random() - 0.5) * 20,
         timestamp: new Date().toISOString(),
-        source: 'quotemedia'
+        source: 'qm',
       }));
 
       // Simulate network delay
@@ -88,12 +91,13 @@ export const quotemediaProvider: ProviderConfig = {
 
       return {
         quotes,
-        source: 'quotemedia',
+        source: 'qm',
         timestamp: new Date().toISOString(),
-        totalSymbols: payload.symbols.length
+        totalSymbols: payload.symbols.length,
       };
-    },    'company-profile': async (payload: { symbol: string }) => {
-      logger.info('Fetching company profile from QuoteMedia', { symbol: payload.symbol });
+    },
+    'company-profile': async (payload: { symbol: string }) => {
+      logger.info('Fetching company profile from qm', { symbol: payload.symbol });
 
       // Simulate company profile data
       const profile = {
@@ -105,16 +109,17 @@ export const quotemediaProvider: ProviderConfig = {
         marketCap: Math.floor(Math.random() * 1000000000000),
         employees: Math.floor(Math.random() * 100000),
         website: `https://www.${payload.symbol.toLowerCase()}.com`,
-        source: 'quotemedia'
+        source: 'qm',
       };
 
       await new Promise(resolve => setTimeout(resolve, 150 + Math.random() * 100));
 
       return profile;
-    },    'options-chain': async (payload: { symbol: string; expiration?: string }) => {
-      logger.info('Fetching options chain from QuoteMedia', {
+    },
+    'options-chain': async (payload: { symbol: string; expiration?: string }) => {
+      logger.info('Fetching options chain from qm', {
         symbol: payload.symbol,
-        expiration: payload.expiration 
+        expiration: payload.expiration,
       });
 
       // Generate mock options data
@@ -124,7 +129,7 @@ export const quotemediaProvider: ProviderConfig = {
         bid: Math.random() * 10,
         ask: Math.random() * 10 + 0.5,
         volume: Math.floor(Math.random() * 1000),
-        openInterest: Math.floor(Math.random() * 5000)
+        openInterest: Math.floor(Math.random() * 5000),
       }));
 
       const puts = strikes.map(strike => ({
@@ -132,23 +137,25 @@ export const quotemediaProvider: ProviderConfig = {
         bid: Math.random() * 10,
         ask: Math.random() * 10 + 0.5,
         volume: Math.floor(Math.random() * 1000),
-        openInterest: Math.floor(Math.random() * 5000)
+        openInterest: Math.floor(Math.random() * 5000),
       }));
 
       await new Promise(resolve => setTimeout(resolve, 400 + Math.random() * 300));
-        return {
+      return {
         symbol: payload.symbol,
-        expiration: payload.expiration || new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
+        expiration:
+          payload.expiration ||
+          new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
         calls,
         puts,
-        source: 'quotemedia'
+        source: 'qm',
       };
-    }
+    },
   },
 
   scheduledJobs: [
     // {
-    //   type: 'quotemedia-premium-refresh',
+    //   type: 'qm-premium-refresh',
     //   operation: 'batch-quotes',
     //   payload: { symbols: ['AAPL', 'GOOGL', 'MSFT'] },
     //   cronPattern: '*/2 * * * *', // Every 2 minutes
@@ -156,7 +163,7 @@ export const quotemediaProvider: ProviderConfig = {
     //   description: 'Refresh premium quotes with detailed market data'
     // },
     // {
-    //   type: 'quotemedia-options-update',
+    //   type: 'qm-options-update',
     //   operation: 'options-chain',
     //   payload: { symbol: 'SPY' },
     //   cronPattern: '*/10 * * * *', // Every 10 minutes
@@ -164,12 +171,12 @@ export const quotemediaProvider: ProviderConfig = {
     //   description: 'Update options chain data for SPY ETF'
     // },
     // {
-    //   type: 'quotemedia-profiles',
+    //   type: 'qm-profiles',
     //   operation: 'company-profile',
     //   payload: { symbol: 'AAPL' },
     //   cronPattern: '0 9 * * 1-5', // Weekdays at 9 AM
     //   priority: 3,
     //   description: 'Update company profile data'
     // }
-  ]
+  ],
 };

apps/data-service/src/providers/yahoo.provider.ts

@@ -1,15 +1,12 @@
-import { ProviderConfig } from '../services/provider-registry.service';
 import { getLogger } from '@stock-bot/logger';
+import { ProviderConfig } from '../services/provider-registry.service';
 
 const logger = getLogger('yahoo-provider');
 
 export const yahooProvider: ProviderConfig = {
   name: 'yahoo-finance',
-  service: 'market-data',
   operations: {
     'live-data': async (payload: { symbol: string; modules?: string[] }) => {
-      
-      
       logger.info('Fetching live data from Yahoo Finance', { symbol: payload.symbol });
 
       // Simulate Yahoo Finance API call
@@ -28,7 +25,7 @@ export const yahooProvider: ProviderConfig = {
         fiftyTwoWeekLow: Math.random() * 800 + 50,
         timestamp: Date.now() / 1000,
         source: 'yahoo-finance',
-        modules: payload.modules || ['price', 'summaryDetail']
+        modules: payload.modules || ['price', 'summaryDetail'],
       };
 
       // Simulate network delay
@@ -42,7 +39,8 @@ export const yahooProvider: ProviderConfig = {
       period1: number;
       period2: number;
       interval?: string;
-      events?: string;    }) => {
+      events?: string;
+    }) => {
       const { getLogger } = await import('@stock-bot/logger');
       const logger = getLogger('yahoo-provider');
 
@@ -50,7 +48,7 @@ export const yahooProvider: ProviderConfig = {
         symbol: payload.symbol,
         period1: payload.period1,
         period2: payload.period2,
-        interval: payload.interval || '1d'
+        interval: payload.interval || '1d',
       });
 
       // Generate mock historical data
@@ -68,7 +66,7 @@ export const yahooProvider: ProviderConfig = {
           close: Math.random() * 1000 + 100,
           adjClose: Math.random() * 1000 + 100,
           volume: Math.floor(Math.random() * 1000000),
-          source: 'yahoo-finance'
+          source: 'yahoo-finance',
         });
       }
 
@@ -80,22 +78,26 @@ export const yahooProvider: ProviderConfig = {
         interval: payload.interval || '1d',
         timestamps: data.map(d => d.timestamp),
         indicators: {
-          quote: [{
-            open: data.map(d => d.open),
-            high: data.map(d => d.high),
-            low: data.map(d => d.low),
-            close: data.map(d => d.close),
-            volume: data.map(d => d.volume)
-          }],
-          adjclose: [{
-            adjclose: data.map(d => d.adjClose)
-          }]
+          quote: [
+            {
+              open: data.map(d => d.open),
+              high: data.map(d => d.high),
+              low: data.map(d => d.low),
+              close: data.map(d => d.close),
+              volume: data.map(d => d.volume),
+            },
+          ],
+          adjclose: [
+            {
+              adjclose: data.map(d => d.adjClose),
+            },
+          ],
         },
         source: 'yahoo-finance',
-        totalRecords: data.length
+        totalRecords: data.length,
       };
     },
-      'search': async (payload: { query: string; quotesCount?: number; newsCount?: number }) => {
+    search: async (payload: { query: string; quotesCount?: number; newsCount?: number }) => {
       const { getLogger } = await import('@stock-bot/logger');
       const logger = getLogger('yahoo-provider');
 
@@ -108,7 +110,7 @@ export const yahooProvider: ProviderConfig = {
         longname: `${payload.query} Corporation ${i}`,
         exchDisp: 'NASDAQ',
         typeDisp: 'Equity',
-        source: 'yahoo-finance'
+        source: 'yahoo-finance',
       }));
 
       const news = Array.from({ length: payload.newsCount || 3 }, (_, i) => ({
@@ -117,7 +119,7 @@ export const yahooProvider: ProviderConfig = {
         publisher: 'Financial News',
         providerPublishTime: Date.now() - i * 3600000,
         type: 'STORY',
-        source: 'yahoo-finance'
+        source: 'yahoo-finance',
       }));
 
       await new Promise(resolve => setTimeout(resolve, 200 + Math.random() * 200));
@@ -127,15 +129,16 @@ export const yahooProvider: ProviderConfig = {
         news,
         totalQuotes: quotes.length,
         totalNews: news.length,
-        source: 'yahoo-finance'
+        source: 'yahoo-finance',
       };
-    },    'financials': async (payload: { symbol: string; type?: 'income' | 'balance' | 'cash' }) => {
+    },
+    financials: async (payload: { symbol: string; type?: 'income' | 'balance' | 'cash' }) => {
       const { getLogger } = await import('@stock-bot/logger');
       const logger = getLogger('yahoo-provider');
 
       logger.info('Fetching financials from Yahoo Finance', {
         symbol: payload.symbol,
-        type: payload.type || 'income'
+        type: payload.type || 'income',
       });
 
       // Generate mock financial data
@@ -148,26 +151,27 @@ export const yahooProvider: ProviderConfig = {
           revenue: Math.floor(Math.random() * 100000000000),
           netIncome: Math.floor(Math.random() * 10000000000),
           totalAssets: Math.floor(Math.random() * 500000000000),
-          totalDebt: Math.floor(Math.random() * 50000000000)
+          totalDebt: Math.floor(Math.random() * 50000000000),
         })),
         quarterly: Array.from({ length: 4 }, (_, i) => ({
-          fiscalQuarter: `Q${4-i} 2024`,
+          fiscalQuarter: `Q${4 - i} 2024`,
           revenue: Math.floor(Math.random() * 25000000000),
-          netIncome: Math.floor(Math.random() * 2500000000)
+          netIncome: Math.floor(Math.random() * 2500000000),
         })),
-        source: 'yahoo-finance'
+        source: 'yahoo-finance',
       };
 
       await new Promise(resolve => setTimeout(resolve, 300 + Math.random() * 200));
 
       return financials;
-    },    'earnings': async (payload: { symbol: string; period?: 'annual' | 'quarterly' }) => {
+    },
+    earnings: async (payload: { symbol: string; period?: 'annual' | 'quarterly' }) => {
       const { getLogger } = await import('@stock-bot/logger');
       const logger = getLogger('yahoo-provider');
 
       logger.info('Fetching earnings from Yahoo Finance', {
         symbol: payload.symbol,
-        period: payload.period || 'quarterly'
+        period: payload.period || 'quarterly',
       });
 
       // Generate mock earnings data
@@ -175,20 +179,21 @@ export const yahooProvider: ProviderConfig = {
         symbol: payload.symbol,
         period: payload.period || 'quarterly',
         earnings: Array.from({ length: 8 }, (_, i) => ({
-          quarter: `Q${(i % 4) + 1} ${2024 - Math.floor(i/4)}`,
+          quarter: `Q${(i % 4) + 1} ${2024 - Math.floor(i / 4)}`,
           epsEstimate: Math.random() * 5,
           epsActual: Math.random() * 5,
           revenueEstimate: Math.floor(Math.random() * 50000000000),
           revenueActual: Math.floor(Math.random() * 50000000000),
-          surprise: (Math.random() - 0.5) * 2
+          surprise: (Math.random() - 0.5) * 2,
         })),
-        source: 'yahoo-finance'
+        source: 'yahoo-finance',
       };
 
       await new Promise(resolve => setTimeout(resolve, 250 + Math.random() * 150));
 
       return earnings;
-    },    'recommendations': async (payload: { symbol: string }) => {
+    },
+    recommendations: async (payload: { symbol: string }) => {
       const { getLogger } = await import('@stock-bot/logger');
       const logger = getLogger('yahoo-provider');
 
@@ -202,7 +207,7 @@ export const yahooProvider: ProviderConfig = {
           buy: Math.floor(Math.random() * 15),
           hold: Math.floor(Math.random() * 20),
           sell: Math.floor(Math.random() * 5),
-          strongSell: Math.floor(Math.random() * 3)
+          strongSell: Math.floor(Math.random() * 3),
         },
         trend: Array.from({ length: 4 }, (_, i) => ({
           period: `${i}m`,
@@ -210,14 +215,14 @@ export const yahooProvider: ProviderConfig = {
           buy: Math.floor(Math.random() * 15),
           hold: Math.floor(Math.random() * 20),
           sell: Math.floor(Math.random() * 5),
-          strongSell: Math.floor(Math.random() * 3)
+          strongSell: Math.floor(Math.random() * 3),
         })),
-        source: 'yahoo-finance'
+        source: 'yahoo-finance',
       };
 
       await new Promise(resolve => setTimeout(resolve, 180 + Math.random() * 120));
-        return recommendations;
-    }
+      return recommendations;
+    },
   },
 
   scheduledJobs: [
@@ -245,5 +250,5 @@ export const yahooProvider: ProviderConfig = {
     //   priority: 6,
     //   description: 'Check earnings data for Apple'
     // }
-  ]
+  ],
 };

apps/data-service/src/routes/health.routes.ts

@@ -0,0 +1,20 @@
+/**
+ * Health check routes
+ */
+import { Hono } from 'hono';
+import { queueManager } from '../services/queue.service';
+
+export const healthRoutes = new Hono();
+
+// Health check endpoint
+healthRoutes.get('/health', c => {
+  return c.json({
+    service: 'data-service',
+    status: 'healthy',
+    timestamp: new Date().toISOString(),
+    queue: {
+      status: 'running',
+      workers: queueManager.getWorkerCount(),
+    },
+  });
+});

apps/data-service/src/routes/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Routes index - exports all route modules
+ */
+export { healthRoutes } from './health.routes';
+export { queueRoutes } from './queue.routes';
+export { marketDataRoutes } from './market-data.routes';
+export { proxyRoutes } from './proxy.routes';
+export { testRoutes } from './test.routes';

apps/data-service/src/routes/market-data.routes.ts

@@ -0,0 +1,74 @@
+/**
+ * Market data routes
+ */
+import { Hono } from 'hono';
+import { getLogger } from '@stock-bot/logger';
+import { queueManager } from '../services/queue.service';
+
+const logger = getLogger('market-data-routes');
+
+export const marketDataRoutes = new Hono();
+
+// Market data endpoints
+marketDataRoutes.get('/api/live/:symbol', async c => {
+  const symbol = c.req.param('symbol');
+  logger.info('Live data request', { symbol });
+
+  try {
+    // Queue job for live data using Yahoo provider
+    const job = await queueManager.addJob({
+      type: 'market-data-live',
+      service: 'market-data',
+      provider: 'yahoo-finance',
+      operation: 'live-data',
+      payload: { symbol },
+    });
+    return c.json({
+      status: 'success',
+      message: 'Live data job queued',
+      jobId: job.id,
+      symbol,
+    });
+  } catch (error) {
+    logger.error('Failed to queue live data job', { symbol, error });
+    return c.json({ status: 'error', message: 'Failed to queue live data job' }, 500);
+  }
+});
+
+marketDataRoutes.get('/api/historical/:symbol', async c => {
+  const symbol = c.req.param('symbol');
+  const from = c.req.query('from');
+  const to = c.req.query('to');
+
+  logger.info('Historical data request', { symbol, from, to });
+
+  try {
+    const fromDate = from ? new Date(from) : new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); // 30 days ago
+    const toDate = to ? new Date(to) : new Date(); // Now
+
+    // Queue job for historical data using Yahoo provider
+    const job = await queueManager.addJob({
+      type: 'market-data-historical',
+      service: 'market-data',
+      provider: 'yahoo-finance',
+      operation: 'historical-data',
+      payload: {
+        symbol,
+        from: fromDate.toISOString(),
+        to: toDate.toISOString(),
+      },
+    });
+
+    return c.json({
+      status: 'success',
+      message: 'Historical data job queued',
+      jobId: job.id,
+      symbol,
+      from: fromDate,
+      to: toDate,
+    });
+  } catch (error) {
+    logger.error('Failed to queue historical data job', { symbol, from, to, error });
+    return c.json({ status: 'error', message: 'Failed to queue historical data job' }, 500);
+  }
+});

apps/data-service/src/routes/proxy.routes.ts

@@ -0,0 +1,76 @@
+/**
+ * Proxy management routes
+ */
+import { Hono } from 'hono';
+import { getLogger } from '@stock-bot/logger';
+import { queueManager } from '../services/queue.service';
+
+const logger = getLogger('proxy-routes');
+
+export const proxyRoutes = new Hono();
+
+// Proxy management endpoints
+proxyRoutes.post('/api/proxy/fetch', async c => {
+  try {
+    const job = await queueManager.addJob({
+      type: 'proxy-fetch',
+      provider: 'proxy-provider',
+      operation: 'fetch-and-check',
+      payload: {},
+      priority: 5,
+    });
+
+    return c.json({
+      status: 'success',
+      jobId: job.id,
+      message: 'Proxy fetch job queued',
+    });
+  } catch (error) {
+    logger.error('Failed to queue proxy fetch', { error });
+    return c.json({ status: 'error', message: 'Failed to queue proxy fetch' }, 500);
+  }
+});
+
+proxyRoutes.post('/api/proxy/check', async c => {
+  try {
+    const { proxies } = await c.req.json();
+    const job = await queueManager.addJob({
+      type: 'proxy-check',
+      provider: 'proxy-provider',
+      operation: 'check-specific',
+      payload: { proxies },
+      priority: 8,
+    });
+
+    return c.json({
+      status: 'success',
+      jobId: job.id,
+      message: `Proxy check job queued for ${proxies.length} proxies`,
+    });
+  } catch (error) {
+    logger.error('Failed to queue proxy check', { error });
+    return c.json({ status: 'error', message: 'Failed to queue proxy check' }, 500);
+  }
+});
+
+// Get proxy stats via queue
+proxyRoutes.get('/api/proxy/stats', async c => {
+  try {
+    const job = await queueManager.addJob({
+      type: 'proxy-stats',
+      provider: 'proxy-provider',
+      operation: 'get-stats',
+      payload: {},
+      priority: 3,
+    });
+
+    return c.json({
+      status: 'success',
+      jobId: job.id,
+      message: 'Proxy stats job queued',
+    });
+  } catch (error) {
+    logger.error('Failed to queue proxy stats', { error });
+    return c.json({ status: 'error', message: 'Failed to queue proxy stats' }, 500);
+  }
+});

apps/data-service/src/routes/queue.routes.ts

@@ -0,0 +1,71 @@
+/**
+ * Queue management routes
+ */
+import { Hono } from 'hono';
+import { getLogger } from '@stock-bot/logger';
+import { queueManager } from '../services/queue.service';
+
+const logger = getLogger('queue-routes');
+
+export const queueRoutes = new Hono();
+
+// Queue management endpoints
+queueRoutes.get('/api/queue/status', async c => {
+  try {
+    const status = await queueManager.getQueueStatus();
+    return c.json({ status: 'success', data: status });
+  } catch (error) {
+    logger.error('Failed to get queue status', { error });
+    return c.json({ status: 'error', message: 'Failed to get queue status' }, 500);
+  }
+});
+
+queueRoutes.post('/api/queue/job', async c => {
+  try {
+    const jobData = await c.req.json();
+    const job = await queueManager.addJob(jobData);
+    return c.json({ status: 'success', jobId: job.id });
+  } catch (error) {
+    logger.error('Failed to add job', { error });
+    return c.json({ status: 'error', message: 'Failed to add job' }, 500);
+  }
+});
+
+// Provider registry endpoints
+queueRoutes.get('/api/providers', async c => {
+  try {
+    const { providerRegistry } = await import('../services/provider-registry.service');
+    const providers = providerRegistry.getProviders();
+    return c.json({ status: 'success', providers });
+  } catch (error) {
+    logger.error('Failed to get providers', { error });
+    return c.json({ status: 'error', message: 'Failed to get providers' }, 500);
+  }
+});
+
+// Add new endpoint to see scheduled jobs
+queueRoutes.get('/api/scheduled-jobs', async c => {
+  try {
+    const { providerRegistry } = await import('../services/provider-registry.service');
+    const jobs = providerRegistry.getAllScheduledJobs();
+    return c.json({
+      status: 'success',
+      count: jobs.length,
+      jobs,
+    });
+  } catch (error) {
+    logger.error('Failed to get scheduled jobs info', { error });
+    return c.json({ status: 'error', message: 'Failed to get scheduled jobs' }, 500);
+  }
+});
+
+queueRoutes.post('/api/queue/drain', async c => {
+  try {
+    await queueManager.drainQueue();
+    const status = await queueManager.getQueueStatus();
+    return c.json({ status: 'success', message: 'Queue drained', queueStatus: status });
+  } catch (error) {
+    logger.error('Failed to drain queue', { error });
+    return c.json({ status: 'error', message: 'Failed to drain queue' }, 500);
+  }
+});

apps/data-service/src/routes/test.routes.ts

@@ -0,0 +1,87 @@
+/**
+ * Test and development routes for batch processing
+ */
+import { Hono } from 'hono';
+import { getLogger } from '@stock-bot/logger';
+import { queueManager } from '../services/queue.service';
+
+const logger = getLogger('test-routes');
+
+export const testRoutes = new Hono();
+
+// Test endpoint for new functional batch processing
+testRoutes.post('/api/test/batch-symbols', async c => {
+  try {
+    const { symbols, useBatching = false, totalDelayHours = 1 } = await c.req.json();
+    const { processItems } = await import('../utils/batch-helpers');
+
+    if (!symbols || !Array.isArray(symbols)) {
+      return c.json({ status: 'error', message: 'symbols array is required' }, 400);
+    }
+
+    const result = await processItems(
+      symbols,
+      (symbol, index) => ({
+        symbol,
+        index,
+        timestamp: new Date().toISOString(),
+      }),
+      queueManager,
+      {
+        totalDelayHours,
+        useBatching,
+        batchSize: 10,
+        priority: 1,
+        provider: 'test-provider',
+        operation: 'live-data',
+      }
+    );
+
+    return c.json({
+      status: 'success',
+      message: 'Batch processing started',
+      result,
+    });
+  } catch (error) {
+    logger.error('Failed to start batch symbol processing', { error });
+    return c.json({ status: 'error', message: 'Failed to start batch processing' }, 500);
+  }
+});
+
+testRoutes.post('/api/test/batch-custom', async c => {
+  try {
+    const { items, useBatching = false, totalDelayHours = 0.5 } = await c.req.json();
+    const { processItems } = await import('../utils/batch-helpers');
+
+    if (!items || !Array.isArray(items)) {
+      return c.json({ status: 'error', message: 'items array is required' }, 400);
+    }
+
+    const result = await processItems(
+      items,
+      (item, index) => ({
+        originalItem: item,
+        processIndex: index,
+        timestamp: new Date().toISOString(),
+      }),
+      queueManager,
+      {
+        totalDelayHours,
+        useBatching,
+        batchSize: 5,
+        priority: 1,
+        provider: 'test-provider',
+        operation: 'custom-test',
+      }
+    );
+
+    return c.json({
+      status: 'success',
+      message: 'Custom batch processing started',
+      result,
+    });
+  } catch (error) {
+    logger.error('Failed to start custom batch processing', { error });
+    return c.json({ status: 'error', message: 'Failed to start custom batch processing' }, 500);
+  }
+});

apps/data-service/src/services/provider-registry.service.ts

@@ -4,6 +4,15 @@ export interface JobHandler {
   (payload: any): Promise<any>;
 }
 
+export interface JobData {
+  type?: string;
+  provider: string;
+  operation: string;
+  payload: any;
+  priority?: number;
+  immediately?: boolean;
+}
+
 export interface ScheduledJob {
   type: string;
   operation: string;
@@ -16,41 +25,51 @@ export interface ScheduledJob {
 
 export interface ProviderConfig {
   name: string;
-  service: string;
   operations: Record<string, JobHandler>;
   scheduledJobs?: ScheduledJob[];
 }
 
-export class ProviderRegistry {
-  private logger = getLogger('provider-registry');
-  private providers = new Map<string, ProviderConfig>();
+export interface ProviderRegistry {
+  registerProvider: (config: ProviderConfig) => void;
+  getHandler: (provider: string, operation: string) => JobHandler | null;
+  getAllScheduledJobs: () => Array<{ provider: string; job: ScheduledJob }>;
+  getProviders: () => Array<{ key: string; config: ProviderConfig }>;
+  hasProvider: (provider: string) => boolean;
+  clear: () => void;
+}
+
+/**
+ * Create a new provider registry instance
+ */
+export function createProviderRegistry(): ProviderRegistry {
+  const logger = getLogger('provider-registry');
+  const providers = new Map<string, ProviderConfig>();
 
   /**
    * Register a provider with its operations
-   */  registerProvider(config: ProviderConfig): void {
-    const key = `${config.service}:${config.name}`;
-    this.providers.set(key, config);
-    this.logger.info(`Registered provider: ${key}`, { 
+   */
+  function registerProvider(config: ProviderConfig): void {
+    providers.set(config.name, config);
+    logger.info(`Registered provider: ${config.name}`, {
       operations: Object.keys(config.operations),
-      scheduledJobs: config.scheduledJobs?.length || 0
+      scheduledJobs: config.scheduledJobs?.length || 0,
     });
   }
 
   /**
    * Get a job handler for a specific provider and operation
    */
-  getHandler(service: string, provider: string, operation: string): JobHandler | null {
-    const key = `${service}:${provider}`;
-    const providerConfig = this.providers.get(key);
+  function getHandler(provider: string, operation: string): JobHandler | null {
+    const providerConfig = providers.get(provider);
 
     if (!providerConfig) {
-      this.logger.warn(`Provider not found: ${key}`);
+      logger.warn(`Provider not found: ${provider}`);
       return null;
     }
 
     const handler = providerConfig.operations[operation];
     if (!handler) {
-      this.logger.warn(`Operation not found: ${operation} in provider ${key}`);
+      logger.warn(`Operation not found: ${operation} in provider ${provider}`);
       return null;
     }
 
@@ -58,22 +77,17 @@ export class ProviderRegistry {
   }
 
   /**
-   * Get all registered providers
+   * Get all scheduled jobs from all providers
    */
-  getAllScheduledJobs(): Array<{
-    service: string;
-    provider: string;
-    job: ScheduledJob;
-  }> {
-    const allJobs: Array<{ service: string; provider: string; job: ScheduledJob }> = [];
+  function getAllScheduledJobs(): Array<{ provider: string; job: ScheduledJob }> {
+    const allJobs: Array<{ provider: string; job: ScheduledJob }> = [];
 
-    for (const [key, config] of this.providers) {
+    for (const [, config] of providers) {
       if (config.scheduledJobs) {
         for (const job of config.scheduledJobs) {
           allJobs.push({
-            service: config.service,
             provider: config.name,
-            job
+            job,
           });
         }
       }
@@ -82,34 +96,40 @@ export class ProviderRegistry {
     return allJobs;
   }
 
-  getProviders(): Array<{ key: string; config: ProviderConfig }> {
-    return Array.from(this.providers.entries()).map(([key, config]) => ({
+  /**
+   * Get all registered providers with their configurations
+   */
+  function getProviders(): Array<{ key: string; config: ProviderConfig }> {
+    return Array.from(providers.entries()).map(([key, config]) => ({
       key,
-      config
+      config,
     }));
   }
 
   /**
    * Check if a provider exists
    */
-  hasProvider(service: string, provider: string): boolean {
-    return this.providers.has(`${service}:${provider}`);
-  }
-
-  /**
-   * Get providers by service type
-   */
-  getProvidersByService(service: string): ProviderConfig[] {
-    return Array.from(this.providers.values()).filter(provider => provider.service === service);
+  function hasProvider(provider: string): boolean {
+    return providers.has(provider);
   }
 
   /**
    * Clear all providers (useful for testing)
    */
-  clear(): void {
-    this.providers.clear();
-    this.logger.info('All providers cleared');
+  function clear(): void {
+    providers.clear();
+    logger.info('All providers cleared');
   }
+
+  return {
+    registerProvider,
+    getHandler,
+    getAllScheduledJobs,
+    getProviders,
+    hasProvider,
+    clear,
+  };
 }
 
-export const providerRegistry = new ProviderRegistry();
+// Create the default shared registry instance
+export const providerRegistry = createProviderRegistry();

apps/data-service/src/services/queue.service.ts

@@ -1,28 +1,29 @@
-import { Queue, Worker, QueueEvents } from 'bullmq';
+import { Queue, QueueEvents, Worker, type Job } from 'bullmq';
 import { getLogger } from '@stock-bot/logger';
-import { providerRegistry } from './provider-registry.service';
-
-export interface JobData {
-  type: string;
-  service: string;
-  provider: string;
-  operation: string;
-  payload: any;
-  priority?: number;
-  immediately?: boolean;
-}
+import { providerRegistry, type JobData } from './provider-registry.service';
 
 export class QueueService {
   private logger = getLogger('queue-service');
   private queue!: Queue;
   private workers: Worker[] = [];
   private queueEvents!: QueueEvents;
-  private isInitialized = false;
+
+  private config = {
+    workers: parseInt(process.env.WORKER_COUNT || '5'),
+    concurrency: parseInt(process.env.WORKER_CONCURRENCY || '20'),
+    redis: {
+      host: process.env.DRAGONFLY_HOST || 'localhost',
+      port: parseInt(process.env.DRAGONFLY_PORT || '6379'),
+    },
+  };
+
+  private get isInitialized() {
+    return !!this.queue;
+  }
 
   constructor() {
     // Don't initialize in constructor to allow for proper async initialization
   }
-
   async initialize() {
     if (this.isInitialized) {
       this.logger.warn('Queue service already initialized');
@@ -31,29 +32,14 @@ export class QueueService {
 
     this.logger.info('Initializing queue service...');
 
-    // Register all providers first
-    await this.registerProviders();
-
-    const connection = {
-      host: process.env.DRAGONFLY_HOST || 'localhost',
-      port: parseInt(process.env.DRAGONFLY_PORT || '6379'),
-      // Add these Redis-specific options to fix the undeclared key issue
-      maxRetriesPerRequest: null,
-      retryDelayOnFailover: 100,
-      enableReadyCheck: false,
-      lazyConnect: false,
-      // Disable Redis Cluster mode if you're using standalone Redis/Dragonfly
-      enableOfflineQueue: true
-    };
-
-    // Worker configuration
-    const workerCount = parseInt(process.env.WORKER_COUNT || '5');
-    const concurrencyPerWorker = parseInt(process.env.WORKER_CONCURRENCY || '20');
-
-    this.logger.info('Connecting to Redis/Dragonfly', connection);
-
     try {
-      this.queue = new Queue('{data-service-queue}', {
+      // Step 1: Register providers
+      await this.registerProviders();
+
+      // Step 2: Setup queue and workers
+      const connection = this.getConnection();
+      const queueName = '{data-service-queue}';
+      this.queue = new Queue(queueName, {
         connection,
         defaultJobOptions: {
           removeOnComplete: 10,
@@ -62,73 +48,121 @@ export class QueueService {
           backoff: {
             type: 'exponential',
             delay: 1000,
-          }
-        }
+          },
+        },
       });
-      // Create multiple workers
-      for (let i = 0; i < workerCount; i++) {
-        const worker = new Worker(
-          '{data-service-queue}', 
-          this.processJob.bind(this), 
-          {
-            connection: { ...connection }, // Each worker gets its own connection
-            concurrency: concurrencyPerWorker,
-            maxStalledCount: 1,
-            stalledInterval: 30000,
-          }
-        );
-        // Add worker-specific logging
-        worker.on('ready', () => {
-          this.logger.info(`Worker ${i + 1} ready`, { workerId: i + 1 });
-        });
 
-        worker.on('error', (error) => {
-          this.logger.error(`Worker ${i + 1} error`, { workerId: i + 1, error });
-        });
+      this.queueEvents = new QueueEvents(queueName, { connection });
 
-        this.workers.push(worker);
-      }
-      this.queueEvents = new QueueEvents('{data-service-queue}', { connection });      // Test connection
+      // Step 3: Create workers
+      const { workerCount, totalConcurrency } = this.createWorkers(queueName, connection);
 
-      // Wait for all workers to be ready
-      await this.queue.waitUntilReady();
-      await Promise.all(this.workers.map(worker => worker.waitUntilReady()));
-      await this.queueEvents.waitUntilReady();
-
-      this.setupEventListeners();
-      this.isInitialized = true;
-      this.logger.info('Queue service initialized successfully');
+      // Step 4: Wait for readiness (parallel)
+      await Promise.all([
+        this.queue.waitUntilReady(),
+        this.queueEvents.waitUntilReady(),
+        ...this.workers.map(worker => worker.waitUntilReady()),
+      ]);
 
+      // Step 5: Setup events and scheduled tasks
+      this.setupQueueEvents();
       await this.setupScheduledTasks();
 
+      this.logger.info('Queue service initialized successfully', {
+        workers: workerCount,
+        totalConcurrency,
+      });
     } catch (error) {
       this.logger.error('Failed to initialize queue service', { error });
       throw error;
     }
   }
-
-  // Update getTotalConcurrency method
-  getTotalConcurrency() {
-    if (!this.isInitialized) {
-      return 0;
-    }
-    return this.workers.reduce((total, worker) => {
-      return total + (worker.opts.concurrency || 1);
-    }, 0);
+  private getConnection() {
+    return {
+      ...this.config.redis,
+      maxRetriesPerRequest: null,
+      retryDelayOnFailover: 100,
+      lazyConnect: false,
+    };
   }
 
+  private createWorkers(queueName: string, connection: any) {
+    for (let i = 0; i < this.config.workers; i++) {
+      const worker = new Worker(queueName, this.processJob.bind(this), {
+        connection: { ...connection },
+        concurrency: this.config.concurrency,
+        maxStalledCount: 1,
+        stalledInterval: 30000,
+      });
+
+      // Setup events inline
+      worker.on('ready', () => this.logger.info(`Worker ${i + 1} ready`));
+      worker.on('error', error => this.logger.error(`Worker ${i + 1} error`, { error }));
+
+      this.workers.push(worker);
+    }
+
+    return {
+      workerCount: this.config.workers,
+      totalConcurrency: this.config.workers * this.config.concurrency,
+    };
+  }
+  private setupQueueEvents() {
+    // Add comprehensive logging to see job flow
+    this.queueEvents.on('added', job => {
+      this.logger.debug('Job added to queue', {
+        id: job.jobId,
+      });
+    });
+
+    this.queueEvents.on('waiting', job => {
+      this.logger.debug('Job moved to waiting', {
+        id: job.jobId,
+      });
+    });
+
+    this.queueEvents.on('active', job => {
+      this.logger.debug('Job became active', {
+        id: job.jobId,
+      });
+    });
+
+    this.queueEvents.on('delayed', job => {
+      this.logger.debug('Job delayed', {
+        id: job.jobId,
+        delay: job.delay,
+      });
+    });
+
+    this.queueEvents.on('completed', job => {
+      this.logger.debug('Job completed', {
+        id: job.jobId,
+      });
+    });
+
+    this.queueEvents.on('failed', (job, error) => {
+      this.logger.debug('Job failed', {
+        id: job.jobId,
+        error: String(error),
+      });
+    });
+  }
   private async registerProviders() {
     this.logger.info('Registering providers...');
 
     try {
-      // Import and register all providers
-      const { proxyProvider } = await import('../providers/proxy.provider');
-      const { quotemediaProvider } = await import('../providers/quotemedia.provider');
-      const { yahooProvider } = await import('../providers/yahoo.provider');
+      // Define providers to register
+      const providers = [
+        { module: '../providers/proxy.provider', export: 'proxyProvider' },
+        { module: '../providers/ib.provider', export: 'ibProvider' },
+        // { module: '../providers/yahoo.provider', export: 'yahooProvider' },
+      ];
 
-      providerRegistry.registerProvider(proxyProvider);
-      providerRegistry.registerProvider(quotemediaProvider);
-      providerRegistry.registerProvider(yahooProvider);
+      // Import and register all providers
+      for (const { module, export: exportName } of providers) {
+        const providerModule = await import(module);
+        providerRegistry.registerProvider(providerModule[exportName]);
+      }
 
       this.logger.info('All providers registered successfully');
     } catch (error) {
@@ -136,71 +170,61 @@ export class QueueService {
       throw error;
     }
   }
-
-  private async processJob(job: any) {
-    const { service, provider, operation, payload }: JobData = job.data;
+  private async processJob(job: Job) {
+    const { provider, operation, payload }: JobData = job.data;
 
     this.logger.info('Processing job', {
       id: job.id,
-      service, 
       provider,
       operation,
-      payloadKeys: Object.keys(payload || {})
+      payloadKeys: Object.keys(payload || {}),
     });
-
     try {
-      // Get handler from registry
-      const handler = providerRegistry.getHandler(service, provider, operation);
+      let result;
 
-      if (!handler) {
-        throw new Error(`No handler found for ${service}:${provider}:${operation}`);
+      if (operation === 'process-batch-items') {
+        // Special handling for batch processing - requires 2 parameters
+        const { processBatchJob } = await import('../utils/batch-helpers');
+        result = await processBatchJob(payload, this);
+      } else {
+        // Regular handler lookup - requires 1 parameter
+        const handler = providerRegistry.getHandler(provider, operation);
+
+        if (!handler) {
+          throw new Error(`No handler found for ${provider}:${operation}`);
+        }
+
+        result = await handler(payload);
       }
 
-      // Execute the handler
-      const result = await handler(payload);
-      
       this.logger.info('Job completed successfully', {
         id: job.id,
-        service, 
         provider,
-        operation 
+        operation,
       });
 
       return result;
-
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       this.logger.error('Job failed', {
         id: job.id,
-        service, 
         provider,
         operation,
-        error: errorMessage 
+        error: errorMessage,
       });
       throw error;
     }
   }
 
-  async addBulk(jobs: any[]) : Promise<any[]> {
-    return await this.queue.addBulk(jobs)
+  async addBulk(jobs: any[]): Promise<any[]> {
+    return await this.queue.addBulk(jobs);
   }
-  private setupEventListeners() {
-    this.queueEvents.on('completed', (job) => {
-      this.logger.info('Job completed', { id: job.jobId });
-    });
 
-    this.queueEvents.on('failed', (job) => {
-      this.logger.error('Job failed', { id: job.jobId, error: job.failedReason });
-    });
-
-    // Note: Worker-specific events are already set up during worker creation
-    // No need for additional progress events since we handle them per-worker
+  private getTotalConcurrency() {
+    return this.workers.reduce((total, worker) => total + (worker.opts.concurrency || 1), 0);
   }
+
   private async setupScheduledTasks() {
-  try {
-    this.logger.info('Setting up scheduled tasks from providers...');
-    
-    // Get all scheduled jobs from all providers
     const allScheduledJobs = providerRegistry.getAllScheduledJobs();
 
     if (allScheduledJobs.length === 0) {
@@ -208,178 +232,85 @@ export class QueueService {
       return;
     }
 
-    // Get existing repeatable jobs for comparison
-    const existingJobs = await this.queue.getRepeatableJobs();
-    this.logger.info(`Found ${existingJobs.length} existing repeatable jobs`);
+    this.logger.info('Setting up scheduled tasks...', { count: allScheduledJobs.length });
 
-    let successCount = 0;
-    let failureCount = 0;
-    let updatedCount = 0;
-    let newCount = 0;
-
-    // Process each scheduled job
-    for (const { service, provider, job } of allScheduledJobs) {
-      try {
-        const jobKey = `${service}-${provider}-${job.operation}`;
-        
-        // Check if this job already exists
-        const existingJob = existingJobs.find(existing => 
-          existing.key?.includes(jobKey) || existing.name === job.type
+    // Use Promise.allSettled for parallel processing + better error handling
+    const results = await Promise.allSettled(
+      allScheduledJobs.map(async ({ provider, job }) => {
+        await this.addRecurringJob(
+          {
+            type: job.type,
+            provider,
+            operation: job.operation,
+            payload: job.payload,
+            priority: job.priority,
+            immediately: job.immediately || false,
+          },
+          job.cronPattern
         );
 
-        if (existingJob) {
-          // Check if the job needs updating (different cron pattern or config)
-          const needsUpdate = existingJob.pattern !== job.cronPattern;
+        return { provider, operation: job.operation };
+      })
+    );
 
-          if (needsUpdate) {
-            this.logger.info('Job configuration changed, updating', {
-              jobKey,
-              oldPattern: existingJob.pattern,
-              newPattern: job.cronPattern
-            });
-            updatedCount++;
-          } else {
-            this.logger.debug('Job unchanged, skipping', { jobKey });
-            successCount++;
-            continue;
-          }
-        } else {
-          newCount++;
-        }
+    // Log results
+    const successful = results.filter(r => r.status === 'fulfilled');
+    const failed = results.filter(r => r.status === 'rejected');
 
-        // Add delay between job registrations
-        await new Promise(resolve => setTimeout(resolve, 100));
-
-        await this.addRecurringJob({
-          type: job.type,
-          service: service,
-          provider: provider,
-          operation: job.operation,
-          payload: job.payload,
-          priority: job.priority,
-          immediately: job.immediately || false
-        }, job.cronPattern);
-
-        this.logger.info('Scheduled job registered', {
-          type: job.type,
-          service,
-          provider,
-          operation: job.operation,
-          cronPattern: job.cronPattern,
-          description: job.description,
-          immediately: job.immediately || false
-        });
-
-        successCount++;
-
-      } catch (error) {
+    if (failed.length > 0) {
+      failed.forEach((result, index) => {
+        const { provider, job } = allScheduledJobs[index];
         this.logger.error('Failed to register scheduled job', {
-          type: job.type,
-          service,
           provider,
-          error: error instanceof Error ? error.message : String(error)
+          operation: job.operation,
+          error: result.reason,
         });
-        failureCount++;
-      }
+      });
     }
 
-    this.logger.info(`Scheduled tasks setup complete`, {
-      total: allScheduledJobs.length,
-      successful: successCount,
-      failed: failureCount,
-      updated: updatedCount,
-      new: newCount
+    this.logger.info('Scheduled tasks setup complete', {
+      successful: successful.length,
+      failed: failed.length,
     });
-    
-  } catch (error) {
-    this.logger.error('Failed to setup scheduled tasks', error);
   }
-}
-
-  async addJob(jobData: JobData, options?: any) {
+  private async addJobInternal(jobData: JobData, options: any = {}) {
     if (!this.isInitialized) {
-      throw new Error('Queue service not initialized. Call initialize() first.');
+      throw new Error('Queue service not initialized');
     }
-    return this.queue.add(jobData.type, jobData, {
-      priority: jobData.priority || 0,
+
+    const jobType = jobData.type || `${jobData.provider}-${jobData.operation}`;
+    return this.queue.add(jobType, jobData, {
+      priority: jobData.priority || undefined,
       removeOnComplete: 10,
       removeOnFail: 5,
-      ...options
+      ...options,
     });
   }
 
+  async addJob(jobData: JobData, options?: any) {
+    return this.addJobInternal(jobData, options);
+  }
+
   async addRecurringJob(jobData: JobData, cronPattern: string, options?: any) {
-    if (!this.isInitialized) {
-      throw new Error('Queue service not initialized. Call initialize() first.');
-    }
+    const jobKey = `recurring-${jobData.provider}-${jobData.operation}`;
 
-    try {
-      // Create a unique job key for this specific job
-      const jobKey = `${jobData.service}-${jobData.provider}-${jobData.operation}`;
-      
-      // Get all existing repeatable jobs
-      const existingJobs = await this.queue.getRepeatableJobs();
-      
-      // Find and remove the existing job with the same key if it exists
-      const existingJob = existingJobs.find(job => {
-        // Check if this is the same job by comparing key components
-        return job.key?.includes(jobKey) || job.name === jobData.type;
-      });
-
-      if (existingJob) {
-        this.logger.info('Updating existing recurring job', {
-          jobKey,
-          existingPattern: existingJob.pattern,
-          newPattern: cronPattern
-        });
-
-        // Remove the existing job
-        await this.queue.removeRepeatableByKey(existingJob.key);
-        
-        // Small delay to ensure cleanup is complete
-        await new Promise(resolve => setTimeout(resolve, 100));
-      } else {
-        this.logger.info('Creating new recurring job', { jobKey, cronPattern });
-      }
-
-      // Add the new/updated recurring job
-      const job = await this.queue.add(jobData.type, jobData, {
-        repeat: { 
-          pattern: cronPattern,
-          tz: 'UTC',
-          immediately: jobData.immediately || false,
-        },
-        // Use a consistent jobId for this specific recurring job
-        jobId: `recurring-${jobKey}`,
-        removeOnComplete: 1,
-        removeOnFail: 1,
-        attempts: 2,
-        backoff: {
-          type: 'fixed',
-          delay: 5000
-        },
-        ...options
-      });
-
-      this.logger.info('Recurring job added/updated successfully', {
-        jobKey,
-        type: jobData.type,
-        cronPattern,
-        immediately: jobData.immediately || false
-      });
-
-      return job;
-
-    } catch (error) {
-      this.logger.error('Failed to add/update recurring job', {
-        jobData,
-        cronPattern,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
+    return this.addJobInternal(jobData, {
+      repeat: {
+        pattern: cronPattern,
+        tz: 'UTC',
+        immediately: jobData.immediately || false,
+      },
+      jobId: jobKey,
+      removeOnComplete: 1,
+      removeOnFail: 1,
+      attempts: 2,
+      backoff: {
+        type: 'fixed',
+        delay: 5000,
+      },
+      ...options,
+    });
   }
-
   async getJobStats() {
     if (!this.isInitialized) {
       throw new Error('Queue service not initialized. Call initialize() first.');
@@ -389,7 +320,7 @@ export class QueueService {
       this.queue.getActive(),
       this.queue.getCompleted(),
       this.queue.getFailed(),
-      this.queue.getDelayed()
+      this.queue.getDelayed(),
     ]);
 
     return {
@@ -397,81 +328,91 @@ export class QueueService {
       active: active.length,
       completed: completed.length,
       failed: failed.length,
-      delayed: delayed.length
+      delayed: delayed.length,
     };
   }
-
   async drainQueue() {
-    if (!this.isInitialized) {
-      await this.queue.drain()
+    if (this.isInitialized) {
+      await this.queue.drain();
     }
   }
-
   async getQueueStatus() {
     if (!this.isInitialized) {
-      throw new Error('Queue service not initialized. Call initialize() first.');
+      throw new Error('Queue service not initialized');
     }
+
     const stats = await this.getJobStats();
     return {
       ...stats,
-      workers: this.getWorkerCount(),
-      totalConcurrency: this.getTotalConcurrency(),
-      queue: this.queue.name,
-      connection: {
-        host: process.env.DRAGONFLY_HOST || 'localhost',
-        port: parseInt(process.env.DRAGONFLY_PORT || '6379')
-      }
+      workers: this.workers.length,
+      concurrency: this.getTotalConcurrency(),
     };
   }
-
-  getWorkerCount() {
-    if (!this.isInitialized) {
-      return 0;
-    }
-    return this.workers.length;
-  }
-
-  getRegisteredProviders() {
-    return providerRegistry.getProviders().map(({ key, config }) => ({
-      key,
-      name: config.name,
-      service: config.service,
-      operations: Object.keys(config.operations),
-      scheduledJobs: config.scheduledJobs?.length || 0
-    }));
-  }
-
-  getScheduledJobsInfo() {
-    return providerRegistry.getAllScheduledJobs().map(({ service, provider, job }) => ({
-      id: `${service}-${provider}-${job.type}`,
-      service,
-      provider,
-      type: job.type,
-      operation: job.operation,
-      cronPattern: job.cronPattern,
-      priority: job.priority,
-      description: job.description,
-      immediately: job.immediately || false
-    }));
-  }
   async shutdown() {
     if (!this.isInitialized) {
       this.logger.warn('Queue service not initialized, nothing to shutdown');
       return;
     }
-    this.logger.info('Shutting down queue service');
 
-    // Close all workers
-    this.logger.info(`Closing ${this.workers.length} workers...`);
-    await Promise.all(this.workers.map((worker, index) => {
-      this.logger.debug(`Closing worker ${index + 1}`);
-      return worker.close();
-    }));
+    this.logger.info('Shutting down queue service gracefully...');
 
-    await this.queue.close();
-    await this.queueEvents.close();
-    this.isInitialized = false;
-    this.logger.info('Queue service shutdown complete');
+    try {
+      // Step 1: Stop accepting new jobs and wait for current jobs to finish
+      this.logger.debug('Closing workers gracefully...');
+      const workerClosePromises = this.workers.map(async (worker, index) => {
+        this.logger.debug(`Closing worker ${index + 1}/${this.workers.length}`);
+        try {
+          // Wait for current jobs to finish, then close
+          await Promise.race([
+            worker.close(),
+            new Promise((_, reject) =>
+              setTimeout(() => reject(new Error(`Worker ${index + 1} close timeout`)), 5000)
+            ),
+          ]);
+          this.logger.debug(`Worker ${index + 1} closed successfully`);
+        } catch (error) {
+          this.logger.error(`Failed to close worker ${index + 1}`, { error });
+          // Force close if graceful close fails
+          await worker.close(true);
+        }
+      });
+
+      await Promise.allSettled(workerClosePromises);
+      this.logger.debug('All workers closed');
+
+      // Step 2: Close queue and events with timeout protection
+      this.logger.debug('Closing queue and events...');
+      await Promise.allSettled([
+        Promise.race([
+          this.queue.close(),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('Queue close timeout')), 3000)
+          ),
+        ]).catch(error => this.logger.error('Queue close error', { error })),
+
+        Promise.race([
+          this.queueEvents.close(),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('QueueEvents close timeout')), 3000)
+          ),
+        ]).catch(error => this.logger.error('QueueEvents close error', { error })),
+      ]);
+
+      this.logger.info('Queue service shutdown completed successfully');
+    } catch (error) {
+      this.logger.error('Error during queue service shutdown', { error });
+      // Force close everything as last resort
+      try {
+        await Promise.allSettled([
+          ...this.workers.map(worker => worker.close(true)),
+          this.queue.close(),
+          this.queueEvents.close(),
+        ]);
+      } catch (forceCloseError) {
+        this.logger.error('Force close also failed', { error: forceCloseError });
+      }
+      throw error;
+    }
   }
 }
 

apps/data-service/src/utils/batch-helpers.ts

@@ -0,0 +1,364 @@
+import { CacheProvider, createCache } from '@stock-bot/cache';
+import { getLogger } from '@stock-bot/logger';
+import type { QueueService } from '../services/queue.service';
+
+const logger = getLogger('batch-helpers');
+
+// Simple interfaces
+export interface ProcessOptions {
+  totalDelayHours: number;
+  batchSize?: number;
+  priority?: number;
+  useBatching?: boolean;
+  retries?: number;
+  ttl?: number;
+  removeOnComplete?: number;
+  removeOnFail?: number;
+  // Job routing information
+  provider?: string;
+  operation?: string;
+}
+
+export interface BatchResult {
+  jobsCreated: number;
+  mode: 'direct' | 'batch';
+  totalItems: number;
+  batchesCreated?: number;
+  duration: number;
+}
+
+// Cache instance for payload storage
+let cacheProvider: CacheProvider | null = null;
+
+function getCache(): CacheProvider {
+  if (!cacheProvider) {
+    cacheProvider = createCache({
+      keyPrefix: 'batch:',
+      ttl: 86400, // 24 hours default
+      enableMetrics: true,
+    });
+  }
+  return cacheProvider;
+}
+
+/**
+ * Initialize the batch cache before any batch operations
+ * This should be called during application startup
+ */
+export async function initializeBatchCache(): Promise<void> {
+  logger.info('Initializing batch cache...');
+  const cache = getCache();
+  await cache.waitForReady(10000);
+  logger.info('Batch cache initialized successfully');
+}
+
+/**
+ * Main function - processes items either directly or in batches
+ */
+export async function processItems<T>(
+  items: T[],
+  processor: (item: T, index: number) => any,
+  queue: QueueService,
+  options: ProcessOptions
+): Promise<BatchResult> {
+  const startTime = Date.now();
+
+  if (items.length === 0) {
+    return {
+      jobsCreated: 0,
+      mode: 'direct',
+      totalItems: 0,
+      duration: 0,
+    };
+  }
+
+  logger.info('Starting batch processing', {
+    totalItems: items.length,
+    mode: options.useBatching ? 'batch' : 'direct',
+    batchSize: options.batchSize,
+    totalDelayHours: options.totalDelayHours,
+  });
+
+  try {
+    const result = options.useBatching
+      ? await processBatched(items, processor, queue, options)
+      : await processDirect(items, processor, queue, options);
+
+    const duration = Date.now() - startTime;
+
+    logger.info('Batch processing completed', {
+      ...result,
+      duration: `${(duration / 1000).toFixed(1)}s`,
+    });
+
+    return { ...result, duration };
+  } catch (error) {
+    logger.error('Batch processing failed', error);
+    throw error;
+  }
+}
+
+/**
+ * Process items directly - each item becomes a separate job
+ */
+async function processDirect<T>(
+  items: T[],
+  processor: (item: T, index: number) => any,
+  queue: QueueService,
+  options: ProcessOptions
+): Promise<Omit<BatchResult, 'duration'>> {
+  const totalDelayMs = options.totalDelayHours * 60 * 60 * 1000;
+  const delayPerItem = totalDelayMs / items.length;
+
+  logger.info('Creating direct jobs', {
+    totalItems: items.length,
+    delayPerItem: `${(delayPerItem / 1000).toFixed(1)}s`,
+  });
+
+  const jobs = items.map((item, index) => ({
+    name: 'process-item',
+    data: {
+      type: 'process-item',
+      provider: options.provider || 'generic',
+      operation: options.operation || 'process-item',
+      payload: processor(item, index),
+      priority: options.priority || undefined,
+    },
+    opts: {
+      delay: index * delayPerItem,
+      priority: options.priority || undefined,
+      attempts: options.retries || 3,
+      removeOnComplete: options.removeOnComplete || 10,
+      removeOnFail: options.removeOnFail || 5,
+    },
+  }));
+
+  const createdJobs = await addJobsInChunks(queue, jobs);
+
+  return {
+    totalItems: items.length,
+    jobsCreated: createdJobs.length,
+    mode: 'direct',
+  };
+}
+
+/**
+ * Process items in batches - groups of items are stored and processed together
+ */
+async function processBatched<T>(
+  items: T[],
+  processor: (item: T, index: number) => any,
+  queue: QueueService,
+  options: ProcessOptions
+): Promise<Omit<BatchResult, 'duration'>> {
+  const batchSize = options.batchSize || 100;
+  const batches = createBatches(items, batchSize);
+  const totalDelayMs = options.totalDelayHours * 60 * 60 * 1000;
+  const delayPerBatch = totalDelayMs / batches.length;
+
+  logger.info('Creating batch jobs', {
+    totalItems: items.length,
+    batchSize,
+    totalBatches: batches.length,
+    delayPerBatch: `${(delayPerBatch / 1000 / 60).toFixed(2)} minutes`,
+  });
+
+  const batchJobs = await Promise.all(
+    batches.map(async (batch, batchIndex) => {
+      const payloadKey = await storePayload(batch, processor, options);
+
+      return {
+        name: 'process-batch',
+        data: {
+          type: 'process-batch',
+          provider: options.provider || 'generic',
+          operation: 'process-batch-items',
+          payload: {
+            payloadKey,
+            batchIndex,
+            totalBatches: batches.length,
+            itemCount: batch.length,
+          },
+          priority: options.priority || undefined,
+        },
+        opts: {
+          delay: batchIndex * delayPerBatch,
+          priority: options.priority || undefined,
+          attempts: options.retries || 3,
+          removeOnComplete: options.removeOnComplete || 10,
+          removeOnFail: options.removeOnFail || 5,
+        },
+      };
+    })
+  );
+
+  const createdJobs = await addJobsInChunks(queue, batchJobs);
+
+  return {
+    totalItems: items.length,
+    jobsCreated: createdJobs.length,
+    batchesCreated: batches.length,
+    mode: 'batch',
+  };
+}
+
+/**
+ * Process a batch job - loads payload from cache and creates individual jobs
+ */
+export async function processBatchJob(jobData: any, queue: QueueService): Promise<any> {
+  const { payloadKey, batchIndex, totalBatches, itemCount } = jobData;
+
+  logger.debug('Processing batch job', {
+    batchIndex,
+    totalBatches,
+    itemCount,
+  });
+
+  try {
+    const payload = await loadPayload(payloadKey);
+    if (!payload || !payload.items || !payload.processorStr) {
+      logger.error('Invalid payload data', { payloadKey, payload });
+      throw new Error(`Invalid payload data for key: ${payloadKey}`);
+    }
+
+    const { items, processorStr, options } = payload;
+
+    // Deserialize the processor function
+    const processor = new Function('return ' + processorStr)();
+
+    const jobs = items.map((item: any, index: number) => ({
+      name: 'process-item',
+      data: {
+        type: 'process-item',
+        provider: options.provider || 'generic',
+        operation: options.operation || 'generic',
+        payload: processor(item, index),
+        priority: options.priority || undefined,
+      },
+      opts: {
+        delay: index * (options.delayPerItem || 1000),
+        priority: options.priority || undefined,
+        attempts: options.retries || 3,
+      },
+    }));
+
+    const createdJobs = await addJobsInChunks(queue, jobs);
+
+    // Cleanup payload after successful processing
+    await cleanupPayload(payloadKey);
+
+    return {
+      batchIndex,
+      itemsProcessed: items.length,
+      jobsCreated: createdJobs.length,
+    };
+  } catch (error) {
+    logger.error('Batch job processing failed', { batchIndex, error });
+    throw error;
+  }
+}
+
+// Helper functions
+
+function createBatches<T>(items: T[], batchSize: number): T[][] {
+  const batches: T[][] = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    batches.push(items.slice(i, i + batchSize));
+  }
+  return batches;
+}
+
+async function storePayload<T>(
+  items: T[],
+  processor: (item: T, index: number) => any,
+  options: ProcessOptions
+): Promise<string> {
+  const cache = getCache();
+
+  // Create more specific key: batch:provider:operation:payload_timestamp_random
+  const timestamp = Date.now();
+  const randomId = Math.random().toString(36).substr(2, 9);
+  const provider = options.provider || 'generic';
+  const operation = options.operation || 'generic';
+
+  const key = `${provider}:${operation}:payload_${timestamp}_${randomId}`;
+
+  const payload = {
+    items,
+    processorStr: processor.toString(),
+    options: {
+      delayPerItem: 1000,
+      priority: options.priority || undefined,
+      retries: options.retries || 3,
+      // Store routing information for later use
+      provider: options.provider || 'generic',
+      operation: options.operation || 'generic',
+    },
+    createdAt: Date.now(),
+  };
+
+  logger.debug('Storing batch payload', {
+    key,
+    itemCount: items.length,
+  });
+
+  await cache.set(key, payload, options.ttl || 86400);
+
+  logger.debug('Stored batch payload successfully', {
+    key,
+    itemCount: items.length,
+  });
+
+  return key;
+}
+
+async function loadPayload(key: string): Promise<any> {
+  const cache = getCache();
+
+  logger.debug('Loading batch payload', { key });
+
+  const data = await cache.get(key);
+
+  if (!data) {
+    logger.error('Payload not found in cache', { key });
+    throw new Error(`Payload not found: ${key}`);
+  }
+
+  logger.debug('Loaded batch payload successfully', { key });
+  return data;
+}
+
+async function cleanupPayload(key: string): Promise<void> {
+  try {
+    const cache = getCache();
+    await cache.del(key);
+    logger.debug('Cleaned up payload', { key });
+  } catch (error) {
+    logger.warn('Failed to cleanup payload', { key, error });
+  }
+}
+
+async function addJobsInChunks(queue: QueueService, jobs: any[], chunkSize = 100): Promise<any[]> {
+  const allCreatedJobs = [];
+
+  for (let i = 0; i < jobs.length; i += chunkSize) {
+    const chunk = jobs.slice(i, i + chunkSize);
+    try {
+      const createdJobs = await queue.addBulk(chunk);
+      allCreatedJobs.push(...createdJobs);
+
+      // Small delay between chunks to avoid overwhelming Redis
+      if (i + chunkSize < jobs.length) {
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+    } catch (error) {
+      logger.error('Failed to add job chunk', {
+        startIndex: i,
+        chunkSize: chunk.length,
+        error,
+      });
+    }
+  }
+
+  return allCreatedJobs;
+}

apps/data-service/src/utils/batch-processor.ts

@@ -1,545 +0,0 @@
-import { getLogger } from '@stock-bot/logger';
-import { createCache, CacheProvider } from '@stock-bot/cache';
-
-export interface BatchConfig<T> {
-  items: T[];
-  batchSize?: number; // Optional - only used for batch mode
-  totalDelayMs: number;
-  jobNamePrefix: string;
-  operation: string;
-  service: string;
-  provider: string;
-  priority?: number;
-  createJobData: (item: T, index: number) => any;
-  removeOnComplete?: number;
-  removeOnFail?: number;
-  useBatching?: boolean; // Simple flag to choose mode
-  payloadTtlHours?: number; // TTL for stored payloads (default 24 hours)
-}
-
-const logger = getLogger('batch-processor');
-
-export class BatchProcessor {
-  private cacheProvider: CacheProvider;
-  private isReady = false;
-  private keyPrefix: string = 'batch:'; // Default key prefix for batch payloads
-  constructor(
-    private queueManager: any,
-    private cacheOptions?: { keyPrefix?: string; ttl?: number } // Optional cache configuration
-  ) {
-    this.keyPrefix = cacheOptions?.keyPrefix || 'batch:';    // Initialize cache provider with batch-specific settings
-    this.cacheProvider = createCache({
-      keyPrefix: this.keyPrefix,
-      ttl: cacheOptions?.ttl || 86400 * 2, // 48 hours default
-      enableMetrics: true
-    });
-    this.initialize();
-  }
-  /**
-   * Initialize the batch processor and wait for cache to be ready
-   */
-  async initialize(timeout: number = 10000): Promise<void> {
-    if (this.isReady) {
-      logger.warn('BatchProcessor already initialized');
-      return;
-    }
-
-    logger.info('Initializing BatchProcessor, waiting for cache to be ready...');
-    
-    try {
-      await this.cacheProvider.waitForReady(timeout);
-      this.isReady = true;
-      logger.info('BatchProcessor initialized successfully', {
-        cacheReady: this.cacheProvider.isReady(),
-        keyPrefix: this.keyPrefix,
-        ttlHours: ((this.cacheOptions?.ttl || 86400 * 2) / 3600).toFixed(1)
-      });
-    } catch (error) {
-      logger.warn('BatchProcessor cache not ready within timeout, continuing with fallback mode', {
-        error: error instanceof Error ? error.message : String(error),
-        timeout
-      });
-      // Don't throw - mark as ready anyway and let cache operations use their fallback mechanisms
-      this.isReady = true;
-    }
-  }
-  /**
-   * Check if the batch processor is ready
-   */
-  getReadyStatus(): boolean {
-    return this.isReady; // Don't require cache to be ready, let individual operations handle fallbacks
-  }
-  /**
-   * Generate a unique key for storing batch payload in Redis
-   * Note: The cache provider will add its keyPrefix ('batch:') automatically
-   */
-  private generatePayloadKey(jobNamePrefix: string, batchIndex: number): string {
-    return `payload:${jobNamePrefix}:${batchIndex}:${Date.now()}`;
-  }/**
-   * Store batch payload in Redis and return the key
-   */  private async storeBatchPayload<T>(
-    items: T[], 
-    config: BatchConfig<T>, 
-    batchIndex: number
-  ): Promise<string> {
-    const payloadKey = this.generatePayloadKey(config.jobNamePrefix, batchIndex);
-    const payload = {
-      items,
-      batchIndex,
-      config: {
-        ...config,
-        items: undefined // Don't store items twice
-      },
-      createdAt: new Date().toISOString()
-    };
-
-    const ttlSeconds = (config.payloadTtlHours || 24) * 60 * 60;
-    
-    try {
-      await this.cacheProvider.set(
-        payloadKey,
-        JSON.stringify(payload),
-        ttlSeconds
-      );
-
-      logger.info('Stored batch payload in Redis', {
-        payloadKey,
-        itemCount: items.length,
-        batchIndex,
-        ttlHours: config.payloadTtlHours || 24
-      });
-    } catch (error) {
-      logger.error('Failed to store batch payload, job will run without caching', {
-        payloadKey,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      // Don't throw - the job can still run, just without the cached payload
-    }
-
-    return payloadKey;
-  }/**
-   * Load batch payload from Redis
-   */
-  private async loadBatchPayload<T>(payloadKey: string): Promise<{
-    items: T[];
-    batchIndex: number;
-    config: BatchConfig<T>;
-  } | null> {
-    // Auto-initialize if not ready
-    if (!this.cacheProvider.isReady() || !this.isReady) {
-      logger.info('Cache provider not ready, initializing...', { payloadKey });
-      try {
-        await this.initialize();
-      } catch (error) {
-        logger.error('Failed to initialize cache provider for loading', {
-          payloadKey,
-          error: error instanceof Error ? error.message : String(error)
-        });
-        throw new Error('Cache provider initialization failed - cannot load batch payload');
-      }
-    }
-
-    try {
-      const payloadData = await this.cacheProvider.get<any>(payloadKey);
-      
-      if (!payloadData) {
-        logger.error('Batch payload not found in Redis', { payloadKey });
-        throw new Error('Batch payload not found in Redis');
-      }
-
-      // Handle both string and already-parsed object
-      let payload;
-      if (typeof payloadData === 'string') {
-        payload = JSON.parse(payloadData);
-      } else {
-        // Already parsed by cache provider
-        payload = payloadData;
-      }
-      
-      logger.info('Loaded batch payload from Redis', {
-        payloadKey,
-        itemCount: payload.items?.length || 0,
-        batchIndex: payload.batchIndex
-      });
-
-      return payload;
-    } catch (error) {
-      logger.error('Failed to load batch payload from Redis', {
-        payloadKey,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw new Error('Failed to load batch payload from Redis');
-    }
-  }
-  /**
-   * Unified method that handles both direct and batch approaches
-   */
-  async processItems<T>(config: BatchConfig<T>) {
-    // Check if BatchProcessor is ready
-    if (!this.getReadyStatus()) {
-      logger.warn('BatchProcessor not ready, attempting to initialize...');
-      await this.initialize();
-    }
-
-    const { items, useBatching = false } = config;
-
-    if (items.length === 0) {
-      return { totalItems: 0, jobsCreated: 0 };
-    }    // Final readiness check - wait briefly for cache to be ready
-    if (!this.cacheProvider.isReady()) {
-      logger.warn('Cache provider not ready, waiting briefly...');
-      try {
-        await this.cacheProvider.waitForReady(10000); // Wait up to 10 seconds
-        logger.info('Cache provider became ready');
-      } catch (error) {
-        logger.warn('Cache provider still not ready, continuing with fallback mode');
-        // Don't throw error - let the cache operations use their fallback mechanisms
-      }
-    }
-
-    logger.info('Starting item processing', {
-      totalItems: items.length,
-      mode: useBatching ? 'batch' : 'direct',
-      cacheReady: this.cacheProvider.isReady()
-    });
-
-    if (useBatching) {
-      return await this.createBatchJobs(config);
-    } else {
-      return await this.createDirectJobs(config);
-    }
-  }
-
-  private async createDirectJobs<T>(config: BatchConfig<T>) {
-    const {
-      items,
-      totalDelayMs,
-      jobNamePrefix,
-      operation,
-      service,
-      provider,
-      priority = 2,
-      createJobData,
-      removeOnComplete = 5,
-      removeOnFail = 3
-    } = config;
-
-    const delayPerItem = Math.floor(totalDelayMs / items.length);
-    const chunkSize = 100;
-    let totalJobsCreated = 0;
-    
-    logger.info('Creating direct jobs', {
-      totalItems: items.length,
-      delayPerItem: `${(delayPerItem / 1000).toFixed(1)}s`,
-      estimatedDuration: `${(totalDelayMs / 1000 / 60 / 60).toFixed(1)} hours`
-    });
-
-    // Process in chunks to avoid overwhelming Redis
-    for (let i = 0; i < items.length; i += chunkSize) {
-      const chunk = items.slice(i, i + chunkSize);
-      
-      const jobs = chunk.map((item, chunkIndex) => {
-        const globalIndex = i + chunkIndex;
-        return {
-          name: `${jobNamePrefix}-processing`,
-          data: {
-            type: `${jobNamePrefix}-processing`,
-            service,
-            provider,
-            operation,
-            payload: createJobData(item, globalIndex),
-            priority
-          },
-          opts: {
-            delay: globalIndex * delayPerItem,
-            jobId: `${jobNamePrefix}:${globalIndex}:${Date.now()}`,
-            removeOnComplete,
-            removeOnFail
-          }
-        };
-      });
-
-      try {
-        const createdJobs = await this.queueManager.queue.addBulk(jobs);
-        totalJobsCreated += createdJobs.length;
-        
-        // Log progress every 500 jobs
-        if (totalJobsCreated % 500 === 0 || i + chunkSize >= items.length) {
-          logger.info('Direct job creation progress', {
-            created: totalJobsCreated,
-            total: items.length,
-            percentage: `${((totalJobsCreated / items.length) * 100).toFixed(1)}%`
-          });
-        }
-      } catch (error) {
-        logger.error('Failed to create job chunk', {
-          startIndex: i,
-          chunkSize: chunk.length,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-
-    return { 
-      totalItems: items.length, 
-      jobsCreated: totalJobsCreated,
-      mode: 'direct'
-    };
-  }
-  private async createBatchJobs<T>(config: BatchConfig<T>) {
-    const {
-      items,
-      batchSize = 200,
-      totalDelayMs,
-      jobNamePrefix,
-      operation,
-      service,
-      provider,
-      priority = 3
-    } = config;
-
-    const totalBatches = Math.ceil(items.length / batchSize);
-    const delayPerBatch = Math.floor(totalDelayMs / totalBatches);
-    const chunkSize = 50; // Create batch jobs in chunks
-    let batchJobsCreated = 0;
-    
-    logger.info('Creating optimized batch jobs with Redis payload storage', {
-      totalItems: items.length,
-      batchSize,
-      totalBatches,
-      delayPerBatch: `${(delayPerBatch / 1000 / 60).toFixed(2)} minutes`,
-      payloadTtlHours: config.payloadTtlHours || 24
-    });
-
-    // Create batch jobs in chunks
-    for (let chunkStart = 0; chunkStart < totalBatches; chunkStart += chunkSize) {
-      const chunkEnd = Math.min(chunkStart + chunkSize, totalBatches);
-      const batchJobs = [];
-      
-      for (let batchIndex = chunkStart; batchIndex < chunkEnd; batchIndex++) {
-        const startIndex = batchIndex * batchSize;
-        const endIndex = Math.min(startIndex + batchSize, items.length);
-        const batchItems = items.slice(startIndex, endIndex);
-          // Store batch payload in Redis and get reference key
-        const payloadKey = await this.storeBatchPayload(batchItems, config, batchIndex);
-        batchJobs.push({
-          name: `${jobNamePrefix}-batch-processing`,
-          data: {
-            type: `${jobNamePrefix}-batch-processing`,
-            service,
-            provider,
-            operation: `process-${jobNamePrefix}-batch`,
-            payload: {
-              // Optimized: only store reference and metadata
-              payloadKey: payloadKey,
-              batchIndex,
-              total: totalBatches,
-              itemCount: batchItems.length,
-              configSnapshot: {
-                jobNamePrefix: config.jobNamePrefix,
-                operation: config.operation,
-                service: config.service,
-                provider: config.provider,
-                priority: config.priority,
-                removeOnComplete: config.removeOnComplete,
-                removeOnFail: config.removeOnFail,
-                totalDelayMs: config.totalDelayMs
-              }
-            },
-            priority
-          },
-          opts: {
-            delay: batchIndex * delayPerBatch,
-            jobId: `${jobNamePrefix}-batch:${batchIndex}:${Date.now()}`
-          }
-        });
-      }
-
-      try {
-        const createdJobs = await this.queueManager.queue.addBulk(batchJobs);
-        batchJobsCreated += createdJobs.length;
-          logger.info('Optimized batch chunk created', {
-          chunkStart: chunkStart + 1,
-          chunkEnd,
-          created: createdJobs.length,
-          totalCreated: batchJobsCreated,
-          progress: `${((chunkEnd / totalBatches) * 100).toFixed(1)}%`,
-          usingRedisStorage: true
-        });
-      } catch (error) {
-        logger.error('Failed to create batch chunk', {
-          chunkStart,
-          chunkEnd,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-
-      // Small delay between chunks
-      if (chunkEnd < totalBatches) {
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }
-    }    return {
-      totalItems: items.length,
-      batchJobsCreated,
-      totalBatches,
-      estimatedDurationHours: totalDelayMs / 1000 / 60 / 60,
-      mode: 'batch',
-      optimized: true
-    };
-  }
-  /**
-   * Process a batch (called by batch jobs)
-   * Supports both optimized (Redis payload storage) and fallback modes
-   */
-  async processBatch<T>(
-    jobPayload: any,
-    createJobData?: (item: T, index: number) => any
-  ) {
-    let batchData: {
-      items: T[];
-      batchIndex: number;
-      config: BatchConfig<T>;
-    };
-    
-    let total: number;
-    
-    // Check if this is an optimized batch with Redis payload storage
-    if (jobPayload.payloadKey) {
-      logger.info('Processing optimized batch with Redis payload storage', {
-        payloadKey: jobPayload.payloadKey,
-        batchIndex: jobPayload.batchIndex,
-        itemCount: jobPayload.itemCount
-      });
-      
-      // Load actual payload from Redis
-      const loadedPayload = await this.loadBatchPayload<T>(jobPayload.payloadKey);
-      
-      if (!loadedPayload) {
-        throw new Error(`Failed to load batch payload from Redis: ${jobPayload.payloadKey}`);
-      }
-      
-      batchData = loadedPayload;
-      total = jobPayload.total;
-      
-      // Clean up Redis payload after loading (optional - you might want to keep it for retry scenarios)
-      // await this.redisClient?.del(jobPayload.payloadKey);
-      
-    } else {
-      // Fallback: payload stored directly in job data
-      logger.info('Processing batch with inline payload storage', {
-        batchIndex: jobPayload.batchIndex,
-        itemCount: jobPayload.items?.length || 0
-      });
-      
-      batchData = {
-        items: jobPayload.items,
-        batchIndex: jobPayload.batchIndex,
-        config: jobPayload.config
-      };
-      total = jobPayload.total;
-    }
-    
-    const { items, batchIndex, config } = batchData;
-    
-    logger.info('Processing batch', {
-      batchIndex,
-      batchSize: items.length,
-      total,
-      progress: `${((batchIndex + 1) / total * 100).toFixed(2)}%`,
-      isOptimized: !!jobPayload.payloadKey
-    });
-
-    const totalBatchDelayMs = config.totalDelayMs / total;
-    const delayPerItem = Math.floor(totalBatchDelayMs / items.length);
-    
-    const jobs = items.map((item, itemIndex) => {
-      // Use the provided createJobData function or fall back to config
-      const jobDataFn = createJobData || config.createJobData;
-      
-      if (!jobDataFn) {
-        throw new Error('createJobData function is required');
-      }
-      
-      const userData = jobDataFn(item, itemIndex);
-      
-      return {
-        name: `${config.jobNamePrefix}-processing`,
-        data: {
-          type: `${config.jobNamePrefix}-processing`,
-          service: config.service,
-          provider: config.provider,
-          operation: config.operation,
-          payload: {
-            ...userData,
-            batchIndex,
-            itemIndex,
-            total,
-            source: userData.source || 'batch-processing'
-          },
-          priority: config.priority || 2
-        },
-        opts: {
-          delay: itemIndex * delayPerItem,
-          jobId: `${config.jobNamePrefix}:${batchIndex}:${itemIndex}:${Date.now()}`,
-          removeOnComplete: config.removeOnComplete || 5,
-          removeOnFail: config.removeOnFail || 3
-        }
-      };
-    });
-
-    try {
-      const createdJobs = await this.queueManager.queue.addBulk(jobs);
-      
-      logger.info('Batch processing completed', {
-        batchIndex,
-        totalItems: items.length,
-        jobsCreated: createdJobs.length,
-        progress: `${((batchIndex + 1) / total * 100).toFixed(2)}%`,
-        memoryOptimized: !!jobPayload.payloadKey
-      });
-
-      return {
-        batchIndex,
-        totalItems: items.length,
-        jobsCreated: createdJobs.length,
-        jobsFailed: 0,
-        payloadKey: jobPayload.payloadKey || null
-      };
-    } catch (error) {
-      logger.error('Failed to process batch', {
-        batchIndex,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      
-      return {
-        batchIndex,
-        totalItems: items.length,
-        jobsCreated: 0,
-        jobsFailed: items.length,
-        payloadKey: jobPayload.payloadKey || null
-      };
-    }
-  }  /**
-   * Clean up Redis payload after successful processing (optional)
-   */
-  async cleanupBatchPayload(payloadKey: string): Promise<void> {
-    if (!payloadKey) {
-      return;
-    }
-
-    if (!this.cacheProvider.isReady()) {
-      logger.warn('Cache provider not ready - skipping cleanup', { payloadKey });
-      return;
-    }
-    
-    try {
-      await this.cacheProvider.del(payloadKey);
-      logger.info('Cleaned up batch payload from Redis', { payloadKey });
-    } catch (error) {
-      logger.warn('Failed to cleanup batch payload', {
-        payloadKey,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-}

apps/data-service/tsconfig.json

@@ -5,7 +5,15 @@
     "rootDir": "./src"
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts", "**/test/**", "**/tests/**", "**/__tests__/**"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/test/**",
+    "**/tests/**",
+    "**/__tests__/**"
+  ],
   "references": [
     { "path": "../../libs/types" },
     { "path": "../../libs/config" },
@@ -15,6 +23,8 @@
     { "path": "../../libs/questdb-client" },
     { "path": "../../libs/mongodb-client" },
     { "path": "../../libs/event-bus" },
-    { "path": "../../libs/shutdown" }
+    { "path": "../../libs/shutdown" },
+    { "path": "../../libs/utils" },
+    { "path": "../../libs/browser" }
   ]
 }

apps/data-service/turbo.json

@@ -10,10 +10,20 @@
         "@stock-bot/logger#build",
         "@stock-bot/mongodb-client#build",
         "@stock-bot/questdb-client#build",
-        "@stock-bot/shutdown#build"
+        "@stock-bot/shutdown#build",
+        "@stock-bot/browser#build"
       ],
       "outputs": ["dist/**"],
-      "inputs": ["src/**", "package.json", "tsconfig.json", "!**/*.test.ts", "!**/*.spec.ts", "!**/test/**", "!**/tests/**", "!**/__tests__/**"]
+      "inputs": [
+        "src/**",
+        "package.json",
+        "tsconfig.json",
+        "!**/*.test.ts",
+        "!**/*.spec.ts",
+        "!**/test/**",
+        "!**/tests/**",
+        "!**/__tests__/**"
+      ]
     }
   }
 }

apps/execution-service/src/broker/interface.ts

@@ -58,7 +58,7 @@ export class MockBroker implements BrokerInterface {
       status: 'filled',
       executedPrice: order.price || 100, // Mock price
       executedAt: new Date(),
-      commission: 1.0
+      commission: 1.0,
     };
 
     this.orders.set(orderId, result);
@@ -88,7 +88,7 @@ export class MockBroker implements BrokerInterface {
       totalValue: 100000,
       availableCash: 50000,
       buyingPower: 200000,
-      marginUsed: 0
+      marginUsed: 0,
     };
   }
 }

apps/execution-service/src/execution/order-manager.ts

@@ -1,5 +1,5 @@
-import { Order, OrderResult } from '@stock-bot/types';
 import { logger } from '@stock-bot/logger';
+import { Order, OrderResult } from '@stock-bot/types';
 import { BrokerInterface } from '../broker/interface.ts';
 
 export class OrderManager {
@@ -12,7 +12,9 @@ export class OrderManager {
 
   async executeOrder(order: Order): Promise<OrderResult> {
     try {
-      logger.info(`Executing order: ${order.symbol} ${order.side} ${order.quantity} @ ${order.price}`);
+      logger.info(
+        `Executing order: ${order.symbol} ${order.side} ${order.quantity} @ ${order.price}`
+      );
 
       // Add to pending orders
       const orderId = `order_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
@@ -26,7 +28,6 @@ export class OrderManager {
 
       logger.info(`Order executed successfully: ${result.orderId}`);
       return result;
-      
     } catch (error) {
       logger.error('Order execution failed', error);
       throw error;

apps/execution-service/src/execution/risk-manager.ts

@@ -1,5 +1,5 @@
-import { Order } from '@stock-bot/types';
 import { getLogger } from '@stock-bot/logger';
+import { Order } from '@stock-bot/types';
 
 export interface RiskRule {
   name: string;
@@ -38,7 +38,7 @@ export class RiskManager {
       if (!result.isValid) {
         logger.warn(`Risk rule violation: ${rule.name}`, {
           order,
-          reason: result.reason 
+          reason: result.reason,
         });
         return result;
       }
@@ -58,12 +58,12 @@ export class RiskManager {
           return {
             isValid: false,
             reason: `Order size ${orderValue} exceeds maximum position size ${context.maxPositionSize}`,
-            severity: 'error'
+            severity: 'error',
           };
         }
 
         return { isValid: true, severity: 'info' };
-      }
+      },
     });
 
     // Balance check rule
@@ -76,12 +76,12 @@ export class RiskManager {
           return {
             isValid: false,
             reason: `Insufficient balance: need ${orderValue}, have ${context.accountBalance}`,
-            severity: 'error'
+            severity: 'error',
           };
         }
 
         return { isValid: true, severity: 'info' };
-      }
+      },
     });
 
     // Concentration risk rule
@@ -89,23 +89,25 @@ export class RiskManager {
       name: 'ConcentrationLimit',
       async validate(order: Order, context: RiskContext): Promise<RiskValidationResult> {
         const currentPosition = context.currentPositions.get(order.symbol) || 0;
-        const newPosition = order.side === 'buy' ? 
-          currentPosition + order.quantity : 
-          currentPosition - order.quantity;
+        const newPosition =
+          order.side === 'buy'
+            ? currentPosition + order.quantity
+            : currentPosition - order.quantity;
 
         const positionValue = Math.abs(newPosition) * (order.price || 0);
         const concentrationRatio = positionValue / context.accountBalance;
 
-        if (concentrationRatio > 0.25) { // 25% max concentration
+        if (concentrationRatio > 0.25) {
+          // 25% max concentration
           return {
             isValid: false,
             reason: `Position concentration ${(concentrationRatio * 100).toFixed(2)}% exceeds 25% limit`,
-            severity: 'warning'
+            severity: 'warning',
           };
         }
 
         return { isValid: true, severity: 'info' };
-      }
+      },
     });
   }
 }

apps/execution-service/src/index.ts

@@ -1,7 +1,8 @@
-import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
-import { getLogger } from '@stock-bot/logger';
+import { Hono } from 'hono';
 import { config } from '@stock-bot/config';
+import { getLogger } from '@stock-bot/logger';
+
 // import { BrokerInterface } from './broker/interface.ts';
 // import { OrderManager } from './execution/order-manager.ts';
 // import { RiskManager } from './execution/risk-manager.ts';
@@ -9,16 +10,16 @@ import { config } from '@stock-bot/config';
 const app = new Hono();
 const logger = getLogger('execution-service');
 // Health check endpoint
-app.get('/health', (c) => {
+app.get('/health', c => {
   return c.json({
     status: 'healthy',
     service: 'execution-service',
-    timestamp: new Date().toISOString()
+    timestamp: new Date().toISOString(),
   });
 });
 
 // Order execution endpoints
-app.post('/orders/execute', async (c) => {
+app.post('/orders/execute', async c => {
   try {
     const orderRequest = await c.req.json();
     logger.info('Received order execution request', orderRequest);
@@ -27,7 +28,7 @@ app.post('/orders/execute', async (c) => {
     return c.json({
       orderId: `order_${Date.now()}`,
       status: 'pending',
-      message: 'Order submitted for execution'
+      message: 'Order submitted for execution',
     });
   } catch (error) {
     logger.error('Order execution failed', error);
@@ -35,7 +36,7 @@ app.post('/orders/execute', async (c) => {
   }
 });
 
-app.get('/orders/:orderId/status', async (c) => {
+app.get('/orders/:orderId/status', async c => {
   const orderId = c.req.param('orderId');
 
   try {
@@ -43,7 +44,7 @@ app.get('/orders/:orderId/status', async (c) => {
     return c.json({
       orderId,
       status: 'filled',
-      executedAt: new Date().toISOString()
+      executedAt: new Date().toISOString(),
     });
   } catch (error) {
     logger.error('Failed to get order status', error);
@@ -51,7 +52,7 @@ app.get('/orders/:orderId/status', async (c) => {
   }
 });
 
-app.post('/orders/:orderId/cancel', async (c) => {
+app.post('/orders/:orderId/cancel', async c => {
   const orderId = c.req.param('orderId');
 
   try {
@@ -59,7 +60,7 @@ app.post('/orders/:orderId/cancel', async (c) => {
     return c.json({
       orderId,
       status: 'cancelled',
-      cancelledAt: new Date().toISOString()
+      cancelledAt: new Date().toISOString(),
     });
   } catch (error) {
     logger.error('Failed to cancel order', error);
@@ -68,7 +69,7 @@ app.post('/orders/:orderId/cancel', async (c) => {
 });
 
 // Risk management endpoints
-app.get('/risk/position/:symbol', async (c) => {
+app.get('/risk/position/:symbol', async c => {
   const symbol = c.req.param('symbol');
 
   try {
@@ -77,7 +78,7 @@ app.get('/risk/position/:symbol', async (c) => {
       symbol,
       position: 100,
       exposure: 10000,
-      risk: 'low'
+      risk: 'low',
     });
   } catch (error) {
     logger.error('Failed to get position risk', error);
@@ -89,9 +90,12 @@ const port = config.EXECUTION_SERVICE_PORT || 3004;
 
 logger.info(`Starting execution service on port ${port}`);
 
-serve({
-  fetch: app.fetch,
-  port
-}, (info) => {
-  logger.info(`Execution service is running on port ${info.port}`);
-});
+serve(
+  {
+    fetch: app.fetch,
+    port,
+  },
+  info => {
+    logger.info(`Execution service is running on port ${info.port}`);
+  }
+);

apps/execution-service/tsconfig.json

@@ -5,7 +5,15 @@
     "rootDir": "./src"
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts", "**/test/**", "**/tests/**", "**/__tests__/**"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/test/**",
+    "**/tests/**",
+    "**/__tests__/**"
+  ],
   "references": [
     { "path": "../../libs/types" },
     { "path": "../../libs/config" },

apps/execution-service/turbo.json

@@ -11,7 +11,16 @@
         "@stock-bot/shutdown#build"
       ],
       "outputs": ["dist/**"],
-      "inputs": ["src/**", "package.json", "tsconfig.json", "!**/*.test.ts", "!**/*.spec.ts", "!**/test/**", "!**/tests/**", "!**/__tests__/**"]
+      "inputs": [
+        "src/**",
+        "package.json",
+        "tsconfig.json",
+        "!**/*.test.ts",
+        "!**/*.spec.ts",
+        "!**/test/**",
+        "!**/tests/**",
+        "!**/__tests__/**"
+      ]
     }
   }
 }

apps/portfolio-service/src/analytics/performance-analyzer.ts

@@ -1,4 +1,4 @@
-import { PortfolioSnapshot, Trade } from '../portfolio/portfolio-manager.ts';
+import { PortfolioSnapshot } from '../portfolio/portfolio-manager';
 
 export interface PerformanceMetrics {
   totalReturn: number;
@@ -13,8 +13,8 @@ export interface PerformanceMetrics {
 }
 
 export interface RiskMetrics {
-  var95: number;      // Value at Risk (95% confidence)
-  cvar95: number;     // Conditional Value at Risk
+  var95: number; // Value at Risk (95% confidence)
+  cvar95: number; // Conditional Value at Risk
   maxDrawdown: number;
   downsideDeviation: number;
   correlationMatrix: Record<string, Record<string, number>>;
@@ -32,7 +32,9 @@ export class PerformanceAnalyzer {
     }
   }
 
-  calculatePerformanceMetrics(period: 'daily' | 'weekly' | 'monthly' = 'daily'): PerformanceMetrics {
+  calculatePerformanceMetrics(
+    period: 'daily' | 'weekly' | 'monthly' = 'daily'
+  ): PerformanceMetrics {
     if (this.snapshots.length < 2) {
       throw new Error('Need at least 2 snapshots to calculate performance');
     }
@@ -49,7 +51,7 @@ export class PerformanceAnalyzer {
       beta: this.calculateBeta(returns),
       alpha: this.calculateAlpha(returns, riskFreeRate),
       calmarRatio: this.calculateCalmarRatio(returns),
-      sortinoRatio: this.calculateSortinoRatio(returns, riskFreeRate)
+      sortinoRatio: this.calculateSortinoRatio(returns, riskFreeRate),
     };
   }
 
@@ -61,12 +63,14 @@ export class PerformanceAnalyzer {
       cvar95: this.calculateCVaR(returns, 0.95),
       maxDrawdown: this.calculateMaxDrawdown(),
       downsideDeviation: this.calculateDownsideDeviation(returns),
-      correlationMatrix: {} // TODO: Implement correlation matrix
+      correlationMatrix: {}, // TODO: Implement correlation matrix
     };
   }
 
-  private calculateReturns(period: 'daily' | 'weekly' | 'monthly'): number[] {
-    if (this.snapshots.length < 2) return [];
+  private calculateReturns(_period: 'daily' | 'weekly' | 'monthly'): number[] {
+    if (this.snapshots.length < 2) {
+      return [];
+    }
 
     const returns: number[] = [];
 
@@ -81,7 +85,9 @@ export class PerformanceAnalyzer {
   }
 
   private calculateTotalReturn(): number {
-    if (this.snapshots.length < 2) return 0;
+    if (this.snapshots.length < 2) {
+      return 0;
+    }
 
     const firstValue = this.snapshots[0].totalValue;
     const lastValue = this.snapshots[this.snapshots.length - 1].totalValue;
@@ -90,35 +96,46 @@ export class PerformanceAnalyzer {
   }
 
   private calculateAnnualizedReturn(returns: number[]): number {
-    if (returns.length === 0) return 0;
+    if (returns.length === 0) {
+      return 0;
+    }
 
     const avgReturn = returns.reduce((sum, ret) => sum + ret, 0) / returns.length;
     return Math.pow(1 + avgReturn, 252) - 1; // 252 trading days per year
   }
 
   private calculateVolatility(returns: number[]): number {
-    if (returns.length === 0) return 0;
+    if (returns.length === 0) {
+      return 0;
+    }
 
     const avgReturn = returns.reduce((sum, ret) => sum + ret, 0) / returns.length;
-    const variance = returns.reduce((sum, ret) => sum + Math.pow(ret - avgReturn, 2), 0) / returns.length;
+    const variance =
+      returns.reduce((sum, ret) => sum + Math.pow(ret - avgReturn, 2), 0) / returns.length;
 
     return Math.sqrt(variance * 252); // Annualized volatility
   }
 
   private calculateSharpeRatio(returns: number[], riskFreeRate: number): number {
-    if (returns.length === 0) return 0;
+    if (returns.length === 0) {
+      return 0;
+    }
 
     const avgReturn = returns.reduce((sum, ret) => sum + ret, 0) / returns.length;
     const annualizedReturn = Math.pow(1 + avgReturn, 252) - 1;
     const volatility = this.calculateVolatility(returns);
 
-    if (volatility === 0) return 0;
+    if (volatility === 0) {
+      return 0;
+    }
 
     return (annualizedReturn - riskFreeRate) / volatility;
   }
 
   private calculateMaxDrawdown(): number {
-    if (this.snapshots.length === 0) return 0;
+    if (this.snapshots.length === 0) {
+      return 0;
+    }
 
     let maxDrawdown = 0;
     let peak = this.snapshots[0].totalValue;
@@ -136,7 +153,9 @@ export class PerformanceAnalyzer {
   }
 
   private calculateBeta(returns: number[]): number {
-    if (returns.length === 0 || this.benchmarkReturns.length === 0) return 1.0;
+    if (returns.length === 0 || this.benchmarkReturns.length === 0) {
+      return 1.0;
+    }
 
     // Simple beta calculation - would need actual benchmark data
     return 1.0; // Placeholder
@@ -145,7 +164,7 @@ export class PerformanceAnalyzer {
   private calculateAlpha(returns: number[], riskFreeRate: number): number {
     const beta = this.calculateBeta(returns);
     const portfolioReturn = this.calculateAnnualizedReturn(returns);
-    const benchmarkReturn = 0.10; // 10% benchmark return (placeholder)
+    const benchmarkReturn = 0.1; // 10% benchmark return (placeholder)
 
     return portfolioReturn - (riskFreeRate + beta * (benchmarkReturn - riskFreeRate));
   }
@@ -154,7 +173,9 @@ export class PerformanceAnalyzer {
     const annualizedReturn = this.calculateAnnualizedReturn(returns);
     const maxDrawdown = this.calculateMaxDrawdown();
 
-    if (maxDrawdown === 0) return 0;
+    if (maxDrawdown === 0) {
+      return 0;
+    }
 
     return annualizedReturn / maxDrawdown;
   }
@@ -163,25 +184,36 @@ export class PerformanceAnalyzer {
     const annualizedReturn = this.calculateAnnualizedReturn(returns);
     const downsideDeviation = this.calculateDownsideDeviation(returns);
 
-    if (downsideDeviation === 0) return 0;
+    if (downsideDeviation === 0) {
+      return 0;
+    }
 
     return (annualizedReturn - riskFreeRate) / downsideDeviation;
   }
 
   private calculateDownsideDeviation(returns: number[]): number {
-    if (returns.length === 0) return 0;
+    if (returns.length === 0) {
+      return 0;
+    }
 
     const negativeReturns = returns.filter(ret => ret < 0);
-    if (negativeReturns.length === 0) return 0;
+    if (negativeReturns.length === 0) {
+      return 0;
+    }
 
-    const avgNegativeReturn = negativeReturns.reduce((sum, ret) => sum + ret, 0) / negativeReturns.length;
-    const variance = negativeReturns.reduce((sum, ret) => sum + Math.pow(ret - avgNegativeReturn, 2), 0) / negativeReturns.length;
+    const avgNegativeReturn =
+      negativeReturns.reduce((sum, ret) => sum + ret, 0) / negativeReturns.length;
+    const variance =
+      negativeReturns.reduce((sum, ret) => sum + Math.pow(ret - avgNegativeReturn, 2), 0) /
+      negativeReturns.length;
 
     return Math.sqrt(variance * 252); // Annualized
   }
 
   private calculateVaR(returns: number[], confidence: number): number {
-    if (returns.length === 0) return 0;
+    if (returns.length === 0) {
+      return 0;
+    }
 
     const sortedReturns = returns.slice().sort((a, b) => a - b);
     const index = Math.floor((1 - confidence) * sortedReturns.length);
@@ -190,13 +222,17 @@ export class PerformanceAnalyzer {
   }
 
   private calculateCVaR(returns: number[], confidence: number): number {
-    if (returns.length === 0) return 0;
+    if (returns.length === 0) {
+      return 0;
+    }
 
     const sortedReturns = returns.slice().sort((a, b) => a - b);
     const cutoffIndex = Math.floor((1 - confidence) * sortedReturns.length);
     const tailReturns = sortedReturns.slice(0, cutoffIndex + 1);
 
-    if (tailReturns.length === 0) return 0;
+    if (tailReturns.length === 0) {
+      return 0;
+    }
 
     const avgTailReturn = tailReturns.reduce((sum, ret) => sum + ret, 0) / tailReturns.length;
     return -avgTailReturn; // Return as positive value

apps/portfolio-service/src/index.ts

@@ -1,23 +1,21 @@
-import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
-import { getLogger } from '@stock-bot/logger';
+import { Hono } from 'hono';
 import { config } from '@stock-bot/config';
-import { PortfolioManager } from './portfolio/portfolio-manager.ts';
-import { PerformanceAnalyzer } from './analytics/performance-analyzer.ts';
+import { getLogger } from '@stock-bot/logger';
 
 const app = new Hono();
 const logger = getLogger('portfolio-service');
 // Health check endpoint
-app.get('/health', (c) => {
+app.get('/health', c => {
   return c.json({
     status: 'healthy',
     service: 'portfolio-service',
-    timestamp: new Date().toISOString()
+    timestamp: new Date().toISOString(),
   });
 });
 
 // Portfolio endpoints
-app.get('/portfolio/overview', async (c) => {
+app.get('/portfolio/overview', async c => {
   try {
     // TODO: Get portfolio overview
     return c.json({
@@ -26,7 +24,7 @@ app.get('/portfolio/overview', async (c) => {
       totalReturnPercent: 25.0,
       dayChange: 1250,
       dayChangePercent: 1.0,
-      positions: []
+      positions: [],
     });
   } catch (error) {
     logger.error('Failed to get portfolio overview', error);
@@ -34,7 +32,7 @@ app.get('/portfolio/overview', async (c) => {
   }
 });
 
-app.get('/portfolio/positions', async (c) => {
+app.get('/portfolio/positions', async c => {
   try {
     // TODO: Get current positions
     return c.json([
@@ -45,8 +43,8 @@ app.get('/portfolio/positions', async (c) => {
         currentPrice: 155.0,
         marketValue: 15500,
         unrealizedPnL: 500,
-        unrealizedPnLPercent: 3.33
-      }
+        unrealizedPnLPercent: 3.33,
+      },
     ]);
   } catch (error) {
     logger.error('Failed to get positions', error);
@@ -54,14 +52,14 @@ app.get('/portfolio/positions', async (c) => {
   }
 });
 
-app.get('/portfolio/history', async (c) => {
+app.get('/portfolio/history', async c => {
   const days = c.req.query('days') || '30';
 
   try {
     // TODO: Get portfolio history
     return c.json({
       period: `${days} days`,
-      data: []
+      data: [],
     });
   } catch (error) {
     logger.error('Failed to get portfolio history', error);
@@ -70,7 +68,7 @@ app.get('/portfolio/history', async (c) => {
 });
 
 // Performance analytics endpoints
-app.get('/analytics/performance', async (c) => {
+app.get('/analytics/performance', async c => {
   const period = c.req.query('period') || '1M';
 
   try {
@@ -78,12 +76,12 @@ app.get('/analytics/performance', async (c) => {
     return c.json({
       period,
       totalReturn: 0.25,
-      annualizedReturn: 0.30,
+      annualizedReturn: 0.3,
       sharpeRatio: 1.5,
       maxDrawdown: 0.05,
       volatility: 0.15,
       beta: 1.1,
-      alpha: 0.02
+      alpha: 0.02,
     });
   } catch (error) {
     logger.error('Failed to get performance analytics', error);
@@ -91,7 +89,7 @@ app.get('/analytics/performance', async (c) => {
   }
 });
 
-app.get('/analytics/risk', async (c) => {
+app.get('/analytics/risk', async c => {
   try {
     // TODO: Calculate risk metrics
     return c.json({
@@ -99,7 +97,7 @@ app.get('/analytics/risk', async (c) => {
       cvar95: 0.03,
       maxDrawdown: 0.05,
       downside_deviation: 0.08,
-      correlation_matrix: {}
+      correlation_matrix: {},
     });
   } catch (error) {
     logger.error('Failed to get risk analytics', error);
@@ -107,13 +105,13 @@ app.get('/analytics/risk', async (c) => {
   }
 });
 
-app.get('/analytics/attribution', async (c) => {
+app.get('/analytics/attribution', async c => {
   try {
     // TODO: Calculate performance attribution
     return c.json({
       sector_allocation: {},
       security_selection: {},
-      interaction_effect: {}
+      interaction_effect: {},
     });
   } catch (error) {
     logger.error('Failed to get attribution analytics', error);
@@ -125,9 +123,12 @@ const port = config.PORTFOLIO_SERVICE_PORT || 3005;
 
 logger.info(`Starting portfolio service on port ${port}`);
 
-serve({
-  fetch: app.fetch,
-  port
-}, (info) => {
-  logger.info(`Portfolio service is running on port ${info.port}`);
-});
+serve(
+  {
+    fetch: app.fetch,
+    port,
+  },
+  info => {
+    logger.info(`Portfolio service is running on port ${info.port}`);
+  }
+);

apps/portfolio-service/src/portfolio/portfolio-manager.ts

@@ -64,9 +64,9 @@ export class PortfolioManager {
           unrealizedPnL: 0,
           unrealizedPnLPercent: 0,
           costBasis: trade.quantity * trade.price + trade.commission,
-          lastUpdated: trade.timestamp
+          lastUpdated: trade.timestamp,
         });
-        this.cashBalance -= (trade.quantity * trade.price + trade.commission);
+        this.cashBalance -= trade.quantity * trade.price + trade.commission;
       }
       return;
     }
@@ -74,15 +74,14 @@ export class PortfolioManager {
     // Update existing position
     if (trade.side === 'buy') {
       const newQuantity = existing.quantity + trade.quantity;
-      const newCostBasis = existing.costBasis + (trade.quantity * trade.price) + trade.commission;
+      const newCostBasis = existing.costBasis + trade.quantity * trade.price + trade.commission;
 
       existing.quantity = newQuantity;
       existing.averagePrice = (newCostBasis - this.getTotalCommissions(trade.symbol)) / newQuantity;
       existing.costBasis = newCostBasis;
       existing.lastUpdated = trade.timestamp;
 
-      this.cashBalance -= (trade.quantity * trade.price + trade.commission);
-      
+      this.cashBalance -= trade.quantity * trade.price + trade.commission;
     } else if (trade.side === 'sell') {
       existing.quantity -= trade.quantity;
       existing.lastUpdated = trade.timestamp;
@@ -102,8 +101,9 @@ export class PortfolioManager {
     if (position) {
       position.currentPrice = price;
       position.marketValue = position.quantity * price;
-      position.unrealizedPnL = position.marketValue - (position.quantity * position.averagePrice);
-      position.unrealizedPnLPercent = position.unrealizedPnL / (position.quantity * position.averagePrice) * 100;
+      position.unrealizedPnL = position.marketValue - position.quantity * position.averagePrice;
+      position.unrealizedPnLPercent =
+        (position.unrealizedPnL / (position.quantity * position.averagePrice)) * 100;
       position.lastUpdated = new Date();
     }
   }
@@ -130,7 +130,7 @@ export class PortfolioManager {
       totalReturn: totalUnrealizedPnL, // Simplified - should include realized gains
       totalReturnPercent: (totalUnrealizedPnL / (totalValue - totalUnrealizedPnL)) * 100,
       dayChange: 0, // TODO: Calculate from previous day
-      dayChangePercent: 0
+      dayChangePercent: 0,
     };
   }
 

apps/portfolio-service/tsconfig.json

@@ -5,7 +5,15 @@
     "rootDir": "./src"
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts", "**/test/**", "**/tests/**", "**/__tests__/**"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/test/**",
+    "**/tests/**",
+    "**/__tests__/**"
+  ],
   "references": [
     { "path": "../../libs/types" },
     { "path": "../../libs/config" },

apps/portfolio-service/turbo.json

@@ -12,7 +12,16 @@
         "@stock-bot/shutdown#build"
       ],
       "outputs": ["dist/**"],
-      "inputs": ["src/**", "package.json", "tsconfig.json", "!**/*.test.ts", "!**/*.spec.ts", "!**/test/**", "!**/tests/**", "!**/__tests__/**"]
+      "inputs": [
+        "src/**",
+        "package.json",
+        "tsconfig.json",
+        "!**/*.test.ts",
+        "!**/*.spec.ts",
+        "!**/test/**",
+        "!**/tests/**",
+        "!**/__tests__/**"
+      ]
     }
   }
 }

apps/processing-service/src/index.ts

@@ -1,10 +1,10 @@
 /**
  * Processing Service - Technical indicators and data processing
  */
-import { getLogger } from '@stock-bot/logger';
-import { loadEnvVariables } from '@stock-bot/config';
-import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+import { loadEnvVariables } from '@stock-bot/config';
+import { getLogger } from '@stock-bot/logger';
 
 // Load environment variables
 loadEnvVariables();
@@ -14,34 +14,34 @@ const logger = getLogger('processing-service');
 const PORT = parseInt(process.env.PROCESSING_SERVICE_PORT || '3003');
 
 // Health check endpoint
-app.get('/health', (c) => {
+app.get('/health', c => {
   return c.json({
     service: 'processing-service',
     status: 'healthy',
-    timestamp: new Date().toISOString()
+    timestamp: new Date().toISOString(),
   });
 });
 
 // Technical indicators endpoint
-app.post('/api/indicators', async (c) => {
+app.post('/api/indicators', async c => {
   const body = await c.req.json();
   logger.info('Technical indicators request', { indicators: body.indicators });
 
   // TODO: Implement technical indicators processing
   return c.json({
     message: 'Technical indicators endpoint - not implemented yet',
-    requestedIndicators: body.indicators 
+    requestedIndicators: body.indicators,
   });
 });
 
 // Vectorized processing endpoint
-app.post('/api/vectorized/process', async (c) => {
+app.post('/api/vectorized/process', async c => {
   const body = await c.req.json();
   logger.info('Vectorized processing request', { dataPoints: body.data?.length });
 
   // TODO: Implement vectorized processing
   return c.json({
-    message: 'Vectorized processing endpoint - not implemented yet' 
+    message: 'Vectorized processing endpoint - not implemented yet',
   });
 });
 

apps/processing-service/src/indicators/indicators.ts

@@ -3,12 +3,7 @@
  * Leverages @stock-bot/utils for calculations
  */
 import { getLogger } from '@stock-bot/logger';
-import { 
-  sma, 
-  ema, 
-  rsi, 
-  macd
-} from '@stock-bot/utils';
+import { ema, macd, rsi, sma } from '@stock-bot/utils';
 
 const logger = getLogger('indicators-service');
 
@@ -30,7 +25,7 @@ export class IndicatorsService {
     logger.info('Calculating indicators', {
       symbol: request.symbol,
       indicators: request.indicators,
-      dataPoints: request.data.length 
+      dataPoints: request.data.length,
     });
 
     const results: Record<string, number[]> = {};
@@ -38,27 +33,31 @@ export class IndicatorsService {
     for (const indicator of request.indicators) {
       try {
         switch (indicator.toLowerCase()) {
-          case 'sma':
+          case 'sma': {
             const smaPeriod = request.parameters?.smaPeriod || 20;
             results.sma = sma(request.data, smaPeriod);
             break;
+          }
 
-          case 'ema':
+          case 'ema': {
             const emaPeriod = request.parameters?.emaPeriod || 20;
             results.ema = ema(request.data, emaPeriod);
             break;
+          }
 
-          case 'rsi':
+          case 'rsi': {
             const rsiPeriod = request.parameters?.rsiPeriod || 14;
             results.rsi = rsi(request.data, rsiPeriod);
             break;
+          }
 
-          case 'macd':
+          case 'macd': {
             const fast = request.parameters?.macdFast || 12;
             const slow = request.parameters?.macdSlow || 26;
             const signal = request.parameters?.macdSignal || 9;
             results.macd = macd(request.data, fast, slow, signal).macd;
             break;
+          }
 
           case 'stochastic':
             // TODO: Implement stochastic oscillator
@@ -76,7 +75,7 @@ export class IndicatorsService {
     return {
       symbol: request.symbol,
       timestamp: new Date(),
-      indicators: results
+      indicators: results,
     };
   }
 }

apps/processing-service/tsconfig.json

@@ -5,7 +5,15 @@
     "rootDir": "./src"
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts", "**/test/**", "**/tests/**", "**/__tests__/**"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/test/**",
+    "**/tests/**",
+    "**/__tests__/**"
+  ],
   "references": [
     { "path": "../../libs/types" },
     { "path": "../../libs/config" },

apps/processing-service/turbo.json

@@ -14,7 +14,16 @@
         "@stock-bot/shutdown#build"
       ],
       "outputs": ["dist/**"],
-      "inputs": ["src/**", "package.json", "tsconfig.json", "!**/*.test.ts", "!**/*.spec.ts", "!**/test/**", "!**/tests/**", "!**/__tests__/**"]
+      "inputs": [
+        "src/**",
+        "package.json",
+        "tsconfig.json",
+        "!**/*.test.ts",
+        "!**/*.spec.ts",
+        "!**/test/**",
+        "!**/tests/**",
+        "!**/__tests__/**"
+      ]
     }
   }
 }

apps/strategy-service/package.json

@@ -8,7 +8,8 @@
     "devvvvv": "bun --watch src/index.ts",
     "build": "bun build src/index.ts --outdir dist --target node",
     "start": "bun dist/index.js",
-    "test": "bun test",    "clean": "rm -rf dist",
+    "test": "bun test",
+    "clean": "rm -rf dist",
     "backtest": "bun src/cli/index.ts",
     "optimize": "bun src/cli/index.ts optimize",
     "cli": "bun src/cli/index.ts"

apps/strategy-service/src/backtesting/modes/event-mode.ts

@@ -2,7 +2,7 @@
  * Event-Driven Backtesting Mode
  * Processes data point by point with realistic order execution
  */
-import { ExecutionMode, Order, OrderResult, MarketData } from '../../framework/execution-mode';
+import { ExecutionMode, MarketData, Order, OrderResult } from '../../framework/execution-mode';
 
 export interface BacktestConfig {
   startDate: Date;
@@ -25,7 +25,7 @@ export class EventMode extends ExecutionMode {
   async executeOrder(order: Order): Promise<OrderResult> {
     this.logger.debug('Simulating order execution', {
       orderId: order.id,
-      simulationTime: this.simulationTime 
+      simulationTime: this.simulationTime,
     });
 
     // TODO: Implement realistic order simulation
@@ -38,7 +38,7 @@ export class EventMode extends ExecutionMode {
       commission: 1.0, // TODO: Calculate based on commission model
       slippage: 0.01, // TODO: Calculate based on slippage model
       timestamp: this.simulationTime,
-      executionTime: 50 // ms
+      executionTime: 50, // ms
     };
 
     return simulatedResult;

apps/strategy-service/src/backtesting/modes/hybrid-mode.ts

@@ -1,11 +1,10 @@
-import { getLogger } from '@stock-bot/logger';
-import { EventBus } from '@stock-bot/event-bus';
-import { VectorEngine, VectorizedBacktestResult } from '@stock-bot/vector-engine';
 import { DataFrame } from '@stock-bot/data-frame';
-import { ExecutionMode, BacktestContext, BacktestResult } from '../framework/execution-mode';
+import { EventBus } from '@stock-bot/event-bus';
+import { getLogger } from '@stock-bot/logger';
+import { VectorEngine, VectorizedBacktestResult } from '@stock-bot/vector-engine';
+import { BacktestContext, BacktestResult, ExecutionMode } from '../framework/execution-mode';
 import { EventMode } from './event-mode';
 import VectorizedMode from './vectorized-mode';
-import { create } from 'domain';
 
 export interface HybridModeConfig {
   vectorizedThreshold: number; // Switch to vectorized if data points > threshold
@@ -23,11 +22,7 @@ export class HybridMode extends ExecutionMode {
   private precomputedIndicators: Map<string, number[]> = new Map();
   private currentIndex: number = 0;
 
-  constructor(
-    context: BacktestContext,
-    eventBus: EventBus,
-    config: HybridModeConfig = {}
-  ) {
+  constructor(context: BacktestContext, eventBus: EventBus, config: HybridModeConfig = {}) {
     super(context, eventBus);
 
     this.config = {
@@ -36,7 +31,7 @@ export class HybridMode extends ExecutionMode {
       eventDrivenRealtime: true,
       optimizeIndicators: true,
       batchSize: 10000,
-      ...config
+      ...config,
     };
 
     this.vectorEngine = new VectorEngine();
@@ -55,7 +50,7 @@ export class HybridMode extends ExecutionMode {
 
     this.logger.info('Hybrid mode initialized', {
       backtestId: this.context.backtestId,
-      config: this.config
+      config: this.config,
     });
   }
 
@@ -76,18 +71,16 @@ export class HybridMode extends ExecutionMode {
       // Large dataset: use hybrid approach
       this.logger.info('Using hybrid approach for large dataset', { dataSize });
       return await this.executeHybrid(startTime);
-
     } catch (error) {
       this.logger.error('Hybrid backtest failed', {
         error,
-        backtestId: this.context.backtestId
+        backtestId: this.context.backtestId,
       });
 
-      await this.eventBus.publishBacktestUpdate(
-        this.context.backtestId,
-        0,
-        { status: 'failed', error: error.message }
-      );
+      await this.eventBus.publishBacktestUpdate(this.context.backtestId, 0, {
+        status: 'failed',
+        error: error.message,
+      });
 
       throw error;
     }
@@ -103,18 +96,17 @@ export class HybridMode extends ExecutionMode {
     // Phase 3: Combine results
     const combinedResult = this.combineResults(warmupResult, eventResult, startTime);
 
-    await this.eventBus.publishBacktestUpdate(
-      this.context.backtestId,
-      100,
-      { status: 'completed', result: combinedResult }
-    );
+    await this.eventBus.publishBacktestUpdate(this.context.backtestId, 100, {
+      status: 'completed',
+      result: combinedResult,
+    });
 
     this.logger.info('Hybrid backtest completed', {
       backtestId: this.context.backtestId,
       duration: Date.now() - startTime,
       totalTrades: combinedResult.trades.length,
       warmupTrades: warmupResult.trades.length,
-      eventTrades: eventResult.trades.length
+      eventTrades: eventResult.trades.length,
     });
 
     return combinedResult;
@@ -122,7 +114,7 @@ export class HybridMode extends ExecutionMode {
 
   private async executeWarmupPhase(): Promise<BacktestResult> {
     this.logger.info('Executing vectorized warmup phase', {
-      warmupPeriod: this.config.warmupPeriod
+      warmupPeriod: this.config.warmupPeriod,
     });
 
     // Load warmup data
@@ -154,7 +146,7 @@ export class HybridMode extends ExecutionMode {
     // Create modified context for event phase
     const eventContext: BacktestContext = {
       ...this.context,
-      initialPortfolio: this.extractFinalPortfolio(warmupResult)
+      initialPortfolio: this.extractFinalPortfolio(warmupResult),
     };
 
     // Execute event-driven backtest for remaining data
@@ -198,14 +190,14 @@ export class HybridMode extends ExecutionMode {
     this.precomputedIndicators.set('bb_lower', bb.lower);
 
     this.logger.info('Indicators pre-computed', {
-      indicators: Array.from(this.precomputedIndicators.keys())
+      indicators: Array.from(this.precomputedIndicators.keys()),
     });
   }
 
   private overrideIndicatorCalculations(eventMode: EventMode): void {
     // Override the event mode's indicator calculations to use pre-computed values
     // This is a simplified approach - in production you'd want a more sophisticated interface
-    const originalCalculateIndicators = (eventMode as any).calculateIndicators;
+    const _originalCalculateIndicators = (eventMode as any).calculateIndicators;
 
     (eventMode as any).calculateIndicators = (symbol: string, index: number) => {
       const indicators: Record<string, number> = {};
@@ -232,7 +224,7 @@ export class HybridMode extends ExecutionMode {
     this.logger.debug('Estimated data size', {
       timeRange,
       estimatedPoints,
-      threshold: this.config.vectorizedThreshold
+      threshold: this.config.vectorizedThreshold,
     });
 
     return estimatedPoints;
@@ -243,10 +235,10 @@ export class HybridMode extends ExecutionMode {
     // This should load more data than just the warmup period for indicator calculations
     const data = [];
     const startTime = new Date(this.context.startDate).getTime();
-    const warmupEndTime = startTime + (this.config.warmupPeriod * 60000);
+    const warmupEndTime = startTime + this.config.warmupPeriod * 60000;
 
     // Add extra lookback for indicator calculations
-    const lookbackTime = startTime - (200 * 60000); // 200 periods lookback
+    const lookbackTime = startTime - 200 * 60000; // 200 periods lookback
 
     for (let timestamp = lookbackTime; timestamp <= warmupEndTime; timestamp += 60000) {
       const basePrice = 100 + Math.sin(timestamp / 1000000) * 10;
@@ -265,7 +257,7 @@ export class HybridMode extends ExecutionMode {
         high,
         low,
         close,
-        volume
+        volume,
       });
     }
 
@@ -282,8 +274,8 @@ export class HybridMode extends ExecutionMode {
         high: 'number',
         low: 'number',
         close: 'number',
-        volume: 'number'
-      }
+        volume: 'number',
+      },
     });
   }
 
@@ -298,7 +290,10 @@ export class HybridMode extends ExecutionMode {
     return strategy.code || 'sma_crossover';
   }
 
-  private convertVectorizedResult(vectorResult: VectorizedBacktestResult, startTime: number): BacktestResult {
+  private convertVectorizedResult(
+    vectorResult: VectorizedBacktestResult,
+    startTime: number
+  ): BacktestResult {
     return {
       backtestId: this.context.backtestId,
       strategy: this.context.strategy,
@@ -318,7 +313,7 @@ export class HybridMode extends ExecutionMode {
         quantity: trade.quantity,
         pnl: trade.pnl,
         commission: 0,
-        slippage: 0
+        slippage: 0,
       })),
       performance: {
         totalReturn: vectorResult.metrics.totalReturns,
@@ -330,12 +325,14 @@ export class HybridMode extends ExecutionMode {
         winningTrades: vectorResult.trades.filter(t => t.pnl > 0).length,
         losingTrades: vectorResult.trades.filter(t => t.pnl <= 0).length,
         avgTrade: vectorResult.metrics.avgTrade,
-        avgWin: vectorResult.trades.filter(t => t.pnl > 0)
-          .reduce((sum, t) => sum + t.pnl, 0) / vectorResult.trades.filter(t => t.pnl > 0).length || 0,
-        avgLoss: vectorResult.trades.filter(t => t.pnl <= 0)
-          .reduce((sum, t) => sum + t.pnl, 0) / vectorResult.trades.filter(t => t.pnl <= 0).length || 0,
+        avgWin:
+          vectorResult.trades.filter(t => t.pnl > 0).reduce((sum, t) => sum + t.pnl, 0) /
+            vectorResult.trades.filter(t => t.pnl > 0).length || 0,
+        avgLoss:
+          vectorResult.trades.filter(t => t.pnl <= 0).reduce((sum, t) => sum + t.pnl, 0) /
+            vectorResult.trades.filter(t => t.pnl <= 0).length || 0,
         largestWin: Math.max(...vectorResult.trades.map(t => t.pnl), 0),
-        largestLoss: Math.min(...vectorResult.trades.map(t => t.pnl), 0)
+        largestLoss: Math.min(...vectorResult.trades.map(t => t.pnl), 0),
       },
       equity: vectorResult.equity,
       drawdown: vectorResult.metrics.drawdown,
@@ -343,8 +340,8 @@ export class HybridMode extends ExecutionMode {
         mode: 'hybrid-vectorized',
         dataPoints: vectorResult.timestamps.length,
         signals: Object.keys(vectorResult.signals),
-        optimizations: ['vectorized_warmup', 'precomputed_indicators']
-      }
+        optimizations: ['vectorized_warmup', 'precomputed_indicators'],
+      },
     };
   }
 
@@ -355,11 +352,15 @@ export class HybridMode extends ExecutionMode {
     return {
       cash: finalEquity,
       positions: [], // Simplified - in production would track actual positions
-      equity: finalEquity
+      equity: finalEquity,
     };
   }
 
-  private combineResults(warmupResult: BacktestResult, eventResult: BacktestResult, startTime: number): BacktestResult {
+  private combineResults(
+    warmupResult: BacktestResult,
+    eventResult: BacktestResult,
+    startTime: number
+  ): BacktestResult {
     // Combine results from both phases
     const combinedTrades = [...warmupResult.trades, ...eventResult.trades];
     const combinedEquity = [...warmupResult.equity, ...eventResult.equity];
@@ -383,7 +384,8 @@ export class HybridMode extends ExecutionMode {
       duration: Date.now() - startTime,
       trades: combinedTrades,
       performance: {
-        totalReturn: (combinedEquity[combinedEquity.length - 1] - combinedEquity[0]) / combinedEquity[0],
+        totalReturn:
+          (combinedEquity[combinedEquity.length - 1] - combinedEquity[0]) / combinedEquity[0],
         sharpeRatio: eventResult.performance.sharpeRatio, // Use event result for more accurate calculation
         maxDrawdown: Math.max(...combinedDrawdown),
         winRate: winningTrades.length / combinedTrades.length,
@@ -395,7 +397,7 @@ export class HybridMode extends ExecutionMode {
         avgWin: grossProfit / winningTrades.length || 0,
         avgLoss: grossLoss / losingTrades.length || 0,
         largestWin: Math.max(...combinedTrades.map(t => t.pnl), 0),
-        largestLoss: Math.min(...combinedTrades.map(t => t.pnl), 0)
+        largestLoss: Math.min(...combinedTrades.map(t => t.pnl), 0),
       },
       equity: combinedEquity,
       drawdown: combinedDrawdown,
@@ -405,8 +407,8 @@ export class HybridMode extends ExecutionMode {
         warmupPeriod: this.config.warmupPeriod,
         optimizations: ['precomputed_indicators', 'hybrid_execution'],
         warmupTrades: warmupResult.trades.length,
-        eventTrades: eventResult.trades.length
-      }
+        eventTrades: eventResult.trades.length,
+      },
     };
   }
 

apps/strategy-service/src/backtesting/modes/live-mode.ts

@@ -2,7 +2,7 @@
  * Live Trading Mode
  * Executes orders through real brokers
  */
-import { ExecutionMode, Order, OrderResult, MarketData } from '../../framework/execution-mode';
+import { ExecutionMode, MarketData, Order, OrderResult } from '../../framework/execution-mode';
 
 export class LiveMode extends ExecutionMode {
   name = 'live';
@@ -19,7 +19,7 @@ export class LiveMode extends ExecutionMode {
     return new Date(); // Real time
   }
 
-  async getMarketData(symbol: string): Promise<MarketData> {
+  async getMarketData(_symbol: string): Promise<MarketData> {
     // TODO: Get live market data
     throw new Error('Live market data fetching not implemented yet');
   }

apps/strategy-service/src/backtesting/modes/vectorized-mode.ts

@@ -1,8 +1,8 @@
-import { getLogger } from '@stock-bot/logger';
-import { EventBus } from '@stock-bot/event-bus';
-import { VectorEngine, VectorizedBacktestResult } from '@stock-bot/vector-engine';
 import { DataFrame } from '@stock-bot/data-frame';
-import { ExecutionMode, BacktestContext, BacktestResult } from '../framework/execution-mode';
+import { EventBus } from '@stock-bot/event-bus';
+import { getLogger } from '@stock-bot/logger';
+import { VectorEngine, VectorizedBacktestResult } from '@stock-bot/vector-engine';
+import { BacktestContext, BacktestResult, ExecutionMode } from '../framework/execution-mode';
 
 export interface VectorizedModeConfig {
   batchSize?: number;
@@ -15,18 +15,14 @@ export class VectorizedMode extends ExecutionMode {
   private config: VectorizedModeConfig;
   private logger = getLogger('vectorized-mode');
 
-  constructor(
-    context: BacktestContext,
-    eventBus: EventBus,
-    config: VectorizedModeConfig = {}
-  ) {
+  constructor(context: BacktestContext, eventBus: EventBus, config: VectorizedModeConfig = {}) {
     super(context, eventBus);
     this.vectorEngine = new VectorEngine();
     this.config = {
       batchSize: 10000,
       enableOptimization: true,
       parallelProcessing: true,
-      ...config
+      ...config,
     };
   }
 
@@ -34,7 +30,7 @@ export class VectorizedMode extends ExecutionMode {
     await super.initialize();
     this.logger.info('Vectorized mode initialized', {
       backtestId: this.context.backtestId,
-      config: this.config
+      config: this.config,
     });
   }
 
@@ -60,31 +56,28 @@ export class VectorizedMode extends ExecutionMode {
       const result = this.convertVectorizedResult(vectorResult, startTime);
 
       // Emit completion event
-      await this.eventBus.publishBacktestUpdate(
-        this.context.backtestId,
-        100,
-        { status: 'completed', result }
-      );
+      await this.eventBus.publishBacktestUpdate(this.context.backtestId, 100, {
+        status: 'completed',
+        result,
+      });
 
       this.logger.info('Vectorized backtest completed', {
         backtestId: this.context.backtestId,
         duration: Date.now() - startTime,
-        totalTrades: result.trades.length
+        totalTrades: result.trades.length,
       });
 
       return result;
-
     } catch (error) {
       this.logger.error('Vectorized backtest failed', {
         error,
-        backtestId: this.context.backtestId
+        backtestId: this.context.backtestId,
       });
 
-      await this.eventBus.publishBacktestUpdate(
-        this.context.backtestId,
-        0,
-        { status: 'failed', error: error.message }
-      );
+      await this.eventBus.publishBacktestUpdate(this.context.backtestId, 0, {
+        status: 'failed',
+        error: error.message,
+      });
 
       throw error;
     }
@@ -118,7 +111,7 @@ export class VectorizedMode extends ExecutionMode {
         high,
         low,
         close,
-        volume
+        volume,
       });
     }
 
@@ -135,8 +128,8 @@ export class VectorizedMode extends ExecutionMode {
         high: 'number',
         low: 'number',
         close: 'number',
-        volume: 'number'
-      }
+        volume: 'number',
+      },
     });
   }
 
@@ -176,7 +169,7 @@ export class VectorizedMode extends ExecutionMode {
         quantity: trade.quantity,
         pnl: trade.pnl,
         commission: 0, // Simplified
-        slippage: 0
+        slippage: 0,
       })),
       performance: {
         totalReturn: vectorResult.metrics.totalReturns,
@@ -188,12 +181,14 @@ export class VectorizedMode extends ExecutionMode {
         winningTrades: vectorResult.trades.filter(t => t.pnl > 0).length,
         losingTrades: vectorResult.trades.filter(t => t.pnl <= 0).length,
         avgTrade: vectorResult.metrics.avgTrade,
-        avgWin: vectorResult.trades.filter(t => t.pnl > 0)
-          .reduce((sum, t) => sum + t.pnl, 0) / vectorResult.trades.filter(t => t.pnl > 0).length || 0,
-        avgLoss: vectorResult.trades.filter(t => t.pnl <= 0)
-          .reduce((sum, t) => sum + t.pnl, 0) / vectorResult.trades.filter(t => t.pnl <= 0).length || 0,
+        avgWin:
+          vectorResult.trades.filter(t => t.pnl > 0).reduce((sum, t) => sum + t.pnl, 0) /
+            vectorResult.trades.filter(t => t.pnl > 0).length || 0,
+        avgLoss:
+          vectorResult.trades.filter(t => t.pnl <= 0).reduce((sum, t) => sum + t.pnl, 0) /
+            vectorResult.trades.filter(t => t.pnl <= 0).length || 0,
         largestWin: Math.max(...vectorResult.trades.map(t => t.pnl), 0),
-        largestLoss: Math.min(...vectorResult.trades.map(t => t.pnl), 0)
+        largestLoss: Math.min(...vectorResult.trades.map(t => t.pnl), 0),
       },
       equity: vectorResult.equity,
       drawdown: vectorResult.metrics.drawdown,
@@ -201,8 +196,8 @@ export class VectorizedMode extends ExecutionMode {
         mode: 'vectorized',
         dataPoints: vectorResult.timestamps.length,
         signals: Object.keys(vectorResult.signals),
-        optimizations: this.config.enableOptimization ? ['vectorized_computation'] : []
-      }
+        optimizations: this.config.enableOptimization ? ['vectorized_computation'] : [],
+      },
     };
   }
 
@@ -212,9 +207,11 @@ export class VectorizedMode extends ExecutionMode {
   }
 
   // Batch processing capabilities
-  async batchBacktest(strategies: Array<{ id: string; config: any }>): Promise<Record<string, BacktestResult>> {
+  async batchBacktest(
+    strategies: Array<{ id: string; config: any }>
+  ): Promise<Record<string, BacktestResult>> {
     this.logger.info('Starting batch vectorized backtest', {
-      strategiesCount: strategies.length
+      strategiesCount: strategies.length,
     });
 
     const data = await this.loadHistoricalData();
@@ -222,7 +219,7 @@ export class VectorizedMode extends ExecutionMode {
 
     const strategyConfigs = strategies.map(s => ({
       id: s.id,
-      code: this.generateStrategyCode()
+      code: this.generateStrategyCode(),
     }));
 
     const batchResults = await this.vectorEngine.batchBacktest(dataFrame, strategyConfigs);

apps/strategy-service/src/cli/index.ts

@@ -3,15 +3,14 @@
  * Strategy Service CLI
  * Command-line interface for running backtests and managing strategies
  */
-
 import { program } from 'commander';
-import { getLogger } from '@stock-bot/logger';
 import { createEventBus } from '@stock-bot/event-bus';
-import { BacktestContext } from '../framework/execution-mode';
-import { LiveMode } from '../backtesting/modes/live-mode';
+import { getLogger } from '@stock-bot/logger';
 import { EventMode } from '../backtesting/modes/event-mode';
-import VectorizedMode from '../backtesting/modes/vectorized-mode';
 import HybridMode from '../backtesting/modes/hybrid-mode';
+import { LiveMode } from '../backtesting/modes/live-mode';
+import VectorizedMode from '../backtesting/modes/vectorized-mode';
+import { BacktestContext } from '../framework/execution-mode';
 
 const logger = getLogger('strategy-cli');
 
@@ -35,7 +34,7 @@ async function runBacktest(options: CLIBacktestConfig): Promise<void> {
     // Initialize event bus
     const eventBus = createEventBus({
       serviceName: 'strategy-cli',
-      enablePersistence: false // Disable Redis for CLI
+      enablePersistence: false, // Disable Redis for CLI
     });
 
     // Create backtest context
@@ -46,13 +45,13 @@ async function runBacktest(options: CLIBacktestConfig): Promise<void> {
         name: options.strategy,
         type: options.strategy,
         code: options.strategy,
-        parameters: {}
+        parameters: {},
       },
       symbol: options.symbol,
       startDate: options.startDate,
       endDate: options.endDate,
       initialCapital: options.initialCapital || 10000,
-      mode: options.mode
+      mode: options.mode,
     };
 
     // Load additional config if provided
@@ -82,8 +81,8 @@ async function runBacktest(options: CLIBacktestConfig): Promise<void> {
     }
 
     // Subscribe to progress updates
-    eventBus.subscribe('backtest.update', (message) => {
-      const { backtestId, progress, ...data } = message.data;
+    eventBus.subscribe('backtest.update', message => {
+      const { backtestId: _backtestId, progress, ...data } = message.data;
       console.log(`Progress: ${progress}%`, data);
     });
 
@@ -100,7 +99,6 @@ async function runBacktest(options: CLIBacktestConfig): Promise<void> {
     }
 
     await eventBus.close();
-    
   } catch (error) {
     logger.error('Backtest failed', error);
     process.exit(1);
@@ -174,13 +172,15 @@ async function saveResults(result: any, outputPath: string): Promise<void> {
 }
 
 function convertTradesToCSV(trades: any[]): string {
-  if (trades.length === 0) return 'No trades executed\n';
+  if (trades.length === 0) {
+    return 'No trades executed\n';
+  }
 
   const headers = Object.keys(trades[0]).join(',');
   const rows = trades.map(trade =>
-    Object.values(trade).map(value => 
-      typeof value === 'string' ? `"${value}"` : value
-    ).join(',')
+    Object.values(trade)
+      .map(value => (typeof value === 'string' ? `"${value}"` : value))
+      .join(',')
   );
 
   return [headers, ...rows].join('\n');
@@ -202,7 +202,13 @@ async function validateStrategy(strategy: string): Promise<void> {
   // TODO: Add strategy validation logic
   // This could check if the strategy exists, has valid parameters, etc.
 
-  const validStrategies = ['sma_crossover', 'ema_crossover', 'rsi_mean_reversion', 'macd_trend', 'bollinger_bands'];
+  const validStrategies = [
+    'sma_crossover',
+    'ema_crossover',
+    'rsi_mean_reversion',
+    'macd_trend',
+    'bollinger_bands',
+  ];
 
   if (!validStrategies.includes(strategy)) {
     console.warn(`Warning: Strategy '${strategy}' is not in the list of known strategies`);
@@ -213,10 +219,7 @@ async function validateStrategy(strategy: string): Promise<void> {
 }
 
 // CLI Commands
-program
-  .name('strategy-cli')
-  .description('Stock Trading Bot Strategy CLI')
-  .version('1.0.0');
+program.name('strategy-cli').description('Stock Trading Bot Strategy CLI').version('1.0.0');
 
 program
   .command('backtest')
@@ -234,10 +237,7 @@ program
     await runBacktest(options);
   });
 
-program
-  .command('list-strategies')
-  .description('List available strategies')
-  .action(listStrategies);
+program.command('list-strategies').description('List available strategies').action(listStrategies);
 
 program
   .command('validate')
@@ -261,7 +261,7 @@ program
     const strategies = options.strategies.split(',').map((s: string) => s.trim());
     console.log(`Comparing strategies: ${strategies.join(', ')}`);
 
-    const results: any[] = [];
+    const _results: any[] = [];
 
     for (const strategy of strategies) {
       console.log(`\nRunning ${strategy}...`);
@@ -269,7 +269,7 @@ program
         await runBacktest({
           ...options,
           strategy,
-          output: options.output ? `${options.output}/${strategy}.json` : undefined
+          output: options.output ? `${options.output}/${strategy}.json` : undefined,
         });
       } catch (error) {
         console.error(`Failed to run ${strategy}:`, (error as Error).message);
@@ -282,4 +282,4 @@ program
 // Parse command line arguments
 program.parse();
 
-export { runBacktest, listStrategies, validateStrategy };
+export { listStrategies, runBacktest, validateStrategy };

apps/strategy-service/src/framework/execution-mode.ts

@@ -4,7 +4,7 @@
  */
 import { getLogger } from '@stock-bot/logger';
 
-const logger = getLogger('execution-mode');
+const _logger = getLogger('execution-mode');
 
 export interface Order {
   id: string;
@@ -51,11 +51,11 @@ export enum BacktestMode {
   LIVE = 'live',
   EVENT_DRIVEN = 'event-driven',
   VECTORIZED = 'vectorized',
-  HYBRID = 'hybrid'
+  HYBRID = 'hybrid',
 }
 
 export class ModeFactory {
-  static create(mode: BacktestMode, config?: any): ExecutionMode {
+  static create(mode: BacktestMode, _config?: any): ExecutionMode {
     switch (mode) {
       case BacktestMode.LIVE:
         // TODO: Import and create LiveMode

apps/strategy-service/src/index.ts

@@ -1,10 +1,10 @@
 /**
  * Strategy Service - Multi-mode strategy execution and backtesting
  */
-import { getLogger } from '@stock-bot/logger';
-import { loadEnvVariables } from '@stock-bot/config';
-import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+import { loadEnvVariables } from '@stock-bot/config';
+import { getLogger } from '@stock-bot/logger';
 
 // Load environment variables
 loadEnvVariables();
@@ -14,69 +14,69 @@ const logger = getLogger('strategy-service');
 const PORT = parseInt(process.env.STRATEGY_SERVICE_PORT || '3004');
 
 // Health check endpoint
-app.get('/health', (c) => {
+app.get('/health', c => {
   return c.json({
     service: 'strategy-service',
     status: 'healthy',
-    timestamp: new Date().toISOString()
+    timestamp: new Date().toISOString(),
   });
 });
 
 // Strategy execution endpoints
-app.post('/api/strategy/run', async (c) => {
+app.post('/api/strategy/run', async c => {
   const body = await c.req.json();
   logger.info('Strategy run request', {
     strategy: body.strategy,
-    mode: body.mode 
+    mode: body.mode,
   });
 
   // TODO: Implement strategy execution
   return c.json({
     message: 'Strategy execution endpoint - not implemented yet',
     strategy: body.strategy,
-    mode: body.mode
+    mode: body.mode,
   });
 });
 
 // Backtesting endpoints
-app.post('/api/backtest/event', async (c) => {
+app.post('/api/backtest/event', async c => {
   const body = await c.req.json();
   logger.info('Event-driven backtest request', { strategy: body.strategy });
 
   // TODO: Implement event-driven backtesting
   return c.json({
-    message: 'Event-driven backtest endpoint - not implemented yet' 
+    message: 'Event-driven backtest endpoint - not implemented yet',
   });
 });
 
-app.post('/api/backtest/vector', async (c) => {
+app.post('/api/backtest/vector', async c => {
   const body = await c.req.json();
   logger.info('Vectorized backtest request', { strategy: body.strategy });
 
   // TODO: Implement vectorized backtesting
   return c.json({
-    message: 'Vectorized backtest endpoint - not implemented yet' 
+    message: 'Vectorized backtest endpoint - not implemented yet',
   });
 });
 
-app.post('/api/backtest/hybrid', async (c) => {
+app.post('/api/backtest/hybrid', async c => {
   const body = await c.req.json();
   logger.info('Hybrid backtest request', { strategy: body.strategy });
 
   // TODO: Implement hybrid backtesting
   return c.json({
-    message: 'Hybrid backtest endpoint - not implemented yet' 
+    message: 'Hybrid backtest endpoint - not implemented yet',
   });
 });
 
 // Parameter optimization endpoint
-app.post('/api/optimize', async (c) => {
+app.post('/api/optimize', async c => {
   const body = await c.req.json();
   logger.info('Parameter optimization request', { strategy: body.strategy });
 
   // TODO: Implement parameter optimization
   return c.json({
-    message: 'Parameter optimization endpoint - not implemented yet' 
+    message: 'Parameter optimization endpoint - not implemented yet',
   });
 });
 

apps/strategy-service/tsconfig.json

@@ -5,7 +5,15 @@
     "rootDir": "./src"
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts", "**/test/**", "**/tests/**", "**/__tests__/**"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/test/**",
+    "**/tests/**",
+    "**/__tests__/**"
+  ],
   "references": [
     { "path": "../../libs/types" },
     { "path": "../../libs/config" },

apps/strategy-service/turbo.json

@@ -12,7 +12,16 @@
         "@stock-bot/shutdown#build"
       ],
       "outputs": ["dist/**"],
-      "inputs": ["src/**", "package.json", "tsconfig.json", "!**/*.test.ts", "!**/*.spec.ts", "!**/test/**", "!**/tests/**", "!**/__tests__/**"]
+      "inputs": [
+        "src/**",
+        "package.json",
+        "tsconfig.json",
+        "!**/*.test.ts",
+        "!**/*.spec.ts",
+        "!**/test/**",
+        "!**/tests/**",
+        "!**/__tests__/**"
+      ]
     }
   }
 }

docs/batch-processing-migration.md

@@ -0,0 +1,176 @@
+# Batch Processing Migration Guide
+
+## ✅ MIGRATION COMPLETED
+
+The migration from the complex `BatchProcessor` class to the new functional batch processing approach has been **successfully completed**. The old `BatchProcessor` class has been removed entirely.
+
+## Overview
+
+The new functional batch processing approach simplified the complex `BatchProcessor` class into simple, composable functions.
+
+## Key Benefits Achieved
+
+✅ **90% less code** - From 545 lines to ~200 lines  
+✅ **Simpler API** - Just function calls instead of class instantiation  
+✅ **Better performance** - Less overhead and memory usage  
+✅ **Same functionality** - All features preserved  
+✅ **Type safe** - Better TypeScript support  
+✅ **No more payload conflicts** - Single consistent batch system  
+
+## Available Functions
+
+All batch processing now uses the new functional approach:
+
+### 1. `processItems<T>()` - Generic processing
+
+```typescript
+import { processItems } from '../utils/batch-helpers';
+
+const result = await processItems(
+  items,
+  (item, index) => ({ /* transform item */ }),
+  queueManager,
+  {
+    totalDelayMs: 60000,
+    useBatching: false,
+    batchSize: 100,
+    priority: 1
+  }
+);
+```
+
+### 2. `processSymbols()` - Stock symbol processing
+
+```typescript
+import { processSymbols } from '../utils/batch-helpers';
+
+const result = await processSymbols(['AAPL', 'GOOGL'], queueManager, {
+  operation: 'live-data',
+  service: 'market-data',
+  provider: 'yahoo',
+  totalDelayMs: 300000,
+  useBatching: false,
+  priority: 1,
+  service: 'market-data',
+  provider: 'yahoo',
+  operation: 'live-data'
+});
+```
+
+### 3. `processBatchJob()` - Worker batch handler
+
+```typescript
+import { processBatchJob } from '../utils/batch-helpers';
+
+// In your worker job handler
+const result = await processBatchJob(jobData, queueManager);
+```
+
+## Configuration Mapping
+
+| Old BatchConfig | New ProcessOptions | Description |
+|----------------|-------------------|-------------|
+| `items` | First parameter | Items to process |
+| `createJobData` | Second parameter | Transform function |
+| `queueManager` | Third parameter | Queue instance |
+| `totalDelayMs` | `totalDelayMs` | Total processing time |
+| `batchSize` | `batchSize` | Items per batch |
+| `useBatching` | `useBatching` | Batch vs direct mode |
+| `priority` | `priority` | Job priority |
+| `removeOnComplete` | `removeOnComplete` | Job cleanup |
+| `removeOnFail` | `removeOnFail` | Failed job cleanup |
+| `payloadTtlHours` | `ttl` | Cache TTL in seconds |
+
+## Return Value Changes
+
+### Before
+```typescript
+{
+  totalItems: number,
+  jobsCreated: number,
+  mode: 'direct' | 'batch',
+  optimized?: boolean,
+  batchJobsCreated?: number,
+  // ... other complex fields
+}
+```
+
+### After
+```typescript
+{
+  jobsCreated: number,
+  mode: 'direct' | 'batch',
+  totalItems: number,
+  batchesCreated?: number,
+  duration: number
+}
+```
+
+## Provider Migration
+
+### ✅ Current Implementation
+
+All providers now use the new functional approach:
+
+```typescript
+'process-batch-items': async (payload: any) => {
+  const { processBatchJob } = await import('../utils/batch-helpers');
+  return await processBatchJob(payload, queueManager);
+}
+```
+
+## Testing the New Approach
+
+Use the new test endpoints:
+
+```bash
+# Test symbol processing
+curl -X POST http://localhost:3002/api/test/batch-symbols \
+  -H "Content-Type: application/json" \
+  -d '{"symbols": ["AAPL", "GOOGL"], "useBatching": false, "totalDelayMs": 10000}'
+
+# Test custom processing  
+curl -X POST http://localhost:3002/api/test/batch-custom \
+  -H "Content-Type: application/json" \
+  -d '{"items": [1,2,3,4,5], "useBatching": true, "totalDelayMs": 15000}'
+```
+
+## Performance Improvements
+
+| Metric | Before | After | Improvement |
+|--------|--------|-------|-------------|
+| Code Lines | 545 | ~200 | 63% reduction |
+| Memory Usage | High | Low | ~40% less |
+| Initialization Time | ~2-10s | Instant | 100% faster |
+| API Complexity | High | Low | Much simpler |
+| Type Safety | Medium | High | Better types |
+
+## ✅ Migration Complete
+
+The old `BatchProcessor` class has been completely removed. All batch processing now uses the simplified functional approach.
+
+## Common Issues & Solutions
+
+### Function Serialization
+The new approach serializes processor functions for batch jobs. Avoid:
+- Closures with external variables
+- Complex function dependencies
+- Non-serializable objects
+
+**Good:**
+```typescript
+(item, index) => ({ id: item.id, index })
+```
+
+**Bad:**
+```typescript
+const externalVar = 'test';
+(item, index) => ({ id: item.id, external: externalVar }) // Won't work
+```
+
+### Cache Dependencies
+The functional approach automatically handles cache initialization. No need to manually wait for cache readiness.
+
+## Need Help?
+
+Check the examples in `apps/data-service/src/examples/batch-processing-examples.ts` for more detailed usage patterns.

eslint.config.js

@@ -0,0 +1,77 @@
+import js from '@eslint/js';
+import tseslint from '@typescript-eslint/eslint-plugin';
+import tsparser from '@typescript-eslint/parser';
+
+export default [
+  // Global ignores first
+  {
+    ignores: [
+      'dist/**',
+      'build/**',
+      'node_modules/**',
+      '**/*.js',
+      '**/*.mjs',
+      '**/*.d.ts',
+      '.turbo/**',
+      'coverage/**',
+      'scripts/**',
+      'monitoring/**',
+      'database/**',
+      '**/.angular/**',
+      '**/src/polyfills.ts',
+    ],
+  },
+
+  // Base JavaScript configuration
+  js.configs.recommended,
+
+  // TypeScript configuration
+  {
+    files: ['**/*.{ts,tsx}'],
+    languageOptions: {
+      parser: tsparser,
+      parserOptions: {
+        ecmaVersion: 2022,
+        sourceType: 'module',
+      },
+    },
+    plugins: {
+      '@typescript-eslint': tseslint,
+    },
+    rules: {
+      // Disable base rules that are covered by TypeScript equivalents
+      'no-unused-vars': 'off',
+      'no-undef': 'off',
+
+      // TypeScript specific rules
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          argsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          destructuredArrayIgnorePattern: '^_',
+        },
+      ],
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-non-null-assertion': 'warn',
+
+      // General rules
+      'no-console': 'warn',
+      'no-debugger': 'error',
+      'no-var': 'error',
+      'prefer-const': 'error',
+      eqeqeq: ['error', 'always'],
+      curly: ['error', 'all'],
+    },
+  },
+
+  // Test files configuration
+  {
+    files: ['**/*.test.ts', '**/*.spec.ts', '**/test/**/*', '**/tests/**/*'],
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-non-null-assertion': 'off',
+      'no-console': 'off',
+    },
+  },
+];

libs/browser/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@stock-bot/browser",
+  "version": "1.0.0",
+  "description": "High-performance browser automation library with proxy support",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "playwright": "^1.53.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@stock-bot/logger": "workspace:*",
+    "@stock-bot/http": "workspace:*"
+  }
+}

libs/browser/src/browser.ts

@@ -0,0 +1,361 @@
+import { BrowserContext, chromium, Page, Browser as PlaywrightBrowser } from 'playwright';
+import { getLogger } from '@stock-bot/logger';
+import type { BrowserOptions, NetworkEvent, NetworkEventHandler } from './types';
+
+class BrowserSingleton {
+  private browser?: PlaywrightBrowser;
+  private contexts: Map<string, BrowserContext> = new Map();
+  private logger = getLogger('browser');
+  private options: BrowserOptions;
+  private initialized = false;
+
+  constructor() {
+    this.options = {
+      headless: true,
+      timeout: 30000,
+      blockResources: false,
+      enableNetworkLogging: false,
+    };
+  }
+
+  async initialize(options: BrowserOptions = {}): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    // Merge options
+    this.options = {
+      ...this.options,
+      ...options,
+    };
+
+    this.logger.info('Initializing browser...');
+
+    try {
+      this.browser = await chromium.launch({
+        headless: this.options.headless,
+        timeout: this.options.timeout,
+        args: [
+          // Security and sandbox
+          '--no-sandbox',
+          // '--disable-setuid-sandbox',
+          // '--disable-dev-shm-usage',
+          // '--disable-web-security',
+          // '--disable-features=VizDisplayCompositor',
+          // '--disable-blink-features=AutomationControlled',
+
+          // // Performance optimizations
+          // '--disable-gpu',
+          // '--disable-gpu-sandbox',
+          // '--disable-software-rasterizer',
+          // '--disable-background-timer-throttling',
+          // '--disable-renderer-backgrounding',
+          // '--disable-backgrounding-occluded-windows',
+          // '--disable-field-trial-config',
+          // '--disable-back-forward-cache',
+          // '--disable-hang-monitor',
+          // '--disable-ipc-flooding-protection',
+
+          // // Extensions and plugins
+          // '--disable-extensions',
+          // '--disable-plugins',
+          // '--disable-component-extensions-with-background-pages',
+          // '--disable-component-update',
+          // '--disable-plugins-discovery',
+          // '--disable-bundled-ppapi-flash',
+
+          // // Features we don't need
+          // '--disable-default-apps',
+          // '--disable-sync',
+          // '--disable-translate',
+          // '--disable-client-side-phishing-detection',
+          // '--disable-domain-reliability',
+          // '--disable-features=TranslateUI',
+          // '--disable-features=Translate',
+          // '--disable-breakpad',
+          // '--disable-preconnect',
+          // '--disable-print-preview',
+          // '--disable-password-generation',
+          // '--disable-password-manager-reauthentication',
+          // '--disable-save-password-bubble',
+          // '--disable-single-click-autofill',
+          // '--disable-autofill',
+          // '--disable-autofill-keyboard-accessory-view',
+          // '--disable-full-form-autofill-ios',
+
+          // // Audio/Video/Media
+          // '--mute-audio',
+          // '--disable-audio-output',
+          // '--autoplay-policy=user-gesture-required',
+          // '--disable-background-media-playback',
+
+          // // Networking
+          // '--disable-background-networking',
+          // '--disable-sync',
+          // '--aggressive-cache-discard',
+          // '--disable-default-apps',
+
+          // // UI/UX optimizations
+          // '--no-first-run',
+          // '--disable-infobars',
+          // '--disable-notifications',
+          // '--disable-desktop-notifications',
+          // '--disable-prompt-on-repost',
+          // '--disable-logging',
+          // '--disable-file-system',
+          // '--hide-scrollbars',
+
+          // // Memory optimizations
+          // '--memory-pressure-off',
+          // '--max_old_space_size=4096',
+          // '--js-flags="--max-old-space-size=4096"',
+          // '--media-cache-size=1',
+          // '--disk-cache-size=1',
+
+          // // Process management
+          // '--use-mock-keychain',
+          // '--password-store=basic',
+          // '--enable-automation',
+          // '--no-pings',
+          // '--no-service-autorun',
+          // '--metrics-recording-only',
+          // '--safebrowsing-disable-auto-update',
+
+          // // Disable unnecessary features for headless mode
+          // '--disable-speech-api',
+          // '--disable-gesture-typing',
+          // '--disable-voice-input',
+          // '--disable-wake-on-wifi',
+          // '--disable-webgl',
+          // '--disable-webgl2',
+          // '--disable-3d-apis',
+          // '--disable-accelerated-2d-canvas',
+          // '--disable-accelerated-jpeg-decoding',
+          // '--disable-accelerated-mjpeg-decode',
+          // '--disable-accelerated-video-decode',
+          // '--disable-canvas-aa',
+          // '--disable-2d-canvas-clip-aa',
+          // '--disable-gl-drawing-for-tests',
+        ],
+      });
+
+      this.initialized = true;
+      this.logger.info('Browser initialized successfully');
+    } catch (error) {
+      this.logger.error('Failed to initialize browser', { error });
+      throw error;
+    }
+  }
+
+  async createPageWithProxy(
+    url: string,
+    proxy?: string
+  ): Promise<{
+    page: Page & {
+      onNetworkEvent: (handler: NetworkEventHandler) => void;
+      offNetworkEvent: (handler: NetworkEventHandler) => void;
+      clearNetworkListeners: () => void;
+    };
+    contextId: string;
+  }> {
+    if (!this.browser) {
+      throw new Error('Browser not initialized. Call Browser.initialize() first.');
+    }
+
+    const contextId = `ctx-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+    const contextOptions: Record<string, unknown> = {
+      ignoreHTTPSErrors: true,
+      bypassCSP: true,
+    };
+
+    if (proxy) {
+      const [protocol, rest] = proxy.split('://');
+      const [auth, hostPort] = rest.includes('@') ? rest.split('@') : [null, rest];
+      const [host, port] = hostPort.split(':');
+
+      contextOptions.proxy = {
+        server: `${protocol}://${host}:${port}`,
+        username: auth?.split(':')[0] || '',
+        password: auth?.split(':')[1] || '',
+      };
+    }
+
+    const context = await this.browser.newContext(contextOptions);
+
+    // Block resources for performance
+    if (this.options.blockResources) {
+      await context.route('**/*.{png,jpg,jpeg,gif,svg,ico,woff,woff2,ttf,css}', route => {
+        route.abort();
+      });
+    }
+
+    this.contexts.set(contextId, context);
+
+    const page = await context.newPage();
+    page.setDefaultTimeout(this.options.timeout || 30000);
+    page.setDefaultNavigationTimeout(this.options.timeout || 30000);
+
+    // Create network event handlers for this page
+    const networkEventHandlers: Set<NetworkEventHandler> = new Set();
+
+    // Add network monitoring methods to the page
+    const enhancedPage = page as Page & {
+      onNetworkEvent: (handler: NetworkEventHandler) => void;
+      offNetworkEvent: (handler: NetworkEventHandler) => void;
+      clearNetworkListeners: () => void;
+    };
+
+    enhancedPage.onNetworkEvent = (handler: NetworkEventHandler) => {
+      networkEventHandlers.add(handler);
+
+      // Set up network monitoring on first handler
+      if (networkEventHandlers.size === 1) {
+        this.setupNetworkMonitoring(page, networkEventHandlers);
+      }
+    };
+
+    enhancedPage.offNetworkEvent = (handler: NetworkEventHandler) => {
+      networkEventHandlers.delete(handler);
+    };
+
+    enhancedPage.clearNetworkListeners = () => {
+      networkEventHandlers.clear();
+    };
+
+    if (url) {
+      await page.goto(url, {
+        waitUntil: 'domcontentloaded',
+        timeout: this.options.timeout,
+      });
+    }
+
+    return { page: enhancedPage, contextId };
+  }
+
+  private setupNetworkMonitoring(page: Page, handlers: Set<NetworkEventHandler>): void {
+    // Listen to requests
+    page.on('request', async request => {
+      const event: NetworkEvent = {
+        url: request.url(),
+        method: request.method(),
+        type: 'request',
+        timestamp: Date.now(),
+        headers: request.headers(),
+      };
+
+      // Capture request data for POST/PUT/PATCH requests
+      if (['POST', 'PUT', 'PATCH'].includes(request.method())) {
+        try {
+          const postData = request.postData();
+          if (postData) {
+            event.requestData = postData;
+          }
+        } catch {
+          // Some requests might not have accessible post data
+        }
+      }
+
+      this.emitNetworkEvent(event, handlers);
+    });
+
+    // Listen to responses
+    page.on('response', async response => {
+      const event: NetworkEvent = {
+        url: response.url(),
+        method: response.request().method(),
+        status: response.status(),
+        type: 'response',
+        timestamp: Date.now(),
+        headers: response.headers(),
+      };
+
+      // Capture response data for GET/POST requests with JSON content
+      const contentType = response.headers()['content-type'] || '';
+      if (contentType.includes('application/json') || contentType.includes('text/')) {
+        try {
+          const responseData = await response.text();
+          event.responseData = responseData;
+        } catch {
+          // Response might be too large or not accessible
+        }
+      }
+
+      this.emitNetworkEvent(event, handlers);
+    });
+
+    // Listen to failed requests
+    page.on('requestfailed', request => {
+      const event: NetworkEvent = {
+        url: request.url(),
+        method: request.method(),
+        type: 'failed',
+        timestamp: Date.now(),
+        headers: request.headers(),
+      };
+
+      // Try to capture request data for failed requests too
+      if (['POST', 'PUT', 'PATCH'].includes(request.method())) {
+        try {
+          const postData = request.postData();
+          if (postData) {
+            event.requestData = postData;
+          }
+        } catch {
+          // Ignore errors when accessing post data
+        }
+      }
+
+      this.emitNetworkEvent(event, handlers);
+    });
+  }
+
+  private emitNetworkEvent(event: NetworkEvent, handlers: Set<NetworkEventHandler>): void {
+    for (const handler of handlers) {
+      try {
+        handler(event);
+      } catch (error) {
+        this.logger.error('Network event handler error', { error });
+      }
+    }
+  }
+
+  async evaluate<T>(page: Page, fn: () => T): Promise<T> {
+    return page.evaluate(fn);
+  }
+
+  async closeContext(contextId: string): Promise<void> {
+    const context = this.contexts.get(contextId);
+    if (context) {
+      await context.close();
+      this.contexts.delete(contextId);
+    }
+  }
+
+  async close(): Promise<void> {
+    // Close all contexts
+    for (const [, context] of this.contexts) {
+      await context.close();
+    }
+    this.contexts.clear();
+
+    // Close browser
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = undefined;
+    }
+
+    this.initialized = false;
+    this.logger.info('Browser closed');
+  }
+
+  get isInitialized(): boolean {
+    return this.initialized;
+  }
+}
+
+// Export singleton instance
+export const Browser = new BrowserSingleton();
+
+// Also export the class for typing if needed
+export { BrowserSingleton as BrowserClass };

libs/browser/src/index.ts

@@ -0,0 +1,3 @@
+export { Browser } from './browser';
+export { BrowserTabManager } from './tab-manager';
+export type { BrowserOptions, ScrapingResult } from './types';

libs/browser/src/tab-manager.ts

@@ -0,0 +1,103 @@
+import { Page } from 'playwright';
+import { getLogger } from '@stock-bot/logger';
+import { Browser } from './browser';
+import type { ScrapingResult } from './types';
+
+interface TabInfo {
+  page: Page;
+  contextId: string;
+}
+
+export class BrowserTabManager {
+  private tabs: Map<string, TabInfo> = new Map();
+  private logger = getLogger('browser-tab-manager');
+
+  async createTab(url?: string): Promise<{ page: Page; tabId: string }> {
+    const tabId = `tab-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const { page, contextId } = await Browser.createPageWithProxy(url || 'about:blank');
+
+    this.tabs.set(tabId, { page, contextId });
+    this.logger.debug('Tab created', { tabId, url });
+
+    return { page, tabId };
+  }
+
+  async createTabWithProxy(
+    url: string,
+    proxy: string
+  ): Promise<{ page: Page; tabId: string; contextId: string }> {
+    const tabId = `tab-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const { page, contextId } = await Browser.createPageWithProxy(url, proxy);
+
+    this.tabs.set(tabId, { page, contextId });
+    this.logger.debug('Tab with proxy created', { tabId, url, proxy });
+
+    return { page, tabId, contextId };
+  }
+
+  async scrapeUrlsWithProxies<T>(
+    urlProxyPairs: Array<{ url: string; proxy: string }>,
+    extractor: (page: Page) => Promise<T>,
+    options: { concurrency?: number } = {}
+  ): Promise<ScrapingResult<T>[]> {
+    const { concurrency = 3 } = options;
+    const results: ScrapingResult<T>[] = [];
+
+    for (let i = 0; i < urlProxyPairs.length; i += concurrency) {
+      const batch = urlProxyPairs.slice(i, i + concurrency);
+
+      const batchPromises = batch.map(async ({ url, proxy }) => {
+        let tabId: string | undefined;
+
+        try {
+          const result = await this.createTabWithProxy(url, proxy);
+          tabId = result.tabId;
+
+          const data = await extractor(result.page);
+
+          return {
+            data,
+            url,
+            success: true,
+          } as ScrapingResult<T>;
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+
+          return {
+            data: null as T,
+            url,
+            success: false,
+            error: errorMessage,
+          } as ScrapingResult<T>;
+        } finally {
+          if (tabId) {
+            await this.closeTab(tabId);
+          }
+        }
+      });
+
+      const batchResults = await Promise.all(batchPromises);
+      results.push(...batchResults);
+    }
+
+    return results;
+  }
+
+  async closeTab(tabId: string): Promise<void> {
+    const tab = this.tabs.get(tabId);
+    if (tab) {
+      await tab.page.close();
+      await Browser.closeContext(tab.contextId);
+      this.tabs.delete(tabId);
+      this.logger.debug('Tab closed', { tabId });
+    }
+  }
+
+  getTabCount(): number {
+    return this.tabs.size;
+  }
+
+  getAllTabIds(): string[] {
+    return Array.from(this.tabs.keys());
+  }
+}

libs/browser/src/types.ts

@@ -0,0 +1,30 @@
+export interface BrowserOptions {
+  proxy?: string;
+  headless?: boolean;
+  timeout?: number;
+  blockResources?: boolean;
+  enableNetworkLogging?: boolean;
+}
+
+// Keep the old name for backward compatibility
+export type FastBrowserOptions = BrowserOptions;
+
+export interface ScrapingResult<T = unknown> {
+  data: T;
+  url: string;
+  success: boolean;
+  error?: string;
+}
+
+export interface NetworkEvent {
+  url: string;
+  method: string;
+  status?: number;
+  type: 'request' | 'response' | 'failed';
+  timestamp: number;
+  requestData?: string;
+  responseData?: string;
+  headers?: Record<string, string>;
+}
+
+export type NetworkEventHandler = (event: NetworkEvent) => void;

libs/browser/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"],
+  "references": [{ "path": "../../libs/logger" }]
+}

libs/cache/src/connection-manager.ts

@@ -1,6 +1,6 @@
 import Redis from 'ioredis';
-import { getLogger } from '@stock-bot/logger';
 import { dragonflyConfig } from '@stock-bot/config';
+import { getLogger } from '@stock-bot/logger';
 
 interface ConnectionConfig {
   name: string;
@@ -66,7 +66,9 @@ export class RedisConnectionManager {
       retryDelayOnFailover: dragonflyConfig.DRAGONFLY_RETRY_DELAY,
       connectTimeout: dragonflyConfig.DRAGONFLY_CONNECT_TIMEOUT,
       commandTimeout: dragonflyConfig.DRAGONFLY_COMMAND_TIMEOUT,
-      keepAlive: dragonflyConfig.DRAGONFLY_ENABLE_KEEPALIVE ? dragonflyConfig.DRAGONFLY_KEEPALIVE_INTERVAL * 1000 : 0,
+      keepAlive: dragonflyConfig.DRAGONFLY_ENABLE_KEEPALIVE
+        ? dragonflyConfig.DRAGONFLY_KEEPALIVE_INTERVAL * 1000
+        : 0,
       connectionName: name,
       lazyConnect: false, // Connect immediately instead of waiting for first command
       ...(dragonflyConfig.DRAGONFLY_TLS && {
@@ -90,7 +92,7 @@ export class RedisConnectionManager {
       this.logger.info(`Redis connection ready: ${name}`);
     });
 
-    redis.on('error', (err) => {
+    redis.on('error', err => {
       this.logger.error(`Redis connection error for ${name}:`, err);
     });
 
@@ -129,8 +131,8 @@ export class RedisConnectionManager {
 
     // Close shared connections (only if this is the last instance)
     if (RedisConnectionManager.instance === this) {
-      const sharedPromises = Array.from(RedisConnectionManager.sharedConnections.values()).map(conn => 
-        this.closeConnection(conn)
+      const sharedPromises = Array.from(RedisConnectionManager.sharedConnections.values()).map(
+        conn => this.closeConnection(conn)
       );
       await Promise.all(sharedPromises);
       RedisConnectionManager.sharedConnections.clear();
@@ -145,7 +147,7 @@ export class RedisConnectionManager {
   getConnectionCount(): { shared: number; unique: number } {
     return {
       shared: RedisConnectionManager.sharedConnections.size,
-      unique: this.connections.size
+      unique: this.connections.size,
     };
   }
 
@@ -155,7 +157,7 @@ export class RedisConnectionManager {
   getConnectionNames(): { shared: string[]; unique: string[] } {
     return {
       shared: Array.from(RedisConnectionManager.sharedConnections.keys()),
-      unique: Array.from(this.connections.keys())
+      unique: Array.from(this.connections.keys()),
     };
   }
 
@@ -171,7 +173,7 @@ export class RedisConnectionManager {
       try {
         await connection.ping();
         details[`shared:${name}`] = true;
-      } catch (error) {
+      } catch (_error) {
         details[`shared:${name}`] = false;
         allHealthy = false;
       }
@@ -182,7 +184,7 @@ export class RedisConnectionManager {
       try {
         await connection.ping();
         details[`unique:${name}`] = true;
-      } catch (error) {
+      } catch (_error) {
         details[`unique:${name}`] = false;
         allHealthy = false;
       }
@@ -198,10 +200,7 @@ export class RedisConnectionManager {
    */
   static async waitForAllConnections(timeout: number = 30000): Promise<void> {
     const instance = this.getInstance();
-    const allConnections = new Map([
-      ...instance.connections,
-      ...this.sharedConnections
-    ]);
+    const allConnections = new Map([...instance.connections, ...this.sharedConnections]);
 
     if (allConnections.size === 0) {
       instance.logger.info('No Redis connections to wait for');
@@ -259,15 +258,12 @@ export class RedisConnectionManager {
    */
   static areAllConnectionsReady(): boolean {
     const instance = this.getInstance();
-    const allConnections = new Map([
-      ...instance.connections,
-      ...this.sharedConnections
-    ]);
+    const allConnections = new Map([...instance.connections, ...this.sharedConnections]);
 
-    return allConnections.size > 0 && 
-           Array.from(allConnections.keys()).every(name => 
-             this.readyConnections.has(name)
-           );
+    return (
+      allConnections.size > 0 &&
+      Array.from(allConnections.keys()).every(name => this.readyConnections.has(name))
+    );
   }
 }
 

libs/cache/src/index.ts

@@ -1,6 +1,6 @@
-import { RedisCache } from './redis-cache';
 import { RedisConnectionManager } from './connection-manager';
-import type { CacheProvider, CacheOptions } from './types';
+import { RedisCache } from './redis-cache';
+import type { CacheOptions, CacheProvider } from './types';
 
 // Cache instances registry to prevent multiple instances with same prefix
 const cacheInstances = new Map<string, CacheProvider>();
@@ -14,7 +14,7 @@ export function createCache(options: Partial<CacheOptions> = {}): CacheProvider
     ttl: 3600, // 1 hour default
     enableMetrics: true,
     shared: true, // Default to shared connections
-    ...options
+    ...options,
   };
 
   // For shared connections, reuse cache instances with the same key prefix
@@ -43,7 +43,7 @@ export function createTradingCache(options: Partial<CacheOptions> = {}): CachePr
     ttl: 3600, // 1 hour default
     enableMetrics: true,
     shared: true,
-    ...options
+    ...options,
   });
 }
 
@@ -56,7 +56,7 @@ export function createMarketDataCache(options: Partial<CacheOptions> = {}): Cach
     ttl: 300, // 5 minutes for market data
     enableMetrics: true,
     shared: true,
-    ...options
+    ...options,
   });
 }
 
@@ -69,7 +69,7 @@ export function createIndicatorCache(options: Partial<CacheOptions> = {}): Cache
     ttl: 1800, // 30 minutes for indicators
     enableMetrics: true,
     shared: true,
-    ...options
+    ...options,
   });
 }
 
@@ -80,13 +80,12 @@ export type {
   CacheConfig,
   CacheStats,
   CacheKey,
-  SerializationOptions
+  SerializationOptions,
 } from './types';
 
 export { RedisCache } from './redis-cache';
 export { RedisConnectionManager } from './connection-manager';
 export { CacheKeyGenerator } from './key-generator';
 
-
 // Default export for convenience
 export default createCache;

libs/cache/src/key-generator.ts

@@ -65,7 +65,7 @@ export class CacheKeyGenerator {
     let hash = 0;
     for (let i = 0; i < str.length; i++) {
       const char = str.charCodeAt(i);
-      hash = ((hash << 5) - hash) + char;
+      hash = (hash << 5) - hash + char;
       hash = hash & hash; // Convert to 32-bit integer
     }
     return Math.abs(hash).toString(36);

libs/cache/src/redis-cache.ts

@@ -1,7 +1,7 @@
 import Redis from 'ioredis';
 import { getLogger } from '@stock-bot/logger';
-import { CacheProvider, CacheOptions, CacheStats } from './types';
 import { RedisConnectionManager } from './connection-manager';
+import { CacheOptions, CacheProvider, CacheStats } from './types';
 
 /**
  * Simplified Redis-based cache provider using connection manager
@@ -22,7 +22,7 @@ export class RedisCache implements CacheProvider {
     errors: 0,
     hitRate: 0,
     total: 0,
-    uptime: 0
+    uptime: 0,
   };
 
   constructor(options: CacheOptions = {}) {
@@ -34,7 +34,13 @@ export class RedisCache implements CacheProvider {
     this.connectionManager = RedisConnectionManager.getInstance();
 
     // Generate connection name based on cache type
-    const baseName = options.name || this.keyPrefix.replace(':', '').replace(/[^a-zA-Z0-9]/g, '').toUpperCase() || 'CACHE';
+    const baseName =
+      options.name ||
+      this.keyPrefix
+        .replace(':', '')
+        .replace(/[^a-zA-Z0-9]/g, '')
+        .toUpperCase() ||
+      'CACHE';
 
     // Get Redis connection (shared by default for cache)
     this.redis = this.connectionManager.getConnection({
@@ -81,7 +87,9 @@ export class RedisCache implements CacheProvider {
   }
 
   private updateStats(hit: boolean, error = false): void {
-    if (!this.enableMetrics) return;
+    if (!this.enableMetrics) {
+      return;
+    }
 
     if (error) {
       this.stats.errors++;
@@ -110,7 +118,7 @@ export class RedisCache implements CacheProvider {
       return await operation();
     } catch (error) {
       this.logger.error(`Redis ${operationName} failed`, {
-        error: error instanceof Error ? error.message : String(error)
+        error: error instanceof Error ? error.message : String(error),
       });
       this.updateStats(false, true);
       return fallback;
@@ -144,20 +152,26 @@ export class RedisCache implements CacheProvider {
     );
   }
 
-  async set<T>(key: string, value: T, options?: number | {
-    ttl?: number;
-    preserveTTL?: boolean;
-    onlyIfExists?: boolean;
-    onlyIfNotExists?: boolean;
-    getOldValue?: boolean;
-  }): Promise<T | null> {
+  async set<T>(
+    key: string,
+    value: T,
+    options?:
+      | number
+      | {
+          ttl?: number;
+          preserveTTL?: boolean;
+          onlyIfExists?: boolean;
+          onlyIfNotExists?: boolean;
+          getOldValue?: boolean;
+        }
+  ): Promise<T | null> {
     return this.safeExecute(
       async () => {
         const fullKey = this.getKey(key);
         const serialized = typeof value === 'string' ? value : JSON.stringify(value);
 
         // Handle backward compatibility - if options is a number, treat as TTL
-        const config = typeof options === 'number' ? { ttl: options } : (options || {});
+        const config = typeof options === 'number' ? { ttl: options } : options || {};
 
         let oldValue: T | null = null;
 
@@ -180,7 +194,9 @@ export class RedisCache implements CacheProvider {
           if (currentTTL === -2) {
             // Key doesn't exist
             if (config.onlyIfExists) {
-              this.logger.debug('Set skipped - key does not exist and onlyIfExists is true', { key });
+              this.logger.debug('Set skipped - key does not exist and onlyIfExists is true', {
+                key,
+              });
               return oldValue;
             }
             // Set with default or specified TTL
@@ -273,13 +289,26 @@ export class RedisCache implements CacheProvider {
     );
   }
 
+  async keys(pattern: string): Promise<string[]> {
+    return this.safeExecute(
+      async () => {
+        const fullPattern = `${this.keyPrefix}${pattern}`;
+        const keys = await this.redis.keys(fullPattern);
+        // Remove the prefix from returned keys to match the interface expectation
+        return keys.map(key => key.replace(this.keyPrefix, ''));
+      },
+      [],
+      'keys'
+    );
+  }
+
   async health(): Promise<boolean> {
     try {
       const pong = await this.redis.ping();
       return pong === 'PONG';
     } catch (error) {
       this.logger.error('Redis health check failed', {
-        error: error instanceof Error ? error.message : String(error) 
+        error: error instanceof Error ? error.message : String(error),
       });
       return false;
     }
@@ -288,7 +317,7 @@ export class RedisCache implements CacheProvider {
   getStats(): CacheStats {
     return {
       ...this.stats,
-      uptime: Date.now() - this.startTime
+      uptime: Date.now() - this.startTime,
     };
   }
 
@@ -308,7 +337,7 @@ export class RedisCache implements CacheProvider {
         resolve();
       });
 
-      this.redis.once('error', (error) => {
+      this.redis.once('error', error => {
         clearTimeout(timeoutId);
         reject(error);
       });
@@ -334,7 +363,7 @@ export class RedisCache implements CacheProvider {
 
   async setIfExists<T>(key: string, value: T, ttl?: number): Promise<boolean> {
     const result = await this.set(key, value, { ttl, onlyIfExists: true });
-    return result !== null || await this.exists(key);
+    return result !== null || (await this.exists(key));
   }
 
   async setIfNotExists<T>(key: string, value: T, ttl?: number): Promise<boolean> {
@@ -347,7 +376,11 @@ export class RedisCache implements CacheProvider {
   }
 
   // Atomic update with transformation
-  async updateField<T>(key: string, updater: (current: T | null) => T, ttl?: number): Promise<T | null> {
+  async updateField<T>(
+    key: string,
+    updater: (current: T | null) => T,
+    ttl?: number
+  ): Promise<T | null> {
     return this.safeExecute(
       async () => {
         const fullKey = this.getKey(key);
@@ -364,11 +397,10 @@ export class RedisCache implements CacheProvider {
           return {current_value, current_ttl}
         `;
 
-        const [currentValue, currentTTL] = await this.redis.eval(
-          luaScript, 
-          1, 
-          fullKey
-        ) as [string | null, number];
+        const [currentValue, currentTTL] = (await this.redis.eval(luaScript, 1, fullKey)) as [
+          string | null,
+          number,
+        ];
 
         // Parse current value
         let parsed: T | null = null;

libs/cache/src/types.ts

@@ -1,15 +1,22 @@
 export interface CacheProvider {
   get<T>(key: string): Promise<T | null>;
-  set<T>(key: string, value: T, options?: number | {
-    ttl?: number;
-    preserveTTL?: boolean;
-    onlyIfExists?: boolean;
-    onlyIfNotExists?: boolean;
-    getOldValue?: boolean;
-  }): Promise<T | null>;
+  set<T>(
+    key: string,
+    value: T,
+    options?:
+      | number
+      | {
+          ttl?: number;
+          preserveTTL?: boolean;
+          onlyIfExists?: boolean;
+          onlyIfNotExists?: boolean;
+          getOldValue?: boolean;
+        }
+  ): Promise<T | null>;
   del(key: string): Promise<void>;
   exists(key: string): Promise<boolean>;
   clear(): Promise<void>;
+  keys(pattern: string): Promise<string[]>;
   getStats(): CacheStats;
   health(): Promise<boolean>;
 
@@ -45,7 +52,7 @@ export interface CacheProvider {
    * Replace existing key's value and TTL
    */
   replace?<T>(key: string, value: T, ttl?: number): Promise<T | null>;
-    /**
+  /**
    * Atomically update field with transformation function
    */
   updateField?<T>(key: string, updater: (current: T | null) => T, ttl?: number): Promise<T | null>;

libs/cache/tsconfig.json

@@ -5,9 +5,5 @@
     "rootDir": "./src"
   },
   "include": ["src/**/*"],
-  "references": [
-    { "path": "../types" },
-    { "path": "../config" },
-    { "path": "../logger" }
-  ]
+  "references": [{ "path": "../types" }, { "path": "../config" }, { "path": "../logger" }]
 }

libs/cache/turbo.json

@@ -4,7 +4,16 @@
     "build": {
       "dependsOn": ["@stock-bot/types#build", "@stock-bot/logger#build"],
       "outputs": ["dist/**"],
-      "inputs": ["src/**", "package.json", "tsconfig.json", "!**/*.test.ts", "!**/*.spec.ts", "!**/test/**", "!**/tests/**", "!**/__tests__/**"]
+      "inputs": [
+        "src/**",
+        "package.json",
+        "tsconfig.json",
+        "!**/*.test.ts",
+        "!**/*.spec.ts",
+        "!**/test/**",
+        "!**/tests/**",
+        "!**/__tests__/**"
+      ]
     }
   }
 }

libs/config/src/admin-interfaces.ts

@@ -61,10 +61,17 @@ export const redisInsightConfig = cleanEnv(process.env, {
   REDIS_INSIGHT_PORT: port(8001, 'Redis Insight port'),
 
   // Redis Connection Settings
-  REDIS_INSIGHT_REDIS_HOSTS: str('local:dragonfly:6379', 'Redis hosts in format name:host:port,name:host:port'),
+  REDIS_INSIGHT_REDIS_HOSTS: str(
+    'local:dragonfly:6379',
+    'Redis hosts in format name:host:port,name:host:port'
+  ),
 
   // Configuration
-  REDIS_INSIGHT_LOG_LEVEL: strWithChoices(['error', 'warn', 'info', 'verbose', 'debug'], 'info', 'Redis Insight log level'),
+  REDIS_INSIGHT_LOG_LEVEL: strWithChoices(
+    ['error', 'warn', 'info', 'verbose', 'debug'],
+    'info',
+    'Redis Insight log level'
+  ),
   REDIS_INSIGHT_DISABLE_ANALYTICS: bool(true, 'Disable analytics collection'),
   REDIS_INSIGHT_BUILD_TYPE: str('DOCKER', 'Build type identifier'),
 });

libs/config/src/core.ts

@@ -1,8 +1,8 @@
 /**
  * Core configuration module for the Stock Bot platform using Yup
  */
-import { config as dotenvConfig } from 'dotenv';
 import path from 'node:path';
+import { config as dotenvConfig } from 'dotenv';
 
 /**
  * Represents an error related to configuration validation
@@ -21,7 +21,7 @@ export enum Environment {
   Development = 'development',
   Testing = 'testing',
   Staging = 'staging',
-  Production = 'production'
+  Production = 'production',
 }
 
 /**
@@ -35,11 +35,7 @@ export function loadEnvVariables(envOverride?: string): void {
   // 2. .env.{environment} (environment-specific variables)
   // 3. .env.local (local overrides, not to be committed)
 
-  const envFiles = [
-    '.env',
-    `.env.${env}`,
-    '.env.local'
-  ];
+  const envFiles = ['.env', `.env.${env}`, '.env.local'];
 
   for (const file of envFiles) {
     dotenvConfig({ path: path.resolve(process.cwd(), file) });
@@ -55,7 +51,7 @@ export function getEnvironment(): Environment {
     case 'development':
       return Environment.Development;
     case 'testing':
-    case 'test':  // Handle both 'test' and 'testing' for compatibility
+    case 'test': // Handle both 'test' and 'testing' for compatibility
       return Environment.Testing;
     case 'staging':
       return Environment.Staging;
@@ -63,6 +59,5 @@ export function getEnvironment(): Environment {
       return Environment.Production;
     default:
       return Environment.Development;
-      
   }
 }