solidity-argus 0.2.0 → 0.3.0

package/src/tools/forge-test-tool.ts

@@ -1,152 +1,151 @@
-import { tool, type ToolContext } from "@opencode-ai/plugin";
+import { type ToolContext, tool } from "@opencode-ai/plugin"
+import { resolveProjectDir } from "../shared/project-utils"
 
 type ForgeTestArgs = {
-  target?: string;
-  match_test?: string;
-  match_contract?: string;
-  fork_url?: string;
-  verbosity?: number;
-  gas_report?: boolean;
-  coverage?: boolean;
-};
+  target?: string
+  match_test?: string
+  match_contract?: string
+  fork_url?: string
+  verbosity?: number
+  gas_report?: boolean
+  coverage?: boolean
+}
 
 type NormalizedForgeTestArgs = {
-  target: string;
-  match_test?: string;
-  match_contract?: string;
-  fork_url?: string;
-  verbosity: number;
-  gas_report?: boolean;
-  coverage: boolean;
-};
+  target: string
+  match_test?: string
+  match_contract?: string
+  fork_url?: string
+  verbosity: number
+  gas_report?: boolean
+  coverage: boolean
+}
 
 type ForgeTestItem = {
-  name: string;
-  contract: string;
-  status: "pass" | "fail";
-  gas: number;
-};
+  name: string
+  contract: string
+  status: "pass" | "fail"
+  gas: number
+}
 
 type ForgeTestSummary = {
-  passed: number;
-  failed: number;
-  skipped: number;
-  total: number;
-};
+  passed: number
+  failed: number
+  skipped: number
+  total: number
+}
 
 type ForgeCoverageFile = {
-  path: string;
-  lines: number;
-  branches: number;
-  functions: number;
-  uncoveredFunctions: string[];
-};
+  path: string
+  lines: number
+  branches: number
+  functions: number
+  uncoveredFunctions: string[]
+}
 
 type ForgeTestResult = {
-  success: boolean;
-  summary: ForgeTestSummary;
-  tests: ForgeTestItem[];
-  gasReport?: Record<string, unknown>;
-  coverageReport?: { files: ForgeCoverageFile[] };
-  executionTime: number;
-  error?: string;
-};
+  success: boolean
+  summary: ForgeTestSummary
+  tests: ForgeTestItem[]
+  gasReport?: Record<string, unknown>
+  coverageReport?: { files: ForgeCoverageFile[] }
+  executionTime: number
+  error?: string
+}
 
 export type ForgeCommandResult = {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-};
