reverse-engine 0.1.0

package/README.md

@@ -0,0 +1,90 @@
+# reverse-engine
+
+웹 서비스 역분석 자동화 도구 — 소스코드를 넣으면 **Excel 문서**, **Mermaid 다이어그램**, **테스트 코드**가 자동 생성됩니다.
+
+## 설치
+
+```bash
+npm install -g reverse-engine
+```
+
+## 사용법
+
+### 전체 파이프라인 (한 줄)
+
+```bash
+reverse-engine full --source ./my-project --output ./output
+```
+
+이 명령 하나로:
+1. 소스코드 분석 (컴포넌트, 함수, API, 라우트, 의존성)
+2. Excel 리포트 생성 (5개 시트)
+3. Mermaid 컴포넌트 다이어그램 생성
+4. E2E + API 테스트 코드 자동 생성
+
+### 개별 명령어
+
+```bash
+# 소스코드 분석
+reverse-engine analyze ./my-project
+
+# 리포트 생성
+reverse-engine report --input output/analysis.json --format excel,mermaid
+
+# 테스트 코드 생성
+reverse-engine test --input output/analysis.json --type e2e,api
+```
+
+## 지원 프레임워크
+
+- **React** / Next.js
+- **Vue** / Nuxt
+- **Angular**
+- **Svelte**
+- TypeScript / JavaScript
+
+## 출력물
+
+### Excel 리포트 (5개 시트)
+
+| 시트 | 내용 |
+|------|------|
+| 컴포넌트 목록 | 이름, 파일, 타입, Props, 하위 컴포넌트, Hooks |
+| API 엔드포인트 | Method, URL, 파일, 함수명, 라인 |
+| 라우트 | Path, Component, 파일 |
+| 함수 호출 체인 | 함수명, 호출/피호출 관계, async/export 여부 |
+| 의존성 패키지 | 패키지명, 버전, prod/dev 구분 |
+
+### Mermaid 다이어그램
+
+컴포넌트 관계 + 라우트 매핑 플로우차트 자동 생성
+
+### 테스트 코드
+
+- **E2E 테스트**: 라우트별 페이지 로드 + 컴포넌트 렌더링
+- **API 테스트**: 엔드포인트별 상태코드 검증
+
+## 프로그래매틱 사용
+
+```typescript
+import { analyze, generateReport, generateTests } from 'reverse-engine';
+
+const result = await analyze('./my-project');
+await generateReport(result, { formats: ['excel', 'mermaid'] });
+await generateTests(result, { types: ['e2e', 'api'] });
+```
+
+## 분석 결과 예시
+
+```
+프레임워크: React
+컴포넌트: 7개 (App, Dashboard, Settings, Login, Layout, StatsCard, ActivityFeed)
+함수: 16개 (loadData, handleRefresh, handleExport, handleLogin, handleSave...)
+API: 7개 (GET /api/dashboard/stats, POST /api/auth/login, PUT /api/settings/profile...)
+라우트: 3개 (/, /settings, /login)
+의존성: 8개 (react, axios, zustand...)
+```
+
+## License
+
+MIT

package/dist/analyzer/extractors/api-call.d.ts

@@ -0,0 +1,2 @@
+import type { ApiClientCall } from '../../types.js';
+export declare function extractApiCalls(source: string, filePath: string, ext: string): ApiClientCall[];

package/dist/analyzer/extractors/api-call.js

@@ -0,0 +1,86 @@
+import _traverse from '@babel/traverse';
+import { parseSource, parseVue } from '../parsers/parse.js';
+const traverse = _traverse.default || _traverse;
+export function extractApiCalls(source, filePath, ext) {
+    const ast = ext === '.vue' ? parseVue(source) : parseSource(source, ext);
+    const calls = [];
+    traverse(ast, {
+        CallExpression(path) {
+            const callee = path.node.callee;
+            let funcText = '';
+            let method = '';
+            // fetch('url')
+            if (callee?.type === 'Identifier' && callee.name === 'fetch') {
+                funcText = 'fetch';
+                method = 'GET';
+                // 두 번째 인자에서 method 확인
+                const opts = path.node.arguments[1];
+                if (opts?.type === 'ObjectExpression') {
+                    for (const prop of opts.properties) {
+                        if (prop.key?.name === 'method' && prop.value?.type === 'StringLiteral') {
+                            method = prop.value.value.toUpperCase();
+                        }
+                    }
+                }
+            }
+            // axios.get/post/put/delete, api.get, $http.get, requests.get
+            if (callee?.type === 'MemberExpression') {
+                const obj = callee.object?.name || '';
+                const prop = callee.property?.name || '';
+                if (['axios', 'api', '$http', 'http', 'requests', 'this'].includes(obj) ||
+                    obj.endsWith('Client') || obj.endsWith('Api')) {
+                    const methodMap = {
+                        get: 'GET', post: 'POST', put: 'PUT', delete: 'DELETE',
+                        patch: 'PATCH', head: 'HEAD', options: 'OPTIONS',
+                    };
+                    if (methodMap[prop]) {
+                        funcText = `${obj}.${prop}`;
+                        method = methodMap[prop];
+                    }
+                }
+            }
+            if (!funcText || !method)
+                return;
+            // URL 추출
+            const firstArg = path.node.arguments[0];
+            let url = '';
+            if (firstArg?.type === 'StringLiteral') {
+                url = firstArg.value;
+            }
+            else if (firstArg?.type === 'TemplateLiteral' && firstArg.quasis?.[0]) {
+                url = firstArg.quasis.map((q) => q.value.raw).join('*');
+            }
+            if (!url)
+                return;
+            // 상위 함수명 찾기
+            const functionName = findEnclosingFunctionName(path);
+            calls.push({
+                method,
+                urlPattern: url,
+                filePath,
+                line: path.node.loc?.start.line || 0,
+                functionName,
+            });
+        },
+    });
+    return calls;
+}
+function findEnclosingFunctionName(path) {
+    let current = path.parentPath;
+    while (current) {
+        if (current.node.type === 'FunctionDeclaration' && current.node.id) {
+            return current.node.id.name;
+        }
+        if (current.node.type === 'VariableDeclarator' && current.node.id?.name) {
+            const init = current.node.init;
+            if (init?.type === 'ArrowFunctionExpression' || init?.type === 'FunctionExpression') {
+                return current.node.id.name;
+            }
+        }
+        if (current.node.type === 'ClassMethod' && current.node.key?.name) {
+            return current.node.key.name;
+        }
+        current = current.parentPath;
+    }
+    return '<anonymous>';
+}

