@parseme/cli 0.0.2

package/dist/analyzers/framework-detector.js

@@ -0,0 +1,180 @@
+export class FrameworkDetector {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async detect(projectInfo) {
+        const deps = { ...projectInfo.dependencies, ...projectInfo.devDependencies };
+        // Check for frameworks in dependencies
+        if (deps['@nestjs/core'] || deps['@nestjs/common']) {
+            return this.detectNestJS(deps);
+        }
+        if (deps['fastify']) {
+            return this.detectFastify(deps);
+        }
+        if (deps['express']) {
+            return this.detectExpress(deps);
+        }
+        if (deps['koa']) {
+            return this.detectKoa(deps);
+        }
+        if (deps['@hapi/hapi']) {
+            return this.detectHapi(deps);
+        }
+        return {
+            name: 'unknown',
+            features: [],
+        };
+    }
+    detectExpress(deps) {
+        const features = [];
+        // Detect common Express features
+        if (deps['express-session']) {
+            features.push('sessions');
+        }
+        if (deps['passport']) {
+            features.push('authentication');
+        }
+        if (deps['express-rate-limit']) {
+            features.push('rate-limiting');
+        }
+        if (deps['helmet']) {
+            features.push('security');
+        }
+        if (deps['cors']) {
+            features.push('cors');
+        }
+        if (deps['body-parser']) {
+            features.push('body-parsing');
+        }
+        if (deps['express-validator']) {
+            features.push('validation');
+        }
+        if (deps['multer']) {
+            features.push('file-upload');
+        }
+        if (deps['express-static']) {
+            features.push('static-files');
+        }
+        return {
+            name: 'express',
+            version: deps['express'],
+            features,
+        };
+    }
+    detectFastify(deps) {
+        const features = [];
+        if (deps['@fastify/cors']) {
+            features.push('cors');
+        }
+        if (deps['@fastify/helmet']) {
+            features.push('security');
+        }
+        if (deps['@fastify/rate-limit']) {
+            features.push('rate-limiting');
+        }
+        if (deps['@fastify/multipart']) {
+            features.push('file-upload');
+        }
+        if (deps['@fastify/static']) {
+            features.push('static-files');
+        }
+        if (deps['@fastify/jwt']) {
+            features.push('jwt');
+        }
+        if (deps['@fastify/session']) {
+            features.push('sessions');
+        }
+        return {
+            name: 'fastify',
+            version: deps['fastify'],
+            features,
+        };
+    }
+    detectNestJS(deps) {
+        const features = [];
+        if (deps['@nestjs/typeorm'] || deps['@nestjs/mongoose']) {
+            features.push('orm');
+        }
+        if (deps['@nestjs/passport']) {
+            features.push('authentication');
+        }
+        if (deps['@nestjs/jwt']) {
+            features.push('jwt');
+        }
+        if (deps['@nestjs/swagger']) {
+            features.push('swagger');
+        }
+        if (deps['@nestjs/graphql']) {
+            features.push('graphql');
+        }
+        if (deps['@nestjs/websockets']) {
+            features.push('websockets');
+        }
+        if (deps['@nestjs/microservices']) {
+            features.push('microservices');
+        }
+        if (deps['@nestjs/testing']) {
+            features.push('testing');
+        }
+        // NestJS uses decorators by default
+        features.push('decorators', 'dependency-injection', 'modules');
+        return {
+            name: 'nestjs',
+            version: deps['@nestjs/core'],
+            features,
+        };
+    }
+    detectKoa(deps) {
+        const features = [];
+        if (deps['@koa/cors']) {
+            features.push('cors');
+        }
+        if (deps['koa-helmet']) {
+            features.push('security');
+        }
+        if (deps['koa-ratelimit']) {
+            features.push('rate-limiting');
+        }
+        if (deps['koa-multer']) {
+            features.push('file-upload');
+        }
+        if (deps['koa-static']) {
+            features.push('static-files');
+        }
+        if (deps['koa-session']) {
+            features.push('sessions');
+        }
+        if (deps['koa-bodyparser']) {
+            features.push('body-parsing');
+        }
+        return {
+            name: 'koa',
+            version: deps['koa'],
+            features,
+        };
+    }
+    detectHapi(deps) {
+        const features = [];
+        if (deps['@hapi/cookie']) {
+            features.push('sessions');
+        }
+        if (deps['@hapi/jwt']) {
+            features.push('jwt');
+        }
+        if (deps['@hapi/inert']) {
+            features.push('static-files');
+        }
+        if (deps['@hapi/vision']) {
+            features.push('templates');
+        }
+        if (deps['@hapi/boom']) {
+            features.push('error-handling');
+        }
+        return {
+            name: 'hapi',
+            version: deps['@hapi/hapi'],
+            features,
+        };
+    }
+}