+  stdout: string
+  stderr: string
+  exitCode: number
+}
 
 type RunForgeCommand = (
   command: string[],
   signal: AbortSignal,
-  cwd: string
-) => Promise<ForgeCommandResult>;
+  cwd: string,
+) => Promise<ForgeCommandResult>
 
 type ForgeTestPayload = {
-  success?: boolean;
+  success?: boolean
   tests?:
     | Record<string, Record<string, { status?: string; gas?: number }>>
-    | Array<{ name?: string; contract?: string; status?: string; gas?: number }>;
+    | Array<{ name?: string; contract?: string; status?: string; gas?: number }>
   summary?: {
-    passed?: number;
-    failed?: number;
-    skipped?: number;
-    total?: number;
-  };
-  gas_report?: Record<string, unknown>;
-  gasReport?: Record<string, unknown>;
-};
+    passed?: number
+    failed?: number
+    skipped?: number
+    total?: number
+  }
+  gas_report?: Record<string, unknown>
+  gasReport?: Record<string, unknown>
+}
 
 type CoveragePayload = {
-  files?: Array<Record<string, unknown>>;
-  coverage?: Record<string, Record<string, unknown>>;
-};
+  files?: Array<Record<string, unknown>>
+  coverage?: Record<string, Record<string, unknown>>
+}
 
 function mapStatus(input?: string): "pass" | "fail" | "skip" {
-  const normalized = (input ?? "").toLowerCase();
+  const normalized = (input ?? "").toLowerCase()
   if (normalized.includes("skip") || normalized.includes("ignore")) {
-    return "skip";
+    return "skip"
   }
   if (normalized.includes("pass") || normalized.includes("success")) {
-    return "pass";
+    return "pass"
   }
-  return "fail";
+  return "fail"
 }
 
 function toNumber(input: unknown, fallback = 0): number {
-  return typeof input === "number" && Number.isFinite(input) ? input : fallback;
+  return typeof input === "number" && Number.isFinite(input) ? input : fallback
 }
 
 function parseTests(payload: ForgeTestPayload): {
-  tests: ForgeTestItem[];
-  summary: ForgeTestSummary;
+  tests: ForgeTestItem[]
+  summary: ForgeTestSummary
 } {
-  const collected: Array<ForgeTestItem | { skipped: true }> = [];
+  const collected: Array<ForgeTestItem | { skipped: true }> = []
 
   if (Array.isArray(payload.tests)) {
     for (const item of payload.tests) {
-      const status = mapStatus(item.status);
+      const status = mapStatus(item.status)
       if (status === "skip") {
-        collected.push({ skipped: true });
-        continue;
+        collected.push({ skipped: true })
+        continue
       }
       collected.push({
         name: item.name ?? "unknown-test",
         contract: item.contract ?? "unknown-contract",
         status,
         gas: toNumber(item.gas),
-      });
+      })
     }
   } else if (payload.tests && typeof payload.tests === "object") {
-    const entries = Object.entries(payload.tests);
+    const entries = Object.entries(payload.tests)
     for (const [contract, tests] of entries) {
       for (const [name, details] of Object.entries(tests)) {
-        const status = mapStatus(details.status);
+        const status = mapStatus(details.status)
         if (status === "skip") {
-          collected.push({ skipped: true });
-          continue;
+          collected.push({ skipped: true })
+          continue
         }
         collected.push({
           name,
           contract,
           status,
           gas: toNumber(details.gas),
-        });
+        })
       }
     }
   }
 
-  const tests = collected.filter((item): item is ForgeTestItem => !("skipped" in item));
-  const passed = tests.filter((item) => item.status === "pass").length;
-  const failed = tests.filter((item) => item.status === "fail").length;
-  const skippedFromTests = collected.length - tests.length;
-  const summary = payload.summary;
-  const skipped =
-    typeof summary?.skipped === "number" ? summary.skipped : skippedFromTests;
-  const total =
-    typeof summary?.total === "number" ? summary.total : passed + failed + skipped;
+  const tests = collected.filter((item): item is ForgeTestItem => !("skipped" in item))
+  const passed = tests.filter((item) => item.status === "pass").length
+  const failed = tests.filter((item) => item.status === "fail").length
+  const skippedFromTests = collected.length - tests.length
+  const summary = payload.summary
+  const skipped = typeof summary?.skipped === "number" ? summary.skipped : skippedFromTests
+  const total = typeof summary?.total === "number" ? summary.total : passed + failed + skipped
 
   return {
     tests,
@@ -156,51 +155,49 @@ function parseTests(payload: ForgeTestPayload): {
       skipped,
       total,
     },
-  };
+  }
 }
 
 function valueFromRecord(record: Record<string, unknown>, keys: string[]): unknown {
   for (const key of keys) {
     if (key in record) {
-      return record[key];
+      return record[key]
     }
   }
-  return undefined;
+  return undefined
 }
 
 function parseUncoveredFunctions(input: unknown): string[] {
   if (!Array.isArray(input)) {
-    return [];
+    return []
   }
 
   return input
     .map((value) => {
       if (typeof value === "string") {
-        return value;
+        return value
       }
       if (value && typeof value === "object" && "name" in value) {
-        const name = (value as { name?: unknown }).name;
-        return typeof name === "string" ? name : "";
+        const name = (value as { name?: unknown }).name
+        return typeof name === "string" ? name : ""
       }
-      return "";
+      return ""
     })
-    .filter((value) => value.length > 0);
+    .filter((value) => value.length > 0)
 }
 
 function normalizeCoverageFile(file: Record<string, unknown>): ForgeCoverageFile {
   return {
     path: (valueFromRecord(file, ["path", "file", "name"]) as string) ?? "unknown",
     lines: toNumber(valueFromRecord(file, ["lines", "lineCoverage", "line_coverage"])),
-    branches: toNumber(
-      valueFromRecord(file, ["branches", "branchCoverage", "branch_coverage"])
-    ),
+    branches: toNumber(valueFromRecord(file, ["branches", "branchCoverage", "branch_coverage"])),
     functions: toNumber(
-      valueFromRecord(file, ["functions", "functionCoverage", "function_coverage"])
+      valueFromRecord(file, ["functions", "functionCoverage", "function_coverage"]),
     ),
     uncoveredFunctions: parseUncoveredFunctions(
-      valueFromRecord(file, ["uncoveredFunctions", "uncovered_functions"])
+      valueFromRecord(file, ["uncoveredFunctions", "uncovered_functions"]),
     ),
-  };
+  }
 }
 
 function parseCoverage(payload: CoveragePayload): { files: ForgeCoverageFile[] } {
@@ -209,32 +206,33 @@ function parseCoverage(payload: CoveragePayload): { files: ForgeCoverageFile[] }
       files: payload.files
         .filter((item): item is Record<string, unknown> => !!item && typeof item === "object")
         .map((item) => normalizeCoverageFile(item)),
-    };
+    }
   }
 
   if (payload.coverage && typeof payload.coverage === "object") {
-    const files: ForgeCoverageFile[] = [];
+    const files: ForgeCoverageFile[] = []
     for (const [path, metrics] of Object.entries(payload.coverage)) {
       if (!metrics || typeof metrics !== "object") {
-        continue;
+        continue
       }
       files.push(
         normalizeCoverageFile({
           path,
           ...metrics,
-        })
-      );
+        }),
+      )
     }
 
