readme-gen-analyzer 1.0.0

package/dist/analyzers/feature.detector.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureDetector = void 0;
+class FeatureDetector {
+    static FEATURE_MAP = {
+        'express': 'REST API Framework',
+        'fastify': 'High-performance REST API',
+        'react': 'Frontend Development',
+        'next': 'Server-side Rendering',
+        'mongoose': 'MongoDB Database Support',
+        'prisma': 'Modern Database ORM',
+        'jest': 'Automated Unit Testing',
+        'cypress': 'End-to-End Testing',
+        'docker': 'Containerization Support',
+        'passport': 'Authentication & Authorization',
+        'jsonwebtoken': 'JWT Auth Tokens',
+        'axios': 'External API Integration',
+        'dotenv': 'Environment Configuration',
+        'typescript': 'Static Type Safety',
+        'turbo': 'Monorepo Pipeline Management',
+        'stripe': 'Payment Processing',
+        'redis': 'Cache & Session Management',
+        'socket.io': 'Real-time Communication',
+        'nest': 'Enterprise-grade Architecture',
+        'fastapi': 'High-performance Python API',
+        'flask': 'Lightweight Python Web Services',
+        'django': 'Full-stack Python Framework',
+        'starlette': 'ASGI Python framework',
+        'uvicorn': 'ASGI server',
+        'gunicorn': 'WSGI HTTP server',
+        'celery': 'Distributed task queue',
+        'sqlalchemy': 'SQL toolkit / ORM',
+        'pydantic': 'Data validation',
+        'httpx': 'HTTP client',
+        'requests': 'HTTP client',
+        'boto3': 'AWS SDK',
+        'pytest': 'Python testing',
+        'ruff': 'Python linter/formatter',
+        'black': 'Python formatter',
+        'gin-gonic/gin': 'Gin HTTP framework',
+        'labstack/echo': 'Echo web framework',
+        'gofiber/fiber': 'Fiber web framework',
+        'go-chi/chi': 'chi router',
+        'gorilla/mux': 'Gorilla mux router',
+        'google.golang.org/grpc': 'gRPC',
+        'grpc-go': 'gRPC Go',
+        'spf13/cobra': 'Cobra CLI',
+        'gorm.io/gorm': 'GORM ORM',
+        'testify': 'Go assertions/mocks',
+    };
+    static detect(dependencies, devDependencies, hasDocker, hasRoutes) {
+        const features = new Set();
+        const allDeps = [...dependencies, ...devDependencies].map(d => d.toLowerCase());
+        for (const [dep, feature] of Object.entries(this.FEATURE_MAP)) {
+            if (allDeps.some(d => d.includes(dep))) {
+                features.add(feature);
+            }
+        }
+        if (hasDocker)
+            features.add('Docker Container Environments');
+        if (hasRoutes)
+            features.add('API Endpoint Management');
+        if (dependencies.length > 0)
+            features.add('Dependency-driven development');
+        return Array.from(features);
+    }
+}
+exports.FeatureDetector = FeatureDetector;

package/dist/analyzers/package.parser.d.ts

@@ -0,0 +1,28 @@
+export interface PackageMetadata {
+    name: string;
+    version: string;
+    description: string;
+    scripts: Record<string, string>;
+    dependencies: {
+        production: string[];
+        development: string[];
+        peer: string[];
+    };
+    frameworks: string[];
+    packageManager: string;
+}
+export declare class PackageParser {
+    static parse(files: Record<string, string>): Promise<PackageMetadata | null>;
+    private static parseMultipleNode;
+    private static detectFramework;
+    private static parsePython;
+    private static detectPythonPm;
+    private static parseRequirementsTxt;
+    /** pip / requirements.txt line → distribution name */
+    private static parseRequirementLine;
+    private static parsePyProjectToml;
+    private static detectPythonFrameworks;
+    private static parseGo;
+    private static parseGoRequireBlock;
+    private static detectGoFrameworks;
+}

