@girardelli/architect-core 8.1.0

package/dist/src/core/locales/pt-BR.d.ts

@@ -0,0 +1,172 @@
+export declare const ptBR: {
+    cli: {
+        phases: {
+            scan: {
+                label: string;
+                verb: string;
+            };
+            dependencies: {
+                label: string;
+                verb: string;
+            };
+            layers: {
+                label: string;
+                verb: string;
+            };
+            antipatterns: {
+                label: string;
+                verb: string;
+            };
+            scoring: {
+                label: string;
+                verb: string;
+            };
+            normalize: {
+                label: string;
+                verb: string;
+            };
+            summarize: {
+                label: string;
+                verb: string;
+            };
+        };
+        results: {
+            score: string;
+            completedIn: string;
+            files: string;
+            lines: string;
+            anitpatterns: string;
+            steps: string;
+            agents: string;
+        };
+    };
+    agents: {
+        generatedBy: string;
+        backend: {
+            description: string;
+            title: string;
+            specialistIn: string;
+            stack: string;
+            language: string;
+            framework: string;
+            architecture: string;
+            test: string;
+            packageManager: string;
+            currentScore: string;
+            domainContext: string;
+            principles: string;
+            modules: string;
+            projectStructure: string;
+            implementationRules: string;
+            implementationRulesBody: string;
+            afterImplementation: string;
+            afterImplementationBody: string;
+        };
+        frontend: {
+            description: string;
+            title: string;
+            specialistIn: string;
+            prerequisites: string;
+            prerequisitesBody: string;
+            implementationRules: string;
+            implementationRulesBody: string;
+        };
+        security: {
+            description: string;
+            title: string;
+            analysisFor: string;
+            checklist: string;
+            checklistBody: string;
+            whenToActivate: string;
+            whenToActivateBody: string;
+            expectedOutput: string;
+            expectedOutputBody: string;
+        };
+        qa: {
+            description: string;
+            title: string;
+            qualityFor: string;
+            nonNegotiable: string;
+            nonNegotiableBody: string;
+            pyramid: string;
+            pyramidBody: string;
+            process: string;
+            processBody: string;
+            refactoringRoadmap: string;
+        };
+        techDebt: {
+            description: string;
+            title: string;
+            controlFor: string;
+            currentState: string;
+            stateTable: string;
+            refactoringRoadmap: string;
+            scoreTargets: string;
+            scoreTargetsBody: string;
+            rules: string;
+            rulesBody: string;
+        };
+        codeReview: {
+            description: string;
+            title: string;
+            mandatoryRule: string;
+            mandatory: string;
+            mandatoryBody: string;
+            functional: string;
+            functionalBody: string;
+            quality: string;
+            qualityBody: string;
+            domainReviewItems: string;
+            domainRules: {
+                fintech: string;
+                healthtech: string;
+                ecommerce: string;
+                default: string;
+            };
+            stackReviewItems: string;
+            stackRules: {
+                ts: string;
+                python: string;
+                go: string;
+                dart: string;
+                default: string;
+            };
+            integrationReviewItems: string;
+            integrationRulesBody: string;
+        };
+    };
+    dynamic: {
+        compliance: {
+            title: string;
+            reason: string;
+            mandatoryChecks: string;
+        };
+        integrations: {
+            title: string;
+            threats: string;
+            types: {
+                payment: string;
+                auth: string;
+                api: string;
+                database: string;
+                government: string;
+                default: string;
+            };
+        };
+        domainThreats: {
+            title: string;
+            fintech: string;
+            healthtech: string;
+            ecommerce: string;
+            default: string;
+        };
+        qaDomain: {
+            title: string;
+            fintech: string;
+            healthtech: string;
+            ecommerce: string;
+            default: string;
+        };
+    };
+};
+export type AppTranslation = typeof ptBR;

package/dist/src/core/locales/pt-BR.js