package/dist/analyzer/extractors/component.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentInfo } from '../../types.js';
+export declare function extractComponents(source: string, filePath: string, ext: string): ComponentInfo[];

package/dist/analyzer/extractors/component.js

@@ -0,0 +1,189 @@
+import _traverse from '@babel/traverse';
+import { parseSource, parseVue } from '../parsers/parse.js';
+const traverse = _traverse.default || _traverse;
+export function extractComponents(source, filePath, ext) {
+    const ast = ext === '.vue' ? parseVue(source) : parseSource(source, ext);
+    const components = [];
+    if (ext === '.vue') {
+        // Vue SFC = 파일 자체가 컴포넌트
+        const name = filePath.split('/').pop()?.replace('.vue', '') || filePath;
+        const hooks = collectHooks(ast);
+        const apiCalls = collectApiPatterns(ast);
+        components.push({
+            name,
+            filePath,
+            lineStart: 1,
+            lineEnd: source.split('\n').length,
+            componentType: inferType(filePath),
+            props: [],
+            children: [],
+            usedBy: [],
+            hooks,
+            apiCalls,
+        });
+        return components;
+    }
+    // React 컴포넌트 추출 (대문자 시작 + JSX 반환)
+    traverse(ast, {
+        FunctionDeclaration(path) {
+            const comp = tryExtractReactComponent(path, filePath, source);
+            if (comp)
+                components.push(comp);
+        },
+        VariableDeclarator(path) {
+            const init = path.node.init;
+            if (!init || (init.type !== 'ArrowFunctionExpression' && init.type !== 'FunctionExpression'))
+                return;
+            if (path.node.id?.type !== 'Identifier')
+                return;
+            const name = path.node.id.name;
+            if (!name[0] || name[0] !== name[0].toUpperCase())
+                return;
+            if (!hasJSX(path))
+                return;
+            const children = collectJSXChildren(path);
+            const hooks = collectHooks(path.get('init'));
+            const apiCalls = collectApiPatterns(path.get('init'));
+            components.push({
+                name,
+                filePath,
+                lineStart: path.node.loc?.start.line || 0,
+                lineEnd: path.node.loc?.end.line || 0,
+                componentType: inferType(filePath),
+                props: extractProps(init),
+                children,
+                usedBy: [],
+                hooks,
+                apiCalls,
+            });
+        },
+    });
+    return components;
+}
+function tryExtractReactComponent(path, filePath, source) {
+    const name = path.node.id?.name;
+    if (!name || name[0] !== name[0].toUpperCase())
+        return null;
+    if (!hasJSX(path))
+        return null;
+    return {
+        name,
+        filePath,
+        lineStart: path.node.loc?.start.line || 0,
+        lineEnd: path.node.loc?.end.line || 0,
+        componentType: inferType(filePath),
+        props: extractProps(path.node),
+        children: collectJSXChildren(path),
+        usedBy: [],
+        hooks: collectHooks(path),
+        apiCalls: collectApiPatterns(path),
+    };
+}
+function hasJSX(path) {
+    let found = false;
+    path.traverse({
+        JSXElement() { found = true; },
+        JSXFragment() { found = true; },
+    });
+    return found;
+}
+function collectJSXChildren(path) {
+    const children = new Set();
+    path.traverse({
+        JSXOpeningElement(jsxPath) {
+            const name = jsxPath.node.name;
+            let tagName = '';
+            if (name.type === 'JSXIdentifier')
+                tagName = name.name;
+            else if (name.type === 'JSXMemberExpression')
+                tagName = name.property?.name || '';
+            if (tagName && tagName[0] === tagName[0].toUpperCase()) {
+                children.add(tagName);
+            }
+        },
+    });
+    return [...children].sort();
+}
+function collectHooks(pathOrAst) {
+    const hooks = new Set();
+    const visitor = {
+        CallExpression(callPath) {
+            const name = callPath.node.callee?.name;
+            if (name?.startsWith('use'))
+                hooks.add(name);
+        },
+    };
+    if (pathOrAst.traverse) {
+        pathOrAst.traverse(visitor);
+    }
+    else {
+        traverse(pathOrAst, visitor);
+    }
+    return [...hooks].sort();
+}
+function collectApiPatterns(pathOrAst) {
+    const apis = new Set();
+    const visitor = {
+        CallExpression(callPath) {
+            const callee = callPath.node.callee;
+            let funcText = '';
+            if (callee?.type === 'MemberExpression') {
+                const obj = callee.object?.name || '';
+                const prop = callee.property?.name || '';
+                funcText = `${obj}.${prop}`;
+            }
+            else if (callee?.type === 'Identifier') {
+                funcText = callee.name;
+            }
+            if (funcText === 'fetch' || funcText.startsWith('axios.') || funcText.startsWith('api.') || funcText.startsWith('$http.')) {
+                const args = callPath.node.arguments;
+                const method = funcText.includes('.get') ? 'GET'
+                    : funcText.includes('.post') ? 'POST'
+                        : funcText.includes('.put') ? 'PUT'
+                            : funcText.includes('.delete') ? 'DELETE'
+                                : funcText === 'fetch' ? 'GET' : 'GET';
+                let url = '';
+                if (args[0]?.type === 'StringLiteral')
+                    url = args[0].value;
+                else if (args[0]?.type === 'TemplateLiteral' && args[0].quasis?.[0]) {
+                    url = args[0].quasis[0].value.raw;
+                }
+                if (url)
+                    apis.add(`${method} ${url}`);
+            }
+        },
+    };
+    if (pathOrAst.traverse) {
+        pathOrAst.traverse(visitor);
+    }
+    else {
+        traverse(pathOrAst, visitor);
+    }
+    return [...apis].sort();
+}
+function extractProps(node) {
+    const params = node.params || [];
+    if (params.length === 0)
+        return [];
+    const first = params[0];
+    if (first.type === 'ObjectPattern') {
+        return first.properties
+            .filter((p) => p.type === 'ObjectProperty' || p.type === 'Property')
+            .map((p) => ({
+            name: p.key?.name || '?',
+            type: 'unknown',
+            required: true,
+        }));
+    }
+    return [];
+}
+function inferType(filePath) {
+    const p = filePath.toLowerCase();
+    if (p.includes('page') || p.includes('views') || p.includes('routes'))
+        return 'Page';
+    if (p.includes('layout'))
+        return 'Layout';
+    if (p.includes('util') || p.includes('helper') || p.includes('hoc'))
+        return 'Utility';
+    return 'Widget';
+}

