@mg21st/dev-assist 1.0.0

package/src/generators/docsGenerator.ts

@@ -0,0 +1,192 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { AstParser } from '../parser/astParser';
+import { ApiDoc, ApiEndpoint, ParsedRoute } from '../shared/types';
+
+export class DocsGenerator {
+  private parser: AstParser;
+
+  constructor() {
+    this.parser = new AstParser();
+  }
+
+  async generate(options: {
+    sourceDir: string;
+    outputDir: string;
+    baseUrl?: string;
+    title?: string;
+  }): Promise<ApiDoc> {
+    const spinner = ora('Scanning source files for API routes...').start();
+
+    const parsedFiles = await this.parser.parseDirectory(options.sourceDir);
+    
+    const endpoints: ApiEndpoint[] = [];
+
+    for (const parsedFile of parsedFiles) {
+      for (const route of parsedFile.routes) {
+        endpoints.push(this.buildEndpoint(route));
+      }
+    }
+
+    spinner.text = `Generating documentation for ${endpoints.length} endpoints...`;
+
+    const doc: ApiDoc = {
+      title: options.title || 'API Documentation',
+      version: '1.0.0',
+      baseUrl: options.baseUrl || 'http://localhost:3000',
+      endpoints,
+      generatedAt: new Date().toISOString(),
+    };
+
+    fs.mkdirSync(options.outputDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(options.outputDir, 'api-docs.json'),
+      JSON.stringify(doc, null, 2)
+    );
+
+    fs.writeFileSync(
+      path.join(options.outputDir, 'api-docs.md'),
+      this.generateMarkdown(doc)
+    );
+
+    fs.writeFileSync(
+      path.join(options.outputDir, 'openapi.json'),
+      JSON.stringify(this.generateOpenApiSpec(doc), null, 2)
+    );
+
+    spinner.succeed(chalk.green(`Generated API docs for ${endpoints.length} endpoints`));
+    return doc;
+  }
+
+  private buildEndpoint(route: ParsedRoute): ApiEndpoint {
+    const pathParams = route.params.map(p => ({
+      name: p,
+      type: 'string',
+      required: true,
+    }));
+
+    const exampleRequest: Record<string, unknown> = {};
+    const exampleResponse: Record<string, unknown> = {
+      success: true,
+      data: {},
+      message: 'Operation completed successfully',
+    };
+
+    if (['POST', 'PUT', 'PATCH'].includes(route.method)) {
+      exampleRequest.body = { key: 'value' };
+    }
+
+    return {
+      method: route.method,
+      path: route.path,
+      params: pathParams,
+      queryParams: [],
+      description: `${route.method} ${route.path}`,
+      exampleRequest,
+      exampleResponse,
+    };
+  }
+
+  private generateMarkdown(doc: ApiDoc): string {
+    const lines: string[] = [
+      `# ${doc.title}`,
+      '',
+      `**Version:** ${doc.version}`,
+      `**Base URL:** ${doc.baseUrl}`,
+      `**Generated:** ${doc.generatedAt}`,
+      '',
+      '## Endpoints',
+      '',
+    ];
+
+    for (const endpoint of doc.endpoints) {
+      lines.push(`### ${endpoint.method} \`${endpoint.path}\``);
+      lines.push('');
+      
+      if (endpoint.description) {
+        lines.push(endpoint.description);
+        lines.push('');
+      }
+
+      if (endpoint.params.length > 0) {
+        lines.push('**Path Parameters:**');
+        lines.push('');
+        lines.push('| Name | Type | Required |');
+        lines.push('|------|------|----------|');
+        for (const p of endpoint.params) {
+          lines.push(`| ${p.name} | ${p.type} | ${p.required ? 'Yes' : 'No'} |`);
+        }
+        lines.push('');
+      }
+
+      if (endpoint.exampleRequest && Object.keys(endpoint.exampleRequest).length > 0) {
+        lines.push('**Example Request:**');
+        lines.push('```json');
+        lines.push(JSON.stringify(endpoint.exampleRequest, null, 2));
+        lines.push('```');
+        lines.push('');
+      }
+
+      if (endpoint.exampleResponse) {
+        lines.push('**Example Response:**');
+        lines.push('```json');
+        lines.push(JSON.stringify(endpoint.exampleResponse, null, 2));
+        lines.push('```');
+        lines.push('');
+      }
+
+      lines.push('---');
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+  private generateOpenApiSpec(doc: ApiDoc): Record<string, unknown> {
+    const paths: Record<string, unknown> = {};
+
+    for (const endpoint of doc.endpoints) {
+      const openApiPath = endpoint.path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+      
+      if (!paths[openApiPath]) {
+        paths[openApiPath] = {};
+      }
+
+      const pathItem = paths[openApiPath] as Record<string, unknown>;
+      const method = endpoint.method.toLowerCase();
+
+      pathItem[method] = {
+        summary: endpoint.description,
+        parameters: endpoint.params.map(p => ({
+          name: p.name,
+          in: 'path',
+          required: p.required,
+          schema: { type: p.type },
+        })),
+        responses: {
+          '200': {
+            description: 'Success',
+            content: {
+              'application/json': {
+                example: endpoint.exampleResponse,
+              },
+            },
+          },
+        },
+      };
+    }
+
+    return {
+      openapi: '3.0.0',
+      info: {
+        title: doc.title,
+        version: doc.version,
+      },
+      servers: [{ url: doc.baseUrl }],
+      paths,
+    };
+  }
+}

package/src/generators/testGenerator.ts

@@ -0,0 +1,174 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { AstParser } from '../parser/astParser';
+import { GeneratedTest, ParsedFunction, ParsedRoute } from '../shared/types';
+
+export class TestGenerator {
+  private parser: AstParser;
+
+  constructor() {
+    this.parser = new AstParser();
+  }
+
+  async generate(options: {
+    sourceDir: string;
+    outputDir: string;
+    framework: 'jest' | 'vitest';
+  }): Promise<GeneratedTest[]> {
+    const spinner = ora('Scanning source files...').start();
+    
+    const parsedFiles = await this.parser.parseDirectory(options.sourceDir);
+    spinner.text = `Generating tests for ${parsedFiles.length} files...`;
+
+    const generated: GeneratedTest[] = [];
+
+    for (const parsedFile of parsedFiles) {
+      if (parsedFile.functions.length === 0 && parsedFile.routes.length === 0) continue;
+
+      const testContent = this.generateTestContent(parsedFile.filePath, {
+        functions: parsedFile.functions,
+        routes: parsedFile.routes,
+        framework: options.framework,
+        sourceDir: options.sourceDir,
+        outputDir: options.outputDir,
+      });
+
+      const relativePath = path.relative(options.sourceDir, parsedFile.filePath);
+      const testFileName = relativePath.replace(/\.(js|ts|jsx|tsx)$/, `.test.${parsedFile.filePath.endsWith('.ts') || parsedFile.filePath.endsWith('.tsx') ? 'ts' : 'js'}`);
+      const outputPath = path.join(options.outputDir, testFileName);
+
+      fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+      fs.writeFileSync(outputPath, testContent);
+
+      generated.push({
+        filePath: outputPath,
+        sourceFile: parsedFile.filePath,
+        framework: options.framework,
+        content: testContent,
+      });
+    }
+
+    spinner.succeed(chalk.green(`Generated ${generated.length} test files`));
+    return generated;
+  }
+
+  private generateTestContent(
+    filePath: string,
+    options: {
+      functions: ParsedFunction[];
+      routes: ParsedRoute[];
+      framework: 'jest' | 'vitest';
+      sourceDir: string;
+      outputDir: string;
+    }
+  ): string {
+    const { functions, routes, framework } = options;
+    const relativeImport = path.relative(
+      path.dirname(path.join(options.outputDir, path.relative(options.sourceDir, filePath))),
+      filePath
+    ).replace(/\.(ts|tsx)$/, '');
+
+    const lines: string[] = [];
+    
+    if (framework === 'vitest') {
+      lines.push(`import { describe, it, expect, vi, beforeEach } from 'vitest';`);
+    } else {
+      lines.push(`import { describe, it, expect, jest, beforeEach } from '@jest/globals';`);
+    }
+    
+    lines.push(`import * as module from '${relativeImport.startsWith('.') ? relativeImport : './' + relativeImport}';`);
+    lines.push('');
+
+    for (const fn of functions) {
+      lines.push(`describe('${fn.name}', () => {`);
+      
+      lines.push(`  it('should be defined', () => {`);
+      lines.push(`    expect(module.${fn.name}).toBeDefined();`);
+      lines.push(`  });`);
+      lines.push('');
+
+      if (fn.isAsync) {
+        lines.push(`  it('should return a promise', async () => {`);
+        const mockArgs = fn.params.map(() => 'undefined').join(', ');
+        lines.push(`    const result = module.${fn.name}(${mockArgs});`);
+        lines.push(`    expect(result).toBeInstanceOf(Promise);`);
+        lines.push(`  });`);
+      } else {
+        lines.push(`  it('should execute without throwing', () => {`);
+        const mockArgs = generateMockArgs(fn.params);
+        lines.push(`    expect(() => module.${fn.name}(${mockArgs})).not.toThrow();`);
+        lines.push(`  });`);
+      }
+      
+      lines.push('');
+      lines.push(`  it('should handle edge case: null/undefined inputs', ${fn.isAsync ? 'async ' : ''}() => {`);
+      lines.push(`    // Edge case: test with null/undefined inputs`);
+      const nullArgs = fn.params.map(() => 'null').join(', ');
+      if (fn.isAsync) {
+        lines.push(`    try {`);
+        lines.push(`      await module.${fn.name}(${nullArgs});`);
+        lines.push(`    } catch (e) {`);
+        lines.push(`      expect(e).toBeDefined();`);
+        lines.push(`    }`);
+      } else {
+        lines.push(`    try {`);
+        lines.push(`      module.${fn.name}(${nullArgs});`);
+        lines.push(`    } catch (e) {`);
+        lines.push(`      expect(e).toBeDefined();`);
+        lines.push(`    }`);
+      }
+      lines.push(`  });`);
+      
+      lines.push(`});`);
+      lines.push('');
+    }
+
+    if (routes.length > 0) {
+      lines.push(`// Express Route Tests`);
+      lines.push(`describe('Express Routes', () => {`);
+      
+      for (const route of routes) {
+        lines.push(`  describe('${route.method} ${route.path}', () => {`);
+        lines.push(`    it('should handle request correctly', () => {`);
+        lines.push(`      const mockReq = {`);
+        lines.push(`        params: { ${route.params.map(p => `${p}: 'test'`).join(', ')} },`);
+        lines.push(`        query: {},`);
+        lines.push(`        body: {},`);
+        lines.push(`        headers: {},`);
+        lines.push(`      };`);
+        lines.push(`      const mockRes = {`);
+        lines.push(`        status: ${framework === 'jest' ? 'jest' : 'vi'}.fn().mockReturnThis(),`);
+        lines.push(`        json: ${framework === 'jest' ? 'jest' : 'vi'}.fn().mockReturnThis(),`);
+        lines.push(`        send: ${framework === 'jest' ? 'jest' : 'vi'}.fn().mockReturnThis(),`);
+        lines.push(`      };`);
+        lines.push(`      expect(mockReq).toBeDefined();`);
+        lines.push(`      expect(mockRes).toBeDefined();`);
+        lines.push(`    });`);
+        lines.push(`  });`);
+        lines.push('');
+      }
+      
+      lines.push(`});`);
+    }
+
+    return lines.join('\n');
+  }
+}
+
+function generateMockArgs(params: string[]): string {
+  return params.map(param => {
+    if (param.includes('...')) return '[]';
+    const lower = param.toLowerCase();
+    if (lower.includes('id')) return "'test-id'";
+    if (lower.includes('name')) return "'test-name'";
+    if (lower.includes('email')) return "'test@example.com'";
+    if (lower.includes('num') || lower.includes('count') || lower.includes('age')) return '0';
+    if (lower.includes('flag') || lower.includes('bool') || lower.includes('is') || lower.includes('has')) return 'false';
+    if (lower.includes('arr') || lower.includes('list') || lower.includes('items')) return '[]';
+    if (lower.includes('obj') || lower.includes('data') || lower.includes('config')) return '{}';
+    if (lower.includes('fn') || lower.includes('callback') || lower.includes('cb')) return '() => {}';
+    return "''";
+  }).join(', ');
+}

package/src/parser/astParser.ts

@@ -0,0 +1,172 @@
+import * as parser from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ParsedFile, ParsedFunction, ParsedRoute } from '../shared/types';
+
+export class AstParser {
+  async parseFile(filePath: string): Promise<ParsedFile> {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const ext = path.extname(filePath);
+    
+    const plugins: parser.ParserPlugin[] = ['jsx'];
+    if (ext === '.ts' || ext === '.tsx') {
+      plugins.push('typescript');
+    }
+
+    let ast: t.File;
+    try {
+      ast = parser.parse(content, {
+        sourceType: 'module',
+        plugins,
+        errorRecovery: true,
+      });
+    } catch {
+      return { filePath, functions: [], routes: [], imports: [] };
+    }
+
+    const functions: ParsedFunction[] = [];
+    const routes: ParsedRoute[] = [];
+    const imports: string[] = [];
+
+    traverse(ast, {
+      ImportDeclaration(nodePath) {
+        imports.push(nodePath.node.source.value);
+      },
+      
+      ExportNamedDeclaration(nodePath) {
+        const declaration = nodePath.node.declaration;
+        if (!declaration) return;
+        
+        if (t.isFunctionDeclaration(declaration) && declaration.id) {
+          functions.push(extractFunction(declaration));
+        } else if (t.isVariableDeclaration(declaration)) {
+          declaration.declarations.forEach(decl => {
+            if (
+              t.isVariableDeclarator(decl) &&
+              t.isIdentifier(decl.id) &&
+              (t.isArrowFunctionExpression(decl.init) || t.isFunctionExpression(decl.init))
+            ) {
+              functions.push(extractVariableFunction(decl.id.name, decl.init));
+            }
+          });
+        }
+      },
+      
+      ExportDefaultDeclaration(nodePath) {
+        const declaration = nodePath.node.declaration;
+        if (t.isFunctionDeclaration(declaration)) {
+          const fn = extractFunction(declaration);
+          fn.name = fn.name || 'default';
+          functions.push(fn);
+        }
+      },
+
+      CallExpression(nodePath) {
+        const node = nodePath.node;
+        if (
+          t.isMemberExpression(node.callee) &&
+          t.isIdentifier(node.callee.property)
+        ) {
+          const method = node.callee.property.name.toUpperCase();
+          const httpMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
+          
+          if (httpMethods.includes(method) && node.arguments.length >= 2) {
+            const firstArg = node.arguments[0];
+            if (t.isStringLiteral(firstArg)) {
+              const routePath = firstArg.value;
+              const params = extractPathParams(routePath);
+              routes.push({
+                method,
+                path: routePath,
+                handler: `handler_${method.toLowerCase()}_${routePath.replace(/[^a-zA-Z0-9]/g, '_')}`,
+                params,
+                middleware: [],
+              });
+            }
+          }
+        }
+      },
+    });
+
+    return { filePath, functions, routes, imports };
+  }
+
+  async parseDirectory(dirPath: string): Promise<ParsedFile[]> {
+    const results: ParsedFile[] = [];
+    const files = this.getFiles(dirPath);
+    
+    for (const file of files) {
+      try {
+        const parsed = await this.parseFile(file);
+        results.push(parsed);
+      } catch {
+        // Skip unparseable files
+      }
+    }
+    
+    return results;
+  }
+
+  private getFiles(dirPath: string): string[] {
+    const files: string[] = [];
+    
+    if (!fs.existsSync(dirPath)) return files;
+    
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      
+      if (entry.isDirectory()) {
+        if (!['node_modules', '.git', 'dist', 'build', 'coverage'].includes(entry.name)) {
+          files.push(...this.getFiles(fullPath));
+        }
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        if (['.js', '.ts', '.jsx', '.tsx'].includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+    
+    return files;
+  }
+}
+
+function extractFunction(node: t.FunctionDeclaration): ParsedFunction {
+  return {
+    name: node.id?.name || 'anonymous',
+    params: node.params.map(p => {
+      if (t.isIdentifier(p)) return p.name;
+      if (t.isAssignmentPattern(p) && t.isIdentifier(p.left)) return p.left.name;
+      if (t.isRestElement(p) && t.isIdentifier(p.argument)) return `...${p.argument.name}`;
+      return 'param';
+    }),
+    isAsync: node.async,
+    isExported: true,
+  };
+}
+
+function extractVariableFunction(
+  name: string,
+  node: t.ArrowFunctionExpression | t.FunctionExpression
+): ParsedFunction {
+  return {
+    name,
+    params: node.params.map(p => {
+      if (t.isIdentifier(p)) return p.name;
+      if (t.isAssignmentPattern(p) && t.isIdentifier(p.left)) return p.left.name;
+      if (t.isRestElement(p) && t.isIdentifier(p.argument)) return `...${p.argument.name}`;
+      return 'param';
+    }),
+    isAsync: node.async,
+    isExported: true,
+  };
+}
+
+function extractPathParams(routePath: string): string[] {
+  const matches = routePath.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g);
+  return matches ? matches.map(m => m.slice(1)) : [];
+}