Fluxo Análise do repositório

[HD220]

• [ ] Buscar status do repositório (se não estiver em análise)
• [ ] Atualizar para em analise
• [ ] Obter commit da última analise
• [ ] Obter as diferenças entre a última analise e o estado atual
• [ ] Gerar AST das diferenças
• [ ] Criar Jobs de analise para cada diferença (jobFlow hierarquizado)
• [ ] Atualizar commit da última analise
• [ ] Atualizar status do repositório no redis para "espera"
• [ ] Gerar grafo de dependências

[HD220]

import graphlib, { Graph } from "graphlib";
import pagerank from "graphlib/lib/alg/pagerank";

// Função que exibe os nós e gera o PageRank
function useSystemGraphWithPageRank(graph: Graph) {
  // Calcula o PageRank
  const dampingFactor = 0.85; // Fator de amortecimento padrão
  const tolerance = 1e-5; // Tolerância para convergência
  const maxIterations = 100; // Máximo de iterações para o algoritmo

  const rank = pagerank(graph, dampingFactor, tolerance, maxIterations);

  // Exibe os nós e suas pontuações de PageRank
  graph.nodes().forEach((nodeId) => {
    const nodeData = graph.node(nodeId);
    console.log(`Node: ${nodeId}`);
    console.log(`File Path: ${nodeData.filePath}`);
    console.log(`Start Line: ${nodeData.startLine}`);
    console.log(`End Line: ${nodeData.endLine}`);
    console.log(`JsDoc: ${nodeData.jsDoc}`);
    console.log(`PageRank: ${rank[nodeId]}`);
    console.log("---");
  });
}

[HD220]

import { Project, Node } from "ts-morph";
import simpleGit from 'simple-git';
import * as fs from 'fs';
import * as path from 'path';
import * as diff from 'diff';

// Função para obter os arquivos e diffs entre dois commits
async function getModifiedFilesAndDiffs(commitA: string, commitB: string) {
  const git = simpleGit();
  const diffOutput = await git.diff([`${commitA}..${commitB}`]);
  return diffOutput;
}

// Função para analisar nós modificados
async function analyzeModifiedNodes(filePath: string, modifiedLines: number[]) {
  const project = new Project();
  project.addSourceFileAtPath(filePath);
  const sourceFile = project.getSourceFileOrThrow(filePath);

  const modifiedNodes: Array<{ 
    filePath: string; 
    nodeText: string; 
    startLine: number; 
    endLine: number; 
    jsDoc: string | null 
  }> = [];

  sourceFile.forEachDescendant((node: Node) => {
    const startLine = node.getStartLineNumber();
    const endLine = node.getEndLineNumber();

    // Verifica se o nó se sobrepõe às linhas modificadas
    const isNodeModified = modifiedLines.some(line => line >= startLine && line <= endLine);

    if (isNodeModified) {
      const jsDocs = node.getJsDocs().map(jsDoc => jsDoc.getComment()).join('\n') || null;

      modifiedNodes.push({
        filePath,
        nodeText: node.getText(),
        startLine,
        endLine,
        jsDoc: jsDocs
      });
    }
  });

  return modifiedNodes;
}

// Função para obter as linhas modificadas
function extractModifiedLines(diffText: string) {
  const modifiedLines: Record<string, number[]> = {};
  const files = diffText.split('diff --git a/');

  files.forEach(fileDiff => {
    const lines = fileDiff.split('\n');
    let currentFile = '';

    lines.forEach((line, index) => {
      if (line.startsWith('+++ b/')) {
        currentFile = line.replace('+++ b/', '').trim();
        modifiedLines[currentFile] = [];
      }

      if (line.startsWith('@@')) {
        const [startLine] = line.match(/\+(\d+)/) ?? [];
        const range = line.split(' ')[2].replace('+', '').split(',');
        const start = parseInt(range[0]);
        const length = parseInt(range[1] || '1');

        for (let i = 0; i < length; i++) {
          modifiedLines[currentFile].push(start + i);
        }
      }
    });
  });

  return modifiedLines;
}

// Função principal para comparar dois commits e gerar nós modificados
async function generateModifiedNodesReport(commitA: string, commitB: string) {
  const diffText = await getModifiedFilesAndDiffs(commitA, commitB);
  const modifiedLines = extractModifiedLines(diffText);

  const allModifiedNodes = [];

  for (const file in modifiedLines) {
    const absolutePath = path.resolve(file);
    if (fs.existsSync(absolutePath)) {
      const modifiedNodes = await analyzeModifiedNodes(absolutePath, modifiedLines[file]);
      allModifiedNodes.push(...modifiedNodes);
    }
  }

  return allModifiedNodes;
}

[HD220]

import { Project, Node } from "ts-morph";

// Carrega o projeto TypeScript
const project = new Project({
  // Configuração opcional, aponta para o arquivo tsconfig.json
  tsConfigFilePath: "./tsconfig.json",
});

// Analisa todos os arquivos do projeto
const sourceFiles = project.getSourceFiles();

// Função para extrair as importações e onde são utilizadas
sourceFiles.forEach((sourceFile) => {
  console.log(`Analisando: ${sourceFile.getFilePath()}`);

  // Obter todas as declarações de importação
  const imports = sourceFile.getImportDeclarations();
  imports.forEach((importDecl) => {
    const importedModule = importDecl.getModuleSpecifierValue();
    console.log(`Importação de: ${importedModule}`);

    // Verificar onde essas importações são usadas no código
    const namedImports = importDecl.getNamedImports();
    namedImports.forEach((namedImport) => {
      const importName = namedImport.getName();
      console.log(` - Importado: ${importName}`);

      // Buscar por onde esse import é usado no arquivo
      const usages = sourceFile.getDescendantsOfKind(Node.isIdentifier)
        .filter((identifier) => identifier.getText() === importName);

      usages.forEach((usage) => {
        console.log(`   - Usado em: ${usage.getStartLineNumber()}`);
        const parentBlock = usage.getParentIfKind(Node.isBlock);
        if (parentBlock) {
          // Extrair o bloco de código onde está sendo usado
          console.log(`   - Bloco de código: ${parentBlock.getText().substring(0, 100)}...`);
        }
      });
    });
  });
});