opencode-telos 1.0.0

package/src/sdd/analysis/compliance.ts

@@ -0,0 +1,279 @@
+import type { KnowledgeGraph } from '../domain/types.js'
+
+export interface ComplianceCheckResult {
+  standard: string
+  requirements: Array<{
+    id: string
+    description: string
+    status: 'met' | 'partially_met' | 'not_met'
+    evidence?: string
+    gap?: string
+  }>
+  score: number
+  recommendations: string[]
+}
+
+export interface ComplianceOptions {
+  /** Custom compliance requirements to add alongside standard ones. */
+  customStandards?: Array<{ id: string; description: string; check: (graph: KnowledgeGraph) => 'met' | 'partially_met' | 'not_met' }>
+  /** Only check these specific requirement IDs. */
+  focusRequirements?: string[]
+  /** Skip these requirement IDs. */
+  excludeChecks?: string[]
+  /** Max requirements to evaluate. */
+  maxRequirements?: number
+}
+
+export function checkCompliance(
+  _graph: KnowledgeGraph,
+  standard: string,
+  options?: ComplianceOptions,
+): ComplianceCheckResult {
+  const requirements: ComplianceCheckResult['requirements'] = []
+  const recommendations: string[] = []
+  const maxReqs = options?.maxRequirements ?? Infinity
+
+  if (standard === 'GDPR') {
+    requirements.push({
+      id: 'GDPR-001',
+      description: 'Consentimento para coleta de dados',
+      status: 'not_met',
+      gap: 'Não há nós de consentimento no grafo',
+    })
+    requirements.push({
+      id: 'GDPR-002',
+      description: 'Direito ao esquecimento',
+      status: 'not_met',
+      gap: 'Não há implementação de exclusão de dados',
+    })
+    requirements.push({
+      id: 'GDPR-003',
+      description: 'Portabilidade de dados',
+      status: 'not_met',
+      gap: 'Não há exportação de dados implementada',
+    })
+    recommendations.push('Adicionar nós de consentimento')
+    recommendations.push('Implementar mecanismo de exclusão')
+    recommendations.push('Adicionar exportação de dados do usuário')
+  } else if (standard === 'LGPD') {
+    requirements.push({
+      id: 'LGPD-001',
+      description: 'Consentimento para coleta de dados pessoais',
+      status: 'not_met',
+      gap: 'Não há nós de consentimento no grafo',
+    })
+    requirements.push({
+      id: 'LGPD-002',
+      description: 'Finalidade específica para coleta',
+      status: 'not_met',
+      gap: 'Não há definição de finalidade para cada coleta',
+    })
+    requirements.push({
+      id: 'LGPD-003',
+      description: 'Direito de acesso e correção',
+      status: 'not_met',
+      gap: 'Não há mecanismo de acesso e correção de dados',
+    })
+    requirements.push({
+      id: 'LGPD-004',
+      description: 'Direito de exclusão (anonymização)',
+      status: 'not_met',
+      gap: 'Não há mecanismo de exclusão ou anonimização',
+    })
+    requirements.push({
+      id: 'LGPD-005',
+      description: 'Relatório de impacto à proteção de dados (RIPD)',
+      status: 'not_met',
+      gap: 'Não há RIPD documentado',
+    })
+    requirements.push({
+      id: 'LGPD-006',
+      description: 'Encarregado de dados (DPO)',
+      status: 'not_met',
+      gap: 'Não há DPO definido',
+    })
+    recommendations.push('Adicionar nós de consentimento com finalidade específica')
+    recommendations.push('Implementar mecanismo de acesso e correção de dados')
+    recommendations.push('Implementar exclusão ou anonimização de dados pessoais')
+    recommendations.push('Criar Relatório de Impacto à Proteção de Dados (RIPD)')
+    recommendations.push('Definir Encarregado de Dados (DPO)')
+    recommendations.push('Documentar bases legais para tratamento de dados')
+  } else if (standard === 'HIPAA') {
+    requirements.push({
+      id: 'HIPAA-001',
+      description: 'Criptografia de dados sensíveis',
+      status: 'not_met',
+      gap: 'Não há criptografia implementada',
+    })
+    requirements.push({
+      id: 'HIPAA-002',
+      description: 'Controle de acesso',
+      status: 'partially_met',
+      evidence: 'Sistema de permissões existe',
+    })
+    requirements.push({
+      id: 'HIPAA-003',
+      description: 'Audit trail',
+      status: 'partially_met',
+      evidence: 'Sistema de auditoria existe',
+    })
+    recommendations.push('Implementar criptografia em repouso e trânsito')
+    recommendations.push('Melhorar controle de acesso')
+  } else if (standard === 'SOC2') {
+    requirements.push({
+      id: 'SOC2-001',
+      description: 'Controle de acesso lógico',
+      status: 'partially_met',
+      evidence: 'Sistema de permissões existe',
+    })
+    requirements.push({
+      id: 'SOC2-002',
+      description: 'Mudanças autorizadas',
+      status: 'met',
+      evidence: 'Sistema de Change management implementado',
+    })
+    requirements.push({
+      id: 'SOC2-003',
+      description: 'Monitoramento de atividades',
+      status: 'not_met',
+      gap: 'Não há sistema de monitoramento',
+    })
+    recommendations.push('Implementar sistema de monitoramento')
+    recommendations.push('Adicionar alertas de segurança')
+  } else if (standard === 'PCI_DSS') {
+    requirements.push({
+      id: 'PCI-001',
+      description: 'Criptografia de dados de cartão de crédito',
+      status: 'not_met',
+      gap: 'Não há criptografia de dados de pagamento implementada',
+    })
+    requirements.push({
+      id: 'PCI-002',
+      description: 'Controle de acesso a dados de cartão',
+      status: 'not_met',
+      gap: 'Não há controle de acesso específico para dados de pagamento',
+    })
+    requirements.push({
+      id: 'PCI-003',
+      description: 'Monitoramento de acesso a dados de cartão',
+      status: 'not_met',
+      gap: 'Não há monitoramento de acesso a dados de pagamento',
+    })
+    requirements.push({
+      id: 'PCI-004',
+      description: 'Testes de segurança regulares',
+      status: 'not_met',
+      gap: 'Não há testes de segurança automatizados',
+    })
+    recommendations.push('Implementar criptografia AES-256 para dados de pagamento')
+    recommendations.push('Implementar tokenização para dados de cartão')
+    recommendations.push('Adicionar controle de acesso baseado em função (RBAC)')
+    recommendations.push('Implementar monitoramento em tempo real')
+    recommendations.push('Adicionar testes de segurança automatizados')
+  } else if (standard === 'ISO27001') {
+    requirements.push({
+      id: 'ISO-001',
+      description: 'Política de segurança da informação',
+      status: 'not_met',
+      gap: 'Não há política de segurança documentada',
+    })
+    requirements.push({
+      id: 'ISO-002',
+      description: 'Gestão de riscos',
+      status: 'not_met',
+      gap: 'Não há processo de gestão de riscos',
+    })
+    requirements.push({
+      id: 'ISO-003',
+      description: 'Controles de segurança',
+      status: 'partially_met',
+      evidence: 'Sistema de permissões existe',
+    })
+    requirements.push({
+      id: 'ISO-004',
+      description: 'Gestão de incidentes',
+      status: 'not_met',
+      gap: 'Não há processo formal de gestão de incidentes',
+    })
+    requirements.push({
+      id: 'ISO-005',
+      description: 'Continuidade de negócios',
+      status: 'not_met',
+      gap: 'Não há plano de continuidade de negócios',
+    })
+    recommendations.push('Documentar política de segurança da informação')
+    recommendations.push('Implementar processo de gestão de riscos')
+    recommendations.push('Estabelecer processo formal de gestão de incidentes')
+    recommendations.push('Criar plano de continuidade de negócios')
+    recommendations.push('Realizar auditorias internas regulares')
+  } else {
+    requirements.push({
+      id: 'GENERIC-001',
+      description: 'Autenticação e autorização',
+      status: 'partially_met',
+      evidence: 'Sistema de permissões existe',
+    })
+    recommendations.push('Verificar requisitos específicos do padrão')
+  }
+
+  // Apply custom standards
+  if (options?.customStandards?.length) {
+    for (const custom of options.customStandards) {
+      if (requirements.length >= maxReqs) break
+      if (options.excludeChecks?.includes(custom.id)) continue
+      if (options.focusRequirements?.length && !options.focusRequirements.includes(custom.id)) continue
+      requirements.push({
+        id: custom.id,
+        description: custom.description,
+        status: custom.check(_graph),
+      })
+    }
+  }
+
+  // Apply focus/exclude filters
+  const filteredReqs = requirements.filter((r) => {
+    if (options?.excludeChecks?.includes(r.id)) return false
+    if (options?.focusRequirements?.length && !options.focusRequirements.includes(r.id)) return false
+    return true
+  }).slice(0, maxReqs)
+
+  const metCount = filteredReqs.filter(r => r.status === 'met').length
+  const partialCount = filteredReqs.filter(r => r.status === 'partially_met').length
+  const score = filteredReqs.length > 0
+    ? Math.round(((metCount + partialCount * 0.5) / filteredReqs.length) * 100)
+    : 0
+
+  return { standard, requirements: filteredReqs, score, recommendations }
+}
+
+export function formatComplianceCheck(result: ComplianceCheckResult): string {
+  const lines = [
+    `## Verificação de Compliance - ${result.standard}`,
+    '',
+    `**Score:** ${result.score}/100`,
+    `**Requisitos:** ${result.requirements.length}`,
+    '',
+  ]
+
+  lines.push('### Status dos Requisitos')
+  for (const req of result.requirements) {
+    const statusIcon = req.status === 'met' ? '✅' : 
+                      req.status === 'partially_met' ? '⚠️' : '❌'
+    lines.push(`${statusIcon} **${req.id}**: ${req.description}`)
+    
+    if (req.evidence) {
+      lines.push(`   - Evidência: ${req.evidence}`)
+    }
+    if (req.gap) {
+      lines.push(`   - Lacuna: ${req.gap}`)
+    }
+  }
+
+  lines.push('')
+  lines.push('### Recomendações')
+  for (const rec of result.recommendations) {
+    lines.push(`- ${rec}`)
+  }
+
+  return lines.join('\n')
+}

