opencode-telos 1.0.0

package/src/sdd/code-quality/complexity.ts

@@ -0,0 +1,235 @@
+import { fileMatchesFocus } from "./utils.js"
+
+export interface FunctionComplexity {
+  name: string
+  file: string
+  line_start: number
+  line_end: number
+  cyclomatic: number
+  cognitive: number
+  lines: number
+  risk: 'low' | 'medium' | 'high' | 'very_high'
+}
+
+export interface ComplexityReport {
+  functions: FunctionComplexity[]
+  summary: {
+    total_functions: number
+    average_cyclomatic: number
+    average_cognitive: number
+    high_risk_count: number
+    very_high_risk_count: number
+  }
+}
+
+/**
+ * Options for controlling complexity analysis scope.
+ */
+export interface ComplexityAnalysisOptions {
+  /** Only analyze functions whose name matches these patterns. */
+  focusFunctions?: string[]
+  /** Skip functions whose name matches these patterns. */
+  excludeFunctions?: string[]
+  /** Minimum risk level to include in results. */
+  minRisk?: "low" | "medium" | "high" | "very_high"
+  /** Only analyze files matching these name patterns (supports * wildcard). */
+  focusFiles?: string[]
+  /** Maximum functions to report. */
+  maxResults?: number
+}
+
+function calculateCyclomaticComplexity(code: string): number {
+  let complexity = 1
+
+  const keywords = [
+    /\bif\b/g,
+    /\belse\s+if\b/g,
+    /\bwhile\b/g,
+    /\bfor\b/g,
+    /\bdo\b/g,
+    /\bswitch\b/g,
+    /\bcase\b/g,
+    /\bcatch\b/g,
+    /\b\?\:/g,
+    /\&\&/g,
+    /\|\|/g,
+    /\?\./g,
+  ]
+
+  for (const keyword of keywords) {
+    const matches = code.match(keyword)
+    if (matches) {
+      complexity += matches.length
+    }
+  }
+
+  return complexity
+}
+
+function calculateCognitiveComplexity(code: string): number {
+  let complexity = 0
+  let nestingLevel = 0
+
+  const lines = code.split('\n')
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+
+    if (trimmed.match(/\b(if|else\s+if|else|while|for|do|switch|catch)\b/)) {
+      complexity += 1 + nestingLevel
+      nestingLevel++
+    }
+
+    if (trimmed.match(/\}/)) {
+      nestingLevel = Math.max(0, nestingLevel - 1)
+    }
+
+    if (trimmed.match(/\b(break|continue)\b/)) {
+      complexity += 1
+    }
+
+    if (trimmed.match(/\b(goto)\b/)) {
+      complexity += 2
+    }
+  }
+
+  return complexity
+}
+
+function assessRisk(cyclomatic: number, cognitive: number): FunctionComplexity['risk'] {
+  if (cyclomatic > 20 || cognitive > 30) return 'very_high'
+  if (cyclomatic > 10 || cognitive > 15) return 'high'
+  if (cyclomatic > 5 || cognitive > 8) return 'medium'
+  return 'low'
+}
+
+export function analyzeComplexity(
+  code: string,
+  fileName: string,
+  options?: ComplexityAnalysisOptions,
+): ComplexityReport {
+  // Early return if file doesn't match focusFiles
+  if (options?.focusFiles?.length && !fileMatchesFocus(fileName, options.focusFiles)) {
+    return { functions: [], summary: { total_functions: 0, average_cyclomatic: 0, average_cognitive: 0, high_risk_count: 0, very_high_risk_count: 0 } }
+  }
+
+  const functions: FunctionComplexity[] = []
+  const riskOrder: Record<string, number> = { low: 0, medium: 1, high: 2, very_high: 3 }
+  const minRiskLevel = options?.minRisk ? riskOrder[options.minRisk] ?? 0 : 0
+
+  const functionRegex = /(?:function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\(|(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+\s*)?\{)/g
+
+  let match
+  while ((match = functionRegex.exec(code)) !== null) {
+    const name = match[1] || match[2] || match[3]
+
+    // Apply focus/exclude filters
+    if (options?.focusFunctions?.length && !options.focusFunctions.some(p => name.includes(p))) continue
+    if (options?.excludeFunctions?.length && options.excludeFunctions.some(p => name.includes(p))) continue
+
+    const startLine = code.substring(0, match.index).split('\n').length
+
+    let braceCount = 0
+    let endLine = startLine
+    let inFunction = false
+
+    for (let i = match.index; i < code.length; i++) {
+      if (code[i] === '{') {
+        braceCount++
+        inFunction = true
+      } else if (code[i] === '}') {
+        braceCount--
+        if (inFunction && braceCount === 0) {
+          endLine = code.substring(0, i + 1).split('\n').length
+          break
+        }
+      }
+    }
+
+    const functionCode = code.substring(match.index, code.indexOf('}', code.indexOf('{', match.index)) + 1)
+    const lines = endLine - startLine + 1
+
+    const cyclomatic = calculateCyclomaticComplexity(functionCode)
+    const cognitive = calculateCognitiveComplexity(functionCode)
+    const risk = assessRisk(cyclomatic, cognitive)
+
+    // Apply risk filter
+    if (riskOrder[risk] < minRiskLevel) continue
+
+    functions.push({
+      name,
+      file: fileName,
+      line_start: startLine,
+      line_end: endLine,
+      cyclomatic,
+      cognitive,
+      lines,
+      risk,
+    })
+  }
+
+  // Apply max results limit
+  const limitedFunctions = options?.maxResults ? functions.slice(0, options.maxResults) : functions
+
+  const totalFunctions = limitedFunctions.length
+  const avgCyclomatic = totalFunctions > 0 ? limitedFunctions.reduce((sum, f) => sum + f.cyclomatic, 0) / totalFunctions : 0
+  const avgCognitive = totalFunctions > 0 ? limitedFunctions.reduce((sum, f) => sum + f.cognitive, 0) / totalFunctions : 0
+  const highRiskCount = limitedFunctions.filter(f => f.risk === 'high').length
+  const veryHighRiskCount = limitedFunctions.filter(f => f.risk === 'very_high').length
+
+  return {
+    functions: limitedFunctions,
+    summary: {
+      total_functions: totalFunctions,
+      average_cyclomatic: Math.round(avgCyclomatic * 100) / 100,
+      average_cognitive: Math.round(avgCognitive * 100) / 100,
+      high_risk_count: highRiskCount,
+      very_high_risk_count: veryHighRiskCount,
+    },
+  }
+}
+
+export function formatComplexityReport(report: ComplexityReport): string {
+  const lines = [
+    '## Relatório de Complexidade',
+    '',
+    `**Total de Funções:** ${report.summary.total_functions}`,
+    `**Complexidade Ciclomática Média:** ${report.summary.average_cyclomatic}`,
+    `**Complexidade Cognitiva Média:** ${report.summary.average_cognitive}`,
+    `**Alto Risco:** ${report.summary.high_risk_count}`,
+    `**Risco Muito Alto:** ${report.summary.very_high_risk_count}`,
+    '',
+  ]
+
+  const highRisk = report.functions.filter(f => f.risk === 'high' || f.risk === 'very_high')
+
+  if (highRisk.length > 0) {
+    lines.push('### Funções de Alto Risco')
+    for (const func of highRisk) {
+      lines.push(`#### ${func.name} (${func.risk})`)
+      lines.push(`- **Arquivo:** ${func.file}`)
+      lines.push(`- **Linhas:** ${func.line_start}-${func.line_end} (${func.lines} linhas)`)
+      lines.push(`- **Ciclomática:** ${func.cyclomatic}`)
+      lines.push(`- **Cognitiva:** ${func.cognitive}`)
+      lines.push('')
+    }
+  }
+
+  const mediumRisk = report.functions.filter(f => f.risk === 'medium')
+  if (mediumRisk.length > 0) {
+    lines.push('### Funções de Risco Médio')
+    for (const func of mediumRisk) {
+      lines.push(`- **${func.name}**: ciclomática=${func.cyclomatic}, cognitiva=${func.cognitive}`)
+    }
+  }
+
+  lines.push(
+    '',
+    '### Recomendações',
+    '- Funções com complexidade ciclomática > 10 devem ser refatoradas',
+    '- Funções com complexidade cognitiva > 15 são difíceis de entender',
+    '- Considere extrair lógica complexa em funções menores',
+  )
+
+  return lines.join('\n')
+}

package/src/sdd/code-quality/conventions.ts

@@ -0,0 +1,220 @@
+import { readFileSync, existsSync, readdirSync } from "fs"
+import { join, extname, relative } from "path"
+
+export interface ProjectConventions {
+  naming: {
+    variables: "camelCase" | "snake_case" | "PascalCase" | "unknown"
+    functions: "camelCase" | "snake_case" | "PascalCase" | "unknown"
+    files: "camelCase" | "snake_case" | "PascalCase" | "kebab-case" | "unknown"
+    constants: "camelCase" | "UPPER_SNAKE_CASE" | "unknown"
+  }
+  imports: {
+    style: "relative" | "absolute" | "mixed"
+    useBarrelFiles: boolean
+    extension: "always" | "never" | "ts-only" | "unknown"
+  }
+  async: {
+    style: "async-await" | "promises" | "callbacks" | "mixed"
+    errorHandling: "try-catch" | "Result" | "error-first-cb" | "mixed"
+  }
+  structure: {
+    organization: "domain" | "feature" | "layer" | "flat" | "unknown"
+    hasIndexFiles: boolean
+    testLocation: "co-located" | "separate" | "mixed"
+  }
+  metadata: Record<string, unknown>
+}
+
+const EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"]
+const EXCLUDE_DIRS = ["node_modules", ".sdd", "dist", "build", ".git", ".opencode", "__pycache__"]
+
+/**
+ * Analyze a project directory to detect coding conventions.
+ * Samples up to 20 files for performance.
+ */
+export function detectConventions(projectDir: string): ProjectConventions {
+  const files = sampleFiles(projectDir, 20)
+  if (files.length === 0) return defaultConventions()
+
+  const allContent = files.map(f => ({
+    path: f.relPath,
+    content: readFileSync(f.fullPath, "utf-8"),
+  }))
+
+  return {
+    naming: detectNamingConventions(allContent),
+    imports: detectImportConventions(allContent),
+    async: detectAsyncConventions(allContent),
+    structure: detectStructureConventions(projectDir, allContent),
+    metadata: { filesSampled: files.length },
+  }
+}
+
+function defaultConventions(): ProjectConventions {
+  return {
+    naming: { variables: "camelCase", functions: "camelCase", files: "kebab-case", constants: "UPPER_SNAKE_CASE" },
+    imports: { style: "relative", useBarrelFiles: false, extension: "ts-only" },
+    async: { style: "async-await", errorHandling: "try-catch" },
+    structure: { organization: "unknown", hasIndexFiles: false, testLocation: "separate" },
+    metadata: {},
+  }
+}
+
+interface SampledFile { fullPath: string; relPath: string }
+
+function sampleFiles(projectDir: string, maxFiles: number): SampledFile[] {
+  const result: SampledFile[] = []
+  const srcDir = join(projectDir, "src")
+  const scanDir = existsSync(srcDir) ? srcDir : projectDir
+
+  function walk(dir: string): void {
+    if (result.length >= maxFiles) return
+    if (!existsSync(dir)) return
+    const entries = readdirSync(dir, { withFileTypes: true })
+    for (const entry of entries) {
+      if (result.length >= maxFiles) return
+      if (EXCLUDE_DIRS.includes(entry.name)) continue
+      const fullPath = join(dir, entry.name)
+      if (entry.isDirectory()) {
+        walk(fullPath)
+      } else if (EXTENSIONS.includes(extname(entry.name))) {
+        result.push({ fullPath, relPath: relative(projectDir, fullPath) })
+      }
+    }
+  }
+  walk(scanDir)
+  return result
+}
+
+function detectNamingConventions(files: Array<{ path: string; content: string }>): ProjectConventions["naming"] {
+  let camelCase = 0, snakeCase = 0, pascalCase = 0, upperSnake = 0
+
+  for (const file of files) {
+    const lines = file.content.split("\n")
+    for (const line of lines.slice(0, 100)) {
+      // Variable declarations
+      const varMatch = line.match(/(?:const|let|var)\s+(\w+)/)
+      if (varMatch) {
+        const name = varMatch[1]
+        if (/^[A-Z][a-zA-Z0-9]+$/.test(name)) pascalCase++
+        else if (/^[a-z][a-zA-Z0-9]+$/.test(name)) camelCase++
+        else if (/^[a-z][a-z0-9_]+$/.test(name)) snakeCase++
+        else if (/^[A-Z][A-Z0-9_]+$/.test(name)) upperSnake++
+      }
+    }
+
+    // File naming
+    const fileName = file.path.split("/").pop() || ""
+    if (/^[a-z][a-z0-9-]+\.[tj]sx?$/.test(fileName)) camelCase++
+    else if (/^[a-z][a-z0-9_]+\.[tj]sx?$/.test(fileName)) snakeCase++
+  }
+
+  const detectVar = (c: number, s: number, p: number): "camelCase" | "snake_case" | "PascalCase" | "unknown" => {
+    const total = c + s + p
+    if (total === 0) return "unknown"
+    if (c / total > 0.6) return "camelCase"
+    if (s / total > 0.6) return "snake_case"
+    if (p / total > 0.6) return "PascalCase"
+    return "unknown"
+  }
+
+  return {
+    variables: detectVar(camelCase, snakeCase, pascalCase),
+    functions: detectVar(camelCase, snakeCase, pascalCase),
+    files: camelCase > snakeCase ? "camelCase" : snakeCase > camelCase ? "snake_case" : "unknown",
+    constants: upperSnake > camelCase ? "UPPER_SNAKE_CASE" : "camelCase",
+  }
+}
+
+function detectImportConventions(files: Array<{ path: string; content: string }>): ProjectConventions["imports"] {
+  let relativeImports = 0, absoluteImports = 0, barrelImports = 0, extensionCount = 0, totalImports = 0
+
+  for (const file of files) {
+    const importMatches = file.content.matchAll(/(?:import|from)\s+['"]([^'"]+)['"]/g)
+    for (const match of importMatches) {
+      const imp = match[1]
+      totalImports++
+      if (imp.startsWith(".")) relativeImports++
+      else absoluteImports++
+      if (imp.endsWith("/index") || (!imp.includes("/") && !imp.startsWith("."))) barrelImports++
+      if (imp.endsWith(".js") || imp.endsWith(".ts")) extensionCount++
+    }
+  }
+
+  return {
+    style: relativeImports > absoluteImports * 2 ? "relative" : absoluteImports > relativeImports * 2 ? "absolute" : "mixed",
+    useBarrelFiles: barrelImports > totalImports * 0.3,
+    extension: totalImports === 0 ? "unknown" : extensionCount > totalImports * 0.5 ? "always" : extensionCount > 0 ? "ts-only" : "never",
+  }
+}
+
+function detectAsyncConventions(files: Array<{ path: string; content: string }>): ProjectConventions["async"] {
+  let asyncAwait = 0, promises = 0, callbacks = 0, tryCatch = 0, resultType = 0
+
+  for (const file of files) {
+    asyncAwait += (file.content.match(/await\s+/g) || []).length
+    promises += (file.content.match(/\.then\(/g) || []).length
+    callbacks += (file.content.match(/callback\s*\(/g) || []).length
+    tryCatch += (file.content.match(/try\s*\{/g) || []).length
+    resultType += (file.content.match(/Result<|ResultType|isOk|isErr/g) || []).length
+  }
+
+  return {
+    style: asyncAwait > promises * 2 ? "async-await" : promises > asyncAwait * 2 ? "promises" : callbacks > 5 ? "callbacks" : "mixed",
+    errorHandling: tryCatch > resultType * 2 ? "try-catch" : resultType > tryCatch * 2 ? "Result" : "mixed",
+  }
+}
+
+function detectStructureConventions(projectDir: string, files: Array<{ path: string; content: string }>): ProjectConventions["structure"] {
+  // Check for index files
+  let indexCount = 0
+  for (const file of files) {
+    if (file.path.split("/").pop()?.startsWith("index.")) indexCount++
+  }
+
+  // Check test location
+  const coLocated = files.filter(f => f.path.includes(".test.") || f.path.includes(".spec.")).length
+  const separateDir = files.filter(f => f.path.includes("/__tests__/") || f.path.includes("/test/")).length
+
+  // Detect organization pattern
+  const pathParts = files.map(f => f.path.split("/"))
+  const hasDomain = pathParts.some(p => p.length > 2 && ["domain", "models", "entities"].includes(p[1]))
+  const hasFeature = pathParts.some(p => p.length > 2 && ["features", "modules", "pages"].includes(p[1]))
+  const hasLayer = pathParts.some(p => p.length > 2 && ["controllers", "services", "repositories", "routes"].includes(p[1]))
+
+  return {
+    organization: hasDomain ? "domain" : hasFeature ? "feature" : hasLayer ? "layer" : "flat",
+    hasIndexFiles: indexCount > files.length * 0.2,
+    testLocation: coLocated > separateDir ? "co-located" : separateDir > coLocated ? "separate" : "mixed",
+  }
+}
+
+/**
+ * Format conventions as a readable report.
+ */
+export function formatConventions(c: ProjectConventions): string {
+  const lines = [
+    "## Project Conventions",
+    "",
+    "### Naming",
+    `- Variables: ${c.naming.variables}`,
+    `- Functions: ${c.naming.functions}`,
+    `- Files: ${c.naming.files}`,
+    `- Constants: ${c.naming.constants}`,
+    "",
+    "### Imports",
+    `- Style: ${c.imports.style}`,
+    `- Barrel files: ${c.imports.useBarrelFiles ? "yes" : "no"}`,
+    `- Extensions: ${c.imports.extension}`,
+    "",
+    "### Async",
+    `- Style: ${c.async.style}`,
+    `- Error handling: ${c.async.errorHandling}`,
+    "",
+    "### Structure",
+    `- Organization: ${c.structure.organization}`,
+    `- Index files: ${c.structure.hasIndexFiles ? "yes" : "no"}`,
+    `- Test location: ${c.structure.testLocation}`,
+  ]
+  return lines.join("\n")
+}

package/src/sdd/code-quality/dependencies.ts

@@ -0,0 +1,203 @@
+import type { KnowledgeGraph } from '../domain/types.js'
+
+export interface DependencyNode {
+  id: string
+  name: string
+  type: string
+  dependencies: string[]
+  dependents: string[]
+}
+
+export interface DependencyReport {
+  nodes: DependencyNode[]
+  cycles: string[][]
+  coupling: {
+    afferent: Record<string, number>
+    efferent: Record<string, number>
+    instability: Record<string, number>
+  }
+  summary: {
+    total_nodes: number
+    total_dependencies: number
+    cycles_found: number
+    most_coupled: string
+    least_stable: string
+  }
+}
+
+function detectCycles(nodes: DependencyNode[]): string[][] {
+  const cycles: string[][] = []
+  const visited = new Set<string>()
+  const recursionStack = new Set<string>()
+
+  function dfs(nodeId: string, path: string[]): void {
+    visited.add(nodeId)
+    recursionStack.add(nodeId)
+    path.push(nodeId)
+
+    const node = nodes.find(n => n.id === nodeId)
+    if (node) {
+      for (const dep of node.dependencies) {
+        if (!visited.has(dep)) {
+          dfs(dep, [...path])
+        } else if (recursionStack.has(dep)) {
+          const cycleStart = path.indexOf(dep)
+          if (cycleStart !== -1) {
+            cycles.push(path.slice(cycleStart))
+          }
+        }
+      }
+    }
+
+    recursionStack.delete(nodeId)
+  }
+
+  for (const node of nodes) {
+    if (!visited.has(node.id)) {
+      dfs(node.id, [])
+    }
+  }
+
+  return cycles
+}
+
+function calculateCoupling(nodes: DependencyNode[]): DependencyReport['coupling'] {
+  const afferent: Record<string, number> = {}
+  const efferent: Record<string, number> = {}
+  const instability: Record<string, number> = {}
+
+  for (const node of nodes) {
+    afferent[node.id] = node.dependents.length
+    efferent[node.id] = node.dependencies.length
+
+    const total = afferent[node.id] + efferent[node.id]
+    instability[node.id] = total > 0 ? efferent[node.id] / total : 0
+  }
+
+  return { afferent, efferent, instability }
+}
+
+export function analyzeDependencies(graph: KnowledgeGraph): DependencyReport {
+  const nodes: DependencyNode[] = []
+
+  for (const node of graph.nodes) {
+    const dependencies = graph.relationships
+      .filter(r => r.from === node.id && ['depends_on', 'uses', 'calls', 'requires'].includes(r.type))
+      .map(r => r.to)
+
+    const dependents = graph.relationships
+      .filter(r => r.to === node.id && ['depends_on', 'uses', 'calls', 'requires'].includes(r.type))
+      .map(r => r.from)
+
+    nodes.push({
+      id: node.id,
+      name: node.name,
+      type: node.type,
+      dependencies,
+      dependents,
+    })
+  }
+
+  const cycles = detectCycles(nodes)
+  const coupling = calculateCoupling(nodes)
+
+  const totalDependencies = nodes.reduce((sum, n) => sum + n.dependencies.length, 0)
+  const mostCoupled = nodes.reduce((most, n) =>
+    (n.dependencies.length + n.dependents.length) > (most.dependencies.length + most.dependents.length) ? n : most
+  , nodes[0])
+
+  const leastStable = Object.entries(coupling.instability)
+    .reduce((max, [id, value]) => value > max.value ? { id, value } : max, { id: '', value: 0 })
+
+  return {
+    nodes,
+    cycles,
+    coupling,
+    summary: {
+      total_nodes: nodes.length,
+      total_dependencies: totalDependencies,
+      cycles_found: cycles.length,
+      most_coupled: mostCoupled?.name || 'N/A',
+      least_stable: leastStable.id ? nodes.find(n => n.id === leastStable.id)?.name || 'N/A' : 'N/A',
+    },
+  }
+}
+
+export function formatDependencyReport(report: DependencyReport): string {
+  const lines = [
+    '## Análise de Dependências',
+    '',
+    `**Total de Nós:** ${report.summary.total_nodes}`,
+    `**Total de Dependências:** ${report.summary.total_dependencies}`,
+    `**Ciclos Encontrados:** ${report.summary.cycles_found}`,
+    `**Mais Acoplado:** ${report.summary.most_coupled}`,
+    `**Menos Estável:** ${report.summary.least_stable}`,
+    '',
+  ]
+
+  if (report.cycles.length > 0) {
+    lines.push('### ⚠️ Ciclos de Dependência Detectados')
+    for (let i = 0; i < report.cycles.length; i++) {
+      const cycle = report.cycles[i]
+      lines.push(`**Ciclo ${i + 1}:**`)
+      lines.push(cycle.map(id => {
+        const node = report.nodes.find(n => n.id === id)
+        return node?.name || id
+      }).join(' → '))
+    }
+    lines.push('')
+    lines.push('**Recomendação:** Quebre os ciclos introduzindo interfaces ou invertendo dependências.')
+    lines.push('')
+  }
+
+  lines.push('### Acoplamento')
+  lines.push('#### Nós com Maior Acoplamento (Efferent)')
+  const sortedByEfferent = Object.entries(report.coupling.efferent)
+    .sort(([, a], [, b]) => b - a)
+    .slice(0, 5)
+
+  for (const [id, count] of sortedByEfferent) {
+    const node = report.nodes.find(n => n.id === id)
+    if (node && count > 0) {
+      lines.push(`- **${node.name}** (${node.type}): ${count} dependências`)
+    }
+  }
+
+  lines.push('')
+  lines.push('#### Nós com Maior Reuso (Afferent)')
+  const sortedByAfferent = Object.entries(report.coupling.afferent)
+    .sort(([, a], [, b]) => b - a)
+    .slice(0, 5)
+
+  for (const [id, count] of sortedByAfferent) {
+    const node = report.nodes.find(n => n.id === id)
+    if (node && count > 0) {
+      lines.push(`- **${node.name}** (${node.type}): ${count} dependentes`)
+    }
+  }
+
+  lines.push('')
+  lines.push('#### Instabilidade')
+  const sortedByInstability = Object.entries(report.coupling.instability)
+    .sort(([, a], [, b]) => b - a)
+    .slice(0, 5)
+
+  for (const [id, value] of sortedByInstability) {
+    const node = report.nodes.find(n => n.id === id)
+    if (node) {
+      const stability = value < 0.3 ? '🟢 Estável' : value < 0.7 ? '🟡 Moderado' : '🔴 Instável'
+      lines.push(`- **${node.name}**: ${(value * 100).toFixed(0)}% ${stability}`)
+    }
+  }
+
+  lines.push(
+    '',
+    '### Recomendações',
+    '- Evite ciclos de dependência',
+    '- Mantenha a instabilidade baixa para módulos reutilizáveis',
+    '- Use inversão de dependência para desacoplar módulos',
+    '- Princípio Dependency Inversion (SOLID)',
+  )
+
+  return lines.join('\n')
+}