solidity-argus 0.1.8 → 0.3.0

package/src/tools/slither-tool.ts

@@ -1,132 +1,134 @@
-import { createHash } from "crypto";
-import { mkdtempSync, writeFileSync, rmSync, readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-import { tool, type ToolContext } from "@opencode-ai/plugin";
-import type { Finding, FindingSeverity } from "../state/types";
-import { hasBinary as hasBinaryShared, parseSolcVersion as parseSolcVersionShared, extractContractNames as extractContractNamesShared } from "../shared/binary-utils";
+import { createHash } from "node:crypto"
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { dirname, isAbsolute, join, resolve } from "node:path"
+import { type ToolContext, tool } from "@opencode-ai/plugin"
+import { createLogger } from "../shared/logger"
+import type { Finding, FindingSeverity } from "../state/types"
+
+const logger = createLogger()
+
+import {
+  extractContractNames as extractContractNamesShared,
+  hasBinary as hasBinaryShared,
+  parseSolcVersion as parseSolcVersionShared,
+} from "../shared/binary-utils"
+import { resolveProjectDir } from "../shared/project-utils"
 
 type SlitherArgs = {
-  target: string;
-  detectors?: string[];
-  exclude?: string[];
-  solc_version?: string;
-  via_ir?: boolean;
-};
+  target: string
+  detectors?: string[]
+  exclude?: string[]
+  solc_version?: string
+  via_ir?: boolean
+}
 
 type SlitherDetector = {
-  check?: string;
-  impact?: string;
-  confidence?: string;
-  description?: string;
+  check?: string
+  impact?: string
+  confidence?: string
+  description?: string
   elements?: Array<{
     source_mapping?: {
-      filename_relative?: string;
-      lines?: number[];
-    };
-  }>;
-};
+      filename_relative?: string
+      lines?: number[]
+    }
+  }>
+}
 
 type SlitherPayload = {
-  success?: boolean;
-  error?: string | null;
+  success?: boolean
+  error?: string | null
   results?: {
-    detectors?: SlitherDetector[];
-  };
-};
+    detectors?: SlitherDetector[]
+  }
+}
 
 export type SlitherRunResult = {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-};
+  stdout: string
+  stderr: string
+  exitCode: number
+}
 
 export type RunSlitherCommand = (
   command: string[],
-  signal: AbortSignal
-) => Promise<SlitherRunResult>;
+  signal: AbortSignal,
+  cwd: string,
+) => Promise<SlitherRunResult>
 
 export type SlitherAnalyzeResult = {
-  success: boolean;
-  findingsCount: number;
-  findings: Finding[];
-  executionTime: number;
-  errors: string[];
-  error?: string;
-};
+  success: boolean
+  findingsCount: number
+  findings: Finding[]
+  executionTime: number
+  errors: string[]
+  error?: string
+}
 
 function mapSeverity(impact?: string): FindingSeverity {
   switch (impact) {
     case "High":
-      return "High";
+      return "High"
     case "Medium":
-      return "Medium";
+      return "Medium"
     case "Low":
-      return "Low";
+      return "Low"
     case "Informational":
-      return "Informational";
+      return "Informational"
     default:
-      return "Informational";
+      return "Informational"
   }
 }
 
 function mapConfidence(confidence?: string): "High" | "Medium" | "Low" {
   switch (confidence) {
     case "High":
-      return "High";
+      return "High"
     case "Medium":
-      return "Medium";
+      return "Medium"
     case "Low":
-      return "Low";
+      return "Low"
     default:
-      return "Low";
+      return "Low"
   }
 }
 
 function findingLines(lines?: number[]): [number, number] {
   if (!lines || lines.length === 0) {
-    return [1, 1];
+    return [1, 1]
   }
 
   if (lines.length === 1) {
-    const only = lines[0] ?? 1;
-    return [only, only];
+    const only = lines[0] ?? 1
+    return [only, only]
   }
 
-  const start = lines[0] ?? 1;
-  const end = lines[lines.length - 1] ?? start;
-  return [start, end];
+  const start = lines[0] ?? 1
+  const end = lines[lines.length - 1] ?? start
+  return [start, end]
 }
 
 function createFindingID(check: string, file: string, lines: [number, number]): string {
-  const key = `${check}:${file}:${lines[0]}-${lines[1]}`;
-  return createHash("sha256").update(key).digest("hex").slice(0, 16);
+  const key = `${check}:${file}:${lines[0]}-${lines[1]}`
+  return createHash("sha256").update(key).digest("hex").slice(0, 16)
 }
 
 function buildCommand(args: SlitherArgs): string[] {
-  const command = [
-    "slither",
-    args.target,
-    "--json",
-    "-",
-    "--filter-paths",
-    "node_modules",
-  ];
+  const command = ["slither", args.target, "--json", "-", "--filter-paths", "node_modules"]
 
   if (args.detectors && args.detectors.length > 0) {
-    command.push("--detect", args.detectors.join(","));
+    command.push("--detect", args.detectors.join(","))
   }
 
   if (args.exclude && args.exclude.length > 0) {
-    command.push("--exclude-detectors", args.exclude.join(","));
+    command.push("--exclude-detectors", args.exclude.join(","))
   }
 
   if (args.solc_version) {
-    command.push("--solc", `solc:${args.solc_version}`);
+    command.push("--solc", `solc:${args.solc_version}`)
   }
 
-  return command;
+  return command
 }
 
 const FALLBACK_TRIGGERS = [
@@ -142,59 +144,91 @@ const FALLBACK_TRIGGERS = [
   "YulException",
   "StackTooDeep",
   "Stack too deep",
-];
+]
 
 function shouldTryFlattenFallback(errors: string[], stderr: string): boolean {
-  const combined = [...errors, stderr].join(" ");
-  return FALLBACK_TRIGGERS.some((trigger) => combined.includes(trigger));
+  const combined = [...errors, stderr].join(" ")
+  return FALLBACK_TRIGGERS.some((trigger) => combined.includes(trigger))
 }
 
 const parseSolcVersion = parseSolcVersionShared
 const extractContractNames = extractContractNamesShared
 const hasBinary = hasBinaryShared
 
