offbyt 1.0.0

package/README.md

@@ -0,0 +1,2 @@
+Generate Backends instantly!!
+OFFBYT

package/cli/index.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../cli.js';

package/cli.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { offlineMode } from './lib/modes/offline.js';
+import { connectFrontendBackend } from './lib/modes/connect.js';
+import { runDoctor } from './lib/utils/doctor.js';
+import { getInteractiveSetup, displaySetupSummary } from './lib/modes/interactiveSetup.js';
+import { generateWithConfig } from './lib/modes/configBasedGenerator.js';
+
+const program = new Command();
+
+function parsePort(value) {
+  const port = Number.parseInt(value, 10);
+  if (Number.isNaN(port) || port < 1 || port > 65535) {
+    throw new Error('Port must be a number between 1 and 65535');
+  }
+
+  return port;
+}
+
+program
+  .name('offbyt')
+  .description('Hybrid Backend Generator - Offline + AI Powered')
+  .version('1.0.0');
+
+program
+  .command('generate [path]')
+  .description('Complete backend generation with automatic API detection & injection')
+  .option('--no-auto-connect', 'Skip auto-connect after generation')
+  .option('--quick', 'Use default configuration (no questions)')
+  .option('--no-api-detect', 'Skip automatic API detection from frontend')
+  .action(async (projectPath, options) => {
+    try {
+      const workingPath = projectPath || process.cwd();
+      let config;
+
+      if (options.quick) {
+        // Use default configuration
+        config = {
+          database: 'mongodb',
+          framework: 'express',
+          enableSocket: true,
+          enableAuth: true,
+          authType: 'jwt',
+          enableValidation: true,
+          enableCaching: false,
+          enableLogging: true
+        };
+        console.log(chalk.cyan('Using default configuration...\n'));
+      } else {
+        // Interactive setup
+        config = await getInteractiveSetup();
+        displaySetupSummary(config);
+      }
+
+      // Generate backend with config
+      const confirmSpinner = ora('Ready to generate backend...').start();
+      confirmSpinner.succeed('Configuration confirmed\n');
+
+      await generateWithConfig(workingPath, config);
+
+      // AUTOMATIC: Smart API detection & generation
+      if (options.apiDetect !== false) {
+        console.log(chalk.cyan('\n\n🎯 Running Smart API Detection...\n'));
+        const { generateSmartAPI } = await import('./lib/modes/generateApi.js');
+        try {
+          await generateSmartAPI(workingPath, { inject: true, config });
+        } catch (error) {
+          console.error(chalk.red('\nError in Smart API Generation:'));
+          console.error(chalk.red(error.message));
+          if (error.stack) {
+            console.error(chalk.gray(error.stack));
+          }
+          throw error;
+        }
+      }
+
+      // Auto-connect if enabled
+      if (options.autoConnect) {
+        console.log(chalk.cyan('Auto-connecting frontend & backend...\n'));
+        await connectFrontendBackend(workingPath);
+      }
+
+    } catch (error) {
+      console.error(chalk.red('Error:', error.message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('connect [path]')
+  .description('Auto-connect frontend & backend (fixes URLs, fields, responses)')
+  .action(async (projectPath) => {
+    try {
+      await connectFrontendBackend(projectPath || process.cwd());
+    } catch (error) {
+      console.error(chalk.red('Error:', error.message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('sync [path]')
+  .description('Sync backend with frontend changes (update backend for new/changed frontend APIs)')
+  .action(async (projectPath) => {
+    try {
+      const { syncBackendWithFrontend } = await import('./lib/modes/sync.js');
+      await syncBackendWithFrontend(projectPath || process.cwd());
+    } catch (error) {
+      console.error(chalk.red('Error:', error.message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('benchmark [path]')
+  .description('Run scalability & performance tests on your backend')
+  .option('--levels <levels>', 'Load levels to test (e.g., 10,100,1000)', '10,100,1000,10000')
+  .option('--duration <seconds>', 'Duration of each test in seconds', '10')
+  .option('--startup-mode', 'Simulate startup growth over time')
+  .action(async (projectPath, options) => {
+    try {
+      const { runBenchmark } = await import('./lib/modes/benchmark.js');
+      await runBenchmark(projectPath || process.cwd(), options);
+    } catch (error) {
+      console.error(chalk.red('Error:', error.message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('deploy [path]')
+  .description('Deploy frontend + backend and auto-connect API URLs')
+  .option('--full', 'Use default stack (Frontend: Vercel, Backend: Railway)')
+  .option('--frontend <provider>', 'Frontend provider: vercel | netlify | cloudflare | skip')
+  .option('--backend <provider>', 'Backend provider: railway | render | cloudflare | skip')
+  .option('--backend-service-id <id>', 'Backend service ID where required (e.g., Render)')
+  .option('--backend-project-name <name>', 'Backend project name where supported (e.g., Railway, Cloudflare Pages)')
+  .option('--backend-service-name <name>', 'Backend service name where supported (e.g., Railway)')
+  .action(async (projectPath, options) => {
+    try {
+      const { runDeploymentFlow } = await import('./deploy/index.js');
+      await runDeploymentFlow(projectPath || process.cwd(), options);
+    } catch (error) {
+      console.error(chalk.red('Error:', error.message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('generate-api [path]')
+  .description('Smart API generation - Detect resources from frontend state & generate full-stack APIs')
+  .option('--no-inject', 'Skip frontend code injection')
+  .action(async (projectPath, options) => {
+    try {
+      const { generateSmartAPI } = await import('./lib/modes/generateApi.js');
+      await generateSmartAPI(projectPath || process.cwd(), options);
+    } catch (error) {
+      console.error(chalk.red('Error:', error.message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('doctor')
+  .description('Diagnose your system readiness')
+  .option('--json', 'Output diagnostics in JSON format')
+  .option('--no-strict', 'Do not treat warnings as blocking issues')
+  .option('--port <number>', 'Port to check for availability (default: 5000)', parsePort, 5000)
+  .action(async options => {
+    const report = await runDoctor(options);
+    process.exitCode = report.exitCode;
+  });
+
+program
+  .command('doctor-ai [path]')
+  .description('AI-powered backend debugger. Monitors a command for errors and generates fixes.')
+  .option('--cmd <command>', 'Command to run and monitor', 'npm run dev')
+  .action(async (projectPath, options) => {
+    try {
+      const { runDoctorAi } = await import('./lib/modes/doctorAi.js');
+      await runDoctorAi(projectPath || process.cwd(), options);
+    } catch (error) {
+      console.error(chalk.red('Error:', error.message));
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+  console.log(chalk.cyan('\nQuick Start:\n'));
+  console.log(chalk.white('  Option 1 (Recommended):'));
+  console.log(chalk.gray('    offbyt generate                    # Generate + Auto-connect\n'));
+  console.log(chalk.white('  Option 2 (Skip auto-connect):'));
+  console.log(chalk.gray('    offbyt generate --no-auto-connect  # Generate only\n'));
+  console.log(chalk.white('  Option 3 (Just connect):'));
+  console.log(chalk.gray('    offbyt connect [path]              # Auto-connect existing project\n'));
+  console.log(chalk.white('  Option 4 (Deploy live):'));
+  console.log(chalk.gray('    offbyt deploy [path]               # Deploy + auto-connect URLs\n'));
+}
+

package/core/detector/detectAxios.js

@@ -0,0 +1,107 @@
+import babelTraverse from '@babel/traverse';
+
+const traverse = babelTraverse.default || babelTraverse;
+
+const AXIOS_NAMES = new Set(['axios', 'api', 'client', 'http', 'request']);
+const METHOD_NAMES = new Set(['get', 'post', 'put', 'patch', 'delete']);
+
+function getStringValue(node) {
+  if (!node) return null;
+  if (node.type === 'StringLiteral') return node.value;
+  if (node.type === 'TemplateLiteral') {
+    return node.quasis.map((q) => q.value.cooked || '').join(':id');
+  }
+  return null;
+}
+
+function normalizeRoute(route) {
+  if (!route) return null;
+  const cleaned = route.split('?')[0];
+  if (cleaned.startsWith('http://') || cleaned.startsWith('https://')) {
+    const index = cleaned.indexOf(`/api/`);
+    if (index >= 0) return cleaned.substring(index);
+  }
+  return cleaned.startsWith('/') ? cleaned : `/${cleaned}`;
+}
+
+function extractFieldsFromNode(node) {
+  if (!node) return [];
+  if (node.type !== 'ObjectExpression') return [];
+
+  return node.properties
+    .filter((p) => p.type === 'ObjectProperty')
+    .map((p) => (p.key.type === 'Identifier' ? p.key.name : p.key.value))
+    .filter(Boolean);
+}
+
+export function detectAxios(ast, file) {
+  if (!ast) return [];
+
+  const detections = [];
+
+  traverse(ast, {
+    CallExpression(path) {
+      const { node } = path;
+
+      if (node.callee.type === 'MemberExpression') {
+        const object = node.callee.object;
+        const property = node.callee.property;
+
+        const objectName = object.type === 'Identifier' ? object.name : null;
+        const methodName = property.type === 'Identifier' ? property.name : null;
+
+        if (!objectName || !methodName) return;
+        if (!AXIOS_NAMES.has(objectName) || !METHOD_NAMES.has(methodName)) return;
+
+        const route = normalizeRoute(getStringValue(node.arguments[0]));
+        if (!route) return;
+        if (!route.includes(`/api`) && !route.startsWith('/')) return;
+
+        const method = methodName.toUpperCase();
+        const dataArgIndex = methodName === 'get' ? -1 : 1;
+        const fields = dataArgIndex >= 0 ? extractFieldsFromNode(node.arguments[dataArgIndex]) : [];
+
+        detections.push({
+          file,
+          type: 'axios',
+          method,
+          route,
+          fields,
+          hasQueryParams: route.includes('?'),
+          line: node.loc?.start?.line || 0,
+          source: 'ast'
+        });
+      }
+
+      if (node.callee.type === 'Identifier' && node.callee.name === 'axios' && node.arguments[0]?.type === 'ObjectExpression') {
+        const config = node.arguments[0];
+
+        const methodProp = config.properties.find((p) => p.type === 'ObjectProperty' && ((p.key.type === 'Identifier' && p.key.name === 'method') || (p.key.type === 'StringLiteral' && p.key.value === 'method')));
+        const urlProp = config.properties.find((p) => p.type === 'ObjectProperty' && ((p.key.type === 'Identifier' && p.key.name === 'url') || (p.key.type === 'StringLiteral' && p.key.value === 'url')));
+        const dataProp = config.properties.find((p) => p.type === 'ObjectProperty' && ((p.key.type === 'Identifier' && p.key.name === 'data') || (p.key.type === 'StringLiteral' && p.key.value === 'data')));
+
+        const route = normalizeRoute(getStringValue(urlProp?.value));
+        if (!route) return;
+        if (!route.includes(`/api`) && !route.startsWith('/')) return;
+
+        const method = (getStringValue(methodProp?.value) || 'GET').toUpperCase();
+        const fields = extractFieldsFromNode(dataProp?.value);
+
+        detections.push({
+          file,
+          type: 'axios',
+          method,
+          route,
+          fields,
+          hasQueryParams: route.includes('?'),
+          line: node.loc?.start?.line || 0,
+          source: 'ast'
+        });
+      }
+    }
+  });
+
+  return detections;
+}
+
+export default detectAxios;

package/core/detector/detectFetch.js

@@ -0,0 +1,148 @@
+import babelTraverse from '@babel/traverse';
+
+const traverse = babelTraverse.default || babelTraverse;
+
+function getMethodFromFetchConfig(configNode) {
+  if (!configNode || configNode.type !== 'ObjectExpression') return 'GET';
+
+  for (const prop of configNode.properties) {
+    if (prop.type !== 'ObjectProperty') continue;
+
+    const keyName = prop.key.type === 'Identifier'
+      ? prop.key.name
+      : prop.key.type === 'StringLiteral'
+        ? prop.key.value
+        : null;
+
+    if (keyName !== 'method') continue;
+
+    if (prop.value.type === 'StringLiteral') return prop.value.value.toUpperCase();
+  }
+
+  const hasBody = configNode.properties.some((prop) => {
+    if (prop.type !== 'ObjectProperty') return false;
+    const keyName = prop.key.type === 'Identifier'
+      ? prop.key.name
+      : prop.key.type === 'StringLiteral'
+        ? prop.key.value
+        : null;
+    return keyName === 'body';
+  });
+
+  return hasBody ? 'POST' : 'GET';
+}
+
+function getRoute(node) {
+  if (!node) return null;
+
+  if (node.type === 'StringLiteral') {
+    return node.value;
+  }
+
+  if (node.type === 'TemplateLiteral') {
+    const text = node.quasis.map((q) => q.value.cooked || '').join(':id');
+    return text;
+  }
+
+  return null;
+}
+
+function extractBodyFields(configNode) {
+  if (!configNode || configNode.type !== 'ObjectExpression') return [];
+
+  const bodyProp = configNode.properties.find((prop) => {
+    if (prop.type !== 'ObjectProperty') return false;
+    const keyName = prop.key.type === 'Identifier'
+      ? prop.key.name
+      : prop.key.type === 'StringLiteral'
+        ? prop.key.value
+        : null;
+    return keyName === 'body';
+  });
+
+  if (!bodyProp) return [];
+
+  const value = bodyProp.value;
+
+  if (value.type === 'ObjectExpression') {
+    return value.properties
+      .filter((p) => p.type === 'ObjectProperty')
+      .map((p) => (p.key.type === 'Identifier' ? p.key.name : p.key.value))
+      .filter(Boolean);
+  }
+
+  if (
+    value.type === 'CallExpression' &&
+    value.callee.type === 'MemberExpression' &&
+    value.callee.object.type === 'Identifier' &&
+    value.callee.object.name === 'JSON' &&
+    value.callee.property.type === 'Identifier' &&
+    value.callee.property.name === 'stringify' &&
+    value.arguments[0] &&
+    value.arguments[0].type === 'ObjectExpression'
+  ) {
+    return value.arguments[0].properties
+      .filter((p) => p.type === 'ObjectProperty')
+      .map((p) => (p.key.type === 'Identifier' ? p.key.name : p.key.value))
+      .filter(Boolean);
+  }
+
+  return [];
+}
+
+function normalizeRoute(route) {
+  if (!route) return null;
+  const cleaned = route.split('?')[0];
+  if (cleaned.startsWith('http://') || cleaned.startsWith('https://')) {
+    const index = cleaned.indexOf(`/api/`);
+    if (index >= 0) return cleaned.substring(index);
+  }
+  return cleaned.startsWith('/') ? cleaned : `/${cleaned}`;
+}
+
+export function detectFetch(ast, file) {
+  if (!ast) return [];
+
+  const detections = [];
+
+  traverse(ast, {
+    CallExpression(path) {
+      const { node } = path;
+      const callee = node.callee;
+
+      const isDirectFetch = callee.type === 'Identifier' && callee.name === 'fetch';
+      const isWindowFetch =
+        callee.type === 'MemberExpression' &&
+        callee.object.type === 'Identifier' &&
+        callee.object.name === 'window' &&
+        callee.property.type === 'Identifier' &&
+        callee.property.name === 'fetch';
+
+      if (!isDirectFetch && !isWindowFetch) return;
+
+      const rawRoute = getRoute(node.arguments[0]);
+      const route = normalizeRoute(rawRoute);
+      if (!route) return;
+      if (!route.includes(`/api`) && !route.startsWith('/')) return;
+
+      const configNode = node.arguments[1];
+      const method = getMethodFromFetchConfig(configNode);
+      const fields = extractBodyFields(configNode);
+
+      detections.push({
+        file,
+        type: 'fetch',
+        method,
+        route,
+        fields,
+        hasQueryParams: route.includes('?'),
+        line: node.loc?.start?.line || 0,
+        source: 'ast'
+      });
+    }
+  });
+
+  return detections;
+}
+
+export default detectFetch;

package/core/detector/detectForms.js

@@ -0,0 +1,55 @@
+import babelTraverse from '@babel/traverse';
+
+const traverse = babelTraverse.default || babelTraverse;
+
+export function detectForms(ast, file) {
+  if (!ast) return [];
+
+  const forms = [];
+
+  traverse(ast, {
+    VariableDeclarator(path) {
+      const { node } = path;
+
+      if (node.init?.type !== 'CallExpression') return;
+      if (node.init.callee.type !== 'Identifier' || node.init.callee.name !== 'useState') return;
+      if (!node.init.arguments[0] || node.init.arguments[0].type !== 'ObjectExpression') return;
+
+      const fields = node.init.arguments[0].properties
+        .filter((p) => p.type === 'ObjectProperty')
+        .map((p) => (p.key.type === 'Identifier' ? p.key.name : p.key.value))
+        .filter(Boolean);
+
+      if (fields.length === 0) return;
+
+      forms.push({
+        file,
+        type: 'form',
+        fields,
+        line: node.loc?.start?.line || 0,
+        source: 'ast'
+      });
+    },
+    CallExpression(path) {
+      const { node } = path;
+
+      if (node.callee.type !== 'MemberExpression') return;
+      if (node.callee.property.type !== 'Identifier' || node.callee.property.name !== 'append') return;
+
+      const keyArg = node.arguments[0];
+      if (!keyArg || keyArg.type !== 'StringLiteral') return;
+
+      forms.push({
+        file,
+        type: 'form-data',
+        fields: [keyArg.value],
+        line: node.loc?.start?.line || 0,
+        source: 'ast'
+      });
+    }
+  });
+
+  return forms;
+}
+
+export default detectForms;