Initial commit for AI coding assistant

Dockerfile

@@ -0,0 +1,89 @@
+# ==========================================
+# Production CPU Runtime Environment
+# ==========================================
+FROM python:3.11-slim
+
+# Install system dependencies, Redis server, OpenBLAS for CPU matrix math, and Node.js
+RUN apt-get update && apt-get install -y \
+    curl \
+    gnupg \
+    build-essential \
+    cmake \
+    pkg-config \
+    git \
+    libopenblas-dev \
+    redis-server \
+    && curl -fsSL https://deb.nodesource.com/setup_22.x | bash - \
+    && apt-get install -y nodejs \
+    && rm -rf /var/lib/apt/lists/*
+
+
+# Install PM2 globally to manage background processes
+RUN npm install -g pm2
+
+# Setup non-root user for Hugging Face compliance (UID 1000)
+RUN useradd -m -u 1000 user
+WORKDIR /home/user/app
+
+# Force llama-cpp-python to compile cleanly for CPU optimization
+ENV CMAKE_ARGS="-DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS"
+
+# Create cache directory for Hugging Face model downloads and set ownership
+ENV HF_HOME=/home/user/app/.cache/huggingface
+RUN mkdir -p $HF_HOME
+
+# --- Setup Python Worker ---
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+COPY python-ai-service/ ./python-ai-service
+
+# --- Setup Node Backend ---
+COPY node-backend/package*.json ./node-backend/
+RUN cd node-backend && npm ci --only=production
+COPY node-backend/ ./node-backend
+
+# --- Setup Pre-built Frontend Static Files ---
+# Copies directly from your react-frontend/dist folder
+COPY react-frontend/dist ./node-backend/public
+
+# Copy startup script
+COPY start.sh .
+RUN chmod +x start.sh
+
+# Set environment variables
+ENV PORT=7860
+ENV NODE_ENV=production
+ENV APP_ENV=production
+ENV REDIS_URL=redis://127.0.0.1:6379
+
+# Set write/read permissions for the Hugging Face non-root user
+RUN chown -R user:user /home/user/app
+USER user
+
+# Create a PM2 ecosystem file to launch Redis, Node Backend, and Python Worker
+RUN echo 'module.exports = { \
+  apps: [ \
+    { \
+      name: "redis-server", \
+      script: "redis-server", \
+      args: "--bind 127.0.0.1 --protected-mode no" \
+    }, \
+    { \
+      name: "node-backend", \
+      script: "cd node-backend && npm start", \
+      env: { PORT: "7860", REDIS_URL: "redis://127.0.0.1:6379" } \
+    }, \
+    { \
+      name: "python-worker", \
+      script: "python -m python-ai-service.main", \
+      env: { REDIS_URL: "redis://127.0.0.1:6379" } \
+    } \
+  ] \
+};' > ecosystem.config.js
+
+# Expose Hugging Face Space default web port
+EXPOSE 7860
+
+# Start Redis, Node, and Python simultaneously
+# CMD ["pm2-runtime", "ecosystem.config.js"]
+CMD ["./start.sh"]

README.md

@@ -0,0 +1,11 @@
+---
+title: My Multi Service App
+emoji: 🚀
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+This is my multi-service application running Node, React, and Python via Docker.

node-backend/.env.development

@@ -0,0 +1,6 @@
+FRONTEND_URL=https://127.0.0.1:5173
+HOST=127.0.0.1
+PORT=3000
+
+SSL_CERT=./src/ssl/certificate.crt
+SSL_KEY=./src/ssl/certificate.key

node-backend/.env.production

@@ -0,0 +1,5 @@
+PORT=7860
+
+REDIS_URL=redis://127.0.0.1:6379
+
+FRONTEND_URL=https://subi333-ai_coding_assistant.hf.space

node-backend/Dockerfile

@@ -0,0 +1,22 @@
+# Stage 1: Build stage
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+COPY . .
+# Compiles your TypeScript code into a clean JavaScript /dist folder
+RUN npm run build 
+
+# Stage 2: Production execution stage
+FROM node:20-alpine AS production
+WORKDIR /app
+ENV NODE_ENV=production
+COPY package*.json ./
+# Installs only lightweight production dependencies (no devDependencies)
+RUN npm ci --only=production
+# Copies only the compiled JavaScript files from the builder stage
+COPY --from=builder /app/dist ./dist
+# If you use raw assets like folders or views, copy them here too
+
+EXPOSE 5000
+CMD ["node", "dist/index.js"]

node-backend/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "Ai-chat-backend",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node dist/index.js",
+    "dev": "powershell -Command \"[Console]::OutputEncoding=[System.Text.Encoding]::UTF8; nodemon --exec ts-node src/server.ts\"",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "@socket.io/redis-adapter": "^8.3.0",
+    "@socket.io/redis-emitter": "^5.1.0",
+    "bcryptjs": "^3.0.2",
+    "bson": "^6.10.4",
+    "bullmq": "^5.66.1",
+    "busboy": "^1.6.0",
+    "cookie-parser": "^1.4.7",
+    "cors": "^2.8.5",
+    "crypto": "^1.0.1",
+    "dotenv": "^16.4.5",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.5.2",
+    "helmet": "^8.0.0",
+    "http": "^0.0.1-security",
+    "https": "^1.0.0",
+    "morgan": "^1.10.0",
+    "nanoid": "^3.3.11",
+    "nodemailer": "^7.0.11",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "redis": "^6.1.0",
+    "socket.io": "^4.8.1",
+    "ua-parser-js": "^2.0.6",
+    "ulid": "^3.0.1",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "@types/cookie-parser": "^1.4.8",
+    "@types/cors": "^2.8.18",
+    "@types/crypto-js": "^4.2.2",
+    "@types/express": "^5.0.2",
+    "@types/node": "^22.19.7",
+    "@types/nodemailer": "^7.0.4",
+    "concurrently": "^9.2.1",
+    "cross-env": "^10.1.0",
+    "nodemon": "^3.1.14",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.2"
+  }
+}

node-backend/src/api/controllers/gpt-chat-controller.ts

@@ -0,0 +1,53 @@
+import { Request, Response, NextFunction } from 'express';
+import { GptChatQueueService } from '../../queues/gpt-chat-queue-services';
+import logger from '../../logger';
+
+export const useGptChatController = (gptChatQueueService: GptChatQueueService) => ({
+    
+    
+    gptChatController: async (req: Request, res: Response, next: NextFunction) => { 
+        try {
+            const { aiInput, msgSession } = req.body;
+            logger.debug(`Prompt received - ${aiInput}`); 
+       
+            const anonId = req.headers['x-anonuser-id'] as string;
+        
+            if (!anonId) {   // 👈 runtime + TS check. Before using req.user.id check !req.user. See authmiddleware to see this
+                res.status(401).json({
+                    success: false,
+                    message: 'Unauthorized',
+                });
+                return;
+            }
+
+         
+            if (!aiInput) {
+                res.status(400).json({
+                    success: false,
+                    message: 'Missing prompt',
+                });
+                return;
+            }
+
+            // Send early response 
+            res.status(200).json({
+                success: true,
+                status: 'processing',
+                message: 'Prompt submitted to AI model',
+            });
+
+            // Send to queue
+            await gptChatQueueService.queueGptChatPrompt(aiInput, msgSession, anonId);
+        
+            return;
+        } catch (err: any) {
+            let msg = 'Prompt submission error';
+            res.status(500).json({
+                success: false,
+                message: msg,
+                error: err.message,
+            });
+            return;
+        }
+    },
+});

node-backend/src/api/controllers/index.ts

@@ -0,0 +1,3 @@
+import { useGptChatController } from './gpt-chat-controller';
+
+export { useGptChatController };

node-backend/src/api/routes/gpt-chat-router.ts

@@ -0,0 +1,13 @@
+import { Router } from 'express';
+import { useGptChatController } from '../controllers';
+import { GptChatQueueService } from '../../queues/gpt-chat-queue-services';
+
+
+export function gptChatRoute(gptChatQueueService: GptChatQueueService) {
+    const router: Router = Router();
+
+    const chatController = useGptChatController(gptChatQueueService);
+    router.post('/aichat', chatController.gptChatController); 
+
+    return router;
+};

node-backend/src/api/routes/index.ts

@@ -0,0 +1,12 @@
+import { Router } from 'express';
+import { gptChatRoute } from './gpt-chat-router';
+import { GptChatQueueService } from '../../queues/gpt-chat-queue-services';
+
+
+export function appRouter(gptChatQueueService: GptChatQueueService) {
+    const router: Router = Router();
+
+    router.use('/api/v1/users', gptChatRoute(gptChatQueueService));
+
+    return router;
+}

node-backend/src/api/socket/socket.ts

@@ -0,0 +1,97 @@
+import { Server as SocketIOServer, Socket } from 'socket.io';
+import { Server as HTTPSServer } from 'https';
+import http, { Server as HttpServer } from "http";
+
+import dotenv from 'dotenv';
+import logger from '../../logger';
+import { createAdapter } from "@socket.io/redis-adapter";
+import { getPubSubRedisInfra } from '../../redis';
+import { createClient } from "redis";
+
+const envFile: string = process.env.NODE_ENV === 'production' ? '.env.production' : '.env.development';
+
+dotenv.config({ path: envFile });
+
+const jwt_access_secret = process.env.JWT_ACCESS_SECRET || '';
+let io: SocketIOServer;
+
+const allowedOrigins = [
+    process.env.FRONTEND_URL,
+];
+
+export const initializeSocket = async (server: HTTPSServer | HttpServer): Promise<SocketIOServer> => {
+
+    io = new SocketIOServer(server, {
+        cors: {
+            origin: allowedOrigins[0],
+            methods: ['GET', 'POST'],
+            credentials: true || false,
+        }
+    });
+
+    // const pubRedisInfra = getPubSubRedisInfra('pub-redis-infra');
+    // const subRedisInfra = getPubSubRedisInfra('sub-redis-infra');
+    // // For kafka service emit event using a redis client to listen
+    // io.adapter(createAdapter(pubRedisInfra.redis, subRedisInfra.redis));
+    const subscriber = createClient();
+
+    await subscriber.connect(); 
+
+    subscriber.subscribe("ai_response", (message: any) => { // This event is generating from python ai service
+        const data = JSON.parse(message);
+        // data.event = "gptChatRes"
+        io.to(`user:${data.userId}`).emit(data.event, {
+                result: data.payload.result,    
+                msgSession: data.msg_session
+            }
+        );
+    });
+
+    io.on('connection', (socket: Socket) => { // in-built listener
+        logger.debug(`✅ A user connected: ${socket.id}`);
+
+        socket.on('disconnect', async() => {  // in-built listener
+            logger.debug(`✅ A user disconnected: ${socket.id}`);
+        });
+
+        socket.on('admin-login', async(adminEmail: string) => {  // Custom listener
+            logger.info(`✅ Admin logined : ${adminEmail}`); //
+        });
+
+        socket.on('admin-logout', async(adminEmail: string) => {  // Custom listener
+            // removeAdmin(socket.id);
+            logger.info(`✅ Admin logged out : ${adminEmail}`); //
+        });
+
+        socket.on('join-user-room', (userId: string) => {
+            socket.join(`user:${userId}`);
+            logger.debug(`✅ A user joined the socket user-room: ${userId}`);
+        });
+
+        socket.on('leave-user-room', (userId: string) => {
+            socket.leave(`user:${userId}`);
+            logger.debug(`✅ A user left the socket user-room: ${userId}`);
+        });
+
+        //Test function
+        socket.on('hello', (callback) => {
+            logger.debug('Received hello');
+            callback('world');
+        });
+    });
+
+    return io;
+};
+
+export const broadcastGptChatRes = async (
+    gptChatRes: any
+): Promise<void> => {
+    
+    if (!io) {
+        logger.error('Socket.io is not initialized');
+        return;
+    }
+    logger.debug('gptChatRes');
+    console.log("Emitting:", `user:${gptChatRes.userId}`);
+    io.to(`user:${gptChatRes.userId}`).emit('gptChatRes', { gptChatRes: gptChatRes });
+};

node-backend/src/logger.ts

@@ -0,0 +1,67 @@
+import pino, { LoggerOptions, Logger } from 'pino';
+import path from 'path';
+import dotenv from 'dotenv';
+
+const envFile: string = process.env.NODE_ENV === 'production' ? '.env.production' : '.env.development';
+dotenv.config({ path: envFile });
+
+const isProduction = process.env.NODE_ENV === 'production';
+
+const options: LoggerOptions = {
+    level: process.env.LOG_LEVEL || (isProduction ? 'info' : 'debug')
+};
+
+// 1. FOR PRODUCTION (JSON Output Layout)
+// Appends a clean "caller" property tracking the file and line number
+options.hooks = {
+    logMethod(inputArgs: any[], method, level) {
+        // Generate a quick call stack trace
+        const stack = new Error().stack;
+        
+        // Split and target line 3 (which points back to where logger.info was called)
+        const callerLine = stack?.split('\n')[3];
+        
+        // Use RegExp to isolate the file path, row, and column position
+        const match = callerLine?.match(/\((.*):(\d+):(\d+)\)/) || callerLine?.match(/at\s+(.*):(\d+):(\d+)/);
+        
+        let callerContext = 'unknown';
+        if (match) {
+        const filePath = match[1];
+        const line = match[2];
+        const fileName = path.basename(filePath);
+        callerContext = `${fileName}:${line}`;
+        }
+
+        // Inject the context directly into the log arguments array
+        return method.apply(this, [ { caller: callerContext }, ...inputArgs ]);
+    }
+};
+
+// Pretty logs only in dev
+if (!isProduction) {
+    options.transport = {
+        target: 'pino-pretty',
+        options: {
+            colorize: true,
+            messageFormat: '\x1b[36m[{caller}]\x1b[0m {msg}',
+            translateTime: 'HH:MM:ss',
+            ignore: 'pid,hostname,caller'
+        }
+    }
+}
+
+const logger: Logger = pino(options);
+
+export default logger;
+
+/* Usage
+Log level	Dev	    Prod
+debug	    ✅	    ❌
+info	    ✅	    ✅
+warn	    ✅	    ✅
+error	    ✅	    ✅ */
+
+// e.g., output - in prod. - {"level":20,"time":...,"pid":12345,"hostname":"server-1","ip":"192.168.1.10","msg":"WiFi IP detected"}
+// e.g., output in dev. - 
+// 15:42:11 DEBUG  WiFi IP detected
+// ip: 192.168.1.10