package/dist/analyzers/git-analyzer.d.ts

@@ -0,0 +1,13 @@
+import type { ParsemeConfig } from '../config.js';
+import type { GitInfo } from '../types.js';
+export declare class GitAnalyzer {
+    private readonly config;
+    constructor(config: ParsemeConfig);
+    analyze(rootDir: string): Promise<GitInfo | undefined>;
+    private getCurrentBranch;
+    private getLastCommit;
+    private getStatus;
+    private getChangedFiles;
+    getFileLastModified(filePath: string, rootDir: string): Promise<string | undefined>;
+    getFileHistory(filePath: string, rootDir: string, limit?: number): Promise<string[]>;
+}

package/dist/analyzers/git-analyzer.js

@@ -0,0 +1,92 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class GitAnalyzer {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async analyze(rootDir) {
+        try {
+            // Check if this is a git repository
+            await execAsync('git rev-parse --git-dir', { cwd: rootDir });
+            const [branch, lastCommit, status, changedFiles] = await Promise.all([
+                this.getCurrentBranch(rootDir),
+                this.getLastCommit(rootDir),
+                this.getStatus(rootDir),
+                this.getChangedFiles(rootDir),
+            ]);
+            return {
+                branch,
+                lastCommit,
+                status,
+                changedFiles,
+            };
+        }
+        catch {
+            // Not a git repository or git not available
+            return undefined;
+        }
+    }
+    async getCurrentBranch(rootDir) {
+        try {
+            const { stdout } = await execAsync('git branch --show-current', { cwd: rootDir });
+            return stdout.trim();
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    async getLastCommit(rootDir) {
+        try {
+            const { stdout } = await execAsync('git log -1 --format="%H %s"', { cwd: rootDir });
+            return stdout.trim();
+        }
+        catch {
+            return 'No commits';
+        }
+    }
+    async getStatus(rootDir) {
+        try {
+            const { stdout } = await execAsync('git status --porcelain', { cwd: rootDir });
+            return stdout.trim() ? 'dirty' : 'clean';
+        }
+        catch {
+            return 'clean';
+        }
+    }
+    async getChangedFiles(rootDir) {
+        try {
+            const { stdout } = await execAsync('git status --porcelain', { cwd: rootDir });
+            return stdout
+                .split('\n')
+                .filter((line) => line.trim())
+                .map((line) => line.substring(3)); // Remove status prefix
+        }
+        catch {
+            return [];
+        }
+    }
+    async getFileLastModified(filePath, rootDir) {
+        try {
+            const { stdout } = await execAsync(`git log -1 --format="%H %ai" -- "${filePath}"`, {
+                cwd: rootDir,
+            });
+            return stdout.trim();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getFileHistory(filePath, rootDir, limit = 5) {
+        try {
+            const { stdout } = await execAsync(`git log --oneline -${limit} -- "${filePath}"`, {
+                cwd: rootDir,
+            });
+            return stdout.split('\n').filter((line) => line.trim());
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/analyzers/pattern-detector.d.ts

@@ -0,0 +1,58 @@
+import * as t from '@babel/types';
+import type { ParsemeConfig } from '../config.js';
+import type { ComponentInfo, RouteInfo } from '../types.js';
+export interface PatternAnalysis {
+    endpoints: EndpointInfo[];
+    components: ComponentInfo[];
+    services: ServiceInfo[];
+    models: ModelInfo[];
+    configs: ConfigInfo[];
+    middleware: MiddlewareInfo[];
+    utilities: UtilityInfo[];
+}
+export interface EndpointInfo extends RouteInfo {
+    type: 'rest' | 'graphql' | 'websocket' | 'rpc' | 'unknown';
+    framework?: string;
+    decorator?: string;
+}
+export interface ServiceInfo {
+    name: string;
+    file: string;
+    line: number;
+    methods: string[];
+    dependencies: string[];
+    type: 'class' | 'function' | 'object';
+}
+export interface ModelInfo {
+    name: string;
+    file: string;
+    line: number;
+    fields: string[];
+    type: 'interface' | 'type' | 'class' | 'schema';
+}
+export interface ConfigInfo {
+    name: string;
+    file: string;
+    line: number;
+    keys: string[];
+    type: 'object' | 'class' | 'env';
+}
+export interface MiddlewareInfo {
+    name: string;
+    file: string;
+    line: number;
+    type: 'function' | 'class' | 'decorator';
+}
+export interface UtilityInfo {
+    name: string;
+    file: string;
+    line: number;
+    functions: string[];
+    type: 'helper' | 'lib' | 'hook' | 'composable';
+}
+export declare class PatternDetector {
+    private readonly config;
+    constructor(config: ParsemeConfig);
+    analyzePatterns(ast: t.File, filePath: string, _content: string): PatternAnalysis;
+    private hasJSXReturn;
+}

package/dist/analyzers/pattern-detector.js

@@ -0,0 +1,174 @@
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+export class PatternDetector {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    analyzePatterns(ast, filePath, _content) {
+        const analysis = {
+            endpoints: [],
+            components: [],
+            services: [],
+            models: [],
+            configs: [],
+            middleware: [],
+            utilities: [],
+        };
+        // Use a single traverse call to detect all patterns
+        traverse.default(ast, {
+            // Detect Express-style routes: app.get(), router.post(), etc.
+            CallExpression: (path) => {
+                if (t.isMemberExpression(path.node.callee) && t.isIdentifier(path.node.callee.property)) {
+                    const methodName = path.node.callee.property.name;
+                    const httpMethods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head', 'all'];
+                    if (httpMethods.includes(methodName)) {
+                        const routeArg = path.node.arguments[0];
+                        const routePath = t.isStringLiteral(routeArg) ? routeArg.value : '/';
+                        analysis.endpoints.push({
+                            method: methodName.toUpperCase(),
+                            path: routePath,
+                            handler: 'callback',
+                            file: filePath,
+                            line: path.node.loc?.start.line || 0,
+                            type: 'rest',
+                        });
+                    }
+                }
+            },
+            // Detect decorator-based routes: @Get(), @Post(), etc.
+            ClassMethod: (path) => {
+                const decorators = path.node.decorators;
+                if (decorators) {
+                    decorators.forEach((decorator) => {
+                        if (t.isDecorator(decorator) && t.isCallExpression(decorator.expression)) {
+                            const callee = decorator.expression.callee;
+                            if (t.isIdentifier(callee)) {
+                                const httpMethods = ['Get', 'Post', 'Put', 'Delete', 'Patch', 'Options', 'Head'];
+                                if (httpMethods.includes(callee.name)) {
+                                    const route = decorator.expression.arguments[0];
+                                    const routePath = t.isStringLiteral(route) ? route.value : '/';
+                                    analysis.endpoints.push({
+                                        method: callee.name.toUpperCase(),
+                                        path: routePath,
+                                        handler: t.isIdentifier(path.node.key) ? path.node.key.name : 'anonymous',
+                                        file: filePath,
+                                        line: path.node.loc?.start.line || 0,
+                                        type: 'rest',
+                                        decorator: callee.name,
+                                    });
+                                }
+                            }
+                        }
+                    });
+                }
+            },
+            // Detect React components
+            FunctionDeclaration: (path) => {
+                const functionName = path.node.id?.name;
+                if (functionName) {
+                    // React hooks
+                    if (functionName.startsWith('use') && functionName.length > 3) {
+                        analysis.utilities.push({
+                            name: functionName,
+                            file: filePath,
+                            line: path.node.loc?.start.line || 0,
+                            functions: [functionName],
+                            type: 'hook',
+                        });
+                    }
+                    // React components (check for JSX return)
+                    if (this.hasJSXReturn(path.node.body)) {
+                        analysis.components.push({
+                            name: functionName,
+                            file: filePath,
+                            line: path.node.loc?.start.line || 0,
+                        });
+                    }
+                    // Middleware functions (req, res, next pattern)
+                    const params = path.node.params;
+                    if (params.length >= 3) {
+                        const paramNames = params
+                            .filter((param) => t.isIdentifier(param))
+                            .map((param) => param.name);
+                        const isMiddleware = paramNames.some((name) => ['req', 'request', 'res', 'response', 'next', 'ctx', 'context'].includes(name.toLowerCase()));
+                        if (isMiddleware) {
+                            analysis.middleware.push({
+                                name: functionName,
+                                file: filePath,
+                                line: path.node.loc?.start.line || 0,
+                                type: 'function',
+                            });
+                        }
+                    }
+                }
+            },
+            // Detect service classes and components
+            ClassDeclaration: (path) => {
+                const className = path.node.id?.name;
+                if (!className) {
+                    return;
+                }
+                // Service classes
+                const hasInjectableDecorator = path.node.decorators?.some((decorator) => t.isDecorator(decorator) &&
+                    t.isCallExpression(decorator.expression) &&
+                    t.isIdentifier(decorator.expression.callee) &&
+                    decorator.expression.callee.name === 'Injectable');
+                const isServiceClass = className.endsWith('Service') ||
+                    className.endsWith('Repository') ||
+                    className.endsWith('Manager') ||
+                    hasInjectableDecorator;
+                if (isServiceClass) {
+                    const methods = path.node.body.body
+                        .filter((member) => t.isClassMethod(member) && t.isIdentifier(member.key))
+                        .map((member) => member.key.name);
+                    analysis.services.push({
+                        name: className,
+                        file: filePath,
+                        line: path.node.loc?.start.line || 0,
+                        methods,
+                        dependencies: [],
+                        type: 'class',
+                    });
+                }
+                // React class components (check for render method)
+                const hasRenderMethod = path.node.body.body.some((member) => t.isClassMethod(member) && t.isIdentifier(member.key) && member.key.name === 'render');
+                if (hasRenderMethod) {
+                    analysis.components.push({
+                        name: className,
+                        file: filePath,
+                        line: path.node.loc?.start.line || 0,
+                    });
+                }
+            },
+            // Detect TypeScript interfaces
+            TSInterfaceDeclaration: (path) => {
+                const interfaceName = path.node.id.name;
+                const fields = path.node.body.body
+                    .filter((member) => t.isTSPropertySignature(member) && t.isIdentifier(member.key))
+                    .map((member) => member.key.name);
+                analysis.models.push({
+                    name: interfaceName,
+                    file: filePath,
+                    line: path.node.loc?.start.line || 0,
+                    fields,
+                    type: 'interface',
+                });
+            },
+            // Detect type aliases
+            TSTypeAliasDeclaration: (path) => {
+                analysis.models.push({
+                    name: path.node.id.name,
+                    file: filePath,
+                    line: path.node.loc?.start.line || 0,
+                    fields: [],
+                    type: 'type',
+                });
+            },
+        });
+        return analysis;
+    }
+    hasJSXReturn(body) {
+        return body.body.some((stmt) => t.isReturnStatement(stmt) && stmt.argument && t.isJSXElement(stmt.argument));
+    }
+}

package/dist/analyzers/project-analyzer.d.ts

@@ -0,0 +1,14 @@
+import type { ParsemeConfig } from '../config.js';
+import type { ProjectInfo } from '../types.js';
+export declare class ProjectAnalyzer {
+    private readonly config;
+    constructor(config: ParsemeConfig);
+    analyze(rootDir: string): Promise<ProjectInfo>;
+    private detectProjectType;
+    private detectPackageManager;
+    private getFilesRecursive;
+    private detectProjectCategory;
+    private detectEntryPoints;
+    private detectOutputTargets;
+    private hasAppDependencies;
+}