@@ -0,0 +1,337 @@
+export const ptBR = {
+    // === CLI ===
+    cli: {
+        phases: {
+            scan: { label: 'FILE SCANNER', verb: 'Escaneando sistema de arquivos' },
+            dependencies: { label: 'DEPENDENCY MAPPER', verb: 'Mapeando grafo de importações' },
+            layers: { label: 'LAYER DETECTOR', verb: 'Classificando arquitetura' },
+            antipatterns: { label: 'PATTERN ANALYZER', verb: 'Detectando anti-patterns' },
+            scoring: { label: 'QUALITY ENGINE', verb: 'Computando métricas de qualidade' },
+            normalize: { label: 'PATH NORMALIZER', verb: 'Normalizando paths' },
+            summarize: { label: 'AI SUMMARIZER', verb: 'Gerando sumário do projeto' }
+        },
+        results: {
+            score: 'ARCHITECTURE SCORE',
+            completedIn: 'Completado em',
+            files: 'arquivos',
+            lines: 'linhas',
+            anitpatterns: 'anti-patterns',
+            steps: 'passos',
+            agents: 'agentes'
+        }
+    },
+    // === AGONTS OUTPUTS ===
+    agents: {
+        generatedBy: 'Gerado por Architect v8.1',
+        backend: {
+            description: '{lang} Backend Developer — APIs, serviços, lógica de negócio',
+            title: '🔧 {lang} BACKEND DEVELOPER',
+            specialistIn: 'Especialista em backend {fw} para {projectName}',
+            stack: 'Stack',
+            language: 'Linguagem',
+            framework: 'Framework',
+            architecture: 'Arquitetura',
+            test: 'Teste',
+            packageManager: 'Package Manager',
+            currentScore: 'Score Atual',
+            domainContext: 'Domínio & Contexto de Negócio',
+            principles: 'Princípios (SOLID + Clean Architecture)',
+            modules: 'Módulos do Projeto',
+            projectStructure: 'Estrutura do Projeto (Detectada)',
+            implementationRules: 'Regras de Implementação',
+            implementationRulesBody: `□ Controller NUNCA contém lógica de negócio (apenas routing)
+□ Service NUNCA acessa Request/Response diretamente
+□ Entity NUNCA é exposta diretamente na API (usar DTO)
+□ Validação de input no DTO / Guard / Pipe
+□ Erros com mensagens claras e códigos HTTP corretos
+□ Logging estruturado (não console.log)
+□ Testes unitários para cada service method
+□ Testes de integração para cada endpoint
+□ Cobertura ≥ {coverage}%`,
+            afterImplementation: 'Após Implementação Backend',
+            afterImplementationBody: `> **OBRIGATÓRIO: Gerar Documento de Integração antes de qualquer frontend/app.**
+
+O documento deve conter:
+- Todos os endpoints criados/modificados
+- Payloads de request e response (com exemplos)
+- Códigos de erro e mensagens
+- Regras de negócio aplicadas
+- Headers necessários (auth, pagination, etc.)`
+        },
+        frontend: {
+            description: '{fw} Frontend Developer — Componentes, UX, state management',
+            title: '🎨 {fw} FRONTEND DEVELOPER',
+            specialistIn: 'Especialista em frontend {fw} para {projectName}',
+            prerequisites: 'Pré-Requisitos para Implementar',
+            prerequisitesBody: `╔══════════════════════════════════════════════╗
+║  ANTES de escrever qualquer componente:     ║
+║                                              ║
+║  □ MOCKUP aprovado pelo humano              ║
+║  □ Documento de Integração disponível       ║
+║  □ User stories com critérios de aceite     ║
+║  □ BDD scenarios escritos                   ║
+╚══════════════════════════════════════════════╝`,
+            implementationRules: 'Regras de Implementação',
+            implementationRulesBody: `□ Componente segue MOCKUP aprovado (não inventar UI)
+□ TODOS os estados implementados:
+  - ✅ Com dados (estado normal)
+  - 📭 Vazio (empty state)
+  - ⏳ Carregando (loading state / skeleton)
+  - ❌ Erro (error state com mensagem clara)
+□ Lógica de negócio em services (NUNCA no componente)
+□ State management adequado (sem prop drilling)
+□ Formulários com validação client-side
+□ Responsivo (testar mobile + desktop)
+□ Acessibilidade básica (labels, aria, contraste)
+□ Lazy loading onde aplicável
+□ Cobertura ≥ {coverage}%`
+        },
+        security: {
+            description: 'Security Auditor — Análise de ameaças, compliance, vulnerabilidades',
+            title: '🛡️ SECURITY AUDITOR',
+            analysisFor: 'Análise de segurança para {projectName}',
+            checklist: 'Checklist OWASP Top 10',
+            checklistBody: `□ A01: Broken Access Control — RBAC implementado?
+□ A02: Cryptographic Failures — Dados sensíveis criptografados?
+□ A03: Injection — Inputs sanitizados? Queries parametrizadas?
+□ A04: Insecure Design — Threat model feito?
+□ A05: Security Misconfiguration — Headers, CORS, defaults?
+□ A06: Vulnerable Components — Deps atualizadas?
+□ A07: Auth Failures — Brute force protegido? Session management?
+□ A08: Software Integrity — Supply chain verificado?
+□ A09: Logging Failures — Audit log para ações sensíveis?
+□ A10: SSRF — Server-side requests validados?`,
+            whenToActivate: 'Quando Ativar',
+            whenToActivateBody: `- Qualquer feature que lida com: autenticação, autorização, dados pessoais, pagamentos
+- Novas APIs públicas
+- Integrações com sistemas externos
+- Mudanças em infra/deploy`,
+            expectedOutput: 'Output Esperado',
+            expectedOutputBody: `1. Lista de findings com severidade (CRITICAL/HIGH/MEDIUM/LOW)
+2. Recomendações de mitigação
+3. Threat model (se aplicável)`
+        },
+        qa: {
+            description: 'QA Test Engineer — Planos de teste, BDD/TDD, cobertura',
+            title: '🧪 QA TEST ENGINEER',
+            qualityFor: 'Qualidade de testes para {projectName}',
+            nonNegotiable: 'Metas Inegociáveis',
+            nonNegotiableBody: `╔══════════════════════════════════════════╗
+║  Cobertura mínima: {coverage}%                ║
+║  Sem testes, sem entrega, sem finalizar  ║
+║  INEGOCIÁVEL.                            ║
+╚══════════════════════════════════════════╝`,
+            pyramid: 'Pirâmide de Testes',
+            pyramidBody: `         ╱╲
+        ╱ E2E╲         → Poucos, lentos, alto valor
+       ╱──────╲
+      ╱Integration╲    → Médio, validam integração
+     ╱──────────────╲
+    ╱   Unit Tests    ╲ → Muitos, rápidos, baratos
+   ╱════════════════════╲`,
+            process: 'Processo',
+            processBody: `1. **BDD primeiro** — cenários Gherkin antes de código
+2. **TDD** — RED → GREEN → REFACTOR
+3. **Coverage** — verificar após cada implementação
+4. **Regressão** — TODOS os testes antigos devem continuar passando
+5. **Review** — testes são revisados junto com código`,
+            refactoringRoadmap: 'Refactoring Roadmap'
+        },
+        techDebt: {
+            description: 'Tech Debt Controller — Controle de débito técnico e metas de score',
+            title: '📊 TECH DEBT CONTROLLER',
+            controlFor: 'Controle de débito técnico para {projectName}',
+            currentState: 'Estado Atual',
+            stateTable: `| Métrica | Valor |
+|---------|-------|
+| Score | {score}/100 |
+| Meta | {target}/100 |
+| Anti-patterns | {antiPatterns} |
+| Refatorações pendentes | {refactoringSteps} |
+| Estimativa de Melhora | +{improvement} pontos |`,
+            refactoringRoadmap: 'Roadmap de Refatoração',
+            scoreTargets: 'Metas de Score',
+            scoreTargetsBody: `Score Atual:            {score}/100
+Meta Curto Prazo:       {targetShort}/100
+Meta Médio Prazo:       {targetMedium}/100
+Mínimo Aceitável:       {threshold}/100`,
+            rules: 'Regras',
+            rulesBody: `□ Score NUNCA pode regredir após um PR
+□ Mínimo: {threshold}/100
+□ Críticos: resolver dentro de 1 sprint
+□ Altos: resolver dentro de 2 sprints
+□ Médios: adicionar ao backlog técnico
+□ Verificar com: architect score ./src`
+        },
+        codeReview: {
+            description: 'Code Review Checklist — Pontos obrigatórios de revisão',
+            title: '🔍 CODE REVIEW CHECKLIST — {projectName}',
+            mandatoryRule: '**Todo PR deve ser verificado contra este checklist.**',
+            mandatory: 'Obrigatório',
+            mandatoryBody: `□ Código compila sem erros
+□ Todos os testes passam
+□ Cobertura ≥ {coverage}%
+□ Lint sem errors
+□ Nenhum secret hardcoded
+□ Score não regrediu`,
+            functional: 'Funcional',
+            functionalBody: `□ Atende aos critérios de aceite
+□ Edge cases tratados
+□ Erros tratados adequadamente
+□ Não quebra features existentes`,
+            quality: 'Qualidade',
+            qualityBody: `□ Código legível sem comentários explicativos
+□ Naming descritivo e consistente
+□ Funções pequenas e com responsabilidade única
+□ Sem código duplicado (DRY)
+□ Lógica complexa está isolada em funções testáveis
+□ Sem grandes blocos de código comentado`,
+            domainReviewItems: 'Itens de Revisão Específicos do Domínio: {domain}',
+            domainRules: {
+                fintech: `□ Transações são idempotentes?
+□ Auditoria completa de todas as operações?
+□ Sem exposição de dados sensíveis em logs?
+□ Valores monetários não usam float (usar Decimal)?
+□ PCI-DSS compliance verificado?`,
+                healthtech: `□ LGPD compliance verificado (consentimento, retenção)?
+□ Dados sensíveis criptografados em repouso?
+□ Acesso auditado e logado?
+□ Anonimização implementada corretamente?
+□ 2FA em operações sensíveis?`,
+                ecommerce: `□ Carrinho é idempotente?
+□ Inventário é atualizado corretamente (race conditions)?
+□ Preços são validados (sem manipulação client-side)?
+□ Cupons/descontos aplicados corretamente?
+□ Fraude detection implementado?`,
+                default: `□ Fluxo crítico de negócio não quebrou?
+□ Rollback é seguro?
+□ Concorrência tratada?
+□ State final é consistente?`
+            },
+            stackReviewItems: 'Checklist Específico para {stack}',
+            stackRules: {
+                ts: `□ \`strict: true\` em tsconfig (sem any sem justificativa)?
+□ Imports circulares?
+□ Async/await tratado (sem unhandled promises)?
+□ Memory leaks (EventListeners desinscritos)?
+□ Console.log/debugger removidos?`,
+                python: `□ Type hints em todas as funções públicas?
+□ Docstrings formatadas (Google ou NumPy style)?
+□ Sem mutable default arguments?
+□ Context managers usados para resources?
+□ F-strings em vez de % ou .format()?
+□ Sem \`eval()\` ou \`exec()\`?`,
+                go: `□ Erros tratados (não ignorados com _)?
+□ Defer para cleanup?
+□ Goroutines com contexto?
+□ Race conditions testadas?
+□ Timeouts implementados?`,
+                dart: `□ Null-safety (! evitado)?
+□ Widgets têm keys quando em listas?
+□ BuildContext acessado apenas em build?
+□ Listeners desinscritos?
+□ Imagens/assets fazem lazy-load?`,
+                default: `□ Código segue padrões do projeto?
+□ Dependencies atualizadas?
+□ Sem warnings do compilador/linter?`
+            },
+            integrationReviewItems: 'Itens de Revisão de Integração',
+            integrationRulesBody: `□ Endpoint trata todos os status codes esperados?
+□ Validação do payload de entrada?
+{auth}
+{validation}
+□ Resposta segue o contrato documentado?
+□ Erros retornam mensagens claras?
+□ Rate limiting aplicado?
+□ Logging estruturado?`
+        }
+    },
+    // === DYNAMIC BLOCKS ===
+    dynamic: {
+        compliance: {
+            title: 'Requisitos de Compliance Detectados',
+            reason: 'Motivo',
+            mandatoryChecks: 'Verificações Obrigatórias'
+        },
+        integrations: {
+            title: 'Segurança em Integrações',
+            threats: 'Ameaças',
+            types: {
+                payment: 'PCI-DSS, criptografia de dados sensíveis, tokenização',
+                auth: 'MFA, session hijacking, credential stuffing',
+                api: 'Rate limiting, API key rotation, HTTPS obrigatório',
+                database: 'SQL Injection, Encryption at rest, Backups',
+                government: 'Compliance regulatório, audit trails, data retention',
+                default: 'Validação de entrada/saída, rate limiting'
+            }
+        },
+        domainThreats: {
+            title: 'Ameaças Específicas do Domínio: {domain}',
+            fintech: `- **Manipulação de dados:** Auditoria de transações, checksums, criptografia
+- **Acesso não autorizado:** MFA em contas privilégiadas, IP whitelist
+- **Conformidade:** PCI-DSS, LGPD, SOX
+- **Fraude:** Detecção de anomalias, rate limiting`,
+            healthtech: `- **Vazamento de dados:** Criptografia end-to-end, anonimização
+- **HIPAA/LGPD:** Audit trails, consentimento explícito
+- **Integridade:** Assinatura digital, blockchain se aplicável
+- **Acesso:** RBAC granular, 2FA para dados sensíveis`,
+            ecommerce: `- **Fraude de pagamento:** CVV validation, 3D Secure
+- **Roubo de dados:** SSL/TLS, PCI-DSS, criptografia em repouso
+- **DoS:** Rate limiting, CAPTCHA, WAF
+- **Autenticação:** MFA, session timeout`,
+            default: `- **Confidencialidade:** Dados em trânsito e repouso criptografados
+- **Integridade:** Validação de entrada, checksums
+- **Disponibilidade:** Backup, disaster recovery, monitoring
+- **Auditoria:** Logging de ações sensíveis, retention policy`
+        },
+        qaDomain: {
+            title: 'Cenários de Teste Específicos do Domínio: {domain}',
+            fintech: `### Testes de Negócio
+- Criar transação com valores válidos
+- Rejeitar transação acima do limite
+- Processar reembolso corretamente
+- Auditoria de todas as transações
+- Validar saldo após múltiplas operações
+
+### Testes de Segurança
+- Não expor dados de cartão em logs
+- Validar PCI-DSS compliance
+- Testar detecção de fraude`,
+            healthtech: `### Testes de Negócio
+- Criar registro de paciente com LGPD compliance
+- Validar consentimento antes de compartilhar dados
+- Anonimizar dados corretamente
+- Respeitar direito ao esquecimento
+- Auditoria de acesso a dados sensíveis
+
+### Testes de Segurança
+- Criptografia end-to-end em repouso
+- Validar 2FA para dados críticos
+- Testar retenção de dados`,
+            ecommerce: `### Testes de Negócio
+- Criar carrinho com múltiplos produtos
+- Aplicar desconto/cupom corretamente
+- Processar pagamento com validação 3DS
+- Atualizar inventário após venda
+- Gerar pedido com status correto
+
+### Testes de Segurança
+- Não expor dados de cartão
+- Validar rate limiting em checkout
+- Testar proteção contra fraud`,
+            default: `### Testes de Negócio
+- Fluxo principal (happy path)
+- Edge cases e limites
+- Concorrência (race conditions)
+- Rollback após erro
+- Idempotência
+
+### Testes de Segurança
+- Inputs inválidos/maliciosos
+- Acesso não autorizado
+- Rate limiting
+- Logging correto`
+        }
+    }
+};
+//# sourceMappingURL=pt-BR.js.map