-function ensureSolc(version: string): boolean {
-  if (hasBinary("solc")) return true;
-  if (!hasBinary("solc-select")) return false;
+async function ensureSolc(version: string): Promise<boolean> {
+  if (hasBinary("solc")) return true
+  if (!hasBinary("solc-select")) return false
   try {
-    execSync(`solc-select install ${version} && solc-select use ${version}`, {
-      stdio: "ignore",
-      timeout: 60_000,
-    });
-    return true;
+    const installProc = Bun.spawn(["solc-select", "install", version], {
+      stdout: "pipe",
+      stderr: "pipe",
+      signal: AbortSignal.timeout(30_000),
+    })
+    const installExit = await installProc.exited
+    if (installExit !== 0) return false
+
+    const useProc = Bun.spawn(["solc-select", "use", version], {
+      stdout: "pipe",
+      stderr: "pipe",
+      signal: AbortSignal.timeout(30_000),
+    })
+    const useExit = await useProc.exited
+    return useExit === 0
   } catch (_e) {
-    return false;
+    return false
   }
 }
 
-export const runSlitherCommand: RunSlitherCommand = async (command, signal) => {
+export const runSlitherCommand: RunSlitherCommand = 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 type SpawnFn = (
+  command: string[],
+  options?: { cwd?: string; timeout?: number },
+) => Promise<{ stdout: string; exitCode: number }>
 
 export type FlattenFallbackDeps = {
-  runCommand: RunSlitherCommand;
-  hasBinary: (name: string) => boolean;
-  ensureSolc: (version: string) => boolean;
-  parseSolcVersion: (target: string) => string | undefined;
-  extractContractNames: (filePath: string) => string[];
-  execSyncFn: typeof execSync;
-};
+  runCommand: RunSlitherCommand
+  hasBinary: (name: string) => boolean
+  ensureSolc: (version: string) => Promise<boolean>
+  parseSolcVersion: (target: string) => Promise<string | undefined> | string | undefined
+  extractContractNames: (filePath: string) => Promise<string[]> | string[]
+  spawnFn: SpawnFn
+  cwd: string
+}
+
+async function defaultSpawnFn(
+  command: string[],
+  options?: { cwd?: string; timeout?: number },
+): Promise<{ stdout: string; exitCode: number }> {
+  const proc = Bun.spawn(command, {
+    stdout: "pipe",
+    stderr: "pipe",
+    cwd: options?.cwd,
+    ...(options?.timeout ? { signal: AbortSignal.timeout(options.timeout) } : {}),
+  })
+  const exitCode = await proc.exited
+  const stdout = await new Response(proc.stdout).text()
+  return { stdout, exitCode }
+}
 
 const defaultFlattenDeps: FlattenFallbackDeps = {
   runCommand: runSlitherCommand,
@@ -202,119 +236,148 @@ const defaultFlattenDeps: FlattenFallbackDeps = {
   ensureSolc,
   parseSolcVersion,
   extractContractNames,
-  execSyncFn: execSync,
-};
+  spawnFn: defaultSpawnFn,
+  cwd: process.cwd(),
+}
 
 export async function flattenFallback(
   args: SlitherArgs,
   context: ToolContext,
   deps: FlattenFallbackDeps = defaultFlattenDeps,
 ): Promise<SlitherAnalyzeResult | undefined> {
-  const startedAt = Date.now();
+  const startedAt = Date.now()
 
   if (!deps.hasBinary("forge")) {
-    return undefined;
+    return {
+      success: false,
+      findingsCount: 0,
+      findings: [],
+      executionTime: Date.now() - startedAt,
+      errors: ["forge binary not found — required for via_ir flatten fallback"],
+      error: "forge binary not found — required for via_ir flatten fallback",
+    }
   }
 
-  const solcVersion = args.solc_version ?? deps.parseSolcVersion(args.target);
+  const solcVersion = args.solc_version ?? (await deps.parseSolcVersion(args.target))
   if (!solcVersion) {
-    return undefined;
+    return {
+      success: false,
+      findingsCount: 0,
+      findings: [],
+      executionTime: Date.now() - startedAt,
+      errors: [
+        "Could not determine solc version from foundry.toml or pragma — required for flatten fallback",
+      ],
+      error:
+        "Could not determine solc version from foundry.toml or pragma — required for flatten fallback",
+    }
   }
 
-  if (!deps.ensureSolc(solcVersion)) {
+  if (!(await deps.ensureSolc(solcVersion))) {
     return {
       success: false,
       findingsCount: 0,
       findings: [],
       executionTime: Date.now() - startedAt,
       errors: ["solc not available and solc-select not found"],
-      error: "Flatten fallback requires solc on PATH. Install with: pipx install solc-select && solc-select install " + solcVersion,
-    };
+      error:
+        "Flatten fallback requires solc on PATH. Install with: pipx install solc-select && solc-select install " +
+        solcVersion,
+    }
   }
 
-  const srcDir = join(args.target, "src");
-  let solFiles: string[] = [];
+  const srcDir = join(args.target, "src")
+  let solFiles: string[] = []
   if (args.target.endsWith(".sol")) {
-    solFiles = [args.target];
+    solFiles = [args.target]
   } else if (existsSync(srcDir)) {
     try {
-      solFiles = deps.execSyncFn(`find "${srcDir}" -name "*.sol" -maxdepth 3 -not -path "*/mocks/*" -not -path "*/test/*"`, {
-        encoding: "utf-8",
-        timeout: 5_000,
-      })
-        .trim()
-        .split("\n")
-        .filter(Boolean);
+      const findResult = await deps.spawnFn(
+        [
+          "find",
+          srcDir,
+          "-maxdepth",
+          "3",
+          "-name",
+          "*.sol",
+          "-not",
+          "-path",
+          "*/mocks/*",
+          "-not",
+          "-path",
+          "*/test/*",
+        ],
+        { timeout: 5_000 },
+      )
+      if (findResult.exitCode !== 0) return undefined
+      solFiles = findResult.stdout.trim().split("\n").filter(Boolean)
     } catch (_e) {
-      return undefined;
+      return undefined
     }
   }
 
-  if (solFiles.length === 0) return undefined;
+  if (solFiles.length === 0) return undefined
 
-  const tmpDir = mkdtempSync(join(tmpdir(), "argus-slither-"));
-  const allFindings: Finding[] = [];
-  const errors: string[] = [];
+  const tmpDir = mkdtempSync(join(tmpdir(), "argus-slither-"))
+  const allFindings: Finding[] = []
+  const errors: string[] = []
 
   try {
     for (const solFile of solFiles) {
-      if (context.abort.aborted) break;
+      if (context.abort.aborted) break
 
-      const baseName = solFile.split("/").pop()?.replace(".sol", "") ?? "Contract";
-      const flatFile = join(tmpDir, `${baseName}.flat.sol`);
-      const originalContracts = deps.extractContractNames(solFile);
+      const baseName = solFile.split("/").pop()?.replace(".sol", "") ?? "Contract"
+      const flatFile = join(tmpDir, `${baseName}.flat.sol`)
+      const originalContracts = await deps.extractContractNames(solFile)
 
       try {
-        const flattened = deps.execSyncFn(`forge flatten "${solFile}"`, {
-          encoding: "utf-8",
+        const flatResult = await deps.spawnFn(["forge", "flatten", solFile], {
+          cwd: deps.cwd,
           timeout: 30_000,
-          cwd: args.target.endsWith(".sol") ? undefined : args.target,
-        });
-        writeFileSync(flatFile, flattened);
+        })
+        if (flatResult.exitCode !== 0) {
+          errors.push(`forge flatten failed for ${solFile}`)
+          continue
+        }
+        writeFileSync(flatFile, flatResult.stdout)
       } catch (_e) {
-        errors.push(`forge flatten failed for ${solFile}`);
-        continue;
+        errors.push(`forge flatten failed for ${solFile}`)
+        continue
       }
 
-      const command = [
-        "slither",
-        flatFile,
-        "--json",
-        "-",
-        "--solc-solcs-select",
-        solcVersion,
-      ];
+      const command = ["slither", flatFile, "--json", "-", "--solc-solcs-select", solcVersion]
 
       try {
-        const runResult = await deps.runCommand(command, context.abort);
+        const runResult = await deps.runCommand(command, context.abort, deps.cwd)
 
-        let payload: SlitherPayload;
+        let payload: SlitherPayload
         try {
-          payload = JSON.parse(runResult.stdout) as SlitherPayload;
+          payload = JSON.parse(runResult.stdout) as SlitherPayload
         } catch (_e) {
-          if (runResult.stderr.trim()) errors.push(runResult.stderr.trim());
-          continue;
+          if (runResult.stderr.trim()) errors.push(runResult.stderr.trim())
+          continue
         }
 
-        const rawFindings = parseFindings(payload);
-        const filtered = originalContracts.length > 0
-          ? rawFindings.filter((f) => {
-              if (f.file.includes(".flat.sol") || f.file === flatFile) return true;
-              return originalContracts.some(
-                (name) => f.description.includes(name) || f.file.includes(name)
-              );
-            })
-          : rawFindings;
+        const rawFindings = parseFindings(payload)
+        const filtered =
+          originalContracts.length > 0
+            ? rawFindings.filter((f) => {
+                if (f.file.includes(".flat.sol") || f.file === flatFile) return true
+                return originalContracts.some(
+                  (name) => f.description.includes(name) || f.file.includes(name),
+                )
+              })
+            : rawFindings
 
         const remapped = filtered.map((f) => ({
           ...f,
-          file: f.file.includes(".flat.sol") ? solFile.replace(args.target + "/", "") : f.file,
-        }));
+          file: f.file.includes(".flat.sol") ? solFile.replace(`${args.target}/`, "") : f.file,
+        }))
 
-        allFindings.push(...remapped);
+        allFindings.push(...remapped)
       } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        errors.push(`Slither flatten fallback failed for ${baseName}: ${msg}`);
+        const msg = e instanceof Error ? e.message : String(e)
+        errors.push(`Slither flatten fallback failed for ${baseName}: ${msg}`)
       }
     }
 