node-backend/src/queues/gpt-chat-queue-services.ts

@@ -0,0 +1,146 @@
+import { Queue, QueueEvents, Job } from 'bullmq';
+import IORedis from 'ioredis';
+import logger from '../logger';
+
+// Gpt Chat service class
+export class GptChatQueueService {
+
+  private queue: Queue;
+  private queueEvents: QueueEvents; // ONLY for listening to events
+  private connection: IORedis;
+  private queueEventsRegistry: Map<string, QueueEvents> = new Map();
+  private queueName: string;
+
+  constructor(gptChatQueueRedis: IORedis, queue: Queue, queueName: string) {
+    this.queueName = queueName;
+    this.queue = queue;
+    this.connection = gptChatQueueRedis;
+    this.queueEvents = new QueueEvents(queueName, {
+      connection: this.connection
+    });
+
+    this.queueEventsRegistry.set(queueName, this.queueEvents); // Register queue events for later use, e.g., when shut down etc.
+
+    this.setupEventListeners();
+  }
+
+  // Setup all event listeners
+  private setupEventListeners(): void {
+
+    // Job started processing
+    this.queueEvents.on('active', async({ jobId }: { jobId: string }) => {
+      logger.debug(`Job ${jobId} started processing: ${this.queueName}`);
+    });
+
+    // Job completed
+    this.queueEvents.on('completed', async({ jobId }: { jobId: string }) => {
+      logger.debug(`Job ${jobId} completed: ${this.queueName}`);
+    });
+
+    // Job failed
+    this.queueEvents.on('failed', async({ jobId, failedReason }: { jobId: string, failedReason: string }) => {
+      logger.error({failedReason}, `Job ${jobId} failed: ${this.queueName}`);
+    });
+
+    // Job progress
+    // this.queueEvents.on('progress', ({ jobId, data }: { jobId: string, data: number }) => {
+    //   logger.info(`Job ${jobId} progress: ${data}%`);
+    //   this.updateProgress(jobId, data);
+    // });
+
+    // Stalled job
+    // this.queueEvents.on('stalled', ({ jobId }: { jobId: string }) => {
+    //   logger.warn(`Job ${jobId} stalled`);
+    //   this.infoJobStatus(jobId, 'stalled');
+    // });
+
+    // Removed job
+    this.queueEvents.on('removed', ({ jobId }: { jobId: string }) => {
+      logger.debug(`Job ${jobId} removed: ${this.queueName}`);
+    });
+
+    // Error in queue
+    this.queueEvents.on('error', (error: Error) => {
+      logger.error({err: error}, `QueueEvents error: ${this.queueName}`);
+    });
+  }
+
+  // Queue gpt chat prompt
+  async queueGptChatPrompt(
+    prompt: string,
+    msgSession: string,
+    userId: string, 
+    priority = 1
+  ) {
+    return this.queue.add('gpt-chat-process', {
+      prompt,
+      msgSession,
+      userId,
+      type: 'gpt-chat-process',
+      queuedAt: new Date().toISOString()
+    }, {
+      priority,
+      delay: 100
+    });
+  }
+
+  // Get queue metrics
+  async getQueueMetrics() {
+    const [waiting, active, completed, failed, delayed] = await Promise.all([
+      this.queue.getWaitingCount(),
+      this.queue.getActiveCount(),
+      this.queue.getCompletedCount(),
+      this.queue.getFailedCount(),
+      this.queue.getDelayedCount()
+    ]);
+
+    return {
+      waiting,
+      active,
+      completed,
+      failed,
+      delayed,
+      total: waiting + active + completed + failed + delayed
+    };
+  }
+
+  // Clean old jobs
+  async cleanOldJobs(olderThanHours = 24) {
+    const timestamp = Date.now() - (olderThanHours * 60 * 60 * 1000);
+    
+    // Clean completed jobs
+    await this.queue.clean(timestamp, 1000, 'completed');
+    
+    // Clean failed jobs (keep for longer)
+    const failedTimestamp = Date.now() - (olderThanHours * 3 * 60 * 60 * 1000);
+    await this.queue.clean(failedTimestamp, 1000, 'failed');
+  }
+
+
+  async closeQueueEvents(): Promise<void> {
+    
+    if (!this.queueEventsRegistry || this.queueEventsRegistry.size === 0) {
+      logger.info(`✅ No active QueueEvents: ${this.queueName}`);
+      return;
+    }
+
+    logger.info(`Closing ${this.queueEventsRegistry.size} ${this.queueEventsRegistry.size > 1 ? 'QueueEvents...' : 'QueueEvent...'}`);
+
+    await Promise.allSettled(
+      Array.from(this.queueEventsRegistry.entries()).map(async ([name, queue]) => {
+        try {
+          // logger.info(`Closing QueueEvents: ${name}`);
+          await queue.close();
+          logger.info(`✅ Closed QueueEvents: ${name}`);
+        } catch (err: any) {
+            logger.error({ err }, `❌ Failed closing QueueEvents: ${name}`);
+          throw err;
+        }
+      })
+    );
+
+    this.queueEventsRegistry.clear();
+    logger.info('✅ All QueueEvents closed');
+  }
+
+}

