coder agent

patches/@langchain+core+1.1.47.patch

@@ -0,0 +1,25 @@
+diff --git a/node_modules/@langchain/core/dist/utils/uuid/index.cjs b/node_modules/@langchain/core/dist/utils/uuid/index.cjs
+index 1151178..c05caf9 100644
+--- a/node_modules/@langchain/core/dist/utils/uuid/index.cjs
++++ b/node_modules/@langchain/core/dist/utils/uuid/index.cjs
+@@ -36,12 +36,12 @@ Object.defineProperty(exports, "uuid_exports", {
+ 		return uuid_exports;
+ 	}
+ });
+-exports.v1 = require_v1;
+-exports.v4 = require_v4;
+-exports.v5 = require_v5;
+-exports.v6 = require_v6;
+-exports.v7 = require_v7;
+-exports.validate = require_validate;
+-exports.version = require_version;
++exports.v1 = require_v1.default;
++exports.v4 = require_v4.default;
++exports.v5 = require_v5.default;
++exports.v6 = require_v6.default;
++exports.v7 = require_v7.default;
++exports.validate = require_validate.default;
++exports.version = require_version.default;
+ 
+ //# sourceMappingURL=index.cjs.map
+

src/agents/coder/agent.ts

@@ -1,20 +1,125 @@
 import { END, type GraphNode, START, StateGraph } from "@langchain/langgraph";
+import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 
 import { CoderState } from "./state.ts";
+import { solidityCoderPrompt, solidityFixPrompt, solidityReviewPrompt } from "./prompts.ts";
+import { compileSolidityTool } from "./tools/compile-solidity.ts";
 
-const PLACEHOLDER_CONTRACT = `// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
+const MAX_FIX_ATTEMPTS = 3;
 
-contract Placeholder {
-    // TODO: implement contract based on requirements
-}`;
+function createLLM() {
+  return new ChatGoogleGenerativeAI({
+    apiKey: process.env.GOOGLE_API_KEY || "",
+    model: process.env.MODEL_NAME || "gemini-2.5-flash",
+    temperature: 0.2,
+  });
+}
 