package/dist/analyzer/extractors/function.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionInfo } from '../../types.js';
+export declare function extractFunctions(source: string, filePath: string, ext: string): FunctionInfo[];

package/dist/analyzer/extractors/function.js

@@ -0,0 +1,111 @@
+import _traverse from '@babel/traverse';
+import { parseSource, parseVue } from '../parsers/parse.js';
+// ESM 호환
+const traverse = _traverse.default || _traverse;
+export function extractFunctions(source, filePath, ext) {
+    const ast = ext === '.vue' ? parseVue(source) : parseSource(source, ext);
+    const functions = [];
+    traverse(ast, {
+        // function foo() {} / async function foo() {}
+        FunctionDeclaration(path) {
+            if (!path.node.id)
+                return;
+            functions.push(buildFunctionInfo(path, filePath));
+        },
+        // const foo = () => {} / const foo = function() {}
+        VariableDeclarator(path) {
+            const init = path.node.init;
+            if (!init)
+                return;
+            if (init.type !== 'ArrowFunctionExpression' && init.type !== 'FunctionExpression')
+                return;
+            if (path.node.id?.type !== 'Identifier')
+                return;
+            const name = path.node.id.name;
+            const calls = collectCallExpressions(path);
+            const isExported = path.parentPath?.parentPath?.node.type === 'ExportNamedDeclaration'
+                || path.parentPath?.parentPath?.node.type === 'ExportDefaultDeclaration';
+            functions.push({
+                name,
+                filePath,
+                lineStart: path.node.loc?.start.line || 0,
+                lineEnd: path.node.loc?.end.line || 0,
+                params: extractParams(init),
+                returnType: init.returnType?.typeAnnotation?.type,
+                calls,
+                calledBy: [],
+                isAsync: init.async || false,
+                isExported,
+            });
+        },
+        // class methods
+        ClassMethod(path) {
+            const name = path.node.key?.name;
+            if (!name)
+                return;
+            functions.push({
+                name,
+                filePath,
+                lineStart: path.node.loc?.start.line || 0,
+                lineEnd: path.node.loc?.end.line || 0,
+                params: extractParams(path.node),
+                returnType: undefined,
+                calls: collectCallExpressions(path),
+                calledBy: [],
+                isAsync: path.node.async || false,
+                isExported: false,
+            });
+        },
+    });
+    return functions;
+}
+function buildFunctionInfo(path, filePath) {
+    const node = path.node;
+    const isExported = path.parentPath?.node.type === 'ExportNamedDeclaration'
+        || path.parentPath?.node.type === 'ExportDefaultDeclaration';
+    return {
+        name: node.id.name,
+        filePath,
+        lineStart: node.loc?.start.line || 0,
+        lineEnd: node.loc?.end.line || 0,
+        params: extractParams(node),
+        returnType: node.returnType?.typeAnnotation?.type,
+        calls: collectCallExpressions(path),
+        calledBy: [],
+        isAsync: node.async || false,
+        isExported,
+    };
+}
+function extractParams(node) {
+    return (node.params || []).map((p) => {
+        if (p.type === 'Identifier')
+            return p.name;
+        if (p.type === 'AssignmentPattern' && p.left?.name)
+            return p.left.name;
+        if (p.type === 'ObjectPattern')
+            return '{...}';
+        if (p.type === 'RestElement')
+            return `...${p.argument?.name || ''}`;
+        return '?';
+    });
+}
+function collectCallExpressions(path) {
+    const calls = new Set();
+    path.traverse({
+        CallExpression(callPath) {
+            const callee = callPath.node.callee;
+            let name = '';
+            if (callee.type === 'Identifier') {
+                name = callee.name;
+            }
+            else if (callee.type === 'MemberExpression') {
+                // a.b.c → c
+                name = callee.property?.name || '';
+            }
+            if (name && name !== 'require') {
+                calls.add(name);
+            }
+        },
+    });
+    return [...calls].sort();
+}

package/dist/analyzer/extractors/route.d.ts

@@ -0,0 +1,2 @@
+import type { RouteInfo } from '../../types.js';
+export declare function extractRoutes(source: string, filePath: string, ext: string): RouteInfo[];