package/dist/src/core/locales/pt-BR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pt-BR.js","sourceRoot":"","sources":["../../../../src/core/locales/pt-BR.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,cAAc;IACd,GAAG,EAAE;QACH,MAAM,EAAE;YACN,IAAI,EAAE,EAAE,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,gCAAgC,EAAE;YACvE,YAAY,EAAE,EAAE,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,+BAA+B,EAAE;YACnF,MAAM,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,2BAA2B,EAAE;YACtE,YAAY,EAAE,EAAE,KAAK,EAAE,kBAAkB,EAAE,IAAI,EAAE,0BAA0B,EAAE;YAC7E,OAAO,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,kCAAkC,EAAE;YAC9E,SAAS,EAAE,EAAE,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,oBAAoB,EAAE;YACnE,SAAS,EAAE,EAAE,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,4BAA4B,EAAE;SAC1E;QACD,OAAO,EAAE;YACP,KAAK,EAAE,oBAAoB;YAC3B,WAAW,EAAE,eAAe;YAC5B,KAAK,EAAE,UAAU;YACjB,KAAK,EAAE,QAAQ;YACf,YAAY,EAAE,eAAe;YAC7B,KAAK,EAAE,QAAQ;YACf,MAAM,EAAE,SAAS;SAClB;KACF;IAED,yBAAyB;IACzB,MAAM,EAAE;QACN,WAAW,EAAE,2BAA2B;QACxC,OAAO,EAAE;YACP,WAAW,EAAE,8DAA8D;YAC3E,KAAK,EAAE,6BAA6B;YACpC,YAAY,EAAE,iDAAiD;YAC/D,KAAK,EAAE,OAAO;YACd,QAAQ,EAAE,WAAW;YACrB,SAAS,EAAE,WAAW;YACtB,YAAY,EAAE,aAAa;YAC3B,IAAI,EAAE,OAAO;YACb,cAAc,EAAE,iBAAiB;YACjC,YAAY,EAAE,aAAa;YAC3B,aAAa,EAAE,+BAA+B;YAC9C,UAAU,EAAE,yCAAyC;YACrD,OAAO,EAAE,oBAAoB;YAC7B,gBAAgB,EAAE,kCAAkC;YACpD,mBAAmB,EAAE,yBAAyB;YAC9C,uBAAuB,EAAE;;;;;;;;0BAQL;YACpB,mBAAmB,EAAE,4BAA4B;YACjD,uBAAuB,EAAE;;;;;;;+CAOgB;SAC1C;QACD,QAAQ,EAAE;YACR,WAAW,EAAE,6DAA6D;YAC1E,KAAK,EAAE,4BAA4B;YACnC,YAAY,EAAE,kDAAkD;YAChE,aAAa,EAAE,iCAAiC;YAChD,iBAAiB,EAAE;;;;;;;iDAOwB;YAC3C,mBAAmB,EAAE,yBAAyB;YAC9C,uBAAuB,EAAE;;;;;;;;;;;;0BAYL;SACrB;QACD,QAAQ,EAAE;YACR,WAAW,EAAE,qEAAqE;YAClF,KAAK,EAAE,sBAAsB;YAC7B,WAAW,EAAE,yCAAyC;YACtD,SAAS,EAAE,wBAAwB;YACnC,aAAa,EAAE;;;;;;;;;8CASyB;YACxC,cAAc,EAAE,eAAe;YAC/B,kBAAkB,EAAE;;;2BAGC;YACrB,cAAc,EAAE,iBAAiB;YACjC,kBAAkB,EAAE;;+BAEK;SAC1B;QACD,EAAE,EAAE;YACF,WAAW,EAAE,wDAAwD;YACrE,KAAK,EAAE,qBAAqB;YAC5B,UAAU,EAAE,wCAAwC;YACpD,aAAa,EAAE,oBAAoB;YACnC,iBAAiB,EAAE;;;;6CAIoB;YACvC,OAAO,EAAE,oBAAoB;YAC7B,WAAW,EAAE;;;;;;0BAMO;YACpB,OAAO,EAAE,UAAU;YACnB,WAAW,EAAE;;;;sDAImC;YAChD,kBAAkB,EAAE,qBAAqB;SAC1C;QACD,QAAQ,EAAE;YACR,WAAW,EAAE,oEAAoE;YACjF,KAAK,EAAE,yBAAyB;YAChC,UAAU,EAAE,+CAA+C;YAC3D,YAAY,EAAE,cAAc;YAC5B,UAAU,EAAE;;;;;;kDAMgC;YAC5C,kBAAkB,EAAE,wBAAwB;YAC5C,YAAY,EAAE,gBAAgB;YAC9B,gBAAgB,EAAE;;;wCAGgB;YAClC,KAAK,EAAE,QAAQ;YACf,SAAS,EAAE;;;;;uCAKsB;SAClC;QACD,UAAU,EAAE;YACV,WAAW,EAAE,wDAAwD;YACrE,KAAK,EAAE,0CAA0C;YACjD,aAAa,EAAE,wDAAwD;YACvE,SAAS,EAAE,aAAa;YACxB,aAAa,EAAE;;;;;qBAKA;YACf,UAAU,EAAE,WAAW;YACvB,cAAc,EAAE;;;iCAGW;YAC3B,OAAO,EAAE,WAAW;YACpB,WAAW,EAAE;;;;;yCAKsB;YACnC,iBAAiB,EAAE,mDAAmD;YACtE,WAAW,EAAE;gBACX,OAAO,EAAE;;;;iCAIgB;gBACzB,UAAU,EAAE;;;;8BAIU;gBACtB,SAAS,EAAE;;;;iCAIc;gBACzB,OAAO,EAAE;;;6BAGY;aACtB;YACD,gBAAgB,EAAE,mCAAmC;YACrD,UAAU,EAAE;gBACV,EAAE,EAAE;;;;kCAIsB;gBAC1B,MAAM,EAAE;;;;;gCAKgB;gBACxB,EAAE,EAAE;;;;0BAIc;gBAClB,IAAI,EAAE;;;;kCAIoB;gBAC1B,OAAO,EAAE;;qCAEoB;aAC9B;YACD,sBAAsB,EAAE,gCAAgC;YACxD,oBAAoB,EAAE;;;;;;;uBAOL;SAClB;KACF;IAED,yBAAyB;IACzB,OAAO,EAAE;QACP,UAAU,EAAE;YACV,KAAK,EAAE,qCAAqC;YAC5C,MAAM,EAAE,QAAQ;YAChB,eAAe,EAAE,2BAA2B;SAC7C;QACD,YAAY,EAAE;YACZ,KAAK,EAAE,0BAA0B;YACjC,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE;gBACL,OAAO,EAAE,uDAAuD;gBAChE,IAAI,EAAE,6CAA6C;gBACnD,GAAG,EAAE,oDAAoD;gBACzD,QAAQ,EAAE,4CAA4C;gBACtD,UAAU,EAAE,sDAAsD;gBAClE,OAAO,EAAE,2CAA2C;aACrD;SACF;QACD,aAAa,EAAE;YACb,KAAK,EAAE,0CAA0C;YACjD,OAAO,EAAE;;;mDAGoC;YAC7C,UAAU,EAAE;;;sDAGoC;YAChD,SAAS,EAAE;;;yCAGwB;YACnC,OAAO,EAAE;;;8DAG+C;SACzD;QACD,QAAQ,EAAE;YACR,KAAK,EAAE,oDAAoD;YAC3D,OAAO,EAAE;;;;;;;;;;4BAUa;YACtB,UAAU,EAAE;;;;;;;;;;2BAUS;YACrB,SAAS,EAAE;;;;;;;;;;+BAUc;YACzB,OAAO,EAAE;;;;;;;;;;;kBAWG;SACb;KACF;CACF,CAAC"}