package/src/sdd/analysis/scalability.ts

@@ -0,0 +1,97 @@
+import type { KnowledgeGraph } from '../domain/types.js'
+
+export interface ScalabilityAnalysisResult {
+  bottlenecks: Array<{
+    type: string
+    location: string
+    impact: 'high' | 'medium' | 'low'
+    description: string
+    recommendation: string
+  }>
+  score: number
+  recommendations: string[]
+}
+
+export function analyzeScalability(graph: KnowledgeGraph): ScalabilityAnalysisResult {
+  const bottlenecks: ScalabilityAnalysisResult['bottlenecks'] = []
+  const recommendations: string[] = []
+
+  const endpoints = graph.nodes.filter(n => n.type === 'endpoint')
+  const entities = graph.nodes.filter(n => n.type === 'entity')
+  
+  for (const endpoint of endpoints) {
+    const meta = endpoint.metadata as any
+    
+    if (meta.method === 'GET' && meta.path.includes(':id')) {
+      bottlenecks.push({
+        type: 'n_plus_one_query',
+        location: `${meta.method} ${meta.path}`,
+        impact: 'medium',
+        description: 'Endpoint de busca por ID pode ter problema N+1',
+        recommendation: 'Implementar eager loading ou batch queries',
+      })
+    }
+  }
+
+  if (entities.length > 20) {
+    bottlenecks.push({
+      type: 'complex_data_model',
+      location: 'Knowledge Graph',
+      impact: 'medium',
+      description: `${entities.length} entidades podem causar complexidade`,
+      recommendation: 'Considerar particionamento ou caching',
+    })
+  }
+
+  const databases = graph.nodes.filter(n => n.type === 'database')
+  if (databases.length === 0 && entities.length > 5) {
+    bottlenecks.push({
+      type: 'missing_database',
+      location: 'Arquitetura',
+      impact: 'high',
+      description: 'Sistema com muitas entidades sem banco de dados definido',
+      recommendation: 'Definir estratégia de persistência',
+    })
+  }
+
+  const score = Math.max(0, 100 - bottlenecks.length * 20)
+
+  recommendations.push('Implementar caching para consultas frequentes')
+  recommendations.push('Considerar índices para campos de busca')
+  
+  if (bottlenecks.length > 0) {
+    recommendations.push('Revisar gargalos identificados')
+  }
+
+  return { bottlenecks, score, recommendations }
+}
+
+export function formatScalabilityAnalysis(result: ScalabilityAnalysisResult): string {
+  const lines = [
+    '## Análise de Escalabilidade',
+    '',
+    `**Score:** ${result.score}/100`,
+    `**Gargalos:** ${result.bottlenecks.length}`,
+    '',
+  ]
+
+  if (result.bottlenecks.length > 0) {
+    lines.push('### Gargalos Identificados')
+    for (const bottleneck of result.bottlenecks) {
+      lines.push(`#### ${bottleneck.type} (${bottleneck.impact})`)
+      lines.push(`- **Local:** ${bottleneck.location}`)
+      lines.push(`- **Descrição:** ${bottleneck.description}`)
+      lines.push(`- **Recomendação:** ${bottleneck.recommendation}`)
+      lines.push('')
+    }
+  } else {
+    lines.push('✅ Nenhum gargalo crítico identificado')
+  }
+
+  lines.push('### Recomendações de Escalabilidade')
+  for (const rec of result.recommendations) {
+    lines.push(`- ${rec}`)
+  }
+
+  return lines.join('\n')
+}

