solidity-argus 0.2.0 → 0.3.0

package/src/tools/contract-analyzer-tool.ts

@@ -1,28 +1,30 @@
-import { dirname, basename, join } from "node:path";
-import { existsSync } from "node:fs";
-import { tool, type ToolContext } from "@opencode-ai/plugin";
-import { extractContractInfo } from "../utils/solidity-parser";
-import type { ContractProfile } from "../state/types";
+import { existsSync } from "node:fs"
+import { basename } from "node:path"
+import { type ToolContext, tool } from "@opencode-ai/plugin"
+import { findFoundryProjectDir } from "../shared/project-utils"
+import type { ContractProfile } from "../state/types"
+import { extractContractInfo } from "../utils/solidity-parser"
 
 type ContractAnalyzerArgs = {
-  file_path: string;
-  project_dir?: string;
-};
+  file_path: string
+  project_dir?: string
+}
 
-type ExtractContractInfoFn = (
-  contractName: string,
-  projectDir: string
-) => Promise<ContractProfile>;
+type ExtractContractInfoFn = (contractName: string, projectDir: string) => Promise<ContractProfile>
 
 type ContractAnalyzerDependencies = {
-  extractInfo: ExtractContractInfoFn;
-};
+  extractInfo: ExtractContractInfoFn
+}
 
 const DEFAULT_DEPENDENCIES: ContractAnalyzerDependencies = {
   extractInfo: extractContractInfo,
-};
+}
 
-function createFailureProfile(contractName: string, filePath: string, error: string): ContractProfile {
+function createFailureProfile(
+  contractName: string,
+  filePath: string,
+  error: string,
+): ContractProfile {
   return {
     name: contractName,
     filePath,
@@ -33,117 +35,98 @@ function createFailureProfile(contractName: string, filePath: string, error: str
     externalCalls: [],
     riskIndicators: [],
     error,
-  };
-}
-
-function findFoundryProjectDir(fromPath: string): string {
-  let current = dirname(fromPath);
-
-  while (true) {
-    if (existsSync(join(current, "foundry.toml"))) {
-      return current;
-    }
-
-    const parent = dirname(current);
-    if (parent === current) {
-      return dirname(fromPath);
-    }
-    current = parent;
   }
 }
 
 function addIndicator(indicators: Set<string>, source: string, indicator: string): void {
   if (source.includes(indicator.split("uses-")[1] ?? "")) {
-    indicators.add(indicator);
+    indicators.add(indicator)
   }
 }
 
 function collectRiskIndicators(source: string, existing: string[]): string[] {
-  const indicators = new Set(existing);
-  const normalized = source.toLowerCase();
+  const indicators = new Set(existing)
+  const normalized = source.toLowerCase()
 
-  addIndicator(indicators, normalized, "uses-delegatecall");
-  addIndicator(indicators, normalized, "uses-selfdestruct");
+  addIndicator(indicators, normalized, "uses-delegatecall")
+  addIndicator(indicators, normalized, "uses-selfdestruct")
   if (/\bassembly\b/.test(normalized)) {
-    indicators.add("uses-assembly");
+    indicators.add("uses-assembly")
   }
   if (/\btx\.origin\b/.test(normalized)) {
-    indicators.add("uses-tx-origin");
+    indicators.add("uses-tx-origin")
   }
 
   const importLines = source
     .split("\n")
     .map((line) => line.trim())
-    .filter((line) => line.startsWith("import "));
-  const importText = importLines.join("\n");
+    .filter((line) => line.startsWith("import "))
+  const importText = importLines.join("\n")
 
   const ozChecks: Array<{ pattern: RegExp; indicator: string }> = [
     { pattern: /\bReentrancyGuard\b/, indicator: "uses-oz-reentrancy-guard" },
     { pattern: /\bAccessControl\b/, indicator: "uses-oz-access-control" },
     { pattern: /\bOwnable\b/, indicator: "uses-oz-ownable" },
     { pattern: /\bPausable\b/, indicator: "uses-oz-pausable" },
-  ];
+  ]
 
   for (const check of ozChecks) {
     if (check.pattern.test(importText)) {
-      indicators.add(check.indicator);
+      indicators.add(check.indicator)
     }
   }
 
-  return [...indicators];
+  return [...indicators]
 }
 
 function withAbort<T>(signal: AbortSignal, operation: Promise<T>): Promise<T> {
   if (signal.aborted) {
-    return Promise.reject(new DOMException("Aborted", "AbortError"));
+    return Promise.reject(new DOMException("Aborted", "AbortError"))
   }
 
   return new Promise<T>((resolve, reject) => {
     const onAbort = () => {
-      reject(new DOMException("Aborted", "AbortError"));
-    };
+      reject(new DOMException("Aborted", "AbortError"))
+    }
 
-    signal.addEventListener("abort", onAbort, { once: true });
+    signal.addEventListener("abort", onAbort, { once: true })
     operation.then(
       (value) => {
-        signal.removeEventListener("abort", onAbort);
-        resolve(value);
+        signal.removeEventListener("abort", onAbort)
+        resolve(value)
       },
       (error) => {
-        signal.removeEventListener("abort", onAbort);
-        reject(error);
-      }
-    );
-  });
+        signal.removeEventListener("abort", onAbort)
+        reject(error)
+      },
+    )
+  })
 }
 
 export async function executeContractAnalyzer(
   args: ContractAnalyzerArgs,
   context: ToolContext,
-  dependencies: ContractAnalyzerDependencies = DEFAULT_DEPENDENCIES
+  dependencies: ContractAnalyzerDependencies = DEFAULT_DEPENDENCIES,
 ): Promise<ContractProfile> {
-  const filePath = args.file_path;
-  const contractName = basename(filePath, ".sol");
+  const filePath = args.file_path
+  const contractName = basename(filePath, ".sol")
 
-  context.metadata({ title: `Analyze contract: ${contractName}` });
+  context.metadata({ title: `Analyze contract: ${contractName}` })
 
   if (!existsSync(filePath)) {
-    return createFailureProfile(contractName, filePath, `Contract file not found: ${filePath}`);
+    return createFailureProfile(contractName, filePath, `Contract file not found: ${filePath}`)
   }
 
-  const projectDir = args.project_dir ?? findFoundryProjectDir(filePath);
+  const projectDir = args.project_dir ?? findFoundryProjectDir(filePath)
 
   try {
     const [contractProfile, sourceText] = await withAbort(
       context.abort,
-      Promise.all([
-        dependencies.extractInfo(contractName, projectDir),
-        Bun.file(filePath).text(),
-      ])
-    );
+      Promise.all([dependencies.extractInfo(contractName, projectDir), Bun.file(filePath).text()]),
+    )
 
     if (context.abort.aborted) {
-      return createFailureProfile(contractName, filePath, "contract analysis aborted");
+      return createFailureProfile(contractName, filePath, "contract analysis aborted")
     }
 
     return {
@@ -151,23 +134,23 @@ export async function executeContractAnalyzer(
       name: contractProfile.name || contractName,
       filePath,
       riskIndicators: collectRiskIndicators(sourceText, contractProfile.riskIndicators),
-    };
+    }
   } catch (error) {
     if (context.abort.aborted || (error instanceof DOMException && error.name === "AbortError")) {
-      return createFailureProfile(contractName, filePath, "contract analysis aborted");
+      return createFailureProfile(contractName, filePath, "contract analysis aborted")
     }
 
-    const maybeError = error as Error & { code?: string };
+    const maybeError = error as Error & { code?: string }
     if (maybeError.code === "ENOENT") {
       return createFailureProfile(
         contractName,
         filePath,
-        "Foundry not found. Install: curl -L https://foundry.paradigm.xyz | bash"
-      );
+        "Foundry not found. Install: curl -L https://foundry.paradigm.xyz | bash",
+      )
     }
 
