Fluxo resolução de issues

[HD220]

Esse fluxo será o fluxo realizado para resolução das issues criadas (humano ou ia).

• [ ] Obter as issues abertas para o repositorio
• [ ] Atrelar o app para uma issue
• [ ] Criar um overlayfs do repositório para um local para resolução da issue
• [ ] Criar uma branch para resolução da issue
• [ ] Obter todos dados relacionados a issue (ChromaDB, descrições, issues)
• [ ] Criar um Jsonl com prompt para resolução da issue
• [ ] Enviar para OpenIA
• [ ] Entrar em modo espera por X minutos
• [ ] Obter retorno da IA
• [ ] Se ela retornar que precisa de mais informações realizar novamente a busca com base no retorno dela e reencaminhar (essa interação deve ser registrada na própria issue)
• [ ] Aplicar as alterações retornadas
• [ ] Fazer commit
• [ ] Criar pullrequest da branch atual para branch default
• [ ] Concluir issue caso o Github não conclua automaticamente
• [ ] Deletar branch
• [ ] Desmontar diretório overlay
• [ ] Apagar dados dos diretórios montados

[HD220]

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

export async function code_change(changeDescription: string) {
  const project = new Project({
    tsConfigFilePath: "./tsconfig.json",
  });

  const sourceFiles = project.getSourceFiles();

  sourceFiles.forEach((sourceFile) => {
    if (changeDescription.includes("rename function")) {
      const oldName = extractOldFunctionName(changeDescription);
      const newName = extractNewFunctionName(changeDescription);
      renameFunctions(sourceFile, oldName, newName);
    } else if (changeDescription.includes("rename class")) {
      const oldName = extractOldClassName(changeDescription);
      const newName = extractNewClassName(changeDescription);
      renameClasses(sourceFile, oldName, newName);
    }

    // Adicionar outras modificações conforme necessário
  });

  await project.save();
}

function renameFunctions(sourceFile: any, oldName: string, newName: string) {
  sourceFile.getFunctions().forEach((func: any) => {
    if (func.getName() === oldName) {
      func.rename(newName);
    }
  });
}

function renameClasses(sourceFile: any, oldName: string, newName: string) {
  sourceFile.getClasses().forEach((cls: any) => {
    if (cls.getName() === oldName) {
      cls.rename(newName);
    }
  });
}

[HD220]

Exemplo de prompt:

import { OpenAIApi, Configuration } from "openai";

// Configuração do cliente OpenAI
const configuration = new Configuration({
  apiKey: process.env.OPENAI_API_KEY,
});
const openai = new OpenAIApi(configuration);

interface RequestData {
  issue: string;
  dadosChroma: string;
}

async function callOpenAI({ issue, dadosChroma }: RequestData): Promise<any> {
  // Prompt único
  const prompt = `
    Você é um bot de análise e modificação de código. Baseado na seguinte issue: "${issue}" e nos dados extraídos do ChromaDB: "${dadosChroma}", 
    você pode executar as seguintes ações:

    1. **code_change**: Realizar as modificações necessárias no código. Forneça instruções detalhadas.
    2. **more_info**: Solicitar informações adicionais se necessário. Explique claramente o que você precisa e por quê.
    3. **suggestions**: Oferecer sugestões de melhorias. Explique brevemente como cada melhoria poderia ser implementada.

    Responda utilizando a ferramenta apropriada e siga as instruções específicas para cada uma.`;

  // Chamada para a OpenAI
  const response = await openai.createChatCompletion({
    model: "gpt-4", // ou o modelo que você preferir
    messages: [{ role: "user", content: prompt }],
    functions: [
      {
        name: "code_change",
        description: "Executa alterações no código conforme as instruções fornecidas. Essa chamada deve ser tratada como uma máquina.",
        parameters: {
          type: "object",
          properties: {
            code: {
              type: "string",
              description: "Código a ser alterado",
            },
            instructions: {
              type: "string",
              description: "Instruções de alteração.",
            },
          },
          required: ["code", "instructions"],
        },
      },
      {
        name: "more_info",
        description: "Solicita informações adicionais para concluir a análise. Esta chamada deve ser tratada como se estivesse conversando com um humano.",
        parameters: {
          type: "object",
          properties: {
            needed_info: {
              type: "string",
              description: "Informações adicionais necessárias.",
            },
            issue: {
              type: "string",
              description: "Descrição da issue em questão.",
            },
          },
          required: ["needed_info", "issue"],
        },
      },
      {
        name: "suggestions",
        description: "Oferece sugestões de melhorias. Esta chamada deve ser tratada como se estivesse conversando com um humano.",
        parameters: {
          type: "object",
          properties: {
            suggestions: {
              type: "string",
              description: "Sugestões de melhorias.",
            },
            issue: {
              type: "string",
              description: "Descrição da issue em questão.",
            },
          },
          required: ["suggestions", "issue"],
        },
      },
    ],
    function_call: { name: "code_change" }, // Você pode definir logicamente qual ferramenta usar
  });

  return response.data;
}