-    return { files };
+    return { files }
   }
 
-  return { files: [] };
+  return { files: [] }
 }
 
-function normalizeArgs(args: ForgeTestArgs): NormalizedForgeTestArgs {
+function normalizeArgs(args: ForgeTestArgs, context: ToolContext): NormalizedForgeTestArgs {
+  const target = args.target && args.target !== "." ? args.target : resolveProjectDir(context)
   return {
-    target: args.target ?? ".",
+    target,
     match_test: args.match_test,
     match_contract: args.match_contract,
     fork_url: args.fork_url,
@@ -244,26 +242,26 @@ function normalizeArgs(args: ForgeTestArgs): NormalizedForgeTestArgs {
         : 3,
     gas_report: args.gas_report,
     coverage: args.coverage ?? false,
-  };
+  }
 }
 
 function buildForgeTestCommand(args: NormalizedForgeTestArgs): string[] {
-  const command = ["forge", "test", "--json", `-v${"v".repeat(args.verbosity - 1)}`];
+  const command = ["forge", "test", "--json", `-v${"v".repeat(args.verbosity - 1)}`]
 
   if (args.match_test) {
-    command.push("--match-test", args.match_test);
+    command.push("--match-test", args.match_test)
   }
   if (args.match_contract) {
-    command.push("--match-contract", args.match_contract);
+    command.push("--match-contract", args.match_contract)
   }
   if (args.fork_url) {
-    command.push("--fork-url", args.fork_url);
+    command.push("--fork-url", args.fork_url)
   }
   if (args.gas_report) {
-    command.push("--gas-report");
+    command.push("--gas-report")
   }
 
-  return command;
+  return command
 }
 
 const runForgeCommand: RunForgeCommand = async (command, signal, cwd) => {
@@ -272,29 +270,29 @@ const runForgeCommand: RunForgeCommand = async (command, signal, cwd) => {
     stdout: "pipe",
     stderr: "pipe",
     signal,
-  });
+  })
 
   const [exitCode, stdout, stderr] = await Promise.all([
     child.exited,
     new Response(child.stdout).text(),
     new Response(child.stderr).text(),
-  ]);
+  ])
 
   return {
     stdout,
     stderr,
     exitCode,
-  };
-};
+  }
+}
 
 export async function executeForgeTest(
   args: ForgeTestArgs,
   context: ToolContext,
-  runCommand: RunForgeCommand = runForgeCommand
+  runCommand: RunForgeCommand = runForgeCommand,
 ): Promise<ForgeTestResult> {
-  const startedAt = Date.now();
-  const normalizedArgs = normalizeArgs(args);
-  context.metadata({ title: `Run forge test: ${normalizedArgs.target}` });
+  const startedAt = Date.now()
+  const normalizedArgs = normalizeArgs(args, context)
+  context.metadata({ title: `Run forge test: ${normalizedArgs.target}` })
 
   const fail = (error: string): ForgeTestResult => ({
     success: false,
@@ -302,23 +300,23 @@ export async function executeForgeTest(
     tests: [],
     executionTime: Date.now() - startedAt,
     error,
-  });
+  })
 
   try {
     const testResult = await runCommand(
       buildForgeTestCommand(normalizedArgs),
       context.abort,
-      normalizedArgs.target
-    );
+      normalizedArgs.target,
+    )
 