-    const message = maybeError.message || "contract analysis failed";
-    return createFailureProfile(contractName, filePath, message);
+    const message = maybeError.message || "contract analysis failed"
+    return createFailureProfile(contractName, filePath, message)
   }
 }
 
@@ -178,7 +161,7 @@ export const contractAnalyzerTool = tool({
     project_dir: tool.schema.string().optional(),
   },
   async execute(args, context) {
-    const contractProfile = await executeContractAnalyzer(args, context);
-    return JSON.stringify(contractProfile);
+    const contractProfile = await executeContractAnalyzer(args, context)
+    return JSON.stringify(contractProfile)
   },
-});
+})

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

@@ -0,0 +1,226 @@
+import { type ToolContext, tool } from "@opencode-ai/plugin"
+import { resolveProjectDir } from "../shared/project-utils"
+
+type ForgeCoverageArgs = {
+  target?: string
+}
+
+type NormalizedForgeCoverageArgs = {
+  target: string
+}
+
+type ForgeCoverageFile = {
+  path: string
+  linesPct: number
+  statementsPct: number
+  branchesPct: number
+  functionsPct: number
+}
+
+type ForgeCoverageSummary = {
+  totalLinesPct: number
+  totalStatementsPct: number
+  totalBranchesPct: number
+  totalFunctionsPct: number
+}
+
+type ForgeCoverageReport = {
+  files: ForgeCoverageFile[]
+  summary: ForgeCoverageSummary
+}
+
+type ForgeCoverageResult = {
+  success: boolean
+  report: ForgeCoverageReport
+  executionTime: number
+  error?: string
+}
+
+export type ForgeCommandRunner = (
+  command: string[],
+  signal: AbortSignal,
+  cwd: string,
+) => Promise<{ stdout: string; stderr: string; exitCode: number }>
+
+const EMPTY_SUMMARY: ForgeCoverageSummary = {
+  totalLinesPct: 0,
+  totalStatementsPct: 0,
+  totalBranchesPct: 0,
+  totalFunctionsPct: 0,
+}
+
+function normalizeArgs(args: ForgeCoverageArgs, context: ToolContext): NormalizedForgeCoverageArgs {
+  return {
+    target: args.target ?? resolveProjectDir(context),
+  }
+}
+
+function parsePercent(input: string): number {
+  const match = input.match(/(\d+(?:\.\d+)?)%/)
+  if (!match?.[1]) {
+    return 0
+  }
+
+  const value = Number.parseFloat(match[1])
+  return Number.isFinite(value) ? value : 0
+}
+
+function parseTableRow(line: string): string[] {
+  if (!line.startsWith("|")) {
+    return []
+  }
+  return line
+    .split("|")
+    .slice(1, -1)
+    .map((item) => item.trim())
+}
+
+function isSeparatorRow(cells: string[]): boolean {
+  if (cells.length === 0) {
+    return false
+  }
+  return cells.every((cell) => /^-+$/.test(cell))
+}
+
+function parseCoverageReport(output: string): ForgeCoverageReport {
+  const lines = output
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("|"))
+
+  const files: ForgeCoverageFile[] = []
+  let summary: ForgeCoverageSummary = { ...EMPTY_SUMMARY }
+  let hasSummary = false
+
+  for (const line of lines) {
+    const cells = parseTableRow(line)
+    if (cells.length < 5) {
+      continue
+    }
+
+    if (isSeparatorRow(cells)) {
+      continue
+    }
+
+    const label = cells[0]?.toLowerCase()
+    if (label === "file") {
+      continue
+    }
+
+    const rowValues = {
+      linesPct: parsePercent(cells[1] ?? "0"),
+      statementsPct: parsePercent(cells[2] ?? "0"),
+      branchesPct: parsePercent(cells[3] ?? "0"),
+      functionsPct: parsePercent(cells[4] ?? "0"),
+    }
+
+    if (label === "total") {
+      summary = {
+        totalLinesPct: rowValues.linesPct,
+        totalStatementsPct: rowValues.statementsPct,
+        totalBranchesPct: rowValues.branchesPct,
+        totalFunctionsPct: rowValues.functionsPct,
+      }
+      hasSummary = true
+      continue
+    }
+
+    files.push({
+      path: cells[0] ?? "unknown",
+      ...rowValues,
+    })
+  }
+
+  if (!hasSummary) {
+    throw new Error("Invalid tabular output from forge coverage")
+  }
+
+  return { files, summary }
+}
+
+const runForgeCommand: ForgeCommandRunner = async (command, signal, cwd) => {
+  const child = Bun.spawn(command, {
+    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 executeForgeCoverage(
+  args: ForgeCoverageArgs,
+  context: ToolContext,
+  runCommand: ForgeCommandRunner = runForgeCommand,
+): Promise<ForgeCoverageResult> {
+  const startedAt = Date.now()
+  const normalizedArgs = normalizeArgs(args, context)
+  context.metadata({ title: `Run forge coverage: ${normalizedArgs.target}` })
+
+  const fail = (error: string): ForgeCoverageResult => ({
+    success: false,
+    report: { files: [], summary: { ...EMPTY_SUMMARY } },
+    executionTime: Date.now() - startedAt,
+    error,
+  })
+
+  try {
+    const runResult = await runCommand(["forge", "coverage"], context.abort, normalizedArgs.target)
+
+    if (runResult.exitCode !== 0) {
+      return fail(
+        runResult.stderr.trim() || `forge coverage exited with code ${runResult.exitCode}`,
+      )
+    }
+
+    let report: ForgeCoverageReport
+    try {
+      report = parseCoverageReport(runResult.stdout)
+    } catch {
+      return fail("Invalid tabular output from forge coverage")
+    }
+
+    return {
+      success: true,
+      report,
+      executionTime: Date.now() - startedAt,
+    }
+  } catch (error) {
+    if (context.abort.aborted || (error instanceof DOMException && error.name === "AbortError")) {
+      return fail("forge coverage aborted")
+    }
+
+    const maybeError = error as Error & { code?: string }
+    if (maybeError.code === "ENOENT") {
+      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 coverage timed out")
+    }
+
+    return fail(maybeError.message || "forge coverage failed")
+  }
+}
+
+export const forgeCoverageTool = tool({
+  description:
+    "Run forge coverage analysis and return structured per-file coverage metrics (lines, statements, branches, functions).",
+  args: {
+    target: tool.schema.string().optional(),
+  },
+  async execute(args, context) {
+    const result = await executeForgeCoverage(args, context)
+    return JSON.stringify(result)
+  },
+})