opencode-telos 1.0.0

package/src/sdd/code-quality/import-analyzer.ts

@@ -0,0 +1,294 @@
+export interface ImportInfo {
+  source: string
+  imported_names: string[]
+  is_default: boolean
+  is_namespace: boolean
+  line: number
+}
+
+export interface ExportInfo {
+  name: string
+  type: 'default' | 'named' | 'reexport'
+  line: number
+}
+
+export interface ImportAnalysis {
+  file_path: string
+  imports: ImportInfo[]
+  exports: ExportInfo[]
+  dependencies: string[]
+  summary: {
+    total_imports: number
+    total_exports: number
+    external_deps: string[]
+    internal_deps: string[]
+  }
+  issues: ImportIssue[]
+}
+
+export interface ImportIssue {
+  type: 'circular' | 'unused_import' | 'missing_import' | 'deep_import' | 'barrel_import'
+  severity: 'warning' | 'error'
+  message: string
+  line?: number
+}
+
+export interface ImportAnalysisOptions {
+  /** Only analyze imports from these module patterns. */
+  focusModules?: string[]
+  /** Skip these module patterns. */
+  excludeModules?: string[]
+  /** Max depth for circular dependency detection (default: unlimited). */
+  maxDepth?: number
+  /** Cache for analysis results (filePath → result). */
+  fileCache?: Map<string, { analysis: ImportAnalysis; contentHash: string }>
+  /** Hash of the source content for cache invalidation. */
+  contentHash?: string
+}
+
+export function analyzeImports(sourceCode: string, filePath: string, options?: ImportAnalysisOptions): ImportAnalysis {
+  const imports: ImportInfo[] = []
+  const exports: ExportInfo[] = []
+  const issues: ImportIssue[] = []
+
+  const lines = sourceCode.split('\n')
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const lineNum = i + 1
+
+    const importMatch = line.match(
+      /import\s+(?:(\w+)\s*,?\s*)?(?:{([^}]+)}\s*)?(?:,\s*{([^}]+)}\s*)?\s+from\s+['"]([^'"]+)['"]/g
+    )
+
+    if (importMatch) {
+      const defaultMatch = line.match(/import\s+(\w+)\s*,/)
+      const namedMatch = line.match(/import\s+{([^}]+)}/)
+      const sourceMatch = line.match(/from\s+['"]([^'"]+)['"]/)
+
+      if (sourceMatch) {
+        const source = sourceMatch[1]
+        const importedNames: string[] = []
+
+        if (defaultMatch) {
+          importedNames.push(defaultMatch[1])
+          imports.push({
+            source,
+            imported_names: [defaultMatch[1]],
+            is_default: true,
+            is_namespace: false,
+            line: lineNum,
+          })
+        }
+
+        if (namedMatch) {
+          const names = namedMatch[1].split(',').map(n => n.trim()).filter(n => n)
+          importedNames.push(...names)
+          imports.push({
+            source,
+            imported_names: names,
+            is_default: false,
+            is_namespace: false,
+            line: lineNum,
+          })
+        }
+
+        if (line.includes('* as')) {
+          const namespaceMatch = line.match(/\*\s+as\s+(\w+)/)
+          if (namespaceMatch) {
+            importedNames.push(namespaceMatch[1])
+            imports.push({
+              source,
+              imported_names: [namespaceMatch[1]],
+              is_default: false,
+              is_namespace: true,
+              line: lineNum,
+            })
+          }
+        }
+      }
+    }
+
+    const exportMatch = line.match(/export\s+(?:default\s+|const\s+|function\s+|class\s+|interface\s+|type\s+|enum\s+)?(\w+)/)
+    if (exportMatch) {
+      const isDefault = line.includes('export default')
+      exports.push({
+        name: exportMatch[1],
+        type: isDefault ? 'default' : 'named',
+        line: lineNum,
+      })
+    }
+
+    if (line.match(/export\s+{([^}]+)}/)) {
+      const namesMatch = line.match(/export\s+{([^}]+)}/)
+      if (namesMatch) {
+        const names = namesMatch[1].split(',').map(n => n.trim()).filter(n => n)
+        for (const name of names) {
+          exports.push({
+            name,
+            type: 'named',
+            line: lineNum,
+          })
+        }
+      }
+    }
+
+    if (line.match(/export\s+\*\s+from/)) {
+      const reexportMatch = line.match(/export\s+\*\s+from\s+['"]([^'"]+)['"]/)
+      if (reexportMatch) {
+        exports.push({
+          name: `* from ${reexportMatch[1]}`,
+          type: 'reexport',
+          line: lineNum,
+        })
+      }
+    }
+  }
+
+  const dependencies = imports.map(i => i.source)
+  const externalDeps = dependencies.filter(d => !d.startsWith('.') && !d.startsWith('/'))
+  const internalDeps = dependencies.filter(d => d.startsWith('.') || d.startsWith('/'))
+
+  // Filter by focus/exclude modules
+  const filteredImports = filterImports(imports, options)
+
+  detectImportIssues(sourceCode, filteredImports, exports, filePath, issues)
+
+  return {
+    file_path: filePath,
+    imports,
+    exports,
+    dependencies,
+    summary: {
+      total_imports: imports.length,
+      total_exports: exports.length,
+      external_deps: externalDeps,
+      internal_deps: internalDeps,
+    },
+    issues,
+  }
+}
+
+function detectImportIssues(
+  sourceCode: string,
+  imports: ImportInfo[],
+  _exports: ExportInfo[],
+  filePath: string,
+  issues: ImportIssue[]
+): void {
+  for (const imp of imports) {
+    if (imp.source.includes('/index') || imp.source.endsWith('/')) {
+      issues.push({
+        type: 'barrel_import',
+        severity: 'warning',
+        message: `Importação de barrel file: ${imp.source}`,
+        line: imp.line,
+      })
+    }
+
+    const depth = imp.source.split('/').length - 1
+    if (depth > 3) {
+      issues.push({
+        type: 'deep_import',
+        severity: 'warning',
+        message: `Importação profunda (nível ${depth}): ${imp.source}`,
+        line: imp.line,
+      })
+    }
+
+    for (const name of imp.imported_names) {
+      const usageRegex = new RegExp(`\\b${name}\\b`, 'g')
+      const usages = sourceCode.match(usageRegex)
+      if (!usages || usages.length <= 1) {
+        issues.push({
+          type: 'unused_import',
+          severity: 'warning',
+          message: `Import não utilizado: ${name} de ${imp.source}`,
+          line: imp.line,
+        })
+      }
+    }
+  }
+
+  const localImports = imports.filter(i => i.source.startsWith('.'))
+  for (const imp of localImports) {
+    const targetPath = resolveRelativePath(filePath, imp.source)
+    if (targetPath === filePath) {
+      issues.push({
+        type: 'circular',
+        severity: 'error',
+        message: `Dependência circular detectada: ${imp.source}`,
+        line: imp.line,
+      })
+    }
+  }
+}
+
+function resolveRelativePath(from: string, relative: string): string {
+  const fromParts = from.split('/').slice(0, -1)
+  const relParts = relative.split('/')
+
+  for (const part of relParts) {
+    if (part === '..') {
+      fromParts.pop()
+    } else if (part !== '.') {
+      fromParts.push(part)
+    }
+  }
+
+  return fromParts.join('/')
+}
+
+/** Filter imports by focus/exclude module patterns. */
+function filterImports(imports: ImportInfo[], options?: ImportAnalysisOptions): ImportInfo[] {
+  if (!options?.focusModules?.length && !options?.excludeModules?.length) return imports
+
+  return imports.filter((imp) => {
+    if (options.excludeModules?.length) {
+      if (options.excludeModules.some((m) => imp.source.includes(m))) return false
+    }
+    if (options.focusModules?.length) {
+      return options.focusModules.some((m) => imp.source.includes(m))
+    }
+    return true
+  })
+}
+
+export function formatImportAnalysis(analysis: ImportAnalysis): string {
+  const lines = [
+    `## Análise de Imports - ${analysis.file_path}`,
+    '',
+    '### Resumo',
+    `- **Imports:** ${analysis.summary.total_imports}`,
+    `- **Exports:** ${analysis.summary.total_exports}`,
+    `- **Deps Externas:** ${analysis.summary.external_deps.length}`,
+    `- **Deps Internas:** ${analysis.summary.internal_deps.length}`,
+    '',
+  ]
+
+  if (analysis.issues.length > 0) {
+    lines.push('### ⚠️ Problemas Detectados')
+    for (const issue of analysis.issues) {
+      const icon = issue.severity === 'error' ? '❌' : '⚠️'
+      lines.push(`${icon} **${issue.type}:** ${issue.message}${issue.line ? ` (linha ${issue.line})` : ''}`)
+    }
+    lines.push('')
+  }
+
+  if (analysis.imports.length > 0) {
+    lines.push('### Imports')
+    for (const imp of analysis.imports) {
+      lines.push(`- **${imp.source}:** ${imp.imported_names.join(', ')}`)
+    }
+    lines.push('')
+  }
+
+  if (analysis.exports.length > 0) {
+    lines.push('### Exports')
+    for (const exp of analysis.exports) {
+      lines.push(`- **${exp.name}** (${exp.type})`)
+    }
+  }
+
+  return lines.join('\n')
+}

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