package/dist/analyzers/package.parser.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageParser = void 0;
+class PackageParser {
+    static async parse(files) {
+        const packageFiles = Object.keys(files).filter(f => f.endsWith('package.json'));
+        if (packageFiles.length > 0) {
+            return this.parseMultipleNode(packageFiles, files);
+        }
+        const req = files['requirements.txt'] || '';
+        const pyproject = files['pyproject.toml'] || '';
+        if (req || pyproject) {
+            return this.parsePython(req, pyproject);
+        }
+        if (files['go.mod']) {
+            return this.parseGo(files['go.mod']);
+        }
+        return null;
+    }
+    static parseMultipleNode(packagePaths, allFiles) {
+        const mergedScripts = {};
+        const mergedDeps = new Set();
+        const mergedDevDeps = new Set();
+        const mergedPeerDeps = new Set();
+        const mergedFrameworks = new Set();
+        let primaryName = '';
+        let primaryDescription = '';
+        let primaryVersion = '0.0.0';
+        // Sort paths by depth (shallowest first) to pick primary metadata from root
+        const sortedPaths = [...packagePaths].sort((a, b) => a.split('/').length - b.split('/').length);
+        sortedPaths.forEach((path, index) => {
+            try {
+                const pkg = JSON.parse(allFiles[path]);
+                // Normalize path for splitting
+                const normalizedPath = path.replace(/\\/g, '/');
+                const parts = normalizedPath.split('/');
+                // If it's a nested package (e.g., apps/api/package.json), prefix with the directory path
+                let prefix = '';
+                if (parts.length > 1) {
+                    const dirParts = parts.slice(0, -1);
+                    prefix = dirParts.join('/') + ':';
+                }
+                // If no primary metadata yet, or if current one is more descriptive, pick it
+                if (!primaryName || (index === 0 && pkg.name)) {
+                    primaryName = pkg.name || primaryName;
+                    primaryDescription = pkg.description || primaryDescription;
+                    primaryVersion = pkg.version || primaryVersion;
+                }
+                // Merge scripts with prefix if not root
+                if (pkg.scripts) {
+                    Object.entries(pkg.scripts).forEach(([name, cmd]) => {
+                        const key = prefix ? `${prefix}${name}` : name;
+                        mergedScripts[key] = cmd;
+                    });
+                }
+                // Merge dependencies
+                if (pkg.dependencies) {
+                    Object.keys(pkg.dependencies).forEach(d => {
+                        mergedDeps.add(d);
+                        this.detectFramework(d, mergedFrameworks);
+                    });
+                }
+                if (pkg.devDependencies) {
+                    Object.keys(pkg.devDependencies).forEach(d => mergedDevDeps.add(d));
+                }
+                if (pkg.peerDependencies) {
+                    Object.keys(pkg.peerDependencies).forEach(d => mergedPeerDeps.add(d));
+                }
+            }
+            catch (e) {
+                console.warn(`Failed to parse ${path}:`, e);
+            }
+        });
+        let packageManager = 'npm';
+        if (Object.keys(allFiles).some(f => f.includes('pnpm-lock.yaml')))
+            packageManager = 'pnpm';
+        else if (Object.keys(allFiles).some(f => f.includes('yarn.lock')))
+            packageManager = 'yarn';
+        else if (Object.keys(allFiles).some(f => f.endsWith('bun.lockb')))
+            packageManager = 'bun';
+        return {
+            name: primaryName || 'Unknown Node Project',
+            version: primaryVersion,
+            description: primaryDescription,
+            scripts: mergedScripts,
+            dependencies: {
+                production: Array.from(mergedDeps),
+                development: Array.from(mergedDevDeps),
+                peer: Array.from(mergedPeerDeps),
+            },
+            frameworks: Array.from(mergedFrameworks),
+            packageManager,
+        };
+    }
+    static detectFramework(dep, frameworks) {
+        const frameworkMap = {
+            'express': 'Express',
+            'react': 'React',
+            'next': 'Next.js',
+            'vue': 'Vue',
+            '@nestjs/core': 'NestJS',
+            'koa': 'Koa',
+            'fastify': 'Fastify',
+            'socket.io': 'Socket.io',
+            'mongoose': 'Mongoose',
+            'prisma': 'Prisma',
+            'tailwindcss': 'TailwindCSS',
+            'vite': 'Vite'
+        };
+        if (frameworkMap[dep])
+            frameworks.add(frameworkMap[dep]);
+    }
+    static parsePython(reqs, pyproject) {
+        const py = pyproject ? this.parsePyProjectToml(pyproject) : null;
+        const reqDeps = this.parseRequirementsTxt(reqs);
+        const prod = Array.from(new Set([...(py?.deps || []), ...reqDeps]));
+        const dev = py?.devDeps || [];
+        const frameworks = this.detectPythonFrameworks(prod, dev, pyproject + reqs);
+        const scripts = { ...py?.scripts };
+        if (frameworks.includes('Django') && !scripts['manage']) {
+            scripts['manage'] = 'python manage.py <command>';
+        }
+        const packageManager = this.detectPythonPm(pyproject);
+        return {
+            name: py?.name || 'Python Project',
+            version: py?.version || '1.0.0',
+            description: py?.description || '',
+            scripts,
+            dependencies: {
+                production: prod,
+                development: dev,
+                peer: [],
+            },
+            frameworks,
+            packageManager,
+        };
+    }
+    static detectPythonPm(pyproject) {
+        if (!pyproject)
+            return 'pip';
+        if (/\[tool\.poetry\]/i.test(pyproject))
+            return 'poetry';
+        if (/\[tool\.uv\]/i.test(pyproject) || /uv\.lock/i.test(pyproject))
+            return 'uv';
+        if (/\[tool\.pdm\]/i.test(pyproject))
+            return 'pdm';
+        if (/\[tool\.hatch\]/i.test(pyproject))
+            return 'hatch';
+        return 'pip';
+    }
+    static parseRequirementsTxt(content) {
+        const names = [];
+        for (const line of content.split('\n')) {
+            const name = this.parseRequirementLine(line);
+            if (name)
+                names.push(name);
+        }
+        return names;
+    }
+    /** pip / requirements.txt line → distribution name */
+    static parseRequirementLine(line) {
+        const t = line.trim();
+        if (!t || t.startsWith('#') || t.startsWith('-'))
+            return null;
+        const head = t.split(/[;#]/)[0].trim();
+        if (!head)
+            return null;
+        const noVersion = head.split(/\s*[<>=~!]/)[0].trim();
+        const noExtra = noVersion.split(/[\[]/)[0].trim();
+        const name = noExtra.split(/[@\s]/)[0].trim();
+        if (!name || !/^[a-zA-Z0-9._-]+$/.test(name))
+            return null;
+        return name;
+    }
+    static parsePyProjectToml(content) {
+        const deps = [];
+        const devDeps = [];
+        const scripts = {};
+        let name;
+        let version;
+        let description;
+        let section = '';
+        const lines = content.split('\n');
+        for (const raw of lines) {
+            const line = raw.split('#')[0].trim();
+            const sec = line.match(/^\[([^\]]+)\]/);
+            if (sec) {
+                section = sec[1].toLowerCase();
+                continue;
+            }
+            if (section === 'project') {
+                const nm = line.match(/^name\s*=\s*["']([^"']+)["']/i);
+                const ver = line.match(/^version\s*=\s*["']([^"']+)["']/i);
+                const desc = line.match(/^description\s*=\s*["']([^"']*)["']/i);
+                if (nm)
+                    name = nm[1];
+                if (ver)
+                    version = ver[1];
+                if (desc)
+                    description = desc[1];
+            }
+            if (section === 'tool.poetry.dependencies' ||
+                section === 'tool.poetry.group.dev.dependencies') {
+                const depKey = line.match(/^([a-zA-Z0-9_.-]+)\s*=/);
+                if (depKey && depKey[1].toLowerCase() !== 'python') {
+                    if (section.includes('dev'))
+                        devDeps.push(depKey[1]);
+                    else
+                        deps.push(depKey[1]);
+                }
+            }
+            if (section === 'tool.poetry.scripts') {
+                const sc = line.match(/^([a-zA-Z0-9_.-]+)\s*=\s*["']([^"']+)["']/);
+                if (sc)
+                    scripts[sc[1]] = sc[2];
+            }
+        }
+        return { name, version, description, deps, devDeps, scripts };
+    }
+    static detectPythonFrameworks(prod, dev, raw) {
+        const all = [...prod, ...dev].map((d) => d.toLowerCase());
+        const text = raw.toLowerCase();
+        const frameworks = [];
+        const add = (f) => {
+            if (!frameworks.includes(f))
+                frameworks.push(f);
+        };
+        const has = (s) => all.some((d) => d.includes(s)) || text.includes(s);
+        if (has('fastapi'))
+            add('FastAPI');
+        if (has('flask'))
+            add('Flask');
+        if (has('django'))
+            add('Django');
+        if (has('starlette'))
+            add('Starlette');
+        if (has('tornado'))
+            add('Tornado');
+        if (has('sanic'))
+            add('Sanic');
+        if (has('litestar'))
+            add('Litestar');
+        if (has('sqlalchemy'))
+            add('SQLAlchemy');
+        if (has('pydantic'))
+            add('Pydantic');
+        if (has('celery'))
+            add('Celery');
+        if (has('pytest'))
+            add('pytest');
+        return frameworks;
+    }
+    static parseGo(content) {
+        const lines = content.split('\n');
+        const moduleLine = lines.find((l) => l.trim().startsWith('module '));
+        const name = moduleLine
+            ? moduleLine.replace(/^\s*module\s+/, '').trim().split(/\s+/)[0]
+            : 'Go Project';
+        const modules = this.parseGoRequireBlock(content);
+        const frameworks = this.detectGoFrameworks(modules);
+        const scripts = {
+            build: 'go build ./...',
+            test: 'go test ./...',
+            vet: 'go vet ./...',
+            mod: 'go mod tidy',
+        };
+        return {
+            name,
+            version: '1.0.0',
+            description: '',
+            scripts,
+            dependencies: {
+                production: modules,
+                development: [],
+                peer: [],
+            },
+            frameworks,
+            packageManager: 'go mod',
+        };
+    }
+    static parseGoRequireBlock(content) {
+        const mods = [];
+        const lines = content.split('\n');
+        let inBlock = false;
+        for (const raw of lines) {
+            const line = raw.trim();
+            if (line.startsWith('require (')) {
+                inBlock = true;
+                continue;
+            }
+            if (inBlock && line === ')') {
+                inBlock = false;
+                continue;
+            }
+            if (inBlock && line && !line.startsWith('//') && !line.startsWith('replace ')) {
+                const modPath = line.split(/\s+/)[0];
+                if (modPath)
+                    mods.push(modPath);
+                continue;
+            }
+            if (line.startsWith('require ') && !line.includes('(')) {
+                const rest = line.replace(/^require\s+/, '').trim();
+                const modPath = rest.split(/\s+/)[0];
+                if (modPath && !modPath.startsWith('//'))
+                    mods.push(modPath);
+            }
+        }
+        return Array.from(new Set(mods));
+    }
+    static detectGoFrameworks(modules) {
+        const frameworks = [];
+        const add = (f) => {
+            if (!frameworks.includes(f))
+                frameworks.push(f);
+        };
+        const s = modules.join(' ').toLowerCase();
+        const pairs = [
+            ['gin-gonic/gin', 'Gin'],
+            ['labstack/echo', 'Echo'],
+            ['gofiber/fiber', 'Fiber'],
+            ['go-chi/chi', 'chi'],
+            ['gorilla/mux', 'Gorilla mux'],
+            ['google.golang.org/grpc', 'gRPC'],
+            ['grpc-go', 'gRPC'],
+            ['grpc/grpc-go', 'gRPC'],
+            ['spf13/cobra', 'Cobra'],
+            ['spf13/viper', 'Viper'],
+            ['stretchr/testify', 'testify'],
+            ['jackc/pgx', 'pgx'],
+            ['go-redis/redis', 'Redis'],
+            ['gorm.io/gorm', 'GORM'],
+            ['entgo.io/ent', 'Ent'],
+        ];
+        for (const [needle, label] of pairs) {
+            if (s.includes(needle))
+                add(label);
+        }
+        return frameworks;
+    }
+}
+exports.PackageParser = PackageParser;

package/dist/analyzers/polyglot.extractors.d.ts

@@ -0,0 +1,18 @@
+/** Same shape as RouteExtractor Route */
+export interface PolyglotRoute {
+    method: string;
+    path: string;
+    file: string;
+    snippet?: string;
+}
+/** Routes & API surface for Python (FastAPI, Flask, Starlette-style) and Go (net/http, gin, echo, chi, mux, fiber). */
+export declare class PolyglotExtractors {
+    static extractRoutes(files: Record<string, string>): PolyglotRoute[];
+    static extractDefinitions(files: Record<string, string>): Record<string, string[]>;
+    private static pythonRoutes;
+    private static flaskMethodsNear;
+    private static goRoutes;
+    private static pythonDefinitions;
+    private static goDefinitions;
+    private static snip;
+}

package/dist/analyzers/polyglot.extractors.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolyglotExtractors = void 0;
+/** Routes & API surface for Python (FastAPI, Flask, Starlette-style) and Go (net/http, gin, echo, chi, mux, fiber). */
+class PolyglotExtractors {
+    static extractRoutes(files) {
+        const routes = [];
+        for (const [filePath, content] of Object.entries(files)) {
+            if (filePath.endsWith(".py")) {
+                routes.push(...this.pythonRoutes(filePath, content));
+            }
+            else if (filePath.endsWith(".go")) {
+                routes.push(...this.goRoutes(filePath, content));
+            }
+        }
+        return routes;
+    }
+    static extractDefinitions(files) {
+        const result = {};
+        for (const [filePath, content] of Object.entries(files)) {
+            if (filePath.endsWith(".py")) {
+                const defs = this.pythonDefinitions(content);
+                if (defs.length)
+                    result[filePath] = defs;
+            }
+            else if (filePath.endsWith(".go")) {
+                const defs = this.goDefinitions(content);
+                if (defs.length)
+                    result[filePath] = defs;
+            }
+        }
+        return result;
+    }
+    static pythonRoutes(file, content) {
+        const out = [];
+        const lines = content.split("\n");
+        // FastAPI / Starlette: @app.get("/path") @router.post(  APIRouter
+        const decRe = /@(?:app|router|api|route)\.(get|post|put|delete|patch|options|head)\s*\(\s*["'`]([^"'`]+)["'`]/gi;
+        let m;
+        while ((m = decRe.exec(content)) !== null) {
+            out.push({
+                method: m[1].toUpperCase(),
+                path: m[2],
+                file,
+                snippet: this.snip(lines, m.index),
+            });
+        }
+        // Flask: @app.route("/x", methods=['GET','POST'])
+        const flaskRe = /@\w+\.route\s*\(\s*["'`]([^"'`]+)["'`]/gi;
+        while ((m = flaskRe.exec(content)) !== null) {
+            const methods = this.flaskMethodsNear(content, m.index);
+            for (const method of methods) {
+                out.push({
+                    method,
+                    path: m[1],
+                    file,
+                    snippet: this.snip(lines, m.index),
+                });
+            }
+        }
+        // Django path() re_path()
+        const djangoPath = /(?:path|re_path)\s*\(\s*["']([^"']+)["']\s*,/g;
+        while ((m = djangoPath.exec(content)) !== null) {
+            out.push({
+                method: "GET",
+                path: m[1],
+                file,
+                snippet: this.snip(lines, m.index),
+            });
+        }
+        return out.slice(0, 200);
+    }
+    static flaskMethodsNear(content, idx) {
+        const slice = content.slice(idx, idx + 400);
+        const mm = slice.match(/methods\s*=\s*\[([^\]]+)\]/i);
+        if (!mm)
+            return ["GET"];
+        const raw = mm[1];
+        const methods = [];
+        const part = raw.matchAll(/['"](GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD)['"]/gi);
+        for (const x of part)
+            methods.push(x[1].toUpperCase());
+        return methods.length ? methods : ["GET"];
+    }
+    static goRoutes(file, content) {
+        const out = [];
+        const lines = content.split("\n");
+        // gin/echo/fiber/chi style: .Get("/path" .POST("/path"
+        const methodPath = /\.(Get|Post|Put|Delete|Patch|Options|Head|Connect|Trace)\s*\(\s*["']([^"']+)["']/gi;
+        let m;
+        while ((m = methodPath.exec(content)) !== null) {
+            out.push({
+                method: m[1].toUpperCase(),
+                path: m[2],
+                file,
+                snippet: this.snip(lines, m.index),
+            });
+        }
+        // stdlib
+        const handleFunc = /HandleFunc\s*\(\s*["']([^"']+)["']/gi;
+        while ((m = handleFunc.exec(content)) !== null) {
+            out.push({
+                method: "GET",
+                path: m[1],
+                file,
+                snippet: this.snip(lines, m.index),
+            });
+        }
+        return out.slice(0, 200);
+    }
+    static pythonDefinitions(content) {
+        const defs = [];
+        const lines = content.split("\n");
+        for (const line of lines) {
+            const t = line.trim();
+            if (/^class\s+[A-Za-z_][\w]*/.test(t)) {
+                defs.push(`Class: ${t.slice(0, 200)}`);
+                continue;
+            }
+            if (/^(async\s+)?def\s+[A-Za-z_][\w]*\s*\(/.test(t)) {
+                defs.push(`Function: ${t.slice(0, 200)}`);
+            }
+        }
+        return defs.slice(0, 80);
+    }
+    static goDefinitions(content) {
+        const defs = [];
+        const funcRe = /^func\s+.+$/gm;
+        let m;
+        while ((m = funcRe.exec(content)) !== null) {
+            const line = m[0].trim();
+            if (line.length > 8)
+                defs.push(`Func: ${line.slice(0, 220)}`);
+        }
+        const typeRe = /^type\s+\w+\s+(struct|interface)\b.*/gm;
+        while ((m = typeRe.exec(content)) !== null) {
+            defs.push(`Type: ${m[0].trim().slice(0, 200)}`);
+        }
+        return defs.slice(0, 80);
+    }
+    static snip(lines, charIndex) {
+        let pos = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const next = pos + lines[i].length + 1;
+            if (charIndex < next) {
+                return lines[i].trim().slice(0, 200);
+            }
+            pos = next;
+        }
+        return undefined;
+    }
+}
+exports.PolyglotExtractors = PolyglotExtractors;

package/dist/analyzers/route.extractor.d.ts

@@ -0,0 +1,10 @@
+export interface Route {
+    method: string;
+    path: string;
+    file: string;
+    snippet?: string;
+}
+export declare class RouteExtractor {
+    private static METHODS;
+    static extract(files: Record<string, string>): Route[];
+}

package/dist/analyzers/route.extractor.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteExtractor = void 0;
+const ts_morph_1 = require("ts-morph");
+const polyglot_extractors_1 = require("./polyglot.extractors");
+class RouteExtractor {
+    static METHODS = ['get', 'post', 'put', 'delete', 'patch', 'use'];
+    static extract(files) {
+        const project = new ts_morph_1.Project({ useInMemoryFileSystem: true });
+        const routes = [];
+        for (const [filePath, content] of Object.entries(files)) {
+            if (!filePath.endsWith('.ts') && !filePath.endsWith('.js') && !filePath.endsWith('.tsx') && !filePath.endsWith('.jsx')) {
+                continue;
+            }
+            const sourceFile = project.createSourceFile(filePath, content);
+            // Look for call expressions like app.get('/', ...) or router.post('/', ...)
+            const callExpressions = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
+            for (const call of callExpressions) {
+                const expression = call.getExpression();
+                if (expression.getKind() === ts_morph_1.SyntaxKind.PropertyAccessExpression) {
+                    const pae = expression;
+                    const methodName = pae.getName().toLowerCase();
+                    if (this.METHODS.includes(methodName)) {
+                        const args = call.getArguments();
+                        if (args.length > 0 && args[0].getKind() === ts_morph_1.SyntaxKind.StringLiteral) {
+                            const routePath = args[0].getText().replace(/['"]/g, '');
+                            routes.push({
+                                method: methodName.toUpperCase(),
+                                path: routePath,
+                                file: filePath,
+                                snippet: call.getText().substring(0, 200) // snippet limited to 200 chars
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return [...routes, ...polyglot_extractors_1.PolyglotExtractors.extractRoutes(files)];
+    }
+}
+exports.RouteExtractor = RouteExtractor;

package/dist/analyzers/schema.analyzer.d.ts

@@ -0,0 +1,3 @@
+export declare class SchemaAnalyzer {
+    static analyze(files: Record<string, string>): any[] | undefined;
+}