@@ -323,24 +386,27 @@ export async function flattenFallback(
       findingsCount: allFindings.length,
       findings: allFindings,
       executionTime: Date.now() - startedAt,
-      errors: errors.length > 0 ? [`[flatten-fallback] ${errors.join("; ")}`] : ["[flatten-fallback] Analysis completed via forge flatten"],
-    };
+      errors:
+        errors.length > 0
+          ? [`[flatten-fallback] ${errors.join("; ")}`]
+          : ["[flatten-fallback] Analysis completed via forge flatten"],
+    }
   } finally {
     try {
-      rmSync(tmpDir, { recursive: true, force: true });
+      rmSync(tmpDir, { recursive: true, force: true })
     } catch (_cleanupErr) {
-      // best-effort: temp dir cleanup failure is non-fatal
+      logger.debug("Failed to clean up temp directory")
     }
   }
 }
 
 function parseFindings(payload: SlitherPayload): Finding[] {
-  const detectors = payload.results?.detectors ?? [];
+  const detectors = payload.results?.detectors ?? []
 
   return detectors.map((detector) => {
-    const file = detector.elements?.[0]?.source_mapping?.filename_relative ?? "unknown";
-    const lines = findingLines(detector.elements?.[0]?.source_mapping?.lines);
-    const check = detector.check ?? "unknown-check";
+    const file = detector.elements?.[0]?.source_mapping?.filename_relative ?? "unknown"
+    const lines = findingLines(detector.elements?.[0]?.source_mapping?.lines)
+    const check = detector.check ?? "unknown-check"
 
     return {
       id: createFindingID(check, file, lines),
@@ -351,58 +417,65 @@ function parseFindings(payload: SlitherPayload): Finding[] {
       file,
       lines,
       source: "slither",
-    };
-  });
+    }
+  })
 }
 
 export async function executeSlitherAnalyze(
   args: SlitherArgs,
   context: ToolContext,
-  runCommand: RunSlitherCommand = runSlitherCommand
+  runCommand: RunSlitherCommand = runSlitherCommand,
+  cwd?: string,
 ): Promise<SlitherAnalyzeResult> {
-  const startedAt = Date.now();
-  context.metadata({ title: `Slither analysis: ${args.target}` });
+  const projectDir = cwd ?? resolveProjectDir(context)
+  const startedAt = Date.now()
+  context.metadata({ title: `Slither analysis: ${args.target}` })
 
   if (args.via_ir) {
     const fallbackResult = await flattenFallback(args, context, {
       ...defaultFlattenDeps,
       runCommand,
-    });
-    if (fallbackResult) return fallbackResult;
+      cwd: projectDir,
+    })
+    if (fallbackResult) return fallbackResult
     return {
       success: false,
       findingsCount: 0,
       findings: [],
       executionTime: Date.now() - startedAt,
-      errors: ["via_ir enabled — flatten fallback failed. Ensure forge and solc are available."],
-      error: "Project uses via_ir which is incompatible with Slither direct analysis. Flatten fallback also failed.",
-    };
+      errors: [
+        "via_ir enabled — flatten fallback failed. Ensure forge and solc-select are installed.",
+      ],
+      error:
+        "Project uses via_ir which is incompatible with Slither direct analysis. Flatten fallback also failed.",
+    }
   }
 