@@ -0,0 +1,232 @@
+export interface FunctionMetrics {
+  name: string
+  file: string
+  line_start: number
+  line_end: number
+  lines_of_code: number
+  nesting_depth: number
+  parameter_count: number
+ LOC: number
+  LLOC: number
+  SLOC: number
+  comments: number
+  blank_lines: number
+}
+
+export interface CodeMetricsReport {
+  functions: FunctionMetrics[]
+  file_summary: {
+    total_lines: number
+    total_code_lines: number
+    total_comment_lines: number
+    total_blank_lines: number
+    average_function_length: number
+    longest_function: string
+    shortest_function: string
+  }
+  issues: Array<{
+    type: string
+    function: string
+    severity: 'warning' | 'error'
+    message: string
+  }>
+}
+
+function countNestingDepth(code: string): number {
+  let maxDepth = 0
+  let currentDepth = 0
+
+  for (const char of code) {
+    if (char === '{') {
+      currentDepth++
+      maxDepth = Math.max(maxDepth, currentDepth)
+    } else if (char === '}') {
+      currentDepth = Math.max(0, currentDepth - 1)
+    }
+  }
+
+  return maxDepth
+}
+
+function countParameters(code: string): number {
+  const paramMatch = code.match(/\(([^)]*)\)/)
+  if (!paramMatch || !paramMatch[1].trim()) return 0
+
+  const params = paramMatch[1].split(',')
+  return params.filter(p => p.trim()).length
+}
+
+function countLines(code: string): { LOC: number; LLOC: number; SLOC: number; comments: number; blank_lines: number } {
+  const lines = code.split('\n')
+  const LOC = lines.length
+
+  let comments = 0
+  let blank_lines = 0
+  let inBlockComment = false
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+
+    if (inBlockComment) {
+      comments++
+      if (trimmed.includes('*/')) {
+        inBlockComment = false
+      }
+      continue
+    }
+
+    if (trimmed === '') {
+      blank_lines++
+      continue
+    }
+
+    if (trimmed.startsWith('//') || trimmed.startsWith('#')) {
+      comments++
+      continue
+    }
+
+    if (trimmed.startsWith('/*')) {
+      comments++
+      if (!trimmed.includes('*/')) {
+        inBlockComment = true
+      }
+      continue
+    }
+  }
+
+  const LLOC = LOC - blank_lines - comments
+  const SLOC = LLOC
+
+  return { LOC, LLOC, SLOC, comments, blank_lines }
+}
+
+export function analyzeMetrics(code: string, fileName: string): CodeMetricsReport {
+  const functions: FunctionMetrics[] = []
+  const issues: CodeMetricsReport['issues'] = []
+
+  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]
+    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 = countLines(functionCode)
+    const nestingDepth = countNestingDepth(functionCode)
+    const parameterCount = countParameters(functionCode)
+
+    functions.push({
+      name,
+      file: fileName,
+      line_start: startLine,
+      line_end: endLine,
+      lines_of_code: lines.LOC,
+      nesting_depth: nestingDepth,
+      parameter_count: parameterCount,
+      ...lines,
+    })
+
+    if (parameterCount > 5) {
+      issues.push({
+        type: 'long_parameter_list',
+        function: name,
+        severity: 'warning',
+        message: `Função ${name} tem ${parameterCount} parâmetros (máximo recomendado: 5)`,
+      })
+    }
+
+    if (lines.LOC > 50) {
+      issues.push({
+        type: 'long_function',
+        function: name,
+        severity: 'warning',
+        message: `Função ${name} tem ${lines.LOC} linhas (máximo recomendado: 50)`,
+      })
+    }
+
+    if (nestingDepth > 4) {
+      issues.push({
+        type: 'deep_nesting',
+        function: name,
+        severity: 'warning',
+        message: `Função ${name} tem aninhamento de ${nestingDepth} níveis (máximo recomendado: 4)`,
+      })
+    }
+  }
+
+  const allLines = countLines(code)
+  const totalFunctionLines = functions.reduce((sum, f) => sum + f.lines_of_code, 0)
+  const avgFunctionLength = functions.length > 0 ? totalFunctionLines / functions.length : 0
+
+  const longestFunction = functions.reduce((longest, f) => f.lines_of_code > longest.lines_of_code ? f : longest, functions[0])
+  const shortestFunction = functions.reduce((shortest, f) => f.lines_of_code < shortest.lines_of_code ? f : shortest, functions[0])
+
+  return {
+    functions,
+    file_summary: {
+      total_lines: allLines.LOC,
+      total_code_lines: allLines.LLOC,
+      total_comment_lines: allLines.comments,
+      total_blank_lines: allLines.blank_lines,
+      average_function_length: Math.round(avgFunctionLength),
+      longest_function: longestFunction?.name || 'N/A',
+      shortest_function: shortestFunction?.name || 'N/A',
+    },
+    issues,
+  }
+}
+
+export function formatMetricsReport(report: CodeMetricsReport): string {
+  const lines = [
+    '## Métricas de Código',
+    '',
+    '### Resumo do Arquivo',
+    `- **Total de Linhas:** ${report.file_summary.total_lines}`,
+    `- **Linhas de Código:** ${report.file_summary.total_code_lines}`,
+    `- **Linhas de Comentário:** ${report.file_summary.total_comment_lines}`,
+    `- **Linhas em Branco:** ${report.file_summary.total_blank_lines}`,
+    `- **Média de Linhas por Função:** ${report.file_summary.average_function_length}`,
+    `- **Função Maior:** ${report.file_summary.longest_function}`,
+    `- **Função Menor:** ${report.file_summary.shortest_function}`,
+    '',
+  ]
+
+  if (report.issues.length > 0) {
+    lines.push('### Problemas Detectados')
+    for (const issue of report.issues) {
+      const icon = issue.severity === 'error' ? '❌' : '⚠️'
+      lines.push(`${icon} **${issue.type}**: ${issue.message}`)
+    }
+    lines.push('')
+  }
+
+  lines.push('### Detalhes por Função')
+  for (const func of report.functions) {
+    lines.push(`#### ${func.name}`)
+    lines.push(`- **Linhas:** ${func.lines_of_code}`)
+    lines.push(`- **Parâmetros:** ${func.parameter_count}`)
+    lines.push(`- **Aninhamento:** ${func.nesting_depth}`)
+    lines.push(`- **LOC/LLOC/SLOC:** ${func.LOC}/${func.LLOC}/${func.SLOC}`)
+    lines.push('')
+  }
+
+  return lines.join('\n')
+}