package/dist/src/core/locales/types.d.ts

@@ -0,0 +1,86 @@
+export interface TranslationDictionary {
+    common: {
+        generatedBy: string;
+        mandatory: string;
+        yes: string;
+        no: string;
+        action: string;
+    };
+    progress: {
+        scan: string;
+        dependencies: string;
+        layers: string;
+        antipatterns: string;
+        scoring: string;
+        normalize: string;
+        summarize: string;
+        scanningSystem: string;
+        mappingGraph: string;
+        classifyingArch: string;
+        detectingAntiPatterns: string;
+        computingMetrics: string;
+        normalizingPaths: string;
+        generatingSummary: string;
+    };
+    agents: {
+        backend: {
+            description: string;
+            title: string;
+            specialistIn: string;
+            stack: string;
+            principles: string;
+            projectStructure: string;
+            implementationRules: string;
+            rulesBody: string;
+            afterImplementation: string;
+            afterBody: string;
+        };
+        frontend: {
+            description: string;
+            title: string;
+            specialistIn: string;
+            stack: string;
+            prerequisites: string;
+            prerequisitesBody: string;
+            implementationRules: string;
+            rulesBody: string;
+        };
+        security: {
+            description: string;
+            title: string;
+            analysisFor: string;
+            checklist: string;
+            checklistBody: string;
+            whenToActivate: string;
+            whenBody: string;
+            expectedOutput: string;
+            outputBody: string;
+        };
+        qa: {
+            description: string;
+            title: string;
+            qualityFor: string;
+            nonNegotiable: string;
+            nonNegotiableBody: (min: number) => string;
+            pyramid: string;
+            process: string;
+            processBody: string;
+        };
+        techDebt: {
+            description: string;
+            title: string;
+            controlFor: string;
+            currentState: string;
+            roadmap: string;
+            targets: string;
+            rules: string;
+        };
+    };
+    enriched: {
+        modules: string;
+        endpoints: string;
+        domainContext: string;
+        untestedModules: string;
+        untestedModulesBody: (count: number) => string;
+    };
+}