[HD220]

Código exemplo overlayFS:

import { exec } from 'child_process';
import { v4 as uuidv4 } from 'uuid';
import { promises as fs } from 'fs';

async function createOverlayMount() {
  const uuid = uuidv4();
  const overlayDir = `/mnt/overlay/${uuid}`;

  try {
    // Criar diretórios upper e work
    await fs.mkdir(`${overlayDir}/upper`, { recursive: true });
    await fs.mkdir(`${overlayDir}/work`, { recursive: true });

    // Montar o overlay
    await new Promise<void>((resolve, reject) => {
      exec(`mount -t overlay overlay -o lowerdir=/app/github/projeto,upperdir=${overlayDir}/upper,workdir=${overlayDir}/work ${overlayDir}`, (error) => {
        if (error) {
          console.error(`Erro ao montar o overlay: ${error.message}`);
          return reject(error);
        }
        resolve();
      });
    });

    console.log(`Overlay mounted successfully at ${overlayDir}`);
  } catch (error) {
    console.error(`An error occurred: ${error instanceof Error ? error.message : error}`);
  }
}

[HD220]

Exemplo de código para pooling das buscas do status do processamento da openai batch

const { Worker } = require('bullmq');

const workflowWorker = new Worker('workflowQueue', async (job) => {
  const { step, jobId, attempt = 0 } = job.data; // Adicione attempt para rastrear o número de tentativas
  const maxAttempts = 10; // Número máximo de tentativas para verificar o status
  const initialDelay = 60 * 1000; // 1 minuto em milissegundos
  const backoffFactor = 2; // Fator de backoff
  const maxDelay = 2 * 60 * 60 * 1000; // 2 horas em milissegundos

  switch (step) {
    case 'start':
      console.log(`Iniciando o Job: ${jobId}`);
      // Lógica para enviar o Job para o sistema externo
      // ...

      // Avance para o próximo passo
      await job.update({ step: 'checkStatus', jobId, attempt: 0 });
      break;

    case 'checkStatus':
      const isCompleted = await checkExternalSystem(jobId); // Verifique o sistema externo
      if (isCompleted) {
        console.log(`Job ${jobId} concluído.`);
        return { status: 'completed' }; // Finaliza o Job
      } else {
        console.log(`Job ${jobId} ainda não concluído. Reprogramando...`);

        // Cálculo do tempo de espera com backoff
        const delay = Math.min(initialDelay * Math.pow(backoffFactor, attempt), maxDelay);
        console.log(`Esperando ${delay / 1000} segundos antes da próxima verificação...`);

        // Reprograme o Job para verificar novamente após o tempo de espera calculado
        await job.moveToWaiting(Date.now() + delay);

        // Atualiza o número de tentativas
        await job.update({ attempt: attempt + 1 });

        // Se o número máximo de tentativas for alcançado, você pode marcar o Job como falhado ou realizar outra ação
        if (attempt >= maxAttempts) {
          console.error(`Job ${jobId} alcançou o número máximo de tentativas. Marcando como falhado.`);
          await job.moveToFailed(new Error('Máximo de tentativas alcançado.'));
        }
      }
      break;

    default:
      throw new Error(`Unknown step: ${step}`);
  }
});