-    let payload: ForgeTestPayload;
+    let payload: ForgeTestPayload
     try {
-      payload = JSON.parse(testResult.stdout) as ForgeTestPayload;
+      payload = JSON.parse(testResult.stdout) as ForgeTestPayload
     } catch {
-      return fail("Invalid JSON output from forge test");
+      return fail("Invalid JSON output from forge test")
     }
 
-    const parsed = parseTests(payload);
+    const parsed = parseTests(payload)
     const output: ForgeTestResult = {
       success:
         testResult.exitCode === 0 &&
@@ -327,55 +325,53 @@ export async function executeForgeTest(
       summary: parsed.summary,
       tests: parsed.tests,
       executionTime: Date.now() - startedAt,
-    };
+    }
 
-    const gasReport = payload.gas_report ?? payload.gasReport;
+    const gasReport = payload.gas_report ?? payload.gasReport
     if (gasReport) {
-      output.gasReport = gasReport;
+      output.gasReport = gasReport
     }
 
     if (normalizedArgs.coverage) {
       const coverageResult = await runCommand(
         ["forge", "coverage", "--report", "json"],
         context.abort,
-        normalizedArgs.target
-      );
+        normalizedArgs.target,
+      )
       if (coverageResult.exitCode !== 0) {
-        output.error = coverageResult.stderr.trim() || "forge coverage failed";
-        output.success = false;
+        output.error = coverageResult.stderr.trim() || "forge coverage failed"
+        output.success = false
       } else {
         try {
-          const coveragePayload = JSON.parse(coverageResult.stdout) as CoveragePayload;
-          output.coverageReport = parseCoverage(coveragePayload);
+          const coveragePayload = JSON.parse(coverageResult.stdout) as CoveragePayload
+          output.coverageReport = parseCoverage(coveragePayload)
         } catch {
-          output.error = "Invalid JSON output from forge coverage";
-          output.success = false;
+          output.error = "Invalid JSON output from forge coverage"
+          output.success = false
         }
       }
     }
 
     if (testResult.exitCode !== 0 && !output.error) {
-      output.error = testResult.stderr.trim() || `forge test exited with code ${testResult.exitCode}`;
+      output.error =
+        testResult.stderr.trim() || `forge test exited with code ${testResult.exitCode}`
     }
 
-    return output;
+    return output
   } catch (error) {
     if (context.abort.aborted || (error instanceof DOMException && error.name === "AbortError")) {
-      return fail("forge test aborted");
+      return fail("forge test aborted")
     }
 
-    const maybeError = error as Error & { code?: string };
+    const maybeError = error as Error & { code?: string }
     if (maybeError.code === "ENOENT") {
-      return fail("Foundry not found. Install: curl -L https://foundry.paradigm.xyz | bash");
+      return fail("Foundry not found. Install: curl -L https://foundry.paradigm.xyz | bash")
     }
-    if (
-      maybeError.code === "ETIMEDOUT" ||
-      maybeError.message.toLowerCase().includes("timed out")
-    ) {
-      return fail("forge test timed out");
+    if (maybeError.code === "ETIMEDOUT" || maybeError.message.toLowerCase().includes("timed out")) {
+      return fail("forge test timed out")
     }
 
-    return fail(maybeError.message || "forge test failed");
+    return fail(maybeError.message || "forge test failed")
   }
 }
 
@@ -391,7 +387,7 @@ export const forgeTestTool = tool({
     coverage: tool.schema.boolean().default(false),
   },
   async execute(args, context) {
-    const result = await executeForgeTest(args, context);
-    return JSON.stringify(result);
+    const result = await executeForgeTest(args, context)
+    return JSON.stringify(result)
   },
-});
+})