node-backend/src/queues/index.ts

@@ -0,0 +1,6 @@
+
+import { QueueInfra } from './queue';
+
+export { 
+    QueueInfra,
+};

node-backend/src/queues/queue.ts

@@ -0,0 +1,185 @@
+import IORedis from 'ioredis';
+import { Queue, Job } from 'bullmq';
+import dotenv from 'dotenv';
+
+import logger from '../logger';
+// import { workerRedis } from './workerRedis';
+
+const envFile: string = process.env.NODE_ENV === 'production' ? '.env.production' : '.env.development';
+
+dotenv.config({ path: envFile });
+
+export class QueueInfra {
+  public readonly queueRedis: IORedis;
+  public readonly queue: Queue;
+  private initialized = false;
+  private queueName: string;
+
+  constructor(queueRedis: IORedis, queueName: string) { 
+    this.queueRedis = queueRedis;
+    this.queueName = queueName;
+
+    // Create the queue for email related tasks
+    this.queue = new Queue(queueName, {
+      connection: this.queueRedis,  // Pass connection object
+      
+      defaultJobOptions: {
+        attempts: 3,
+        backoff: {
+          type: 'exponential',  // Options: 'fixed' | 'exponential'
+          delay: 3000           // Delay in ms
+        },
+        removeOnComplete: {
+          count: 1000,          // Keep last 1000 completed jobs
+          age: 24 * 3600        // OR keep for 24 hours (optional)
+        },
+        removeOnFail: {
+          count: 6000,          // Keep last 5000 failed jobs
+          age: 72 * 3600        // OR keep for 72 hours (optional)
+        },
+      
+        // Timeouts are handled at worker level
+      }
+    });
+
+  }
+
+  async init() {
+    if (this.initialized) return;
+    this.initialized = true;
+
+    // this.setupRedisEventListeners();
+    this.setupQueueEventListeners();
+  }
+
+  /*private setupRedisEventListeners(): void {
+    // Add event handlers
+    this.emailQueueRedis.on('connect', () => {
+      logger.info('✅ Redis connected (Email queue redis)');
+    });
+
+    this.emailQueueRedis.on('ready', () => {
+      logger.info('✅ Redis ready (Email queue redis)');
+    });
+
+    this.emailQueueRedis.on('error', (err) => {
+      logger.error({ err }, `❌ Redis connection error (Email queue redis): ${err.message}`);
+      // Don't crash the app on Redis errors
+    });
+
+    this.emailQueueRedis.on('close', () => {
+      logger.info('⚠️  Redis connection closed (Email queue redis)');
+    });
+
+    this.emailQueueRedis.on('reconnecting', (delay: number) => {
+      logger.info(`🔄 Redis reconnecting in ${delay}ms (email queue redis)`);
+    });
+
+    this.emailQueueRedis.on('end', () => {
+      logger.info('🔴 Redis connection ended (email queue redis)');
+    });
+  } */
+
+  private setupQueueEventListeners(): void {
+    // The callback receives a Job object directly, not an args object
+    this.queue.on('waiting', (job: Job) => {
+      logger.info(`📥 Job ${job.id} is waiting: ${this.queueName}`);
+      logger.info(`Job data: ${job.data}: ${this.queueName}`);
+    });
+
+    this.queue.on('error', (err: Error) => {
+      logger.error({ err }, `❌ Queue error: ${err.message}: ${this.queueName}`);
+    });
+
+    this.queue.on('progress', (job: string, progress: any) => {
+      logger.debug(`📊 Job ${job} progress: ${progress} : ${this.queueName}`);
+    });
+
+    // Other available events:
+    this.queue.on('paused', () => {
+      logger.info(`⏸️ Queue paused: ${this.queueName}`);
+    });
+
+    this.queue.on('resumed', () => {
+      logger.info(`▶️ Queue resumed: ${this.queueName}`);
+    });
+
+    this.queue.on('cleaned', (jobs: string[], type: string) => {
+      logger.debug(`🧹 Cleaned ${jobs.length} ${type} jobs: ${this.queueName}`);
+    });
+
+    this.queue.on('removed', (job: string) => {
+      logger.debug(`🗑️ Job ${job} removed: ${this.queueName}`);
+    });
+
+    // Redis-specific events
+    this.queue.on('ioredis:close', () => {
+      logger.info(`🔌 Redis connection closed: ${this.queueName}`);
+    });
+  }
+  
+  // Test connection on startup
+  public async testQueueRedisConnection() {
+    try {
+      await this.queueRedis.ping();
+      logger.info(`✅ Redis connection test passed: ${this.queueName}`);
+    } catch (err: any) {
+        logger.error({err}, `❌ Redis connection test failed: ${err.message}: ${this.queueName}`);
+    }
+  }
+
+  public async closeQueue() {
+    logger.info(`⏳ Closing ${this.queueName}...`);
+    if (!this.queue) {
+      logger.info(`✅ ${this.queueName} is not active.`);
+      return;
+    }
+
+    try {
+      await this.queue.close();
+      logger.info(`✅ ${this.queueName} closed`);
+    } catch (err: any) {
+        logger.error({ err }, `❌ Failed to close ${this.queueName}`);
+        throw err; // propagate to main shutdown  
+    }
+  }
+  
+  public async closeQueueRedis() {
+    logger.info(`⏳ Closing Redis connection: ${this.queueName}...`);
+
+    if(!this.queueRedis) {
+      logger.info(`✅ Redis connection: ${this.queueName} is not active`);
+      return;   
+    }
+
+    try {
+      await this.queueRedis.quit(); // Graceful Redis shutdown
+      logger.info(`✅ Redis connection closed: ${this.queueName} `);
+    } catch (err: any) {
+        logger.error({ err }, `❌ Failed to close Redis connection: ${this.queueName}`);
+        throw err; // propagate to main shutdown  
+    }
+  }
+
+};
+
+
+/*
+Never do:
+
+try {
+   everything
+}
+
+Always do:
+
+START log
+if exists
+   try risky close
+SUCCESS log
+FAIL log
+
+This is architecturally correct
+
+
+*/

node-backend/src/redis/index.ts

@@ -0,0 +1,16 @@
+import { RedisClientInfra } from './redisClient';
+import { APIRedisService } from './redisServices';
+
+import { 
+    initPubSubRedis,
+    getPubSubRedisInfra,
+    closePubSubRedis
+} from './socket_redis';
+
+export {
+    RedisClientInfra,
+    APIRedisService,
+    initPubSubRedis,
+    getPubSubRedisInfra,
+    closePubSubRedis
+}; 

