cast-code 1.0.0

package/dist/modules/project/services/project-analyzer.service.js

@@ -0,0 +1,1063 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ProjectAnalyzerService", {
+    enumerable: true,
+    get: function() {
+        return ProjectAnalyzerService;
+    }
+});
+const _common = require("@nestjs/common");
+const _promises = /*#__PURE__*/ _interop_require_wildcard(require("node:fs/promises"));
+const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+const _glob = require("glob");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+const LANGUAGES = {
+    typescript: {
+        name: 'TypeScript',
+        extensions: [
+            '.ts',
+            '.tsx'
+        ],
+        configFiles: [
+            'tsconfig.json'
+        ],
+        entryPatterns: [
+            'src/main.ts',
+            'src/index.ts',
+            'index.ts',
+            'main.ts'
+        ],
+        importPatterns: [
+            /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g,
+            /import\s*\(['"]([^'"]+)['"]\)/g,
+            /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+        ],
+        commentPatterns: {
+            single: '//',
+            multi: [
+                '/*',
+                '*/'
+            ]
+        }
+    },
+    javascript: {
+        name: 'JavaScript',
+        extensions: [
+            '.js',
+            '.jsx',
+            '.mjs'
+        ],
+        configFiles: [
+            'package.json',
+            '.eslintrc.js'
+        ],
+        entryPatterns: [
+            'src/main.js',
+            'src/index.js',
+            'index.js',
+            'main.js',
+            'app.js'
+        ],
+        importPatterns: [
+            /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g,
+            /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+        ],
+        commentPatterns: {
+            single: '//',
+            multi: [
+                '/*',
+                '*/'
+            ]
+        }
+    },
+    python: {
+        name: 'Python',
+        extensions: [
+            '.py'
+        ],
+        configFiles: [
+            'pyproject.toml',
+            'requirements.txt',
+            'setup.py',
+            'Pipfile'
+        ],
+        entryPatterns: [
+            'main.py',
+            'app.py',
+            'src/main.py',
+            '__main__.py',
+            'manage.py'
+        ],
+        importPatterns: [
+            /(?:from|import)\s+([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)/g
+        ],
+        commentPatterns: {
+            single: '#',
+            multi: [
+                '"""',
+                '"""'
+            ]
+        }
+    },
+    go: {
+        name: 'Go',
+        extensions: [
+            '.go'
+        ],
+        configFiles: [
+            'go.mod',
+            'go.sum'
+        ],
+        entryPatterns: [
+            'main.go',
+            'cmd/main.go',
+            'src/main.go'
+        ],
+        importPatterns: [
+            /import\s+\(\s*([^)]+)\)/g,
+            /import\s+['"]([^'"]+)['"]/g
+        ],
+        commentPatterns: {
+            single: '//',
+            multi: [
+                '/*',
+                '*/'
+            ]
+        }
+    },
+    rust: {
+        name: 'Rust',
+        extensions: [
+            '.rs'
+        ],
+        configFiles: [
+            'Cargo.toml',
+            'Cargo.lock'
+        ],
+        entryPatterns: [
+            'src/main.rs',
+            'src/lib.rs',
+            'main.rs'
+        ],
+        importPatterns: [
+            /use\s+([a-zA-Z_][a-zA-Z0-9_:]*)/g,
+            /extern\s+crate\s+([a-zA-Z_][a-zA-Z0-9_]*)/g
+        ],
+        commentPatterns: {
+            single: '//',
+            multi: [
+                '/*',
+                '*/'
+            ]
+        }
+    },
+    java: {
+        name: 'Java',
+        extensions: [
+            '.java'
+        ],
+        configFiles: [
+            'pom.xml',
+            'build.gradle',
+            'gradlew'
+        ],
+        entryPatterns: [
+            'src/main/java/Main.java',
+            'src/Main.java',
+            'Main.java'
+        ],
+        importPatterns: [
+            /import\s+([a-zA-Z_][a-zA-Z0-9_.]*)/g
+        ],
+        commentPatterns: {
+            single: '//',
+            multi: [
+                '/*',
+                '*/'
+            ]
+        }
+    },
+    php: {
+        name: 'PHP',
+        extensions: [
+            '.php'
+        ],
+        configFiles: [
+            'composer.json',
+            'composer.lock'
+        ],
+        entryPatterns: [
+            'index.php',
+            'public/index.php',
+            'src/index.php'
+        ],
+        importPatterns: [
+            /use\s+([a-zA-Z_][a-zA-Z0-9_\\]*)/g,
+            /require(?:_once)?\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+            /include(?:_once)?\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+        ],
+        commentPatterns: {
+            single: '//',
+            multi: [
+                '/*',
+                '*/'
+            ]
+        }
+    },
+    ruby: {
+        name: 'Ruby',
+        extensions: [
+            '.rb'
+        ],
+        configFiles: [
+            'Gemfile',
+            'Gemfile.lock',
+            '*.gemspec'
+        ],
+        entryPatterns: [
+            'main.rb',
+            'app.rb',
+            'config.ru',
+            'bin/'
+        ],
+        importPatterns: [
+            /require\s+['"]([^'"]+)['"]/g,
+            /require_relative\s+['"]([^'"]+)['"]/g
+        ],
+        commentPatterns: {
+            single: '#'
+        }
+    },
+    csharp: {
+        name: 'C#',
+        extensions: [
+            '.cs'
+        ],
+        configFiles: [
+            '*.csproj',
+            '*.sln'
+        ],
+        entryPatterns: [
+            'Program.cs',
+            'Main.cs',
+            'Startup.cs'
+        ],
+        importPatterns: [
+            /using\s+([a-zA-Z_][a-zA-Z0-9_.]*)/g
+        ],
+        commentPatterns: {
+            single: '//',
+            multi: [
+                '/*',
+                '*/'
+            ]
+        }
+    }
+};
+const ARCHITECTURE_PATTERNS = [
+    {
+        name: 'Layered Architecture',
+        indicators: [
+            'controllers',
+            'services',
+            'repositories',
+            'models',
+            'dao'
+        ],
+        description: 'Separação em camadas: apresentação, negócio, dados'
+    },
+    {
+        name: 'Clean Architecture',
+        indicators: [
+            'entities',
+            'usecases',
+            'adapters',
+            'frameworks',
+            'interfaces'
+        ],
+        description: 'Independência de frameworks, testável, independente de UI e banco'
+    },
+    {
+        name: 'Hexagonal Architecture (Ports & Adapters)',
+        indicators: [
+            'ports',
+            'adapters',
+            'domain',
+            'application'
+        ],
+        description: 'Domínio no centro, adaptadores externos plugáveis'
+    },
+    {
+        name: 'Microservices',
+        indicators: [
+            'services/',
+            'api/',
+            'gateway',
+            'proto/',
+            'grpc'
+        ],
+        description: 'Serviços independentes, comunicação via API/mensagens'
+    },
+    {
+        name: 'Serverless',
+        indicators: [
+            'functions/',
+            'handlers/',
+            'lambda',
+            'serverless.yml'
+        ],
+        description: 'Funções como unidade de deployment, event-driven'
+    },
+    {
+        name: 'Modular Monolith',
+        indicators: [
+            'modules/',
+            'bounded-contexts',
+            'packages/'
+        ],
+        description: 'Monolito dividido em módulos bem definidos'
+    },
+    {
+        name: 'Domain-Driven Design (DDD)',
+        indicators: [
+            'domain/',
+            'aggregates',
+            'value-objects',
+            'entities',
+            'domain-events'
+        ],
+        description: 'Modelagem focada no domínio de negócio'
+    },
+    {
+        name: 'CQRS',
+        indicators: [
+            'commands/',
+            'queries/',
+            'handlers/',
+            'read-model',
+            'write-model'
+        ],
+        description: 'Separação de leitura e escrita'
+    },
+    {
+        name: 'Event Sourcing',
+        indicators: [
+            'events/',
+            'event-store',
+            'projections',
+            'aggregates'
+        ],
+        description: 'Estado derivado de uma sequência de eventos'
+    },
+    {
+        name: 'MVC/MVP/MVVM',
+        indicators: [
+            'views/',
+            'viewmodels',
+            'presenters',
+            'controllers'
+        ],
+        description: 'Separação de concerns de UI'
+    }
+];
+// Pattern roles based on file/directory names
+const PATTERN_ROLES = {
+    // Controllers
+    controller: 'Controlador - Recebe requisições, delega processamento',
+    handler: 'Handler - Processa requisições/eventos',
+    resource: 'Resource - Endpoints REST',
+    router: 'Router - Define rotas',
+    route: 'Route - Configuração de rota',
+    service: 'Serviço - Lógica de negócio',
+    usecase: 'Caso de Uso - Orquestra operação específica',
+    interactor: 'Interactor - Coordena fluxo de dados',
+    repository: 'Repositório - Acesso a dados',
+    dao: 'DAO - Data Access Object',
+    model: 'Modelo - Entidade/Modelo de dados',
+    entity: 'Entidade - Objeto de domínio',
+    schema: 'Schema - Definição de estrutura de dados',
+    migration: 'Migration - Alteração de banco de dados',
+    aggregate: 'Aggregate - Raiz de agregação DDD',
+    valueobject: 'Value Object - Objeto de valor imutável',
+    domainevent: 'Domain Event - Evento de domínio',
+    adapter: 'Adapter - Adapta interface externa',
+    gateway: 'Gateway - Interface para sistema externo',
+    client: 'Client - Cliente HTTP/API',
+    provider: 'Provider - Provedor de serviço/dependência',
+    config: 'Configuração - Setup e configurações',
+    settings: 'Settings - Configurações do projeto',
+    env: 'Environment - Variáveis de ambiente',
+    utils: 'Utilitários - Funções auxiliares',
+    helpers: 'Helpers - Funções de apoio',
+    common: 'Common - Código compartilhado',
+    shared: 'Shared - Recursos compartilhados',
+    lib: 'Library - Biblioteca interna',
+    test: 'Teste - Testes unitários/integração',
+    spec: 'Spec - Especificação/teste',
+    mock: 'Mock - Simulação para testes',
+    fixture: 'Fixture - Dados de teste',
+    component: 'Componente - Componente de UI',
+    page: 'Page - Página da aplicação',
+    layout: 'Layout - Template de layout',
+    style: 'Style - Estilos CSS/styled',
+    event: 'Event - Definição de evento',
+    listener: 'Listener - Ouvinte de evento',
+    subscriber: 'Subscriber - Assinante de evento',
+    producer: 'Producer - Produtor de evento',
+    consumer: 'Consumer - Consumidor de evento/mensagem',
+    middleware: 'Middleware - Interceptador de requisições',
+    guard: 'Guard - Proteção de rotas/recursos',
+    interceptor: 'Interceptor - Intercepta execução',
+    filter: 'Filter - Filtro de dados/requisições',
+    pipe: 'Pipe - Transformação de dados',
+    decorator: 'Decorator - Decorador/annotation',
+    job: 'Job - Tarefa em background',
+    worker: 'Worker - Processador de tarefas',
+    queue: 'Queue - Fila de processamento',
+    schedule: 'Schedule - Tarefa agendada',
+    cron: 'Cron - Job periódico',
+    dto: 'DTO - Data Transfer Object',
+    request: 'Request - Objeto de requisição',
+    response: 'Response - Objeto de resposta',
+    serializer: 'Serializer - Serialização de dados',
+    validator: 'Validator - Validação de dados'
+};
+let ProjectAnalyzerService = class ProjectAnalyzerService {
+    async analyze(projectPath = process.cwd()) {
+        const name = _path.basename(projectPath);
+        const languages = await this.detectLanguages(projectPath);
+        const primaryLanguage = languages[0] || 'unknown';
+        const structure = await this.analyzeStructure(projectPath, primaryLanguage);
+        const architecture = await this.detectArchitecture(projectPath, structure.directories);
+        const modules = await this.analyzeModules(projectPath, structure.directories);
+        const dependencies = await this.getDependencies(projectPath, primaryLanguage);
+        const conventions = await this.detectConventions(projectPath);
+        const allFiles = await this.getAllFiles(projectPath, languages);
+        const configFiles = await this.getConfigFiles(projectPath);
+        const objective = this.generateObjective(name, primaryLanguage, architecture);
+        const description = this.generateDescription(name, primaryLanguage, architecture, modules.length);
+        return {
+            name,
+            objective,
+            description,
+            primaryLanguage,
+            languages,
+            architecture,
+            structure,
+            modules,
+            dependencies,
+            conventions,
+            rawData: {
+                allFiles,
+                configFiles
+            }
+        };
+    }
+    async detectLanguages(projectPath) {
+        const languages = [];
+        const counts = {};
+        for (const [key, config] of Object.entries(LANGUAGES)){
+            try {
+                const files = await (0, _glob.glob)(`**/*{${config.extensions.join(',')}}`, {
+                    cwd: projectPath,
+                    nodir: true,
+                    ignore: [
+                        'node_modules/**',
+                        '**/node_modules/**',
+                        '.git/**',
+                        'dist/**',
+                        'build/**',
+                        'target/**'
+                    ]
+                });
+                if (files.length > 0) {
+                    counts[key] = files.length;
+                }
+            } catch  {}
+        }
+        return Object.entries(counts).sort((a, b)=>b[1] - a[1]).map(([lang])=>lang);
+    }
+    async analyzeStructure(projectPath, primaryLanguage) {
+        const langConfig = LANGUAGES[primaryLanguage];
+        const directories = [];
+        const entryPoints = [];
+        const commonDirs = [
+            'src',
+            'lib',
+            'app',
+            'source',
+            'core',
+            'packages',
+            'internal',
+            'cmd',
+            'pkg'
+        ];
+        for (const dir of commonDirs){
+            try {
+                const stat = await _promises.stat(_path.join(projectPath, dir));
+                if (stat.isDirectory()) {
+                    directories.push(dir);
+                }
+            } catch  {}
+        }
+        if (langConfig) {
+            for (const pattern of langConfig.entryPatterns){
+                try {
+                    await _promises.access(_path.join(projectPath, pattern));
+                    entryPoints.push(pattern);
+                } catch  {}
+            }
+        }
+        return {
+            root: projectPath,
+            directories,
+            entryPoints
+        };
+    }
+    async detectArchitecture(projectPath, directories) {
+        const dirSet = new Set(directories.map((d)=>d.toLowerCase()));
+        const allDirs = await this.getAllDirectories(projectPath);
+        const allDirsLower = allDirs.map((d)=>d.toLowerCase());
+        let bestMatch = null;
+        for (const pattern of ARCHITECTURE_PATTERNS){
+            const matchingIndicators = pattern.indicators.filter((indicator)=>allDirsLower.some((dir)=>dir.includes(indicator.toLowerCase())));
+            if (matchingIndicators.length > 0) {
+                if (!bestMatch || matchingIndicators.length > bestMatch.count) {
+                    bestMatch = {
+                        pattern,
+                        count: matchingIndicators.length
+                    };
+                }
+            }
+        }
+        if (bestMatch) {
+            const confidence = bestMatch.count >= 3 ? 'high' : bestMatch.count >= 2 ? 'medium' : 'low';
+            return {
+                pattern: bestMatch.pattern.name,
+                description: bestMatch.pattern.description,
+                confidence
+            };
+        }
+        return undefined;
+    }
+    async analyzeModules(projectPath, directories) {
+        const modules = [];
+        for (const dir of directories){
+            const dirPath = _path.join(projectPath, dir);
+            try {
+                const entries = await _promises.readdir(dirPath, {
+                    withFileTypes: true
+                });
+                for (const entry of entries){
+                    if (entry.isDirectory() && !entry.name.startsWith('.') && !entry.name.startsWith('_')) {
+                        const modulePath = _path.join(dirPath, entry.name);
+                        const files = await this.getFilesInDir(modulePath);
+                        const keyFiles = files.slice(0, 5);
+                        const role = this.detectRole(entry.name);
+                        modules.push({
+                            name: entry.name,
+                            path: _path.join(dir, entry.name),
+                            role,
+                            fileCount: files.length,
+                            keyFiles
+                        });
+                    }
+                }
+            } catch  {}
+        }
+        return modules.sort((a, b)=>b.fileCount - a.fileCount);
+    }
+    detectRole(dirName) {
+        const lower = dirName.toLowerCase();
+        for (const [pattern, role] of Object.entries(PATTERN_ROLES)){
+            if (lower.includes(pattern)) {
+                return role;
+            }
+        }
+        if ([
+            'auth',
+            'authentication',
+            'security'
+        ].some((p)=>lower.includes(p))) {
+            return 'Autenticação e autorização';
+        }
+        if ([
+            'user',
+            'users',
+            'account',
+            'accounts'
+        ].some((p)=>lower.includes(p))) {
+            return 'Gestão de usuários/contas';
+        }
+        if ([
+            'payment',
+            'billing',
+            'finance',
+            'subscription'
+        ].some((p)=>lower.includes(p))) {
+            return 'Pagamentos e faturamento';
+        }
+        if ([
+            'notification',
+            'email',
+            'sms',
+            'push'
+        ].some((p)=>lower.includes(p))) {
+            return 'Notificações';
+        }
+        if ([
+            'api',
+            'rest',
+            'graphql',
+            'grpc'
+        ].some((p)=>lower.includes(p))) {
+            return 'API/Interface externa';
+        }
+        if ([
+            'db',
+            'database',
+            'storage',
+            'cache'
+        ].some((p)=>lower.includes(p))) {
+            return 'Persistência de dados';
+        }
+        if ([
+            'queue',
+            'job',
+            'worker',
+            'background'
+        ].some((p)=>lower.includes(p))) {
+            return 'Processamento em background';
+        }
+        if ([
+            'frontend',
+            'web',
+            'ui',
+            'mobile',
+            'app'
+        ].some((p)=>lower.includes(p))) {
+            return 'Interface do usuário';
+        }
+        return 'Funcionalidade específica do domínio';
+    }
+    async getDependencies(projectPath, language) {
+        const internal = [];
+        const external = [];
+        switch(language){
+            case 'typescript':
+            case 'javascript':
+                try {
+                    const pkg = JSON.parse(await _promises.readFile(_path.join(projectPath, 'package.json'), 'utf-8'));
+                    const allDeps = {
+                        ...pkg.dependencies,
+                        ...pkg.devDependencies
+                    };
+                    for (const [name, version] of Object.entries(allDeps)){
+                        if (name.startsWith('@') && name.includes('/')) {
+                            const scope = name.split('/')[0];
+                            if (scope === `@${pkg.name}` || name.startsWith('@internal')) {
+                                internal.push(name);
+                            } else {
+                                external.push(name);
+                            }
+                        } else {
+                            external.push(name);
+                        }
+                    }
+                } catch  {}
+                break;
+            case 'python':
+                try {
+                    const requirements = await _promises.readFile(_path.join(projectPath, 'requirements.txt'), 'utf-8');
+                    external.push(...requirements.split('\n').map((line)=>line.split('==')[0].split('>=')[0].trim()).filter((line)=>line && !line.startsWith('#') && !line.startsWith('-')));
+                } catch  {}
+                break;
+            case 'go':
+                try {
+                    const modContent = await _promises.readFile(_path.join(projectPath, 'go.mod'), 'utf-8');
+                    const matches = modContent.match(/require\s+\(([^)]+)\)/s);
+                    if (matches) {
+                        external.push(...matches[1].split('\n').map((line)=>line.trim().split(' ')[0]).filter((line)=>line && !line.startsWith('//')));
+                    }
+                } catch  {}
+                break;
+            case 'rust':
+                try {
+                    const cargo = await _promises.readFile(_path.join(projectPath, 'Cargo.toml'), 'utf-8');
+                    const matches = cargo.match(/\[dependencies\]([^\[]+)/);
+                    if (matches) {
+                        external.push(...matches[1].split('\n').map((line)=>line.split('=')[0].trim()).filter((line)=>line && !line.startsWith('#')));
+                    }
+                } catch  {}
+                break;
+        }
+        return {
+            internal: [
+                ...new Set(internal)
+            ].slice(0, 10),
+            external: [
+                ...new Set(external)
+            ].slice(0, 20)
+        };
+    }
+    async detectConventions(projectPath) {
+        const naming = 'mixed';
+        let testing = false;
+        let linting = false;
+        try {
+            await _promises.access(_path.join(projectPath, 'test'));
+            testing = true;
+        } catch  {
+            try {
+                await _promises.access(_path.join(projectPath, 'tests'));
+                testing = true;
+            } catch  {}
+        }
+        const lintFiles = [
+            '.eslintrc',
+            '.eslintrc.js',
+            '.eslintrc.json',
+            'pyproject.toml',
+            'setup.cfg'
+        ];
+        for (const file of lintFiles){
+            try {
+                await _promises.access(_path.join(projectPath, file));
+                linting = true;
+                break;
+            } catch  {}
+        }
+        return {
+            naming,
+            testing,
+            linting
+        };
+    }
+    async getAllFiles(projectPath, languages) {
+        const allFiles = [];
+        const extensions = languages.flatMap((lang)=>LANGUAGES[lang]?.extensions || []);
+        if (extensions.length === 0) return allFiles;
+        try {
+            const files = await (0, _glob.glob)(`**/*{${extensions.join(',')}}`, {
+                cwd: projectPath,
+                nodir: true,
+                ignore: [
+                    '**/node_modules/**',
+                    '**/.git/**',
+                    '**/dist/**',
+                    '**/build/**',
+                    '**/target/**',
+                    '**/__pycache__/**'
+                ]
+            });
+            allFiles.push(...files);
+        } catch  {}
+        return allFiles.slice(0, 100);
+    }
+    async getConfigFiles(projectPath) {
+        const configFiles = [];
+        const patterns = [
+            '*.config.*',
+            '.*rc*',
+            'Makefile',
+            'Dockerfile*',
+            'docker-compose*',
+            '.env*',
+            '*.toml',
+            '*.yaml',
+            '*.yml',
+            '*.json'
+        ];
+        for (const pattern of patterns){
+            try {
+                const files = await (0, _glob.glob)(pattern, {
+                    cwd: projectPath,
+                    nodir: true
+                });
+                configFiles.push(...files);
+            } catch  {}
+        }
+        return [
+            ...new Set(configFiles)
+        ].slice(0, 20);
+    }
+    async getAllDirectories(projectPath) {
+        const dirs = [];
+        try {
+            const entries = await _promises.readdir(projectPath, {
+                withFileTypes: true,
+                recursive: true
+            });
+            for (const entry of entries){
+                if (entry.isDirectory() && !entry.name.startsWith('.') && !entry.name.startsWith('_') && entry.name !== 'node_modules' && entry.name !== 'dist' && entry.name !== 'build') {
+                    dirs.push(entry.name);
+                }
+            }
+        } catch  {}
+        return dirs;
+    }
+    async getFilesInDir(dirPath) {
+        try {
+            const files = await (0, _glob.glob)('**/*', {
+                cwd: dirPath,
+                nodir: true,
+                ignore: [
+                    '*.spec.*',
+                    '*.test.*',
+                    '*_test.*',
+                    '__pycache__/**'
+                ]
+            });
+            return files;
+        } catch  {
+            return [];
+        }
+    }
+    generateObjective(name, language, architecture) {
+        const parts = [
+            `Desenvolver e manter o projeto ${name}`
+        ];
+        if (language !== 'unknown') {
+            parts.push(`utilizando ${LANGUAGES[language]?.name || language}`);
+        }
+        if (architecture) {
+            parts.push(`com arquitetura ${architecture.pattern}`);
+        }
+        return parts.join(' ') + '.';
+    }
+    generateDescription(name, language, architecture, moduleCount) {
+        const parts = [
+            `Projeto ${name}`
+        ];
+        if (language !== 'unknown') {
+            parts.push(`desenvolvido em ${LANGUAGES[language]?.name || language}`);
+        }
+        if (architecture) {
+            parts.push(`seguindo ${architecture.pattern}`);
+        }
+        if (moduleCount > 0) {
+            parts.push(`com ${moduleCount} módulo(s) organizado(s)`);
+        }
+        return parts.join(' ') + '.';
+    }
+    generateMarkdown(context) {
+        const lines = [];
+        lines.push('---');
+        lines.push(`name: ${context.name}`);
+        lines.push(`objective: |`);
+        lines.push(`  ${context.objective}`);
+        lines.push(`primary_language: ${context.primaryLanguage}`);
+        lines.push(`languages:`);
+        context.languages.forEach((lang)=>{
+            const langName = LANGUAGES[lang]?.name || lang;
+            lines.push(`  - ${langName}`);
+        });
+        if (context.architecture) {
+            lines.push(`architecture:`);
+            lines.push(`  pattern: ${context.architecture.pattern}`);
+            lines.push(`  confidence: ${context.architecture.confidence}`);
+        }
+        lines.push('---');
+        lines.push('');
+        lines.push('# Visão Geral');
+        lines.push('');
+        lines.push(context.description);
+        lines.push('');
+        if (context.architecture) {
+            lines.push('## Arquitetura');
+            lines.push('');
+            lines.push(`**Padrão:** ${context.architecture.pattern}`);
+            lines.push('');
+            lines.push(`**Confiança:** ${context.architecture.confidence}`);
+            lines.push('');
+            lines.push(context.architecture.description);
+            lines.push('');
+        }
+        lines.push('## Estrutura');
+        lines.push('');
+        if (context.structure.entryPoints.length > 0) {
+            lines.push('### Pontos de Entrada');
+            context.structure.entryPoints.forEach((ep)=>lines.push(`- \`${ep}\``));
+            lines.push('');
+        }
+        if (context.structure.directories.length > 0) {
+            lines.push('### Diretórios Principais');
+            context.structure.directories.forEach((dir)=>lines.push(`- \`${dir}/\``));
+            lines.push('');
+        }
+        if (context.modules.length > 0) {
+            lines.push('## Módulos');
+            lines.push('');
+            context.modules.forEach((mod)=>{
+                lines.push(`### ${mod.name}`);
+                lines.push('');
+                lines.push(`**Caminho:** \`${mod.path}\``);
+                lines.push('');
+                lines.push(`**Papel:** ${mod.role}`);
+                lines.push('');
+                lines.push(`**Arquivos:** ${mod.fileCount}`);
+                lines.push('');
+                if (mod.keyFiles.length > 0) {
+                    lines.push('**Arquivos-chave:**');
+                    mod.keyFiles.forEach((file)=>lines.push(`- \`${file}\``));
+                    lines.push('');
+                }
+                lines.push('---');
+                lines.push('');
+            });
+        }
+        if (context.dependencies.external.length > 0) {
+            lines.push('## Dependências');
+            lines.push('');
+            lines.push('### Externas Principais');
+            context.dependencies.external.slice(0, 15).forEach((dep)=>lines.push(`- ${dep}`));
+            lines.push('');
+        }
+        if (context.dependencies.internal.length > 0) {
+            lines.push('### Internas');
+            context.dependencies.internal.forEach((dep)=>lines.push(`- ${dep}`));
+            lines.push('');
+        }
+        lines.push('## Convenções');
+        lines.push('');
+        lines.push(`- **Nomenclatura:** ${context.conventions.naming}`);
+        lines.push(`- **Testes:** ${context.conventions.testing ? 'Sim' : 'Não detectado'}`);
+        lines.push(`- **Linting:** ${context.conventions.linting ? 'Sim' : 'Não detectado'}`);
+        lines.push('');
+        lines.push('## Estatísticas');
+        lines.push('');
+        lines.push(`- **Total de arquivos:** ${context.rawData.allFiles.length}`);
+        lines.push(`- **Arquivos de configuração:** ${context.rawData.configFiles.length}`);
+        lines.push(`- **Módulos:** ${context.modules.length}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    generateAgentInstructions(context) {
+        return `Analise profundamente o projeto "${context.name}" localizado em ${context.structure.root}.
+
+## Tarefas:
+
+1. **Explore a estrutura completa**
+   - Liste todos os diretórios principais
+   - Identifique a organização de pastas
+   - Encontre todos os arquivos de configuração
+
+2. **Analise os módulos**
+${context.modules.map((m)=>`   - **${m.name}** (${m.path}): ${m.role}`).join('\n')}
+
+3. **Entenda as dependências**
+   - Analise o arquivo de dependências principal
+   - Identifique dependências críticas
+   - Entenda o propósito de cada dependência principal
+
+4. **Documente padrões de código**
+   - Como são organizados os imports?
+   - Quais convenções de nomenclatura são usadas?
+   - Existe um estilo consistente de código?
+
+5. **Identifique fluxos de dados**
+   - Como os dados fluem entre camadas?
+   - Onde estão as validações?
+   - Como é feita a persistência?
+
+6. **Encontre exemplos representativos**
+   - Um controller/handler típico
+   - Um serviço/caso de uso típico
+   - Um modelo/entidade típica
+   - Um teste típico (se existir)
+
+## Formato do Relatório:
+
+Gere um resumo estruturado em Markdown com:
+
+### 1. Resumo Executivo
+- Propósito do projeto (1 parágrafo)
+- Arquitetura geral
+- Complexidade estimada
+
+### 2. Módulos Detalhados
+Para cada módulo encontrado:
+- Nome e propósito
+- Responsabilidades específicas
+- Interações com outros módulos
+- Arquivos principais
+
+### 3. Fluxos de Negócio
+- Principais operações/casos de uso
+- Como os dados entram e saem
+- Pontos críticos de validação
+
+### 4. Stack Completa
+- Linguagens e frameworks
+- Bancos de dados
+- Ferramentas de build/deploy
+- Bibliotecas significativas
+
+### 5. Convenções e Padrões
+- Estilo de código
+- Estrutura de commits
+- Organização de testes
+- Documentação
+
+### 6. Pontos de Atenção
+- Débito técnico aparente
+- Código duplicado
+- Dependências desatualizadas
+- Áreas complexas
+
+Use as ferramentas disponíveis para explorar o código e gerar este relatório.`;
+    }
+};
+ProjectAnalyzerService = _ts_decorate([
+    (0, _common.Injectable)()
+], ProjectAnalyzerService);
+
+//# sourceMappingURL=project-analyzer.service.js.map