package/dist/src/core/locales/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/core/locales/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/core/locales/types.ts"],"names":[],"mappings":""}

package/dist/src/core/plugin-loader.d.ts

@@ -0,0 +1,11 @@
+import { CustomAntiPatternDetector } from './types/plugin.js';
+import { ArchitectConfig } from './types/core.js';
+export declare class PluginLoader {
+    private projectPath;
+    private config;
+    private customDetectors;
+    constructor(projectPath: string, config: ArchitectConfig);
+    get customAntiPatternDetectors(): CustomAntiPatternDetector[];
+    loadPlugins(): Promise<void>;
+    private loadSinglePlugin;
+}

package/dist/src/core/plugin-loader.js

@@ -0,0 +1,67 @@
+import path from 'path';
+import fs from 'fs';
+import { logger } from '../infrastructure/logger.js';
+export class PluginLoader {
+    projectPath;
+    config;
+    customDetectors = [];
+    constructor(projectPath, config) {
+        this.projectPath = projectPath;
+        this.config = config;
+    }
+    get customAntiPatternDetectors() {
+        return this.customDetectors;
+    }
+    async loadPlugins() {
+        if (!this.config.plugins || this.config.plugins.length === 0) {
+            return;
+        }
+        const context = {
+            projectPath: this.projectPath,
+            config: this.config
+        };
+        for (const pluginSpec of this.config.plugins) {
+            try {
+                await this.loadSinglePlugin(pluginSpec, context);
+            }
+            catch (err) {
+                logger.warn(`[Architect Plugin] Failed to load plugin '${pluginSpec}': ${err.message}`);
+            }
+        }
+    }
+    async loadSinglePlugin(pluginSpec, context) {
+        // 1. Resolve path (could be relative to project or node_modules)
+        let pluginPath = pluginSpec;
+        // If it starts with ./ or ../ we assume it's relative to the target project
+        if (pluginSpec.startsWith('./') || pluginSpec.startsWith('../')) {
+            pluginPath = path.resolve(this.projectPath, pluginSpec);
+        }
+        // Verify file exists if we are resolving a local JS file to avoid unhelpful stack traces
+        if (!pluginSpec.startsWith('@') && !pluginSpec.match(/^[a-z0-9_-]+$/i)) {
+            if (!fs.existsSync(pluginPath)) {
+                throw new Error(`File not found at ${pluginPath}`);
+            }
+            // Node 20+ ESM dynamic imports need absolute file:// URIs on Windows
+            if (process.platform === 'win32') {
+                pluginPath = `file://${pluginPath.replace(/\\/g, '/')}`;
+            }
+        }
+        // 2. Load the module using dynamic import
+        const pluginModule = await import(pluginPath);
+        // 3. Extract default export mapping
+        const plugin = pluginModule.default || pluginModule;
+        if (!plugin || typeof plugin !== 'object') {
+            throw new Error(`Plugin must export an 'ArchitectPlugin' object as default.`);
+        }
+        // 4. Register hooks
+        if (typeof plugin.detectAntiPatterns === 'function') {
+            // Wrap the detector so it automatically receives the PluginContext
+            const wrappedDetector = async (fileTree, deps) => {
+                return plugin.detectAntiPatterns(fileTree, deps, context);
+            };
+            this.customDetectors.push(wrappedDetector);
+            logger.info(`[Architect Plugin] Registered Custom Rules from: ${plugin.name || pluginSpec}`);
+        }
+    }
+}
+//# sourceMappingURL=plugin-loader.js.map