lint and use logger

src/agents/tester/nodes/context.ts

@@ -1,10 +1,11 @@
 import fs from "fs/promises";
 import path from "path";
+
 import { PoCState } from "../state.js";
 import { logger } from "../../../logger.js";
 
 export async function contextNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[contextNode] Preparando ambiente de testes para:", state.report.title);
+  logger.info(`[Tester] contextNode: Preparando ambiente de testes para: ${state.report.title}`);
 
   if (state.report.customSandboxDir) {
     try {
@@ -18,16 +19,16 @@ export async function contextNode(state: PoCState): Promise<Partial<PoCState>> {
         }
       }
       if (removed > 0) {
-        console.log(`[contextNode] Limpos ${removed} arquivos de teste antigos.`);
+        logger.info(`[Tester] contextNode: Limpos ${removed} arquivos de teste antigos.`);
       }
     } catch (e) {
-      console.warn("[contextNode] falha na limpeza do diretório de testes:", (e as Error).message);
+      logger.warn(`[Tester] contextNode: falha na limpeza do diretório de testes: ${(e as Error).message}`);
     }
   }
 
-  return { 
-    templateCode: "", 
-    pocCode: "", 
-    infrastructurePhase: false
+  return {
+    templateCode: "",
+    pocCode: "",
+    infrastructurePhase: false,
   };
 }

src/agents/tester/nodes/pocoAgent.ts

@@ -2,7 +2,7 @@ import { HumanMessage, SystemMessage, AIMessage, trimMessages } from "@langchain
 import { PoCState } from "../state.js";
 import { pocoTools } from "../tools.js";
 import { createLLM } from "../../../config/llm.js";
-import { emitStep } from "../../../logger.js";
+import { logger, emitStep } from "../../../logger.js";
 
 const MAX_STEPS = 30; // Max tool calls threshold
 const MAX_COST_USD = 3.0; // Max cost threshold
@@ -67,63 +67,66 @@ export async function pocoAgentNode(state: PoCState): Promise<Partial<PoCState>>
     const sandboxDir = state.report.customSandboxDir || process.cwd();
     const targetFile = state.report.affectedContract.sourceFilePath || state.report.affectedContract.name;
     const desc = state.report.description || state.report.title;
-    
+
     // Original PoCo prompt
     const taskPrompt = `Create a vulnerability exposing PoC forge test for the vulnerable contract at ${targetFile} using the vulnerability description: ${desc}. Use the write_file tool to save your PoC code to test/Exploit.t.sol. Write ONLY the test file, test ONLY the described vulnerability, and do NOT modify the original contract. Iterate on compilation, test, and logical errors using the smart_contract_compile and smart_contract_test tools. You are done when the test compiles and successfully demonstrates the vulnerability through passing assertions. Note: your execution sandbox is ${sandboxDir}. Ensure all commands target this directory.`;
 
-    initialMessages = [
-      new SystemMessage(POCO_SYSTEM_PROMPT),
-      new HumanMessage(taskPrompt)
-    ];
+    initialMessages = [new SystemMessage(POCO_SYSTEM_PROMPT), new HumanMessage(taskPrompt)];
     messages = initialMessages;
   }
 
   // Invoke model
-  console.log(`[pocoAgent] Invoking model (Steps: ${state.toolCallCount}/${MAX_STEPS}, Cost: $${state.totalCost.toFixed(2)})...`);
-  let response;
+  logger.info(
+    `[Tester] pocoAgent: Invoking model (Steps: ${state.toolCallCount}/${MAX_STEPS}, Cost: $${state.totalCost.toFixed(2)})...`,
+  );
+  let response: any;
   let runCost = 0;