node-backend/src/redis/redisClient.ts

@@ -0,0 +1,186 @@
+// src/redis/client.ts
+import IORedis from 'ioredis';
+import { Queue, Job } from 'bullmq';
+import dotenv from 'dotenv';
+
+import logger from '../logger';
+
+
+const envFile: string = process.env.NODE_ENV === 'production' ? '.env.production' : '.env.development';
+
+dotenv.config({ path: envFile });
+
+export class RedisClientInfra {
+  public readonly redis: IORedis;
+  // public readonly apiUserActionsQueue: Queue;
+  private initialized: boolean;
+  private redisName: string;
+
+  constructor(redisName: string) {
+    this.redis = new IORedis({
+      host: process.env.REDIS_HOST1 || 'localhost',
+      port: parseInt(process.env.REDIS_PORT || '6379'),
+      
+      // Connection options
+      maxRetriesPerRequest: null,
+      enableReadyCheck: false,
+      enableOfflineQueue: true,
+
+      // Socket options (CRITICAL for preventing ECONNABORTED)
+      retryStrategy: (times: number) => {
+        logger.info(`Redis connection attempt(${redisName}) ${times}`);
+        if (times > 10) {
+          logger.info(`Too many redis connection attempts(${redisName})`);
+          return null;
+        }
+        const delay = Math.min(times * 50, 2000);
+        return delay;
+      },
+
+      // Timeout settings
+      connectTimeout: 10000, // 10 seconds to connect
+      commandTimeout: 30000, // 30 seconds for commands
+
+      reconnectOnError: (err: any) => {
+        // Reconnect on network errors but not on command errors
+        const targetErrors = ['READONLY', 'ECONNRESET', 'ETIMEDOUT'];
+        return targetErrors.some(error => err.message.includes(error));
+      },
+
+    }); 
+    
+    this.initialized = false;
+    this.redisName = redisName;
+
+    /*
+    // Create a new queue for API service
+    this.apiUserActionsQueue = new Queue('api-user-actions-queue', {
+      connection: this.apiRedis, // Pass connection object
+
+      defaultJobOptions: {
+        attempts: 3,
+        backoff: {
+          type: 'exponential', // Options: 'fixed' | 'exponential
+          delay: 3000          // Delay in ms
+        },
+        removeOnComplete: {
+          count: 1000,         // Keep last 1000 completed jobs
+          age: 24 * 3600       // OR keep for 24 hours (optional)
+        },
+        removeOnFail: {
+          count: 6000,         // Keep last 5000 failed jobs
+          age: 72 * 3600       // OR keep for 72 hours (optional)
+        },
+      }
+    }); */
+  }
+
+  async init() {
+    if (this.initialized) return;
+    this.initialized = true;
+
+    this.setupRedisEventListeners();
+    // this.setupUserActionsQueueEventListeners();
+  }
+
+  // Handle connection events
+  private setupRedisEventListeners(): void {
+    this.redis.on('connect', () => {
+      logger.info(`✅ Redis Connected (${this.redisName})`);
+    });   
+
+    this.redis.on('ready', () => {
+      logger.info(`🟢 Redis ready (${this.redisName})`);
+    });
+
+    this.redis.on('error', (err: any) => {
+      logger.error({ err }, `❌ Redis connection error (${this.redisName}): ${err.message}`);
+    });
+
+    this.redis.on('close', () => {
+      logger.info(`⚠️  Redis connection closed (${this.redisName})`);
+    });
+
+    this.redis.on('reconnecting', (delay: number) => {
+      logger.info(`🔄 Redis reconnecting in ${delay}ms (${this.redisName})`);
+    });
+
+    this.redis.on('end', () => {
+      logger.info(`🔴 Redis connection ended (${this.redisName})`);
+    });
+
+  }
+
+  /*private setupApiUserActionsQueueEventListeners(): void {
+    // The callback receives a Job object directly, not an args object
+    this.apiUserActionsQueue.on('waiting', (job: Job) => {
+      logger.info(`📥 Job ${job.id} is waiting`);
+      logger.info(`Job data: ${job.data}`);
+    });
+
+    this.apiUserActionsQueue.on('error', (err: Error) => {
+      logger.error({ err }, `❌ Queue error: ${err.message}`);
+    });
+
+    this.apiUserActionsQueue.on('progress', (job: string, progress: any) => {
+      logger.debug(`📊 Job ${job} progress: ${progress}`);
+    });
+
+    // Other available events:
+    this.apiUserActionsQueue.on('paused', () => {
+      logger.info('⏸️ Queue paused');
+    });
+
+    this.apiUserActionsQueue.on('resumed', () => {
+      logger.info('▶️ Queue resumed');
+    });
+
+    this.apiUserActionsQueue.on('cleaned', (jobs: string[], type: string) => {
+      logger.debug(`🧹 Cleaned ${jobs.length} ${type} jobs`);
+    });
+
+    this.apiUserActionsQueue.on('removed', (job: string) => {
+      logger.debug(`🗑️ Job ${job} removed`);
+    });
+
+    // Redis-specific events
+    this.apiUserActionsQueue.on('ioredis:close', () => {
+      logger.info('🔌 Redis connection closed(API redis)');
+    });
+  } */
+  
+  // Test connection on startup
+  public async testRedisConnection() {
+    try {
+      await this.redis.ping();
+      logger.info(`✅ Redis connection test passed(${this.redisName})`);
+    } catch (err: any) {
+        logger.error({err}, `❌ Redis connection test failed(${this.redisName}): ${err.message}`);
+    }
+  }
+
+  async redisGracefulShutdown(): Promise<void> {
+    logger.info(`⏳ Closing Redis connection for ${this.redisName}...`);
+
+    if(!this.redis) {
+      logger.info(`✅ Redis connection for ${this.redisName} is not active`);
+      return;   
+    }
+
+    try {
+      await this.redis.quit(); // Graceful Redis shutdown
+      logger.info(`✅ Redis connection closed for ${this.redisName}`);
+    } catch (err: any) {
+        logger.error({ err }, `❌ Failed to close redis connection for ${this.redisName}`);
+        throw err; // propagate to main shutdown  
+    }
+  }
+
+}
+
+
+/*
+If age exceeded → delete
+OR
+If count exceeded → delete
+*/

node-backend/src/redis/redisServices.ts

@@ -0,0 +1,35 @@
+
+import IORedis from 'ioredis';
+import { Queue } from 'bullmq';
+
+export class APIRedisService {
+  // public connection: IORedis;
+  // public userActionsQueue: Queue;
+
+  constructor(
+    private readonly connection: IORedis,/*private readonly userActionsQueue: Queue*/) {
+    // this.connection = redis;
+    // this.userActionsQueue = queue;
+  }
+
+  async set(key: string, value: any, ttlSeconds?: number) {
+    const data = JSON.stringify(value);
+
+    if (ttlSeconds) {
+      await this.connection.set(key, data, 'EX', ttlSeconds);
+    } else {
+        await this.connection.set(key, data);
+    }
+  }
+
+
+  async get<T = any>(key: string): Promise<T | null> {
+    const data = await this.connection.get(key);
+    return data ? JSON.parse(data) : null;
+  }
+
+
+  async del(key: string) {
+    await this.connection.del(key);
+  }
+}

node-backend/src/redis/socket_redis.ts

@@ -0,0 +1,34 @@
+import { RedisClientInfra } from './'; 
+
+let pubRedisInfra: RedisClientInfra;
+let subRedisInfra: RedisClientInfra;
+
+export async function initPubSubRedis(pubRedisName: string, subRedisName: string) {
+  
+  pubRedisInfra = new RedisClientInfra(pubRedisName);
+  subRedisInfra = new RedisClientInfra(subRedisName);
+
+  await pubRedisInfra.init();
+  await subRedisInfra.init();
+
+  await pubRedisInfra.testRedisConnection();
+  await subRedisInfra.testRedisConnection();
+}
+    
+export function getPubSubRedisInfra(label: string) {
+  if (label === 'sub-redis-infra') {
+    return subRedisInfra;
+  } else {
+    return pubRedisInfra;
+  }
+}
+
+export async function closePubSubRedis() {
+  if(pubRedisInfra) {
+    await pubRedisInfra.redisGracefulShutdown();
+  }
+
+ if(subRedisInfra) {
+    await subRedisInfra.redisGracefulShutdown();
+  }
+}

node-backend/src/server.ts