package/dist/analyzer/extractors/route.js

@@ -0,0 +1,98 @@
+import _traverse from '@babel/traverse';
+import { parseSource } from '../parsers/parse.js';
+const traverse = _traverse.default || _traverse;
+export function extractRoutes(source, filePath, ext) {
+    // Next.js/Nuxt 파일 기반 라우팅
+    if (filePath.includes('pages/') || filePath.includes('app/')) {
+        const route = inferFileBasedRoute(filePath);
+        if (route)
+            return [route];
+    }
+    if (ext === '.vue')
+        return []; // Vue Router는 별도 설정 파일에서
+    const ast = parseSource(source, ext);
+    const routes = [];
+    traverse(ast, {
+        // <Route path="..." element={<Comp />} />
+        JSXOpeningElement(path) {
+            const name = path.node.name;
+            if (name?.type !== 'JSXIdentifier' || name.name !== 'Route')
+                return;
+            let routePath = '';
+            let component = '';
+            for (const attr of path.node.attributes || []) {
+                if (attr.type !== 'JSXAttribute')
+                    continue;
+                const attrName = attr.name?.name;
+                if (attrName === 'path' && attr.value?.type === 'StringLiteral') {
+                    routePath = attr.value.value;
+                }
+                if ((attrName === 'element' || attrName === 'component') && attr.value?.type === 'JSXExpressionContainer') {
+                    const expr = attr.value.expression;
+                    if (expr.type === 'JSXElement') {
+                        component = expr.openingElement?.name?.name || '';
+                    }
+                    else if (expr.type === 'Identifier') {
+                        component = expr.name;
+                    }
+                }
+            }
+            if (routePath) {
+                routes.push({
+                    path: routePath,
+                    component: component || '?',
+                    filePath,
+                    guards: [],
+                });
+            }
+        },
+        // Vue Router / generic: { path: '...', component: ... }
+        ObjectExpression(path) {
+            let routePath = '';
+            let component = '';
+            for (const prop of path.node.properties || []) {
+                if (prop.type !== 'ObjectProperty')
+                    continue;
+                const key = prop.key?.name || prop.key?.value;
+                if (key === 'path' && prop.value?.type === 'StringLiteral') {
+                    routePath = prop.value.value;
+                }
+                if (key === 'component' && prop.value?.type === 'Identifier') {
+                    component = prop.value.name;
+                }
+            }
+            if (routePath.startsWith('/') && component) {
+                // 중복 방지
+                if (!routes.some(r => r.path === routePath)) {
+                    routes.push({ path: routePath, component, filePath, guards: [] });
+                }
+            }
+        },
+    });
+    return routes;
+}
+function inferFileBasedRoute(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    let routePart = '';
+    if (normalized.includes('pages/')) {
+        routePart = normalized.split('pages/')[1];
+    }
+    else if (normalized.includes('app/')) {
+        routePart = normalized.split('app/')[1];
+    }
+    else {
+        return null;
+    }
+    const routePath = routePart
+        .replace(/\.(tsx?|jsx?|vue)$/, '')
+        .replace(/\/index$/, '')
+        .replace(/\/page$/, '')
+        .replace(/\[(\w+)\]/g, ':$1');
+    const component = filePath.split('/').pop()?.split('.')[0] || '';
+    return {
+        path: routePath ? `/${routePath}` : '/',
+        component,
+        filePath,
+        guards: [],
+    };
+}

package/dist/analyzer/framework.d.ts

@@ -0,0 +1 @@
+export declare function detectFramework(sourcePath: string): Promise<string>;

package/dist/analyzer/framework.js

@@ -0,0 +1,22 @@
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+export async function detectFramework(sourcePath) {
+    try {
+        const pkg = JSON.parse(await readFile(join(sourcePath, 'package.json'), 'utf-8'));
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (allDeps['next'])
+            return 'Next.js';
+        if (allDeps['nuxt'])
+            return 'Nuxt';
+        if (allDeps['@angular/core'])
+            return 'Angular';
+        if (allDeps['svelte'])
+            return 'Svelte';
+        if (allDeps['vue'])
+            return 'Vue';
+        if (allDeps['react'])
+            return 'React';
+    }
+    catch { /* no package.json */ }
+    return 'Unknown';
+}

package/dist/analyzer/index.d.ts

@@ -0,0 +1,7 @@
+import type { AnalysisResult } from '../types.js';
+export interface AnalyzeOptions {
+    include?: string[];
+    exclude?: string[];
+    framework?: string;
+}
+export declare function analyze(sourcePath: string, options?: AnalyzeOptions): Promise<AnalysisResult>;

package/dist/analyzer/index.js