-  
+
   let attempts = 0;
   while (attempts < 3) {
     try {
       const trimmedMessages = await trimMessages(messages, {
         maxTokens: 100000,
         strategy: "last",
-        tokenCounter: (msgs) => msgs.map(m => m.content ? m.content.toString().length / 4 : 0).reduce((a, b) => a + b, 0),
+        tokenCounter: (msgs) =>
+          msgs.map((m) => (m.content ? m.content.toString().length / 4 : 0)).reduce((a, b) => a + b, 0),
         includeSystem: true,
         allowPartial: false,
       });
 
       response = await model.invoke(trimmedMessages, {
-        configurable: { sandboxDir: state.report.customSandboxDir || process.cwd() }
+        configurable: { sandboxDir: state.report.customSandboxDir || process.cwd() },
       });
-      
+
       if (process.env.DEBUG_CONTEXT === "true") {
-        console.log(`\n--- Agent Response [Step ${state.toolCallCount}] ---`);
-        console.log(response.content);
+        logger.debug(`[Tester]\n--- Agent Response [Step ${state.toolCallCount}] ---`);
+        logger.debug(response.content);
         if (response.tool_calls) {
-          console.log("Tool Calls:", JSON.stringify(response.tool_calls, null, 2));
+          logger.debug(`[Tester] Tool Calls: ${JSON.stringify(response.tool_calls, null, 2)}`);
         }
       }
-      
+
       // Calculate costs
       if (response.response_metadata?.tokenUsage) {
         const usage: any = response.response_metadata.tokenUsage;
-        runCost = calculateCost(usage.promptTokens || usage.input_tokens || usage.prompt_tokens || 0, usage.completionTokens || usage.output_tokens || usage.completion_tokens || 0);
+        runCost = calculateCost(
+          usage.promptTokens || usage.input_tokens || usage.prompt_tokens || 0,
+          usage.completionTokens || usage.output_tokens || usage.completion_tokens || 0,
+        );
       }
       break; // Success, exit retry loop
     } catch (err: any) {
       attempts++;
-      console.log(`[pocoAgent] API Error (attempt ${attempts}): ${err.message}`);
+      logger.warn(`[Tester] pocoAgent: API Error (attempt ${attempts}): ${err.message}`);
       if (attempts >= 3) {
         return {
           messages: [new HumanMessage(`Model API Error after 3 attempts: ${err.message}.`)],
           status: "failed",
-          lastError: err.message
+          lastError: err.message,
         };
       }
       // Wait 10 seconds before retrying (in case of strict rate limits)
-      await new Promise(r => setTimeout(r, 10000));
+      await new Promise((r) => setTimeout(r, 10000));
     }
   }
 

src/agents/tester/tools/foundryRunner.ts

@@ -3,7 +3,9 @@ import { promisify } from "util";
 import { writeFile, access } from "fs/promises";
 import { join } from "path";
 
-const execAsync  = promisify(exec);
+import { logger } from "../../../logger.ts";
+
+const execAsync = promisify(exec);
 const DEFAULT_SANDBOX = process.env.SANDBOX_DIR || "/tmp/poc-sandbox";
 const TIMEOUT_MS = 60_000;
 
@@ -22,7 +24,7 @@ async function ensureSandbox(sandboxDir: string) {
   try {
     await access(join(sandboxDir, "foundry.toml"));
   } catch {
-    console.log(`[foundryRunner] Sandbox em ${sandboxDir} não encontrado. Inicializando...`);
+    logger.info(`[Tester] foundryRunner: Sandbox em ${sandboxDir} não encontrado. Inicializando...`);
     // Caminho absoluto para o script de setup (assume execução da raiz do projeto)
     await execAsync("./scripts/setup-sandbox.sh", { env: { ...process.env, SANDBOX_DIR: sandboxDir } });
   }
@@ -30,7 +32,7 @@ async function ensureSandbox(sandboxDir: string) {
 
 export async function runFoundry(solidityCode: string, sandboxDir: string = DEFAULT_SANDBOX): Promise<FoundryResult> {
   await ensureSandbox(sandboxDir);
-  
+
   // Ensure test directory exists
   const testDir = join(sandboxDir, "test");
   try {
@@ -38,20 +40,17 @@ export async function runFoundry(solidityCode: string, sandboxDir: string = DEFA
   } catch {
     await execAsync(`mkdir -p "${testDir}"`);
   }
-  
+
   // Escrever o arquivo no sandbox
   const testPath = join(testDir, "Exploit.t.sol");
   await writeFile(testPath, solidityCode, "utf-8");
 
   try {
-    const { stdout, stderr } = await execAsync(
-      "forge test --match-contract ExploitTest -vvvv",
-      { 
-        cwd: sandboxDir, 
-        timeout: TIMEOUT_MS, 
-        env: { ...process.env, PATH: `${process.env.HOME}/.foundry/bin:${process.env.PATH}` } 
-      }
-    );
+    const { stdout, stderr } = await execAsync("forge test --match-contract ExploitTest -vvvv", {
+      cwd: sandboxDir,
+      timeout: TIMEOUT_MS,
+      env: { ...process.env, PATH: `${process.env.HOME}/.foundry/bin:${process.env.PATH}` },
+    });
     return {
       exitCode: 0,
       stdout,