@mg21st/dev-assist 1.0.0

package/src/server/index.ts

@@ -0,0 +1,238 @@
+import express from 'express';
+import cors from 'cors';
+import * as path from 'path';
+import * as fs from 'fs';
+import { createServer } from 'http';
+import { Server as SocketIOServer } from 'socket.io';
+import chalk from 'chalk';
+import open from 'open';
+import chokidar from 'chokidar';
+import rateLimit from 'express-rate-limit';
+import { AstParser } from '../parser/astParser';
+import { TestGenerator } from '../generators/testGenerator';
+import { DocsGenerator } from '../generators/docsGenerator';
+import { loadConfig } from '../config';
+
+export async function startServer(options: { port: number; openBrowser: boolean }): Promise<void> {
+  const app = express();
+  const httpServer = createServer(app);
+  const io = new SocketIOServer(httpServer, { cors: { origin: '*' } });
+  const config = await loadConfig();
+
+  app.use(cors());
+  app.use(express.json());
+
+  // Rate limiter: max 60 requests per minute per IP for API routes
+  const apiLimiter = rateLimit({
+    windowMs: 60_000,
+    max: 60,
+    standardHeaders: true,
+    legacyHeaders: false,
+    message: { error: 'Too many requests, please try again later.' },
+  });
+
+  const uiDistPath = path.join(__dirname, '../../ui/dist');
+  if (fs.existsSync(uiDistPath)) {
+    app.use(express.static(uiDistPath));
+  }
+
+  const parser = new AstParser();
+  const testGenerator = new TestGenerator();
+  const docsGenerator = new DocsGenerator();
+
+  app.get('/api/summary', apiLimiter, async (_req, res) => {
+    try {
+      const sourceDir = config.sourceDir || './src';
+      const parsedFiles = await parser.parseDirectory(path.resolve(process.cwd(), sourceDir));
+      
+      let totalFunctions = 0;
+      let totalRoutes = 0;
+      
+      for (const file of parsedFiles) {
+        totalFunctions += file.functions.length;
+        totalRoutes += file.routes.length;
+      }
+
+      res.json({
+        totalFiles: parsedFiles.length,
+        totalFunctions,
+        totalRoutes,
+        totalTests: 0,
+        generatedAt: new Date().toISOString(),
+      });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+
+  app.get('/api/files', apiLimiter, async (_req, res) => {
+    try {
+      const sourceDir = config.sourceDir || './src';
+      const parsedFiles = await parser.parseDirectory(path.resolve(process.cwd(), sourceDir));
+      res.json(parsedFiles);
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+
+  app.post('/api/generate/tests', apiLimiter, async (req, res) => {
+    try {
+      const { sourceDir, outputDir, framework } = req.body as {
+        sourceDir?: string;
+        outputDir?: string;
+        framework?: string;
+      };
+      const generated = await testGenerator.generate({
+        sourceDir: sourceDir || config.sourceDir || './src',
+        outputDir: outputDir || config.testOutputDir || './__tests__',
+        framework: (framework || config.testFramework || 'jest') as 'jest' | 'vitest',
+      });
+      res.json({ success: true, files: generated });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+
+  app.post('/api/generate/docs', apiLimiter, async (req, res) => {
+    try {
+      const { sourceDir, outputDir } = req.body as {
+        sourceDir?: string;
+        outputDir?: string;
+      };
+      const doc = await docsGenerator.generate({
+        sourceDir: sourceDir || config.sourceDir || './src',
+        outputDir: outputDir || config.docsOutputDir || './docs',
+        baseUrl: config.baseUrl,
+      });
+      res.json({ success: true, doc });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+
+  app.get('/api/docs', apiLimiter, async (_req, res) => {
+    try {
+      const docsPath = path.join(process.cwd(), config.docsOutputDir || './docs', 'api-docs.json');
+      if (fs.existsSync(docsPath)) {
+        const docs = JSON.parse(fs.readFileSync(docsPath, 'utf-8'));
+        res.json(docs);
+      } else {
+        res.json({ endpoints: [], title: 'API Documentation', version: '1.0.0', baseUrl: config.baseUrl });
+      }
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+
+  app.get('/api/tests', apiLimiter, async (_req, res) => {
+    try {
+      const testDir = path.join(process.cwd(), config.testOutputDir || './__tests__');
+      const tests: { filePath: string; content: string }[] = [];
+      
+      if (fs.existsSync(testDir)) {
+        const getTestFiles = (dir: string): string[] => {
+          const files: string[] = [];
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) files.push(...getTestFiles(fullPath));
+            else if (entry.isFile() && entry.name.includes('.test.')) files.push(fullPath);
+          }
+          return files;
+        };
+
+        const testFiles = getTestFiles(testDir);
+        for (const file of testFiles) {
+          tests.push({
+            filePath: path.relative(process.cwd(), file),
+            content: fs.readFileSync(file, 'utf-8'),
+          });
+        }
+      }
+      
+      res.json(tests);
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+
+  app.post('/api/proxy', async (req, res) => {
+    try {
+      const { url, method, headers, body } = req.body as {
+        url: string;
+        method: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+      };
+
+      const startTime = Date.now();
+      
+      const fetchOptions: RequestInit = {
+        method: method || 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(headers || {}),
+        },
+      };
+
+      if (body && ['POST', 'PUT', 'PATCH'].includes(method?.toUpperCase() || '')) {
+        fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
+      }
+
+      const response = await fetch(url, fetchOptions);
+      const responseTime = Date.now() - startTime;
+      
+      let responseData: unknown;
+      const contentType = response.headers.get('content-type') || '';
+      
+      if (contentType.includes('application/json')) {
+        responseData = await response.json();
+      } else {
+        responseData = await response.text();
+      }
+
+      res.json({
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+        data: responseData,
+        responseTime,
+      });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+
+  app.get('*', apiLimiter, (_req, res) => {
+    const indexPath = path.join(__dirname, '../../ui/dist/index.html');
+    if (fs.existsSync(indexPath)) {
+      res.sendFile(indexPath);
+    } else {
+      res.json({ message: 'DevAssist API Server', status: 'running' });
+    }
+  });
+
+  if (config.watchMode) {
+    const watcher = chokidar.watch(config.sourceDir || './src', {
+      ignored: /node_modules/,
+      persistent: true,
+    });
+    
+    watcher.on('change', (filePath: string) => {
+      io.emit('file-changed', { filePath });
+    });
+  }
+
+  io.on('connection', (socket) => {
+    socket.emit('connected', { message: 'DevAssist server connected' });
+  });
+
+  httpServer.listen(options.port, () => {
+    console.log(chalk.green.bold(`\n✅ DevAssist UI running at http://localhost:${options.port}\n`));
+    console.log(chalk.gray('Press Ctrl+C to stop the server\n'));
+    
+    if (options.openBrowser) {
+      open(`http://localhost:${options.port}`);
+    }
+  });
+}

package/src/shared/types.ts

@@ -0,0 +1,83 @@
+export interface ParsedFunction {
+  name: string;
+  params: string[];
+  isAsync: boolean;
+  isExported: boolean;
+  returnType?: string;
+}
+
+export interface ParsedRoute {
+  method: string;
+  path: string;
+  handler: string;
+  params: string[];
+  middleware: string[];
+}
+
+export interface ParsedFile {
+  filePath: string;
+  functions: ParsedFunction[];
+  routes: ParsedRoute[];
+  imports: string[];
+}
+
+export interface GeneratedTest {
+  filePath: string;
+  sourceFile: string;
+  framework: 'jest' | 'vitest';
+  content: string;
+}
+
+export interface ApiEndpoint {
+  method: string;
+  path: string;
+  params: PathParam[];
+  queryParams: QueryParam[];
+  bodySchema?: BodySchema;
+  description?: string;
+  exampleRequest?: Record<string, unknown>;
+  exampleResponse?: Record<string, unknown>;
+}
+
+export interface PathParam {
+  name: string;
+  type: string;
+  required: boolean;
+}
+
+export interface QueryParam {
+  name: string;
+  type: string;
+  required: boolean;
+}
+
+export interface BodySchema {
+  type: string;
+  properties: Record<string, { type: string; required?: boolean }>;
+}
+
+export interface ApiDoc {
+  title: string;
+  version: string;
+  baseUrl: string;
+  endpoints: ApiEndpoint[];
+  generatedAt: string;
+}
+
+export interface DevAssistConfig {
+  testFramework: 'jest' | 'vitest';
+  sourceDir: string;
+  testOutputDir: string;
+  docsOutputDir: string;
+  port: number;
+  watchMode: boolean;
+  baseUrl: string;
+}
+
+export interface ProjectSummary {
+  totalFiles: number;
+  totalFunctions: number;
+  totalRoutes: number;
+  totalTests: number;
+  generatedAt: string;
+}

package/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "exclude": ["node_modules", "dist", "ui", "**/*.test.ts", "**/*.spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "ui"]
+}

package/ui/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>DevAssist - Developer Toolkit</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>