-const generateContract: GraphNode<typeof CoderState> = async (_state) => {
-  return { contract: PLACEHOLDER_CONTRACT };
+/**
+ * Extrai apenas o bloco de código Solidity de uma resposta do LLM.
+ */
+function extractSolidityCode(text: string): string {
+  const match = text.match(/```(?:solidity)?\s*\n([\s\S]*?)```/);
+  if (match) return match[1].trim();
+  // Se não tem bloco de código, assume que a resposta inteira é código
+  return text.trim();
+}
+
+/**
+ * Nó 1: Gera o smart contract a partir dos requisitos.
+ */
+const generateContract: GraphNode<typeof CoderState> = async (state) => {
+  const llm = createLLM();
+  const chain = solidityCoderPrompt.pipe(llm);
+
+  const requirementsText = state.requirements
+    .map((r, i) => `${i + 1}. ${r}`)
+    .join("\n");
+
+  const result = await chain.invoke({ requirements: requirementsText });
+  const code = extractSolidityCode(
+    typeof result.content === "string" ? result.content : JSON.stringify(result.content),
+  );
+
+  return { contract: code, compilationErrors: [] };
 };
 
+/**
+ * Nó 2: Compila o contrato e armazena erros (se houver).
+ */
+const compileContract: GraphNode<typeof CoderState> = async (state) => {
+  const result = await compileSolidityTool.invoke({
+    sourceCode: state.contract,
+    filename: "Contract.sol",
+  });
+
+  return { compilationErrors: result.errors };
+};
+
+/**
+ * Nó 3: Corrige o contrato com base nos erros de compilação.
+ */
+const fixContract: GraphNode<typeof CoderState> = async (state) => {
+  const llm = createLLM();
+  const chain = solidityFixPrompt.pipe(llm);
+
+  const errorsText = state.compilationErrors.join("\n\n");
+
+  const result = await chain.invoke({
+    contract: state.contract,
+    errors: errorsText,
+  });
+
+  const code = extractSolidityCode(
+    typeof result.content === "string" ? result.content : JSON.stringify(result.content),
+  );
+
+  return { contract: code, compilationErrors: [] };
+};
+
+/**
+ * Nó 4: Revisa o contrato compilado quanto a segurança e boas práticas.
+ */
+const reviewContract: GraphNode<typeof CoderState> = async (state) => {
+  const llm = createLLM();
+  const chain = solidityReviewPrompt.pipe(llm);
+
+  const requirementsText = state.requirements.join(", ");
+
+  const result = await chain.invoke({
+    requirements: requirementsText,
+    contract: state.contract,
+  });
+
+  const summary =
+    typeof result.content === "string" ? result.content : JSON.stringify(result.content);
+
+  return { reviewSummary: summary };
+};
+
+/**
+ * Roteador: decide se precisa corrigir ou se pode seguir para revisão.
+ * Controla o número de tentativas de correção.
+ */
+let fixAttempts = 0;
+
+function shouldFix(state: { compilationErrors: string[] }): "fixContract" | "reviewContract" {
+  if (state.compilationErrors.length > 0 && fixAttempts < MAX_FIX_ATTEMPTS) {
+    fixAttempts++;
+    return "fixContract";
+  }
+  fixAttempts = 0; // reset para próxima execução
+  return "reviewContract";
+}
+
 export const coderAgent = new StateGraph(CoderState)
   .addNode("generateContract", generateContract)
+  .addNode("compileContract", compileContract)
+  .addNode("fixContract", fixContract)
+  .addNode("reviewContract", reviewContract)
   .addEdge(START, "generateContract")
-  .addEdge("generateContract", END)
+  .addEdge("generateContract", "compileContract")
+  .addConditionalEdges("compileContract", shouldFix)
+  .addEdge("fixContract", "compileContract")
+  .addEdge("reviewContract", END)
   .compile();

src/agents/coder/prompts.ts

@@ -0,0 +1,96 @@
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+
+/**
+ * Prompt para gerar smart contracts Solidity a partir de requisitos.
+ */
+export const solidityCoderPrompt = ChatPromptTemplate.fromMessages([
+  [
+    "system",
+    `Você é um desenvolvedor sênior especialista em smart contracts Solidity.
+Sua função é gerar contratos Solidity completos, compiláveis e seguros.
+
+Regras:
+- Gere código Solidity production-ready
+- Use pragma solidity ^0.8.20
+- NÃO use imports externos (OpenZeppelin, etc.) — implemente tudo inline
+- Adicione comentários NatDoc explicativos
+- Inclua eventos para todas as operações relevantes
+- Use modificadores de acesso customizados (ex: onlyOwner)
+- Inclua tratamento de erros com require e mensagens claras
+- Siga boas práticas de segurança (checks-effects-interactions, proteção contra reentrância)
+- NÃO use placeholders como "TODO" ou "implementar depois"
+- O contrato deve compilar sem erros com solc 0.8.20+`,
+  ],
+  [
+    "human",
+    `Gere um smart contract Solidity completo com base nos seguintes requisitos:
+
+{requirements}
+
+Retorne APENAS o código Solidity completo, sem explicações adicionais.
+O código deve ser auto-contido (sem imports externos).`,
+  ],
+]);
+
+/**
+ * Prompt para corrigir erros de compilação em contratos Solidity.
+ */
+export const solidityFixPrompt = ChatPromptTemplate.fromMessages([
+  [
+    "system",
+    `Você é um desenvolvedor sênior especialista em smart contracts Solidity.
+Sua função é corrigir erros de compilação em contratos Solidity.
+
+Regras:
+- Corrija TODOS os erros indicados
+- Mantenha a lógica de negócio original intacta
+- NÃO adicione imports externos
+- O contrato deve compilar sem erros com solc 0.8.20+
+- Retorne APENAS o código Solidity corrigido completo`,
+  ],
+  [
+    "human",
+    `O seguinte contrato Solidity tem erros de compilação. Corrija-os:
+
+**Código atual:**
+\`\`\`solidity
+{contract}
+\`\`\`
+
+**Erros de compilação:**
+{errors}
+
+Retorne APENAS o código Solidity corrigido completo, sem explicações.`,
+  ],
+]);
+
+/**
+ * Prompt para revisar contratos Solidity quanto a segurança e boas práticas.
+ */
+export const solidityReviewPrompt = ChatPromptTemplate.fromMessages([
+  [
+    "system",
+    `Você é um auditor de segurança sênior especialista em smart contracts Solidity.
+Analise o contrato quanto a:
+- Vulnerabilidades de segurança (reentrância, overflow, acesso não autorizado)
+- Aderência a boas práticas Solidity
+- Legibilidade e manutenibilidade
+- Potenciais problemas de gas
+
+Seja objetivo e conciso. Responda em português brasileiro.`,
+  ],
+  [
+    "human",
+    `Revise o seguinte smart contract:
+
+**Requisitos originais:**
+{requirements}
+
+**Código:**
+\`\`\`solidity
+{contract}
+\`\`\`
+
+Forneça um resumo breve da revisão em 2-3 frases destacando se o contrato está seguro e funcional.`,
+  ],
+]);

src/agents/coder/run.ts

@@ -0,0 +1,33 @@
+import "dotenv/config";
+import { readFileSync, mkdirSync, writeFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { coderAgent } from "./agent.ts";
+
+const inputPath = process.argv[2];
+
+if (!inputPath) {
+  console.log("Uso: npx tsx src/agents/coder/run.ts <caminho-do-arquivo-de-requisitos>");
+  console.log("Exemplo: npx tsx src/agents/coder/run.ts input/requirements.md");
+  process.exit(1);
+}
+
+const requirementsText = readFileSync(resolve(inputPath), "utf-8");
+console.log("Requisitos carregados de:", inputPath);
+console.log("Gerando contrato...\n");
+
+const result = await coderAgent.invoke({ requirements: [requirementsText] });
+
+console.log("======= Contrato Gerado =======");
+console.log(result.contract);
+console.log("\n======= Erros de Compilação =======");
+console.log(result.compilationErrors.length === 0 ? "Nenhum erro" : result.compilationErrors.join("\n"));
+console.log("\n======= Revisão de Segurança =======");
+console.log(result.reviewSummary);
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const outputDir = resolve(__dirname, "outputs");
+mkdirSync(outputDir, { recursive: true });
+const outputPath = resolve(outputDir, "Contract.sol");
+writeFileSync(outputPath, result.contract, "utf-8");
+console.log("\nContrato salvo em:", outputPath);

src/agents/coder/state.ts

@@ -4,4 +4,6 @@ import { z } from "zod";
 export const CoderState = new StateSchema({
   requirements: z.array(z.string()).default([]),
   contract: z.string().default(""),
+  compilationErrors: z.array(z.string()).default([]),
+  reviewSummary: z.string().default(""),
 });

src/agents/coder/tools/compile-solidity.ts

@@ -0,0 +1,50 @@
+import { tool } from "langchain";
+import { z } from "zod";
+import solc from "solc";
+
+/**
+ * Tool que compila código Solidity usando solc e retorna erros/warnings.
+ */
+export const compileSolidityTool = tool(
+  async (input) => {
+    const compilerInput = {
+      language: "Solidity",
+      sources: {
+        [input.filename]: { content: input.sourceCode },
+      },
+      settings: {
+        outputSelection: {
+          "*": { "*": ["abi", "evm.bytecode.object"] },
+        },
+      },
+    };
+
+    const output = JSON.parse(solc.compile(JSON.stringify(compilerInput)));
+
+    const errors = (output.errors || [])
+      .filter((e: { severity: string }) => e.severity === "error")
+      .map((e: { formattedMessage: string }) => e.formattedMessage);
+
+    const warnings = (output.errors || [])
+      .filter((e: { severity: string }) => e.severity === "warning")
+      .map((e: { formattedMessage: string }) => e.formattedMessage);
+
+    const contracts = output.contracts?.[input.filename] || {};
+    const contractNames = Object.keys(contracts);
+
+    return {
+      success: errors.length === 0,
+      errors,
+      warnings,
+      contracts: contractNames,
+    };
+  },
+  {
+    name: "compilar_solidity",
+    description: "Compila código Solidity com solc e retorna erros, warnings e contratos encontrados.",
+    schema: z.object({
+      sourceCode: z.string().describe("Código-fonte Solidity completo"),
+      filename: z.string().default("Contract.sol").describe("Nome do arquivo .sol"),
+    }),
+  },
+);