offbyt 1.0.0

package/core/detector/detectSocket.js

@@ -0,0 +1,341 @@
+import babelTraverse from '@babel/traverse';
+
+const traverse = babelTraverse.default || babelTraverse;
+
+/**
+ * Socket.io / WebSocket Pattern Detector
+ * Detects real-time communication patterns in frontend code
+ * 
+ * Detects:
+ * - Socket.io client initialization
+ * - WebSocket connections
+ * - Chat UI components
+ * - Message sending/receiving
+ * - Presence/typing indicators
+ * - Room/channel patterns
+ */
+
+const CHAT_PATTERNS = {
+  socketIo: [
+    /io\(['"].*['"]\)/gi,
+    /socket\.io-client/gi,
+    /new\s+Socket/gi,
+    /socketIOClient/gi,
+  ],
+  websocket: [
+    /new\s+WebSocket/gi,
+    /ws:\/\//gi,
+    /wss:\/\//gi,
+  ],
+  events: [
+    /on\(['"]message/gi,
+    /emit\(['"]message/gi,
+    /on\(['"]chat/gi,
+    /emit\(['"]chat/gi,
+    /socket\.send/gi,
+    /socket\.on/gi,
+    /socket\.emit/gi,
+  ],
+  chatUI: [
+    /sendMessage/gi,
+    /receiveMessage/gi,
+    /chatBox/gi,
+    /messageList/gi,
+    /conversation/gi,
+    /chat.*input/gi,
+    /message.*input/gi,
+    /typing.*indicator/gi,
+  ],
+  presence: [
+    /user.*online/gi,
+    /user.*offline/gi,
+    /presence/gi,
+    /is.*typing/gi,
+  ],
+  rooms: [
+    /join.*room/gi,
+    /leave.*room/gi,
+    /join.*channel/gi,
+    /room.*id/gi,
+    /channel.*id/gi,
+  ]
+};
+
+/**
+ * Main socket detection function
+ */
+export function detectSocket(ast, sourceCode) {
+  const detections = {
+    hasSocket: false,
+    hasChat: false,
+    socketType: null, // 'socket.io' | 'websocket' | null
+    events: [],
+    rooms: false,
+    presence: false,
+    endpoints: []
+  };
+
+  // AST-based detection
+  traverse(ast, {
+    // Detect Socket.io initialization: io('http://...')
+    CallExpression(path) {
+      const { callee, arguments: args } = path.node;
+
+      // Socket.io: io(url)
+      if (callee.type === 'Identifier' && callee.name === 'io') {
+        detections.hasSocket = true;
+        detections.socketType = 'socket.io';
+        
+        if (args.length > 0 && args[0].type === 'StringLiteral') {
+          detections.endpoints.push({
+            type: 'socket.io',
+            url: args[0].value
+          });
+        }
+      }
+
+      // Socket.io: socketIOClient(url)
+      if (callee.type === 'Identifier' && callee.name === 'socketIOClient') {
+        detections.hasSocket = true;
+        detections.socketType = 'socket.io';
+      }
+
+      // WebSocket: new WebSocket(url)
+      if (callee.type === 'NewExpression' && 
+          callee.callee?.name === 'WebSocket') {
+        detections.hasSocket = true;
+        detections.socketType = 'websocket';
+        
+        if (args.length > 0 && args[0].type === 'StringLiteral') {
+          detections.endpoints.push({
+            type: 'websocket',
+            url: args[0].value
+          });
+        }
+      }
+
+      // Detect socket.emit('event', data)
+      if (callee.type === 'MemberExpression' &&
+          callee.property.type === 'Identifier' &&
+          callee.property.name === 'emit') {
+        
+        if (args.length > 0 && args[0].type === 'StringLiteral') {
+          const eventName = args[0].value;
+          detections.events.push({
+            type: 'emit',
+            name: eventName
+          });
+
+          // Check for chat-related events
+          if (isChatEvent(eventName)) {
+            detections.hasChat = true;
+          }
+
+          // Check for room events
+          if (isRoomEvent(eventName)) {
+            detections.rooms = true;
+          }
+
+          // Check for presence events
+          if (isPresenceEvent(eventName)) {
+            detections.presence = true;
+          }
+        }
+      }
+
+      // Detect socket.on('event', callback)
+      if (callee.type === 'MemberExpression' &&
+          callee.property.type === 'Identifier' &&
+          callee.property.name === 'on') {
+        
+        if (args.length > 0 && args[0].type === 'StringLiteral') {
+          const eventName = args[0].value;
+          detections.events.push({
+            type: 'on',
+            name: eventName
+          });
+
+          if (isChatEvent(eventName)) {
+            detections.hasChat = true;
+          }
+
+          if (isRoomEvent(eventName)) {
+            detections.rooms = true;
+          }
+
+          if (isPresenceEvent(eventName)) {
+            detections.presence = true;
+          }
+        }
+      }
+    },
+
+    // Detect import statements
+    ImportDeclaration(path) {
+      const source = path.node.source.value;
+      
+      if (source === 'socket.io-client' || source.includes('socket.io')) {
+        detections.hasSocket = true;
+        detections.socketType = 'socket.io';
+      }
+    },
+
+    // Detect chat-related variable/function names
+    Identifier(path) {
+      const name = path.node.name;
+      
+      if (isChatIdentifier(name)) {
+        detections.hasChat = true;
+      }
+    }
+  });
+
+  // Regex-based detection (fallback)
+  const regexDetections = detectSocketRegex(sourceCode);
+  
+  if (regexDetections.hasSocket) {
+    detections.hasSocket = true;
+    detections.socketType = detections.socketType || regexDetections.socketType;
+  }
+  
+  if (regexDetections.hasChat) {
+    detections.hasChat = true;
+  }
+
+  if (regexDetections.rooms) {
+    detections.rooms = true;
+  }
+
+  if (regexDetections.presence) {
+    detections.presence = true;
+  }
+
+  // Deduplicate events
+  detections.events = Array.from(
+    new Map(detections.events.map(e => [e.name, e])).values()
+  );
+
+  return detections;
+}
+
+/**
+ * Regex-based socket detection (fallback)
+ */
+function detectSocketRegex(sourceCode) {
+  const result = {
+    hasSocket: false,
+    hasChat: false,
+    socketType: null,
+    rooms: false,
+    presence: false
+  };
+
+  // Check Socket.io patterns
+  for (const pattern of CHAT_PATTERNS.socketIo) {
+    if (pattern.test(sourceCode)) {
+      result.hasSocket = true;
+      result.socketType = 'socket.io';
+      break;
+    }
+  }
+
+  // Check WebSocket patterns
+  if (!result.hasSocket) {
+    for (const pattern of CHAT_PATTERNS.websocket) {
+      if (pattern.test(sourceCode)) {
+        result.hasSocket = true;
+        result.socketType = 'websocket';
+        break;
+      }
+    }
+  }
+
+  // Check chat UI patterns
+  for (const pattern of CHAT_PATTERNS.chatUI) {
+    if (pattern.test(sourceCode)) {
+      result.hasChat = true;
+      break;
+    }
+  }
+
+  // Check events
+  for (const pattern of CHAT_PATTERNS.events) {
+    if (pattern.test(sourceCode)) {
+      result.hasChat = true;
+      break;
+    }
+  }
+
+  // Check rooms
+  for (const pattern of CHAT_PATTERNS.rooms) {
+    if (pattern.test(sourceCode)) {
+      result.rooms = true;
+      break;
+    }
+  }
+
+  // Check presence
+  for (const pattern of CHAT_PATTERNS.presence) {
+    if (pattern.test(sourceCode)) {
+      result.presence = true;
+      break;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Helper: Check if event name is chat-related
+ */
+function isChatEvent(eventName) {
+  const chatKeywords = [
+    'message', 'chat', 'send', 'receive',
+    'msg', 'text', 'conversation'
+  ];
+  
+  const lowerName = eventName.toLowerCase();
+  return chatKeywords.some(kw => lowerName.includes(kw));
+}
+
+/**
+ * Helper: Check if event name is room-related
+ */
+function isRoomEvent(eventName) {
+  const roomKeywords = [
+    'room', 'channel', 'join', 'leave',
+    'subscribe', 'unsubscribe'
+  ];
+  
+  const lowerName = eventName.toLowerCase();
+  return roomKeywords.some(kw => lowerName.includes(kw));
+}
+
+/**
+ * Helper: Check if event name is presence-related
+ */
+function isPresenceEvent(eventName) {
+  const presenceKeywords = [
+    'online', 'offline', 'presence',
+    'typing', 'active', 'idle'
+  ];
+  
+  const lowerName = eventName.toLowerCase();
+  return presenceKeywords.some(kw => lowerName.includes(kw));
+}
+
+/**
+ * Helper: Check if identifier is chat-related
+ */
+function isChatIdentifier(name) {
+  const chatKeywords = [
+    'sendMessage', 'receiveMessage', 'chatBox',
+    'messageList', 'messageInput', 'chatInput',
+    'conversation', 'chatHistory', 'messageHistory'
+  ];
+  
+  const lowerName = name.toLowerCase();
+  return chatKeywords.some(kw => lowerName.includes(kw.toLowerCase()));
+}
+
+export default detectSocket;

package/core/generator/generateControllers.js

@@ -0,0 +1,17 @@
+function pascalCase(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+export function generateControllers(ir) {
+  const output = {};
+
+  for (const resource of ir.resources || []) {
+    const model = pascalCase(resource.name);
+
+    output[`controllers/${resource.name}Controller.js`] = `import ${model} from '../models/${model}.js';\n\nexport const list${model}s = async (req, res) => {\n  const data = await ${model}.find();\n  res.json({ success: true, data });\n};\n\nexport const get${model} = async (req, res) => {\n  const data = await ${model}.findById(req.params.id);\n  res.json({ success: true, data });\n};\n\nexport const create${model} = async (req, res) => {\n  const data = await ${model}.create(req.body);\n  res.status(201).json({ success: true, data });\n};\n\nexport const update${model} = async (req, res) => {\n  const data = await ${model}.findByIdAndUpdate(req.params.id, req.body, { new: true });\n  res.json({ success: true, data });\n};\n\nexport const delete${model} = async (req, res) => {\n  await ${model}.findByIdAndDelete(req.params.id);\n  res.json({ success: true });\n};\n`;
+  }
+
+  return output;
+}
+
+export default generateControllers;

package/core/generator/generateModels.js

@@ -0,0 +1,25 @@
+function mapFieldToMongoose(field) {
+  if (field.type === 'ObjectId') {
+    return `${field.name}: { type: mongoose.Schema.Types.ObjectId${field.ref ? `, ref: '${field.ref}'` : ''}${field.required ? ', required: true' : ''} }`;
+  }
+  return `${field.name}: { type: ${field.type}${field.required ? ', required: true' : ''} }`;
+}
+
+function modelName(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+export function generateModels(ir) {
+  const output = {};
+
+  for (const resource of ir.resources || []) {
+    const schemaFields = (resource.fields || []).map(mapFieldToMongoose).join(',\n  ');
+    const className = modelName(resource.name);
+
+    output[`models/${className}.js`] = `import mongoose from 'mongoose';\n\nconst ${resource.name}Schema = new mongoose.Schema({\n  ${schemaFields}\n}, { timestamps: true });\n\nexport default mongoose.model('${className}', ${resource.name}Schema);\n`;
+  }
+
+  return output;
+}
+
+export default generateModels;

package/core/generator/generateRoutes.js

@@ -0,0 +1,17 @@
+function pascalCase(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+export function generateRoutes(ir) {
+  const output = {};
+
+  for (const resource of ir.resources || []) {
+    const model = pascalCase(resource.name);
+
+    output[`routes/${resource.name}.routes.js`] = `import express from 'express';\nimport {\n  list${model}s,\n  get${model},\n  create${model},\n  update${model},\n  delete${model}\n} from '../controllers/${resource.name}Controller.js';\n\nconst router = express.Router();\n\nrouter.get('/', list${model}s);\nrouter.get('/:id', get${model});\nrouter.post('/', create${model});\nrouter.put('/:id', update${model});\nrouter.delete('/:id', delete${model});\n\nexport default router;\n`;
+  }
+
+  return output;
+}
+
+export default generateRoutes;

package/core/generator/generateServer.js

@@ -0,0 +1,18 @@
+export function generateServer(ir) {
+  const imports = (ir.resources || [])
+    .map((r) => `import ${r.name}Routes from './routes/${r.name}.routes.js';`)
+    .join('\n');
+
+  const routes = (ir.resources || [])
+    .map((r) => `app.use('/api/${r.name}s', ${r.name}Routes);`)
+    .join('\n');
+
+  const serverCode = `import 'dotenv/config';\nimport express from 'express';\nimport cors from 'cors';\nimport mongoose from 'mongoose';\n${imports}\n\nconst app = express();\nconst PORT = process.env.PORT || 3000;\nconst MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/offbyt';\n\napp.use(cors());\napp.use(express.json());\n\n${routes}\n\nconst healthHandler = (req, res) => {\n  res.json({\n    status: 'ok',\n    timestamp: new Date().toISOString(),\n    database: mongoose.connection.readyState === 1 ? 'Connected' : 'Disconnected'\n  });\n};\n\napp.get('/health', healthHandler);\napp.get(`/api/health`, healthHandler);\n\napp.use((req, res) => {\n  res.status(404).json({\n    error: 'Not Found',\n    path: req.path,\n    method: req.method\n  });\n});\n\nasync function connectDB() {\n  try {\n    await mongoose.connect(MONGODB_URI, {\n      serverSelectionTimeoutMS: 5000\n    });\n    console.log('✅ MongoDB Connected');\n  } catch (error) {\n    console.error('❌ MongoDB Connection Failed:', error.message);\n    process.exit(1);\n  }\n}\n\nasync function startServer() {\n  await connectDB();\n  app.listen(PORT, () => {\n    console.log(\`🚀 Server running on \${PORT}\`);\n  });\n}\n\nstartServer().catch((error) => {\n  console.error(error);\n  process.exit(1);\n});\n`;
+
+  return {
+    'server.js': serverCode
+  };
+}
+
+export default generateServer;
+

package/core/generator/generateSocket.js

@@ -0,0 +1,160 @@
+/**
+ * Socket/Chat Backend Generator
+ * 
+ * Generates complete Socket.io backend infrastructure including:
+ * - Socket.io server setup
+ * - Chat models (Message, Conversation)
+ * - REST API routes for chat
+ * - Authentication middleware
+ */
+
+import { socketServerTemplate } from '../../templates/socket.server.template.js';
+import { messageModelTemplate, conversationModelTemplate } from '../../templates/chat.models.template.js';
+import { chatRoutesTemplate } from '../../templates/chat.routes.template.js';
+
+/**
+ * Generate complete socket/chat backend
+ */
+export function generateSocketBackend(socketDetection) {
+  const files = {};
+
+  // Only generate if socket is detected
+  if (!socketDetection || !socketDetection.hasSocket) {
+    return files;
+  }
+
+  // 1. Socket.io server setup
+  files['socket/index.js'] = socketServerTemplate;
+
+  // 2. Chat models
+  files['models/Message.js'] = messageModelTemplate;
+  files['models/Conversation.js'] = conversationModelTemplate;
+
+  // 3. Chat routes (REST API endpoints)
+  files['routes/chat.routes.js'] = chatRoutesTemplate;
+
+  // 4. Package.json dependencies
+  const socketDependencies = {
+    'socket.io': '^4.6.1',
+    'jsonwebtoken': '^9.0.2'
+  };
+
+  return {
+    files,
+    dependencies: socketDependencies,
+    instructions: generateSetupInstructions(socketDetection)
+  };
+}
+
+/**
+ * Generate setup instructions
+ */
+function generateSetupInstructions(socketDetection) {
+  const instructions = {
+    title: '🔌 Socket.io Chat Backend Generated',
+    steps: [
+      '1. Install dependencies: npm install socket.io jsonwebtoken',
+      '2. Import socket initialization in server.js',
+      '3. Initialize Socket.io with HTTP server',
+      '4. Register chat routes at /api/chat',
+      '5. Set JWT_SECRET in .env file',
+      '6. Set CLIENT_URL in .env (for CORS)'
+    ],
+    features: []
+  };
+
+  if (socketDetection.hasChat) {
+    instructions.features.push('✅ Real-time messaging');
+    instructions.features.push('✅ Message history & persistence');
+  }
+
+  if (socketDetection.rooms) {
+    instructions.features.push('✅ Rooms/Channels support');
+    instructions.features.push('✅ Group conversations');
+  }
+
+  if (socketDetection.presence) {
+    instructions.features.push('✅ Online/Offline presence');
+    instructions.features.push('✅ Typing indicators');
+  }
+
+  instructions.features.push('✅ Read receipts');
+  instructions.features.push('✅ File sharing support');
+  instructions.features.push('✅ Message reactions');
+  instructions.features.push('✅ JWT Authentication');
+
+  return instructions;
+}
+
+/**
+ * Generate modified server.js with Socket.io integration
+ */
+export function generateServerWithSocket(baseServerCode, hasSocket = false) {
+  if (!hasSocket) {
+    return baseServerCode;
+  }
+
+  let modifiedCode = baseServerCode;
+
+  // Check if already has Socket.io imports
+  if (modifiedCode.includes('socket.io') || modifiedCode.includes('initializeSocket')) {
+    return modifiedCode; // Already integrated
+  }
+
+  // Add Socket.io imports after express import
+  const socketImports = `import { createServer } from 'http';
+import initializeSocket from './socket/index.js';
+`;
+
+  // Insert imports after express import
+  modifiedCode = modifiedCode.replace(
+    /(import express from ['"]express['"];)/,
+    `$1\n${socketImports}`
+  );
+
+  // Create HTTP server and initialize Socket.io after app creation
+  const serverSetup = `
+// ============================================
+// SOCKET.IO SETUP
+// ============================================
+const httpServer = createServer(app);
+const io = initializeSocket(httpServer);
+
+// Make io accessible in routes via req.app.get('io')
+app.set('io', io);
+`;
+
+  // Add server setup after app initialization (after const app = express())
+  modifiedCode = modifiedCode.replace(
+    /(const app = express\(\);[\s\S]*?const API_VERSION[^;]*;)/,
+    `$1\n${serverSetup}`
+  );
+
+  // Replace app.listen with httpServer.listen at the end
+  modifiedCode = modifiedCode.replace(
+    /app\.listen\((PORT[^)]*)\)/g,
+    'httpServer.listen($1)'
+  );
+
+  return modifiedCode;
+}
+
+/**
+ * Update package.json with socket dependencies
+ */
+export function addSocketDependencies(packageJson) {
+  if (!packageJson.dependencies) {
+    packageJson.dependencies = {};
+  }
+
+  packageJson.dependencies['socket.io'] = '^4.6.1';
+  packageJson.dependencies['jsonwebtoken'] = '^9.0.2';
+
+  return packageJson;
+}
+
+export default {
+  generateSocketBackend,
+  generateServerWithSocket,
+  addSocketDependencies
+};

package/core/index.js

@@ -0,0 +1,14 @@
+export { scanProject } from './scanner/scanProject.js';
+export { parseJS } from './parser/parseJS.js';
+export { parseTS } from './parser/parseTS.js';
+export { detectFetch } from './detector/detectFetch.js';
+export { detectAxios } from './detector/detectAxios.js';
+export { detectForms } from './detector/detectForms.js';
+export { detectSocket } from './detector/detectSocket.js';
+export { buildIRFromDetections } from './ir/buildIR.js';
+export { applyRuleEngine } from './rules/resourceRules.js';
+export { generateModels } from './generator/generateModels.js';
+export { generateControllers } from './generator/generateControllers.js';
+export { generateRoutes } from './generator/generateRoutes.js';
+export { generateServer } from './generator/generateServer.js';
+export { generateSocketBackend, generateServerWithSocket, addSocketDependencies } from './generator/generateSocket.js';

package/core/ir/IRTypes.js

@@ -0,0 +1,25 @@
+export function createField(name, type = 'String', required = false, extra = {}) {
+  return { name, type, required, ...extra };
+}
+
+export function createResource({ name, path, fields = [], methods = [] }) {
+  return {
+    name,
+    path,
+    fields,
+    methods: Array.from(new Set(methods)).sort()
+  };
+}
+
+export function createRelation({ from, to, type = 'many-to-one' }) {
+  return { from, to, type };
+}
+
+export function createIR({ resources = [], relations = [], auth = { enabled: false }, database = 'mongodb' } = {}) {
+  return {
+    resources,
+    relations,
+    auth,
+    database
+  };
+}