-  const command = buildCommand(args);
+  const command = buildCommand(args)
 
   try {
-    const runResult = await runCommand(command, context.abort);
-    const errors: string[] = [];
+    const runResult = await runCommand(command, context.abort, projectDir)
+    const errors: string[] = []
 
     if (runResult.exitCode !== 0) {
-      errors.push(`Slither exited with code ${runResult.exitCode}`);
+      errors.push(`Slither exited with code ${runResult.exitCode}`)
     }
     if (runResult.stderr.trim().length > 0) {
-      errors.push(runResult.stderr.trim());
+      errors.push(runResult.stderr.trim())
     }
 
-    let payload: SlitherPayload;
+    let payload: SlitherPayload
     try {
-      payload = JSON.parse(runResult.stdout) as SlitherPayload;
+      payload = JSON.parse(runResult.stdout) as SlitherPayload
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown parse error";
+      const message = error instanceof Error ? error.message : "Unknown parse error"
       if (shouldTryFlattenFallback(errors, runResult.stderr)) {
         const fallbackResult = await flattenFallback(args, context, {
           ...defaultFlattenDeps,
           runCommand,
-        });
-        if (fallbackResult) return fallbackResult;
+          cwd: projectDir,
+        })
+        if (fallbackResult) return fallbackResult
       }
       return {
         success: false,
@@ -411,22 +484,23 @@ export async function executeSlitherAnalyze(
         executionTime: Date.now() - startedAt,
         errors,
         error: `Slither output parse error: ${message}`,
-      };
+      }
     }
 
     if (payload.error) {
-      errors.push(payload.error);
+      errors.push(payload.error)
     }
 