@@ -0,0 +1,277 @@
+import express, { Request, Response, NextFunction, Express } from 'express'; //use express module to create a server obj
+import IORedis from 'ioredis';
+// import { Queue } from 'bullmq';
+import { rateLimit, ipKeyGenerator } from 'express-rate-limit';
+
+//For flutter app .dev purpose
+import http, { Server as HttpServer } from "http";
+
+import https, { Server as HttpsServer } from 'https';
+import cors from 'cors';
+import helmet from 'helmet';
+import path from 'path';
+import dotenv from 'dotenv';
+import cookieParser from 'cookie-parser';
+
+import logger from './logger';
+
+import { appRouter } from './api/routes/index'; // import a centralized routes group
+import { initializeSocket } from './api/socket/socket';
+import { RedisClientInfra } from './redis';
+import { QueueInfra } from './queues';
+// import { GptChatWorker } from './workers';
+import { GptChatQueueService } from './queues/gpt-chat-queue-services';
+import { 
+    initPubSubRedis,
+    closePubSubRedis
+} from './redis';
+
+import * as fs from 'fs';
+
+// Load env file based on NODE_ENV
+const envFile: string = process.env.NODE_ENV === 'production' ? '.env.production' : '.env.development';
+
+dotenv.config({ path: envFile });
+
+const certPath = process.env.SSL_CERT || './ssl/certificate.crt';
+const keyPath = process.env.SSL_KEY || './ssl/certificate.key';
+
+const allowedOrigins = [process.env.FRONTEND_URL as string];
+
+const host: string | undefined = process.env.HOST; 
+const port: number = Number(process.env.PORT || 7860);
+
+const app: Express = express(); // create a server
+
+// Global rate limiting
+const globalLimiter = rateLimit({
+    windowMs: 1 * 1000, // 1 second
+    max: 10000, // 10,000 requests per second globally
+    handler: (req: Request, res: Response) => {
+        res.status(429).json({ error: 'System overloaded' });
+    }
+});
+
+// Express rate limiter configuration
+const ipLimiter = rateLimit({
+    windowMs: 10 * 1000, // 10 Sec window
+    max: 60, // Maximum 60 requests per 10 Secs per user
+    keyGenerator: (req: Request) =>  ipKeyGenerator(req.ip ?? 'unknown-ip'),
+    message: { message: 'Too many requests from this IP, please try again after some time' },
+    headers: true,
+});
+
+const corsOptions = {
+    origin: function (origin: string | undefined, callback: Function) {
+        // Allow requests with no origin (like mobile apps or curl requests)
+        console.log("CORS callback origin:", origin);
+        console.log("Allowed:", allowedOrigins);
+
+        if (!origin) {
+            console.log("No origin");
+            return callback(null, true);
+        }
+
+        if (allowedOrigins.includes(origin)) {
+            console.log("Origin allowed");
+            callback(null, origin);
+        } else {
+            console.log("Cors blocked");
+            return callback(new Error("Not allowed by CORS"));
+        }
+      
+    },
+    credentials: true,
+    exposedHeaders: ['Authorization'],
+    allowedHeaders: [
+        'Content-Type',
+        'Authorization',
+        'X-Requested-With',
+        'x-socket-id',
+        'x-anonuser-id',
+        // 'Cookie'
+    ],
+    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+};
+
+if (process.env.NODE_ENV !== 'production') {
+    app.use((req, res, next) => {
+        console.log("Method:", req.method);
+        console.log("Origin:", req.headers.origin);
+        next();
+    });
+}
+
+app.use(cors(corsOptions));
+app.options(/.*/, cors(corsOptions));
+
+app.use(globalLimiter);
+app.use(ipLimiter);
+app.use(cookieParser());
+
+app.use(helmet());
+app.use(express.json()); //middleware to parse JSON
+
+let server: HttpsServer | HttpServer;
+if (process.env.NODE_ENV === 'production') {
+    // HTTP for production
+    server = http.createServer(app); //This binding is required to handle some low-level server event handling
+} else {
+    // HTTPS for development
+    const cert: Buffer = fs.readFileSync(certPath);
+    const key: Buffer = fs.readFileSync(keyPath);
+    server = https.createServer({ key, cert }, app); //This binding is required to handle some low-level server event handling
+}
+
+let aiQueueRedisInfra: RedisClientInfra;
+let aiQueueInfra: QueueInfra;
+// let gptChatWorker: GptChatWorker;
+let gptChatQueueService: GptChatQueueService;
+
+async function initQueueWorkers() {
+    // Setup redis connection
+    aiQueueRedisInfra = new RedisClientInfra('gpt-chat-redis');
+    aiQueueRedisInfra.init();
+    aiQueueRedisInfra.testRedisConnection();
+
+    // Setup and start queue
+    aiQueueInfra = new QueueInfra(aiQueueRedisInfra.redis, 'gpt-chat');
+    aiQueueInfra.init();
+    aiQueueInfra.testQueueRedisConnection();
+
+    // Setup and start worker
+    // gptChatWorker = new GptChatWorker(aiQueueRedisInfra.redis, 'gpt-chat');
+    // gptChatWorker.init();
+
+    gptChatQueueService = new GptChatQueueService(aiQueueRedisInfra.redis, aiQueueInfra.queue, 'gpt-chat');
+};
+
+
+async function bootStrap() {
+    
+    try {
+        logger.info('🚀 Server starting...');
+
+        // Redis socket notification
+        await initPubSubRedis('api-pub-redis', 'api-sub-redis');
+
+        await initializeSocket(server); //Initialize socket.io with the server
+
+        // Start API Queue and workers
+        await initQueueWorkers();
+
+        if (gptChatQueueService) {
+            app.use(appRouter(gptChatQueueService));
+        } else {
+            logger.error('Some services are still not ready, restart the server');
+        }
+        server.listen(port , () => {
+            logger.info(`Server running on ${host}:${port}`);
+        });
+    } catch (err: any) {
+        logger.error('Server startup failed', err);
+        process.exit(1);
+    }
+};
+
+bootStrap();
+
+//Confirm that the server is listening after successfull start
+server.on('listening', () => {
+    logger.info('Server successfully started');
+    logger.info(`Server is listening on localhost:${port}`);
+});
+
+//Handle error when server starts
+server.on('error', (err: NodeJS.ErrnoException) => {
+    logger.error({err}, `Server error: , ${err.message}`);
+    if (err.code === 'EADDRINUSE') { //In case any error happened by the selected port number
+        logger.warn(`Port ${port} is already in use`);
+        //////////////////////////////////////
+        //code to handle to manually select a port and manual restart of server using electron
+        //////////////////////////////////////
+    }
+});
+
+server.on('close', () => {
+   logger.info('All API connections closed');
+});
+
+
+const closeServer = () => {
+  return new Promise<void>((resolve) => {
+    const timeout = setTimeout(() => {
+      logger.warn('Force closing server (timeout)');
+      resolve();
+    }, 10000);
+
+    server.close(() => {
+      clearTimeout(timeout);   // ⭐ stop timeout
+      logger.info('HTTP server closed');
+      resolve();
+    });
+  });
+};
+
+
+//Server and database shut down function 
+const serverShutdown = async (): Promise<void> => {
+    
+    try {
+        logger.info('Server shutting down started...');
+        await closeServer();
+        // Stop all Workers, Queueu events, Queueu and Redis for queue
+        if (aiQueueInfra) {
+            // await gptChatWorker.closeGptChatWorker(); // First close all workers related to the queue
+            await gptChatQueueService.closeQueueEvents(); // Then close all queue events related to queue
+            await aiQueueInfra.closeQueue(); // Then close all queue 
+            await aiQueueInfra.closeQueueRedis(); // At last close the redis connection which makes the queue possible            
+        }
+       
+    } catch (err: any) {
+        logger.error({err}, '❌ Error stopping schedulers');
+    }
+};
+
+const withTimeout = (promise: Promise<any>, timeoutMs: number, operation: string): Promise<any> => {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => 
+            setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms for ${operation}`)), timeoutMs)
+        )
+    ]);
+};
+
+let isGracefullShuttingDown = false;
+
+const gracefulShutdown = async (signal?: string): Promise<void> => {
+    if (isGracefullShuttingDown) {
+        logger.warn(`Shutdown already running. Ignoring ${signal}`);
+        return;
+    }
+
+    isGracefullShuttingDown = true;
+    logger.info(`Received ${signal}. Starting graceful shutdown...`);
+
+    try {
+        logger.info('🚨 Starting graceful shutdown process...');
+        
+        logger.info('🛑 Server shutdown called...');
+        await withTimeout(serverShutdown(), 60000, 'serverShutdown');
+        logger.info('✅ Server shutdown completed');
+
+        logger.info('🎉 All cleanup completed successfully');
+        process.exit(0);
+        
+    } catch (err: any) {
+        logger.error({err}, '❌ Shutdown error');
+        process.exit(1);
+    }
+};
+
+process.removeAllListeners('SIGTERM');
+process.removeAllListeners('SIGINT');
+
+// Signal listeners
+process.on('SIGTERM', gracefulShutdown);
+process.on('SIGINT', gracefulShutdown);

node-backend/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es2020",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "module": "commonjs", 
+    "typeRoots": ["./src/api/types", "./node_modules/@types"],
+    "types": ["node", "express"],
+    "outDir": "./dist",                               /* Specify what module code is generated. */
+    "rootDir": "./src",
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  },
+
+}

python-ai-service/QueueAndWorker/gpt_chat.py

@@ -0,0 +1,67 @@
+# from llama_cpp import Llama
+import logging
+from .model_manager import get_model
+
+logger = logging.getLogger(__name__)
+
+def gpt_chat_process(prompt: str, msg_session: str, user_id: str):
+    try:
+        model = get_model()
+        if not model:
+            logger.error("Model instance could not be retrieved")
+            return {'error': 'Model unavailable', 'user_id': user_id}
+
+        response = model.create_chat_completion(
+            messages=[
+                {
+                    "role": "system",
+                    "content": (
+                        "You are Qwen2.5-Coder, a specialized AI coding assistant. "
+                        "Your task is to analyze the user request and apply these strict rules:\n\n"
+                        
+                        "1. If the request asks about who developed you, who your creator is, or asks for "
+                        "developer profile information, you MUST reply with exactly this message format:\n"
+                        "\"This coding assistant was developed by [Subeesh Palamadathil]. You can find more information "
+                        "and connect on GitHub: [GitHub Profile](https://github.com/Subeesh4020) and "
+                        "LinkedIn: [LinkedIn Profile](https://www.linkedin.com/in/subeesh-palamadathil-170249193/).\"\n\n"
+            
+                        "1. If the request is a general greeting, conversational chit-chat, or entirely unrelated to "
+                        "software development, programming, or coding, you MUST reply with exactly this sentence: "
+                        "'Please ask any coding related questions. I am a coding assistant.' Do not provide any code.\n\n"
+                        "2. If the request is related to programming, provide only clean, efficient, and well-commented "
+                        "code wrapped in a standard markdown code block. Do not include conversational filler or explanations."
+                    )
+                    # "content": (
+                    #     "You are an expert software engineer. Provide only clean, efficient, "
+                    #     "and well-commented code based on the user request. Do not include "
+                    #     "any introductory or concluding conversational explanations. Output "
+                    #     "the response wrapped in a standard markdown code block."
+                    # )
+                },
+                {
+                    "role": "user",
+                    # Example prompt: "Write a typescript function to validate email"
+                    "content": f"{prompt}" 
+                }
+            ],
+            temperature=0.2, # Lower temperature is critical for accurate, deterministic code
+            max_tokens=1000 # Increased tokens since code files are larger than social posts
+        )
+
+        choices = response.get("choices", [])
+        if not choices:
+            raise ValueError("Model returned an empty choices array")
+
+        # Accessing the message content safely
+        message = choices[0].get("message", {})
+        content = message.get("content", "")
+
+        return { 
+            'result': content.strip(), 
+            'msg_session': msg_session,
+            'user_id': user_id 
+        }
+
+    except Exception as e:
+        logger.exception(f"Failed to generate code for user {user_id}")
+        return {'error': 'Code generation failed', 'user_id': user_id}

python-ai-service/QueueAndWorker/model_manager.py

@@ -0,0 +1,38 @@
+
+from llama_cpp import Llama
+from pathlib import Path
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+_model = None
+
+def load_model():
+    global _model
+
+    if _model is None:
+        logger.info("Qwen2.5-coder-3b-instruct model loading started")
+        try:
+            BASE_DIR = Path(__file__).resolve().parent.parent
+            model_path_qwen = BASE_DIR / "AiModels" / "CodingModel" / "qwen2.5-coder-3b-instruct-q4_k_m.gguf"
+            model_path_qwen = os.environ.get('MODEL_PATH', str(model_path_qwen))
+            
+            _model = Llama(
+                model_path=model_path_qwen,
+                n_ctx=4096,
+                n_threads=2,       # adjust based on your CPU
+                verbose=False
+            )
+            logger.info("✅ Qwen2.5-coder-3b-instruct model loaded")
+        except Exception as e:
+            logger.exception("Failed to load Qwen2.5-coder-3b-instruct model")
+            
+def get_model():
+    return _model
+
+
+# Do not bake the .gguf file into your Docker image. This makes your Docker builds incredibly slow and 
+# fills up your local storage.The Best Practice: Mount the folder containing your AI models as a Docker Volume 
+# on your Oracle Server. 
+# This allows your container to read the model file directly from the host system disk.

python-ai-service/QueueAndWorker/queue_manager.py

@@ -0,0 +1,38 @@
+# import asyncio
+# from typing import Dict, Any
+# from bullmq import Queue
+# import logging
+
+# logger = logging.getLogger(__name__)
+
+# class QueueManager:
+#     def __init__(self, queue_name: str, redis_url: str = "redis://127.0.0.1:6379"):
+#         self.queue_name = queue_name
+#         self.redis_url = redis_url
+#         self.queue = None
+
+#     async def connect(self) -> None:
+#         """Initializes the connection to the BullMQ Redis queue."""
+#         if not self.queue:
+#             # Passing connection string via opts dict
+#             self.queue = Queue(self.queue_name, opts={"connection": self.redis_url})
+#             logger.info(f"📡 Connected to Queue: {self.queue_name}")
+
+#     async def add_job(self, job_name: str, data: Dict[str, Any], priority: int = 0) -> Any:
+#         """Adds a job into the queue with optional configurations."""
+#         if not self.queue:
+#             await self.connect()
+            
+#          # Inject the model string cleanly into the payload dictionary
+#         opts = {"priority": priority} if priority > 0 else {}
+#         # Call queue.add using only the valid signature parameters
+#         job = await self.queue.add(job_name, data, opts)
+#         logger.debug(f"➕ Job added! ID: {job.id} | Name: {job_name}")
+#         return job
+
+#     async def disconnect(self) -> None:
+#         """Gracefully closes the queue connections."""
+#         if self.queue:
+#             await self.queue.close()
+#             self.queue = None
+#             logger.info(f"🛑 Disconnected from Queue: {self.queue_name}")

python-ai-service/QueueAndWorker/worker_manager.py

@@ -0,0 +1,104 @@
+import asyncio
+import re
+import json
+from typing import Any
+import logging
+from bullmq import Worker, Job
+import redis
+# from socketio_emitter import Emitter
+
+from .gpt_chat import gpt_chat_process
+# from TextGeneration.generate_ai_desc_producer import send_ai_gen_desc_message
+logger = logging.getLogger(__name__)
+
+class WorkerManager:
+    def __init__(self, queue_name: str, redis_url: str = "redis://127.0.0.1:6379"):
+        self.queue_name = queue_name
+         # 2. Defensive handling in case someone explicitly passes None as redis_url
+        if redis_url is None:
+            redis_url = "redis://127.0.0.1:6379"
+            
+        self.redis_url = redis_url
+        self.worker = None
+        self.redis_client = redis.Redis.from_url(redis_url)
+        # self.io_emitter = Emitter(client=self.redis_client, namespace="/")
+
+    async def job_processor(self, job: Job, token: str) -> Any:
+        """The core business logic that runs when a job is picked up."""
+        logger.debug(f"⚙️  Processing Job {job.id} [{job.name}]...")
+        
+        try:
+            # Simulate background task workload (e.g., calling an LLM or database script)
+            # await asyncio.sleep(2) 
+            if job.name == 'gpt-chat-process':
+                prompt = job.data.get('prompt')
+                msg_session = job.data.get('msgSession')
+                user_id = job.data.get('userId')
+                
+                result = await asyncio.to_thread(gpt_chat_process, prompt, msg_session, user_id)
+                
+                logger.debug(result)
+                text_content = result.get('result')
+                msg_session = result.get('msg_session')
+                user_id = result.get('user_id')
+                # Regex tracking to grab exactly what sits inside the markdown ticks
+                code_match = re.search(r'```(?:python)?\n(.*?)```', text_content, re.DOTALL)
+                clean_code = code_match.group(1).strip() if code_match else text_content.strip()
+                
+                self.redis_client.publish(
+                    "ai_response",
+                    json.dumps({
+                        "event": "gptChatRes",
+                        "userId": user_id,
+                        "msg_session": msg_session,
+                        "payload": {
+                            "result": clean_code
+                        }
+                    })
+                )
+        except Exception:
+            logger.exception("Message send failed")
+            
+        # This return value will be stored in Redis as the job result
+        return {"status": "success", "processed_data": job.data}
+
+    def setup_event_listeners(self) -> None:
+        """Hooks into specific job lifecycles using event callbacks."""
+        if not self.worker:
+            return
+
+        # @self.worker.on("completed")
+        def on_completed(job: Job, result: Any, token: str):
+            logger.debug(f"✅ Event: Job {job.id} completed! Result: {result}")
+
+        self.worker.on("completed", on_completed)
+        
+        # @self.worker.on("failed")
+        def on_failed(job: Job, error: Exception, token: str):
+            logger.debug(f"❌ Event: Job {job.id} failed! Reason: {error}")
+
+        self.worker.on("failed", on_failed)
+        
+        # @self.worker.on("active")
+        def on_active(job: Job, token: str):
+            logger.debug(f"🏃 Event: Job {job.id} is now active.")
+
+        self.worker.on("active", on_active)
+        
+    async def start(self) -> None:
+        """Starts the background worker instance."""
+        if not self.worker:
+            self.worker = Worker(
+                self.queue_name, 
+                self.job_processor, 
+                opts={"connection": self.redis_url}
+            )
+            self.setup_event_listeners()
+            logger.info(f"🚀 Worker is running and listening to queue: {self.queue_name}")
+
+    async def stop(self) -> None:
+        """Gracefully closes the worker loop."""
+        if self.worker:
+            await self.worker.close()
+            self.worker = None
+            logger.info(f"🛑 Worker stopped safely.")

python-ai-service/classInfra.py

@@ -0,0 +1,21 @@
+from dotenv import load_dotenv
+import os
+
+# from kafka_python.producer_manager import ProducerManager
+# from kafka_python.consumer_manager import ConsumerManager
+
+load_dotenv()
+
+QUEUE_NAME = "gpt-chat"
+REDIS_URI = os.getenv('REDIS_URI')
+
+# CREATE MANAGERS
+# producer_manager = ProducerManager()
+# consumer_manager = ConsumerManager()
+
+# from QueueAndWorker.queue_manager import QueueManager
+from QueueAndWorker.worker_manager import WorkerManager
+
+# Init queue and workers 
+# queue_service = QueueManager(QUEUE_NAME, REDIS_URI)
+worker_service = WorkerManager(QUEUE_NAME, REDIS_URI)

python-ai-service/main.py

@@ -0,0 +1,132 @@
+import logging
+import os
+import signal
+import time
+import sys
+import asyncio
+
+# from kafka_python.topic_setup import create_topics
+# from ModerationService.image_moderation_consumer import ImageModerationConsumer
+# from TextGeneration.generate_ai_desc_consumer import GenAiDescConsumer
+from classInfra import worker_service
+from QueueAndWorker.model_manager import load_model
+
+
+# Check if the environment is production. Default to 'development' if not set.
+ENVIRONMENT = os.getenv("APP_ENV", "development")
+
+# Automatically pick the level based on the environment
+if ENVIRONMENT == "production":
+    LOG_LEVEL = logging.INFO    # Hides DEBUG noise in production
+else:
+    LOG_LEVEL = logging.DEBUG   # Shows EVERYTHING in development
+    
+logging.basicConfig(
+    level=LOG_LEVEL,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+# logging.getLogger("kafka").setLevel(logging.WARNING)
+
+# Works all of these if set logging.DEBUG 
+# logger.debug() 
+# logger.info() 
+# logger.warning()
+# logger.error() 
+# logger.critical()
+
+logging.basicConfig(level=logging.INFO)
+
+logger = logging.getLogger(__name__)
+
+# def kafka_init():
+    
+#     create_topics()
+
+#     # START PRODUCERS
+#     producer_manager.create_producer(
+#         producer_name="image-moderation-producer",
+#         max_retries=6
+#     )
+
+#     producer_manager.create_producer(
+#         producer_name="text-gen-producer",
+#         max_retries=6
+#     )
+    
+#     # START CONSUMERS
+#     image_moderation_consumer = ImageModerationConsumer()
+#     image_moderation_consumer.start()
+    
+#     text_generation_consumer = GenAiDescConsumer()
+#     text_generation_consumer.start()
+        
+        
+shutdown_event = None
+
+def signal_handler(sig, frame):
+    logger.info(
+        "🛑 Shutdown signal received"
+    )
+    shutdown_event.set()
+    
+# MAIN APPLICATION
+async def main():
+    global shutdown_event
+    exit_code = 0
+    
+    # logger.info(
+    #     "🚀 Starting moderation service"
+    # )
+    
+    # logger.info(
+    #     "Starting topic creation"
+    # )
+    
+    try: 
+        # Simulate adding jobs via our Producer class
+        # await queue_service.connect()
+        # Start up the background worker service
+        await worker_service.start()
+        load_model()
+        
+        # CREATE TOPICS
+        # 💡 FIX: Force the blocking Kafka call to execute on a separate thread
+        
+        # await asyncio.to_thread(kafka_init)
+        
+        shutdown_event = asyncio.Event()
+        # Wait until Ctrl+C or SIGTERM
+        await shutdown_event.wait()
+
+        # KEEP SERVICE RUNNING - no need this because we already has await shutdown_event.wait()
+        # while True:
+        #     await asyncio.sleep(60)
+    except Exception as e:
+        logger.exception("❌ Error starting service")
+        exit_code = 1
+    finally:
+        logging.info("Cleaning up...")
+        
+        try: 
+            # consumer_manager.stop_all_consumers()
+            # producer_manager.stop_all_producers()
+            
+            # Clean queue and worker
+            await worker_service.stop()
+            # await queue_service.disconnect()
+
+            logger.info(
+                "✅ Graceful shutdown completed"
+            )
+        except Exception as e: 
+            logger.exception("❌ Graceful shutdown failed")
+        finally:
+            sys.exit(exit_code)
+        
+
+# SERVICE ENTRY POINT
+if __name__ == "__main__":
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    asyncio.run(main()) # no need of sys.exit(0) at last, asyncio will do that

react-frontend/dist/assets/index-BKJNczi-.css

@@ -0,0 +1 @@
+html,body,#root{background-color:#212121;width:100vw;height:100vh;margin:0;padding:0}body{display:block}pre code.hljs{padding:1em;display:block;overflow-x:auto}code.hljs{padding:3px 5px}.hljs{color:#c9d1d9;background:#0d1117}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#ff7b72}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#d2a8ff}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-variable,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id{color:#79c0ff}.hljs-regexp,.hljs-string,.hljs-meta .hljs-string{color:#a5d6ff}.hljs-built_in,.hljs-symbol{color:#ffa657}.hljs-comment,.hljs-code,.hljs-formula{color:#8b949e}.hljs-name,.hljs-quote,.hljs-selector-tag,.hljs-selector-pseudo{color:#7ee787}.hljs-subst{color:#c9d1d9}.hljs-section{color:#1f6feb;font-weight:700}.hljs-bullet{color:#f2cc60}.hljs-emphasis{color:#c9d1d9;font-style:italic}.hljs-strong{color:#c9d1d9;font-weight:700}.hljs-addition{color:#aff5b4;background-color:#033a16}.hljs-deletion{color:#ffdcd7;background-color:#67060c}._codeBlockContainer_l4365_3{background-color:#0f172a;border-radius:8px;margin:1rem 0;position:relative;overflow:hidden}._copyCodeBtn_l4365_21{z-index:10;color:#94a3b8;cursor:pointer;opacity:0;background-color:#1e293b;border:1px solid #334155;border-radius:4px;padding:4px 10px;font-family:sans-serif;font-size:12px;font-weight:500;transition:opacity .2s,background-color .2s,color .2s;position:absolute;top:12px;right:12px}._codeBlockContainer_l4365_3:hover ._copyCodeBtn_l4365_21{opacity:1}._copyCodeBtn_l4365_21:hover{color:#fff;background-color:#475569}._customPre_l4365_81{margin:0;padding:16px;overflow-x:auto;background:0 0!important}._spinnerContainer_1y0ia_1{width:var(--spinner-size);height:var(--spinner-size);justify-content:center;align-items:center;display:inline-flex}._spinner_1y0ia_1{width:100%;height:100%;position:relative}._tick_1y0ia_29{transform-origin:50% 200%;width:2px;height:25%;transform:translateX(-50%) rotate(calc(var(--tick-index) * 30deg));animation:1.2s linear infinite _fadePulse_1y0ia_1;animation-delay:calc(var(--tick-index) * -.1s);background-color:#6366f1;border-radius:2px;position:absolute;top:0;left:50%}@keyframes _fadePulse_1y0ia_1{0%{opacity:1}to{opacity:.15}}._appWrapper_1u7vo_1{color:#e3e3e3;background-color:#212121;width:100vw;height:100vh;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica,Arial,sans-serif;display:flex;overflow:hidden}._sidebar_1u7vo_23{background-color:#171717;border-right:1px solid #2f2f2f;flex-direction:column;flex-shrink:0;width:260px;height:100%;transition:transform .25s cubic-bezier(.4,0,.2,1),width .25s;display:flex}._sidebarClosed_1u7vo_45{border-right:none;width:0;transform:translate(-260px)}._sidebarHeader_1u7vo_57{justify-content:space-between;align-items:center;gap:8px;padding:12px;display:flex}._newChatBtn_1u7vo_73{color:#fff;cursor:pointer;text-align:left;background:0 0;border:1px solid #424242;border-radius:6px;flex:1;align-items:center;gap:8px;padding:10px 14px;font-size:14px;transition:background .2s;display:flex}._newChatBtn_1u7vo_73:hover{background-color:#2a2a2a}._toggleCollapseBtn_1u7vo_113,._menuExpandBtn_1u7vo_113{color:#b4b4b4;cursor:pointer;background:0 0;border:none;border-radius:6px;padding:8px;font-size:18px}._toggleCollapseBtn_1u7vo_113:hover,._menuExpandBtn_1u7vo_113:hover{color:#fff;background-color:#2a2a2a}._historyList_1u7vo_143{flex:1;padding:0 12px;overflow-y:auto}._historySectionTitle_1u7vo_155{color:#8e8e8e;padding:12px 8px 6px;font-size:12px;font-weight:600}._historyItem_1u7vo_169{cursor:pointer;border-radius:6px;align-items:center;gap:10px;padding:10px 8px;font-size:14px;transition:background .15s;display:flex}._historyItem_1u7vo_169:hover{background-color:#2a2a2a}._chatTitle_1u7vo_199{white-space:nowrap;text-overflow:ellipsis;overflow:hidden}._mainCanvas_1u7vo_213{background-color:#212121;flex-direction:column;flex:1;height:100%;display:flex;position:relative}._topBar_1u7vo_231{justify-content:space-between;align-items:center;height:56px;padding:0 16px;display:flex}._modelBadge_1u7vo_247{color:#b4b4b4;font-size:15px;font-weight:600}._scrollContainer_1u7vo_261{flex:1;padding-bottom:24px;overflow-y:auto}._contentConstrain_1u7vo_273{max-width:720px;margin:0 auto;padding:0 16px}._messageRow_1u7vo_285{flex-direction:column;gap:8px;padding:20px 0;animation:.3s ease-out forwards _fadeIn_1u7vo_1;display:flex}@keyframes _fadeIn_1u7vo_1{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}._identityGroup_1u7vo_311{align-items:center;gap:12px;display:flex}._avatarIcon_1u7vo_323{border-radius:50%;justify-content:center;align-items:center;width:28px;height:28px;font-size:12px;font-weight:700;display:flex}._userAvatar_1u7vo_345{color:#fff;background-color:#543fd7}._assistantAvatar_1u7vo_355{color:#fff;background-color:#10a37f}._senderLabel_1u7vo_365{font-size:14px;font-weight:600}._bubblePayload_1u7vo_375{color:#d1d1d1;padding-left:40px;font-size:16px;line-height:1.6}._bubblePayload_1u7vo_375 p{margin:0}._typingIndicator_1u7vo_399{align-items:center;gap:4px;height:24px;padding-left:40px;display:flex}._typingIndicator_1u7vo_399 span{background-color:#b4b4b4;border-radius:50%;width:6px;height:6px;animation:1.4s ease-in-out infinite both _bounce_1u7vo_1}._typingIndicator_1u7vo_399 span:first-child{animation-delay:-.32s}._typingIndicator_1u7vo_399 span:nth-child(2){animation-delay:-.16s}@keyframes _bounce_1u7vo_1{0%,80%,to{transform:scale(0)}40%{transform:scale(1)}}._dockFooter_1u7vo_449{background-color:#212121;padding:0 16px 24px}._dockConstrain_1u7vo_459{flex-direction:column;gap:12px;max-width:720px;margin:0 auto;display:flex}._inputFormBox_1u7vo_475{background-color:#2f2f2f;border:1px solid #424242;border-radius:16px;align-items:flex-end;padding:10px 14px;display:flex;position:relative}._spinnerCont_1u7vo_495{text-align:center}._textField_1u7vo_503{color:#fff;resize:none;background:0 0;border:none;outline:none;flex:1;max-height:200px;padding-right:40px;font-family:inherit;font-size:16px;line-height:1.5}._textField_1u7vo_503::placeholder{color:#7d7d7d}._actionSendBtn_1u7vo_539{color:#000;cursor:pointer;background-color:#fff;border:none;border-radius:8px;justify-content:center;align-items:center;width:32px;height:32px;font-size:12px;transition:background .2s,opacity .2s;display:flex;position:absolute;bottom:10px;right:10px}._actionSendBtn_1u7vo_539:disabled{color:#171717;cursor:not-allowed;background-color:#424242}._disclaimerText_1u7vo_587{color:#7d7d7d;text-align:center;margin:0;font-size:12px}.counter{color:var(--accent);background:var(--accent-bg);border:2px solid #0000;border-radius:5px;margin-bottom:24px;padding:5px 10px;font-size:16px;transition:border-color .3s}.counter:hover{border-color:var(--accent-border)}.counter:focus-visible{outline:2px solid var(--accent);outline-offset:2px}.hero{position:relative}.hero .base,.hero .framework,.hero .vite{margin:0 auto;inset-inline:0}.hero .base{z-index:0;width:170px;position:relative}.hero .framework,.hero .vite{position:absolute}.hero .framework{z-index:1;height:28px;top:34px;transform:perspective(2000px)rotate(300deg)rotateX(44deg)rotateY(39deg)scale(1.4)}.hero .vite{z-index:0;width:auto;height:26px;top:107px;transform:perspective(2000px)rotate(300deg)rotateX(40deg)rotateY(39deg)scale(.8)}#center{flex-direction:column;flex-grow:1;place-content:center;place-items:center;gap:25px;display:flex}@media (width<=1024px){#center{gap:18px;padding:32px 20px 24px}}#next-steps{border-top:1px solid var(--border);text-align:left;display:flex}#next-steps>div{flex:1 1 0;padding:32px}@media (width<=1024px){#next-steps>div{padding:24px 20px}}#next-steps .icon{width:22px;height:22px;margin-bottom:16px}@media (width<=1024px){#next-steps{text-align:center;flex-direction:column}}#docs{border-right:1px solid var(--border)}@media (width<=1024px){#docs{border-right:none;border-bottom:1px solid var(--border)}}#next-steps ul{gap:8px;margin:32px 0 0;padding:0;list-style:none;display:flex}#next-steps ul .logo{height:18px}#next-steps ul a{color:var(--text-h);background:var(--social-bg);border-radius:6px;align-items:center;gap:8px;padding:6px 12px;font-size:16px;text-decoration:none;transition:box-shadow .3s;display:flex}#next-steps ul a:hover{box-shadow:var(--shadow)}#next-steps ul a .button-icon{width:18px;height:18px}@media (width<=1024px){#next-steps ul{flex-wrap:wrap;justify-content:center;margin-top:20px}#next-steps ul li{flex:calc(50% - 8px)}#next-steps ul a{box-sizing:border-box;justify-content:center;width:100%}}#spacer{border-top:1px solid var(--border);height:88px}@media (width<=1024px){#spacer{height:48px}}.ticks{width:100%;position:relative}.ticks:before,.ticks:after{content:"";border:5px solid #0000;position:absolute;top:-4.5px}.ticks:before{border-left-color:var(--border);left:0}.ticks:after{border-right-color:var(--border);right:0}

react-frontend/dist/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>code-for-me</title>
+    <script type="module" crossorigin src="/assets/index-BKxufNR1.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BKJNczi-.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

requirements.txt

@@ -0,0 +1,10 @@
+# --- AI & Model Inference (CPU optimized) ---
+llama-cpp-python>=0.2.55
+huggingface_hub>=0.21.0
+
+# --- Queue & Asynchronous Processing ---
+redis>=5.0.1
+
+# --- Utilities ---
+pydantic>=2.6.0
+typing-extensions>=4.10.0

start.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+echo "Starting Redis..."
+redis-server --bind 127.0.0.1 --protected-mode no &
+
+echo "Waiting for Redis..."
+
+until redis-cli ping >/dev/null 2>&1
+do
+    sleep 1
+done
+
+echo "Redis is ready."
+
+exec pm2-runtime ecosystem.config.js