@@ -0,0 +1,95 @@
+import { readFile } from 'fs/promises';
+import { join, extname } from 'path';
+import { glob } from 'glob';
+import { extractComponents } from './extractors/component.js';
+import { extractFunctions } from './extractors/function.js';
+import { extractApiCalls } from './extractors/api-call.js';
+import { extractRoutes } from './extractors/route.js';
+import { detectFramework } from './framework.js';
+export async function analyze(sourcePath, options = {}) {
+    const framework = options.framework && options.framework !== 'auto'
+        ? options.framework
+        : await detectFramework(sourcePath);
+    const include = options.include || ['**/*.{ts,tsx,js,jsx,mjs,vue}'];
+    const exclude = options.exclude || ['node_modules/**', 'dist/**', 'build/**', '.next/**', '**/*.test.*', '**/*.spec.*'];
+    // 파일 수집
+    const files = await glob(include, {
+        cwd: sourcePath,
+        ignore: exclude,
+        absolute: false,
+    });
+    let components = [];
+    let functions = [];
+    let apiClients = [];
+    let routes = [];
+    // 각 파일 분석
+    for (const file of files) {
+        const fullPath = join(sourcePath, file);
+        const source = await readFile(fullPath, 'utf-8');
+        const ext = extname(file);
+        try {
+            const fileComponents = extractComponents(source, file, ext);
+            const fileFunctions = extractFunctions(source, file, ext);
+            const fileApiCalls = extractApiCalls(source, file, ext);
+            const fileRoutes = extractRoutes(source, file, ext);
+            components.push(...fileComponents);
+            functions.push(...fileFunctions);
+            apiClients.push(...fileApiCalls);
+            routes.push(...fileRoutes);
+        }
+        catch {
+            // 파싱 실패한 파일은 건너뜀
+        }
+    }
+    // 역참조 구축
+    buildReverseReferences(functions, components);
+    // 의존성 추출
+    const dependencies = await extractDependencies(sourcePath);
+    return {
+        sourcePath,
+        framework,
+        components,
+        routes,
+        functions,
+        apiClients,
+        dependencies,
+    };
+}
+function buildReverseReferences(functions, components) {
+    // calledBy
+    for (const func of functions) {
+        for (const callee of func.calls) {
+            const target = functions.find(f => f.name === callee);
+            if (target && !target.calledBy.includes(func.name)) {
+                target.calledBy.push(func.name);
+            }
+        }
+    }
+    // usedBy
+    for (const comp of components) {
+        for (const child of comp.children) {
+            const target = components.find(c => c.name === child);
+            if (target && !target.usedBy.includes(comp.name)) {
+                target.usedBy.push(comp.name);
+            }
+        }
+    }
+}
+async function extractDependencies(sourcePath) {
+    const deps = [];
+    const pkgPath = join(sourcePath, 'package.json');
+    try {
+        const content = JSON.parse(await readFile(pkgPath, 'utf-8'));
+        for (const [name, version] of Object.entries(content.dependencies || {})) {
+            deps.push({ name, currentVersion: version, depType: 'Production' });
+        }
+        for (const [name, version] of Object.entries(content.devDependencies || {})) {
+            deps.push({ name, currentVersion: version, depType: 'Development' });
+        }
+        for (const [name, version] of Object.entries(content.peerDependencies || {})) {
+            deps.push({ name, currentVersion: version, depType: 'Peer' });
+        }
+    }
+    catch { /* no package.json */ }
+    return deps;
+}

package/dist/analyzer/parsers/parse.d.ts

@@ -0,0 +1,5 @@
+import type { File } from '@babel/types';
+/** 소스코드를 AST로 파싱 (TS/TSX/JS/JSX 지원) */
+export declare function parseSource(source: string, ext: string): File;
+/** Vue SFC에서 <script> 블록 추출 후 파싱 */
+export declare function parseVue(source: string): File;

package/dist/analyzer/parsers/parse.js