-    const findings = parseFindings(payload);
-    const success = findings.length > 0 || (runResult.exitCode === 0 && payload.success !== false);
+    const findings = parseFindings(payload)
+    const success = findings.length > 0 || (runResult.exitCode === 0 && payload.success !== false)
 
     if (!success && findings.length === 0 && shouldTryFlattenFallback(errors, runResult.stderr)) {
       const fallbackResult = await flattenFallback(args, context, {
         ...defaultFlattenDeps,
         runCommand,
-      });
-      if (fallbackResult) return fallbackResult;
+        cwd: projectDir,
+      })
+      if (fallbackResult) return fallbackResult
     }
 
     return {
@@ -435,10 +509,10 @@ export async function executeSlitherAnalyze(
       findings,
       executionTime: Date.now() - startedAt,
       errors,
-    };
+    }
   } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    const maybeErrno = error as Error & { code?: string; name?: string };
+    const message = error instanceof Error ? error.message : "Unknown error"
+    const maybeErrno = error as Error & { code?: string; name?: string }
 
     if (maybeErrno.code === "ENOENT") {
       return {
@@ -448,7 +522,7 @@ export async function executeSlitherAnalyze(
         executionTime: Date.now() - startedAt,
         errors: [],
         error: "Slither not found. Install with: pip install slither-analyzer",
-      };
+      }
     }
 
     if (maybeErrno.name === "AbortError" || context.abort.aborted) {
@@ -459,7 +533,7 @@ export async function executeSlitherAnalyze(
         executionTime: Date.now() - startedAt,
         errors: ["Slither analysis aborted"],
         error: "Slither analysis aborted",
-      };
+      }
     }
 
     return {
@@ -469,34 +543,50 @@ export async function executeSlitherAnalyze(
       executionTime: Date.now() - startedAt,
       errors: [message],
       error: message,
-    };
+    }
   }
 }
 
 export function detectViaIr(target: string): boolean {
-  const projectDir = target.endsWith(".sol") ? join(target, "..") : target;
-  const foundryTomlPath = join(projectDir, "foundry.toml");
-  if (!existsSync(foundryTomlPath)) return false;
-  try {
-    const content = readFileSync(foundryTomlPath, "utf-8");
-    return /^\s*via[_-]ir\s*=\s*true/m.test(content);
-  } catch {
-    return false;
+  let dir = resolve(target.endsWith(".sol") ? dirname(target) : target)
+  const root = resolve("/")
+
+  while (true) {
+    const foundryTomlPath = join(dir, "foundry.toml")
+    if (existsSync(foundryTomlPath)) {
+      try {
+        const content = readFileSync(foundryTomlPath, "utf-8")
+        if (/^\s*via[_-]ir\s*=\s*true/m.test(content)) return true
+      } catch {
+        logger.debug("Unreadable foundry.toml, continuing directory walk")
+      }
+    }
+    if (dir === root) break
+    dir = dirname(dir)
   }
+
+  return false
 }
 
 export const slitherTool = tool({
-  description:
-    "Run Slither static analysis and return normalized findings for Solidity targets.",
+  description: "Run Slither static analysis and return normalized findings for Solidity targets.",
   args: {
     target: tool.schema.string(),
     detectors: tool.schema.array(tool.schema.string()).optional(),
     exclude: tool.schema.array(tool.schema.string()).optional(),
     solc_version: tool.schema.string().optional(),
+    via_ir: tool.schema.boolean().optional(),
   },
   async execute(args, context) {
-    const viaIr = detectViaIr(args.target);
-    const result = await executeSlitherAnalyze({ ...args, via_ir: viaIr }, context);
-    return JSON.stringify(result);
+    const projectDir = resolveProjectDir(context)
+    const resolvedTarget = isAbsolute(args.target) ? args.target : resolve(projectDir, args.target)
+    const viaIr = args.via_ir ?? detectViaIr(resolvedTarget)
+    const result = await executeSlitherAnalyze(
+      { ...args, target: resolvedTarget, via_ir: viaIr },
+      context,
+      runSlitherCommand,
+      projectDir,
+    )
+    return JSON.stringify(result)
   },
-});
+})