package/src/sdd/analysis/security.ts

@@ -0,0 +1,135 @@
+import type { KnowledgeGraph } from '../domain/types.js'
+
+export interface SecurityAuditResult {
+  vulnerabilities: Array<{
+    type: string
+    severity: 'critical' | 'high' | 'medium' | 'low'
+    location: string
+    description: string
+    recommendation: string
+  }>
+  score: number
+  recommendations: string[]
+}
+
+export interface SecurityAuditOptions {
+  /** Only audit these specific endpoint IDs. */
+  focusEndpoints?: string[]
+  /** Only audit these specific entity IDs. */
+  focusEntities?: string[]
+  /** Minimum severity to include in results. */
+  minSeverity?: 'critical' | 'high' | 'medium' | 'low'
+  /** Max vulnerabilities to report. */
+  maxVulnerabilities?: number
+}
+
+const SEVERITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 }
+
+export function performSecurityAudit(
+  graph: KnowledgeGraph,
+  options?: SecurityAuditOptions,
+): SecurityAuditResult {
+  const vulnerabilities: SecurityAuditResult['vulnerabilities'] = []
+  const recommendations: string[] = []
+  const maxVulns = options?.maxVulnerabilities ?? Infinity
+
+  // Filter endpoints
+  let endpoints = graph.nodes.filter(n => n.type === 'endpoint')
+  if (options?.focusEndpoints?.length) {
+    endpoints = endpoints.filter(e => options.focusEndpoints!.includes(e.id))
+  }
+  
+  for (const endpoint of endpoints) {
+    if (vulnerabilities.length >= maxVulns) break
+    const meta = endpoint.metadata as any
+    
+    if (meta.method === 'POST' || meta.method === 'PUT' || meta.method === 'DELETE') {
+      const hasAuth = graph.relationships.some(
+        r => r.from === endpoint.id && r.type === 'requires'
+      )
+      
+      if (!hasAuth) {
+        const vuln = {
+          type: 'missing_authentication',
+          severity: 'high' as const,
+          location: `${meta.method} ${meta.path}`,
+          description: 'Endpoint de modificação sem autenticação',
+          recommendation: 'Adicionar middleware de autenticação',
+        }
+        if (!options?.minSeverity || SEVERITY_ORDER[vuln.severity] <= SEVERITY_ORDER[options.minSeverity]) {
+          vulnerabilities.push(vuln)
+        }
+      }
+    }
+  }
+
+  // Filter entities
+  let entities = graph.nodes.filter(n => n.type === 'entity')
+  if (options?.focusEntities?.length) {
+    entities = entities.filter(e => options.focusEntities!.includes(e.id))
+  }
+  for (const entity of entities) {
+    if (vulnerabilities.length >= maxVulns) break
+    const fields = (entity.metadata as any).fields || []
+    const sensitiveFields = fields.filter((f: any) => 
+      f.name.includes('password') || 
+      f.name.includes('token') || 
+      f.name.includes('secret')
+    )
+    
+    if (sensitiveFields.length > 0) {
+      const vuln = {
+        type: 'sensitive_dataexposure',
+        severity: 'medium' as const,
+        location: `Entity: ${entity.name}`,
+        description: `Campos sensíveis detectados: ${sensitiveFields.map((f: any) => f.name).join(', ')}`,
+        recommendation: 'Criptografar ou mascarar campos sensíveis',
+      }
+      if (!options?.minSeverity || SEVERITY_ORDER[vuln.severity] <= SEVERITY_ORDER[options.minSeverity]) {
+        vulnerabilities.push(vuln)
+      }
+    }
+  }
+
+  const score = Math.max(0, 100 - vulnerabilities.length * 15)
+
+  if (vulnerabilities.length === 0) {
+    recommendations.push('Nenhuma vulnerabilidade crítica detectada')
+  } else {
+    recommendations.push('Corrigir vulnerabilidades antes de produção')
+    recommendations.push('Implementar HTTPS em todos os endpoints')
+    recommendations.push('Adicionar rate limiting')
+  }
+
+  return { vulnerabilities, score, recommendations }
+}
+
+export function formatSecurityAudit(result: SecurityAuditResult): string {
+  const lines = [
+    '## Relatório de Auditoria de Segurança',
+    '',
+    `**Score:** ${result.score}/100`,
+    `**Vulnerabilidades:** ${result.vulnerabilities.length}`,
+    '',
+  ]
+
+  if (result.vulnerabilities.length > 0) {
+    lines.push('### Vulnerabilidades Detectadas')
+    for (const vuln of result.vulnerabilities) {
+      lines.push(`#### ${vuln.type} (${vuln.severity})`)
+      lines.push(`- **Local:** ${vuln.location}`)
+      lines.push(`- **Descrição:** ${vuln.description}`)
+      lines.push(`- **Recomendação:** ${vuln.recommendation}`)
+      lines.push('')
+    }
+  } else {
+    lines.push('✅ Nenhuma vulnerabilidade detectada')
+  }
+
+  lines.push('### Recomendações Gerais')
+  for (const rec of result.recommendations) {
+    lines.push(`- ${rec}`)
+  }
+
+  return lines.join('\n')
+}