@@ -0,0 +1,26 @@
+import { parse as babelParse } from '@babel/parser';
+/** 소스코드를 AST로 파싱 (TS/TSX/JS/JSX 지원) */
+export function parseSource(source, ext) {
+    const isTS = ext === '.ts' || ext === '.tsx';
+    const isJSX = ext === '.tsx' || ext === '.jsx';
+    return babelParse(source, {
+        sourceType: 'module',
+        plugins: [
+            ...(isTS ? ['typescript'] : []),
+            ...(isJSX || isTS ? ['jsx'] : []),
+            'decorators-legacy',
+            'classProperties',
+            'optionalChaining',
+            'nullishCoalescingOperator',
+            'dynamicImport',
+        ],
+        errorRecovery: true,
+    });
+}
+/** Vue SFC에서 <script> 블록 추출 후 파싱 */
+export function parseVue(source) {
+    const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+    const scriptContent = scriptMatch?.[1] || '';
+    const isTS = source.includes('lang="ts"') || source.includes("lang='ts'");
+    return parseSource(scriptContent, isTS ? '.ts' : '.js');
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { analyze } from '../analyzer/index.js';
+import { generateReport } from '../docgen/index.js';
+import { generateTests } from '../testgen/index.js';
+const program = new Command();
+program
+    .name('reverse-engine')
+    .version('0.1.0')
+    .description('웹 서비스 역분석 자동화 도구 - 소스코드 분석, 문서 생성, 테스트 자동화');
+// analyze
+program
+    .command('analyze <path>')
+    .description('소스코드 정적 분석')
+    .option('--framework <name>', '프레임워크 지정 (auto, react, vue, angular, next)', 'auto')
+    .option('--include <patterns>', '포함 패턴 (쉼표 구분)', 'src/**/*.{ts,tsx,js,jsx,vue}')
+    .option('--output <dir>', '출력 디렉토리', './output')
+    .action(async (sourcePath, opts) => {
+    console.log(chalk.green('▶'), '코드 분석 시작:', chalk.cyan(sourcePath));
+    const result = await analyze(sourcePath, {
+        framework: opts.framework,
+        include: opts.include.split(','),
+    });
+    console.log(chalk.green('✓'), '코드 분석 완료!');
+    console.log(`  프레임워크: ${result.framework}`);
+    console.log(`  컴포넌트: ${result.components.length}개`);
+    console.log(`  함수: ${result.functions.length}개`);
+    console.log(`  API: ${result.apiClients.length}개`);
+    console.log(`  라우트: ${result.routes.length}개`);
+    console.log(`  의존성: ${result.dependencies.length}개`);
+    await mkdir(opts.output, { recursive: true });
+    const outputPath = `${opts.output}/analysis.json`;
+    await writeFile(outputPath, JSON.stringify(result, null, 2));
+    console.log(`  결과 저장: ${chalk.cyan(outputPath)}`);
+});
+// report
+program
+    .command('report')
+    .description('분석 결과로 리포트 생성')
+    .requiredOption('--input <file>', '분석 결과 JSON 파일')
+    .option('--format <formats>', '출력 형식 (excel,mermaid)', 'excel,mermaid')
+    .option('--output <dir>', '출력 디렉토리', './output/reports')
+    .action(async (opts) => {
+    console.log(chalk.green('▶'), '리포트 생성 시작');
+    const data = JSON.parse(await readFile(opts.input, 'utf-8'));
+    const formats = opts.format.split(',');
+    const outputs = await generateReport(data, { formats, outputDir: opts.output });
+    console.log(chalk.green('✓'), '리포트 생성 완료!');
+    outputs.forEach(p => console.log(`  → ${chalk.cyan(p)}`));
+});
+// test
+program
+    .command('test')
+    .description('테스트 코드 자동 생성')
+    .requiredOption('--input <file>', '분석 결과 JSON 파일')
+    .option('--type <types>', '테스트 종류 (e2e,api)', 'e2e,api')
+    .option('--output <dir>', '출력 디렉토리', './output/tests')
+    .action(async (opts) => {
+    console.log(chalk.green('▶'), '테스트 코드 생성 시작');
+    const data = JSON.parse(await readFile(opts.input, 'utf-8'));
+    const types = opts.type.split(',');
+    const files = await generateTests(data, { types, outputDir: opts.output });
+    console.log(chalk.green('✓'), `테스트 코드 생성 완료! (${files.length}개 파일)`);
+    files.forEach(p => console.log(`  → ${chalk.cyan(p)}`));
+});
+// full
+program
+    .command('full')
+    .description('전체 파이프라인 (analyze → report → test)')
+    .requiredOption('--source <path>', '소스코드 경로')
+    .option('--output <dir>', '출력 디렉토리', './output')
+    .option('--framework <name>', '프레임워크', 'auto')
+    .action(async (opts) => {
+    console.log(chalk.green('\n◆'), 'ReversEngine 전체 파이프라인 시작\n');
+    // Step 1: 분석
+    console.log(chalk.gray('━'.repeat(50)));
+    const result = await analyze(opts.source, { framework: opts.framework });
+    console.log(chalk.green('✓'), `분석 완료: 컴포넌트 ${result.components.length}, 함수 ${result.functions.length}, API ${result.apiClients.length}, 라우트 ${result.routes.length}`);
+    await mkdir(opts.output, { recursive: true });
+    await writeFile(`${opts.output}/analysis.json`, JSON.stringify(result, null, 2));
+    // Step 2: 리포트
+    console.log(chalk.gray('━'.repeat(50)));
+    const reports = await generateReport(result, { outputDir: `${opts.output}/reports` });
+    console.log(chalk.green('✓'), '리포트 생성 완료!');
+    reports.forEach(p => console.log(`  → ${chalk.cyan(p)}`));
+    // Step 3: 테스트
+    console.log(chalk.gray('━'.repeat(50)));
+    const tests = await generateTests(result, { outputDir: `${opts.output}/tests` });
+    console.log(chalk.green('✓'), `테스트 생성 완료! (${tests.length}개)`);
+    tests.forEach(p => console.log(`  → ${chalk.cyan(p)}`));
+    console.log(chalk.green('\n✓'), '전체 파이프라인 완료!', chalk.cyan(opts.output), '\n');
+});
+program.parse();

package/dist/docgen/index.d.ts

@@ -0,0 +1,6 @@
+import type { AnalysisResult } from '../types.js';
+export interface ReportOptions {
+    formats?: ('excel' | 'mermaid')[];
+    outputDir?: string;
+}
+export declare function generateReport(data: AnalysisResult, options?: ReportOptions): Promise<string[]>;

package/dist/docgen/index.js

@@ -0,0 +1,105 @@
+import ExcelJS from 'exceljs';
+import { writeFile, mkdir } from 'fs/promises';
+export async function generateReport(data, options = {}) {
+    const formats = options.formats || ['excel', 'mermaid'];
+    const outputDir = options.outputDir || 'output/reports';
+    await mkdir(outputDir, { recursive: true });
+    const outputs = [];
+    if (formats.includes('excel')) {
+        outputs.push(await generateExcel(data, outputDir));
+    }
+    if (formats.includes('mermaid')) {
+        outputs.push(await generateMermaid(data, outputDir));
+    }
+    return outputs;
+}
+async function generateExcel(data, outDir) {
+    const wb = new ExcelJS.Workbook();
+    wb.creator = 'reverse-engine';
+    const hs = {
+        font: { bold: true, color: { argb: 'FFFFFFFF' }, size: 11 },
+        fill: { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FF2B579A' } },
+        alignment: { horizontal: 'center', vertical: 'middle' },
+    };
+    // 컴포넌트
+    const s1 = wb.addWorksheet('컴포넌트 목록');
+    s1.columns = [
+        { header: 'No', width: 6 }, { header: '컴포넌트명', width: 20 },
+        { header: '파일 경로', width: 35 }, { header: '타입', width: 12 },
+        { header: '하위 컴포넌트', width: 30 }, { header: '사용처', width: 20 },
+        { header: 'Hooks', width: 25 }, { header: 'API 호출', width: 30 },
+    ];
+    s1.getRow(1).eachCell(c => { c.style = hs; });
+    data.components.forEach((c, i) => s1.addRow([
+        i + 1, c.name, c.filePath, c.componentType,
+        c.children.join(', '), c.usedBy.join(', '),
+        c.hooks.join(', '), c.apiCalls.join(', '),
+    ]));
+    // API
+    const s2 = wb.addWorksheet('API 엔드포인트');
+    s2.columns = [
+        { header: 'No', width: 6 }, { header: 'Method', width: 10 },
+        { header: 'URL', width: 35 }, { header: '파일', width: 35 },
+        { header: '함수', width: 25 }, { header: '라인', width: 8 },
+    ];
+    s2.getRow(1).eachCell(c => { c.style = hs; });
+    data.apiClients.forEach((a, i) => s2.addRow([i + 1, a.method, a.urlPattern, a.filePath, a.functionName, a.line]));
+    // 라우트
+    const s3 = wb.addWorksheet('라우트');
+    s3.columns = [
+        { header: 'No', width: 6 }, { header: 'Path', width: 25 },
+        { header: 'Component', width: 25 }, { header: '파일', width: 35 },
+    ];
+    s3.getRow(1).eachCell(c => { c.style = hs; });
+    data.routes.forEach((r, i) => s3.addRow([i + 1, r.path, r.component, r.filePath]));
+    // 함수
+    const s4 = wb.addWorksheet('함수 호출 체인');
+    s4.columns = [
+        { header: 'No', width: 6 }, { header: '함수명', width: 25 },
+        { header: '파일', width: 35 }, { header: 'Async', width: 8 },
+        { header: 'Export', width: 8 }, { header: '호출하는 함수', width: 40 },
+        { header: '호출되는 곳', width: 25 },
+    ];
+    s4.getRow(1).eachCell(c => { c.style = hs; });
+    data.functions.forEach((f, i) => s4.addRow([
+        i + 1, f.name, f.filePath, f.isAsync ? 'Y' : 'N', f.isExported ? 'Y' : 'N',
+        f.calls.join(', '), f.calledBy.join(', '),
+    ]));
+    // 의존성
+    const s5 = wb.addWorksheet('의존성 패키지');
+    s5.columns = [
+        { header: 'No', width: 6 }, { header: '패키지명', width: 30 },
+        { header: '현재 버전', width: 15 }, { header: '타입', width: 15 },
+    ];
+    s5.getRow(1).eachCell(c => { c.style = hs; });
+    data.dependencies.forEach((d, i) => s5.addRow([i + 1, d.name, d.currentVersion, d.depType]));
+    const path = `${outDir}/reverseng-report.xlsx`;
+    await wb.xlsx.writeFile(path);
+    return path;
+}
+async function generateMermaid(data, outDir) {
+    const cm = {};
+    let mm = 'graph TD\n';
+    data.components.forEach((c, i) => {
+        cm[c.name] = `C${i}`;
+        mm += `    C${i}["${c.name}"]\n`;
+    });
+    data.components.forEach((c, i) => {
+        c.children.forEach(ch => { if (cm[ch])
+            mm += `    C${i} --> ${cm[ch]}\n`; });
+    });
+    data.routes.forEach((r, i) => {
+        if (cm[r.component])
+            mm += `    R${i}("${r.path}") -.-> ${cm[r.component]}\n`;
+    });
+    mm += '\n    classDef page fill:#e74c3c,color:#fff\n';
+    mm += '    classDef widget fill:#3498db,color:#fff\n';
+    mm += '    classDef layout fill:#2ecc71,color:#fff\n';
+    data.components.forEach((c, i) => {
+        const cls = c.componentType === 'Page' ? 'page' : c.componentType === 'Layout' ? 'layout' : 'widget';
+        mm += `    class C${i} ${cls}\n`;
+    });
+    const path = `${outDir}/component-graph.mmd`;
+    await writeFile(path, mm, 'utf-8');
+    return path;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { analyze } from './analyzer/index.js';
+export { generateReport } from './docgen/index.js';
+export { generateTests } from './testgen/index.js';
+export type * from './types.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { analyze } from './analyzer/index.js';
+export { generateReport } from './docgen/index.js';
+export { generateTests } from './testgen/index.js';

package/dist/testgen/index.d.ts

@@ -0,0 +1,6 @@
+import type { AnalysisResult } from '../types.js';
+export interface TestGenOptions {
+    types?: ('e2e' | 'api')[];
+    outputDir?: string;
+}
+export declare function generateTests(data: AnalysisResult, options?: TestGenOptions): Promise<string[]>;

package/dist/testgen/index.js

@@ -0,0 +1,80 @@
+import { writeFile, mkdir } from 'fs/promises';
+export async function generateTests(data, options = {}) {
+    const types = options.types || ['e2e', 'api'];
+    const outputDir = options.outputDir || 'output/tests';
+    const files = [];
+    if (types.includes('e2e'))
+        files.push(...await genE2E(data, outputDir));
+    if (types.includes('api'))
+        files.push(...await genAPI(data, outputDir));
+    return files;
+}
+async function genE2E(data, outDir) {
+    const files = [];
+    // 라우트 테스트
+    await mkdir(`${outDir}/e2e`, { recursive: true });
+    let code = `import { test, expect } from '@playwright/test';\n\n`;
+    for (const r of data.routes) {
+        code += `test.describe('${r.path} (${r.component})', () => {\n`;
+        code += `  test('페이지 로드', async ({ page }) => {\n`;
+        code += `    const response = await page.goto('${r.path}');\n`;
+        code += `    expect(response?.status()).toBeLessThan(400);\n`;
+        code += `  });\n});\n\n`;
+    }
+    const p1 = `${outDir}/e2e/routes.spec.ts`;
+    await writeFile(p1, code);
+    files.push(p1);
+    // 페이지 컴포넌트 테스트
+    await mkdir(`${outDir}/components`, { recursive: true });
+    for (const c of data.components.filter(c => c.componentType === 'Page')) {
+        const route = data.routes.find(r => r.component === c.name);
+        const url = route?.path || '/';
+        let t = `import { test, expect } from '@playwright/test';\n\n`;
+        t += `test.describe('${c.name}', () => {\n`;
+        t += `  test('렌더링 확인', async ({ page }) => {\n`;
+        t += `    await page.goto('${url}');\n`;
+        for (const ch of c.children)
+            t += `    // ${ch} 컴포넌트 확인\n`;
+        t += `  });\n`;
+        for (const api of c.apiCalls) {
+            t += `\n  test('API: ${api}', async ({ page }) => {\n`;
+            t += `    await page.goto('${url}');\n`;
+            t += `    // TODO: ${api} 검증\n`;
+            t += `  });\n`;
+        }
+        t += `});\n`;
+        const p = `${outDir}/components/${c.name}.spec.ts`;
+        await writeFile(p, t);
+        files.push(p);
+    }
+    return files;
+}
+async function genAPI(data, outDir) {
+    await mkdir(`${outDir}/api`, { recursive: true });
+    let code = `import { test, expect } from '@playwright/test';\n\n`;
+    code += `test.describe('API 엔드포인트', () => {\n`;
+    for (const a of data.apiClients) {
+        code += `  test('${a.method} ${a.urlPattern}', async ({ request }) => {\n`;
+        switch (a.method) {
+            case 'GET':
+                code += `    const response = await request.get('${a.urlPattern}');\n`;
+                break;
+            case 'POST':
+                code += `    const response = await request.post('${a.urlPattern}', { data: {} });\n`;
+                break;
+            case 'PUT':
+                code += `    const response = await request.put('${a.urlPattern}', { data: {} });\n`;
+                break;
+            case 'DELETE':
+                code += `    const response = await request.delete('${a.urlPattern}');\n`;
+                break;
+            default: code += `    const response = await request.fetch('${a.urlPattern}', { method: '${a.method}' });\n`;
+        }
+        code += `    expect(response.status()).toBeLessThan(500);\n`;
+        code += `  });\n\n`;
+    }
+    code += `});\n`;
+    const p = `${outDir}/api/endpoints.spec.ts`;
+    await writeFile(p, code);
+    return [p];
+}

package/dist/types.d.ts

@@ -0,0 +1,102 @@
+/** 분석 결과 전체 */
+export interface AnalysisResult {
+    sourcePath: string;
+    framework: string;
+    components: ComponentInfo[];
+    routes: RouteInfo[];
+    functions: FunctionInfo[];
+    apiClients: ApiClientCall[];
+    dependencies: DependencyInfo[];
+}
+export interface ComponentInfo {
+    name: string;
+    filePath: string;
+    lineStart: number;
+    lineEnd: number;
+    componentType: 'Page' | 'Layout' | 'Widget' | 'Utility';
+    props: PropInfo[];
+    children: string[];
+    usedBy: string[];
+    hooks: string[];
+    apiCalls: string[];
+}
+export interface PropInfo {
+    name: string;
+    type: string;
+    required: boolean;
+    defaultValue?: string;
+}
+export interface RouteInfo {
+    path: string;
+    component: string;
+    filePath: string;
+    guards: string[];
+    meta?: Record<string, unknown>;
+}
+export interface FunctionInfo {
+    name: string;
+    filePath: string;
+    lineStart: number;
+    lineEnd: number;
+    params: string[];
+    returnType?: string;
+    calls: string[];
+    calledBy: string[];
+    isAsync: boolean;
+    isExported: boolean;
+}
+export interface ApiClientCall {
+    method: string;
+    urlPattern: string;
+    filePath: string;
+    line: number;
+    functionName: string;
+}
+export interface DependencyInfo {
+    name: string;
+    currentVersion: string;
+    latestVersion?: string;
+    depType: 'Production' | 'Development' | 'Peer';
+    license?: string;
+}
+/** 크롤링 결과 */
+export interface CrawlResult {
+    targetUrl: string;
+    pages: PageInfo[];
+    timestamp: string;
+}
+export interface PageInfo {
+    url: string;
+    title: string;
+    screenshotPath: string | null;
+    elements: {
+        links: {
+            text: string;
+            href: string;
+            selector: string;
+        }[];
+        buttons: {
+            text: string;
+            selector: string;
+            navigatesTo: string | null;
+        }[];
+        forms: {
+            id: string | null;
+            action: string | null;
+            method: string;
+            fields: {
+                name: string;
+                fieldType: string;
+                required: boolean;
+            }[];
+        }[];
+    };
+    apiCalls: {
+        method: string;
+        url: string;
+        responseStatus: number;
+        triggeredBy: string | null;
+    }[];
+    navigatesTo: string[];
+    authRequired: boolean;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "reverse-engine",
+  "version": "0.1.0",
+  "description": "웹 서비스 역분석 자동화 도구 - 소스코드 분석, 문서 생성, 테스트 자동화",
+  "keywords": [
+    "reverse-engineering",
+    "code-analysis",
+    "documentation",
+    "test-generation",
+    "crawler",
+    "static-analysis",
+    "ast",
+    "react",
+    "vue",
+    "angular",
+    "excel"
+  ],
+  "author": "injaehwang",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/injaehwang/revers-eng"
+  },
+  "type": "module",
+  "bin": {
+    "reverse-engine": "dist/cli/index.js",
+    "reverseng": "dist/cli/index.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli/index.ts",
+    "prepublishOnly": "npm run build",
+    "test": "node --test dist/**/*.test.js"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.26.0",
+    "@babel/traverse": "^7.26.0",
+    "@babel/types": "^7.26.0",
+    "commander": "^13.0.0",
+    "exceljs": "^4.4.0",
+    "chalk": "^5.4.0",
+    "ora": "^8.2.0",
+    "playwright": "^1.49.0",
+    "glob": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/babel__traverse": "^7.20.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "tsx": "^4.19.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}