solidity-argus 0.3.7 → 0.5.7

package/src/utils/solidity-parser.ts

@@ -140,6 +140,36 @@ export function parseExternalCalls(sourceText: string): string[] {
   }
 }
 
+async function spawnForgeInspect(
+  contractName: string,
+  inspectType: string,
+  cwd: string,
+): Promise<{ success: boolean; stdout: string; stderr: string }> {
+  const proc = Bun.spawn(["forge", "inspect", contractName, inspectType, "--json"], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+
+  const timeout = 15_000
+  let timerId: ReturnType<typeof setTimeout> | undefined
+  const timer = new Promise<never>((_, reject) => {
+    timerId = setTimeout(() => {
+      proc.kill()
+      reject(new Error(`forge inspect ${inspectType} timed out after ${timeout}ms`))
+    }, timeout)
+  })
+
+  try {
+    const exitCode = await Promise.race([proc.exited, timer])
+    const stdout = await new Response(proc.stdout).text()
+    const stderr = await new Response(proc.stderr).text()
+    return { success: exitCode === 0, stdout, stderr }
+  } finally {
+    if (timerId !== undefined) clearTimeout(timerId)
+  }
+}
+
 /**
  * Extract contract information using forge inspect
  * Runs forge inspect <contractName> abi and storage-layout
@@ -162,39 +192,24 @@ export async function extractContractInfo(
   }
 
   try {
-    // Run forge inspect abi
-    const abiResult = Bun.spawnSync(["forge", "inspect", contractName, "abi", "--json"], {
-      cwd: projectDir,
-      stdout: "pipe",
-      stderr: "pipe",
-      timeout: 15_000,
-    })
+    // Run both forge inspect commands in parallel (async, non-blocking)
+    const [abiResult, storageResult] = await Promise.all([
+      spawnForgeInspect(contractName, "abi", projectDir),
+      spawnForgeInspect(contractName, "storage-layout", projectDir),
+    ])
 
     if (!abiResult.success) {
-      const errorMsg = abiResult.stderr?.toString() || "Unknown error"
-      result.error = `Failed to inspect ABI: ${errorMsg}`
+      result.error = `Failed to inspect ABI: ${abiResult.stderr}`
       return result
     }
 
-    // Run forge inspect storage-layout
-    const storageResult = Bun.spawnSync(
-      ["forge", "inspect", contractName, "storage-layout", "--json"],
-      {
-        cwd: projectDir,
-        stdout: "pipe",
-        stderr: "pipe",
-        timeout: 15_000,
-      },
-    )
-
     if (!storageResult.success) {
-      const errorMsg = storageResult.stderr?.toString() || "Unknown error"
-      result.error = `Failed to inspect storage layout: ${errorMsg}`
+      result.error = `Failed to inspect storage layout: ${storageResult.stderr}`
       return result
     }
 
     // Parse ABI
-    const abiRaw = abiResult.stdout?.toString() || "[]"
+    const abiRaw = abiResult.stdout || "[]"
     const abiOutput = extractJson(abiRaw, "[")
     let abi: ABIFunction[] = []
     try {
@@ -205,7 +220,7 @@ export async function extractContractInfo(
     }
 
     // Parse storage layout
-    const storageRaw = storageResult.stdout?.toString() || "{}"
+    const storageRaw = storageResult.stdout || "{}"
     const storageOutput = extractJson(storageRaw, "{")
     let storageLayout: StorageLayout = { storage: [], types: {} }
     try {

package/src/features/migration/index.ts

@@ -1,14 +0,0 @@
-export {
-  adaptLegacyFindings,
-  adaptLegacyStateToReportInput,
-  getMigrationMode,
-  type MigrationMode,
-  validateStrictCompatibility,
-} from "./migration-adapter"
-
-export {
-  computeParityMetrics,
-  formatParityReport,
-  type ParityMetrics,
-  type SeverityDistribution,
-} from "./parity-telemetry"

package/src/features/migration/migration-adapter.ts

@@ -1,151 +0,0 @@
-import {
-  createDropDiagnosticsCollector,
-  type DropDiagnosticsCollector,
-} from "../../shared/drop-diagnostics"
-import { normalizeLegacyFindingsArray, normalizeToCanonicalFinding } from "../../state/adapters"
-import type { CanonicalFinding, ReportInput } from "../../state/schemas"
-import { SCHEMA_VERSION } from "../../state/schemas"
-import type { AuditState, Finding } from "../../state/types"
-
-export type MigrationMode = "legacy" | "dual" | "strict"
-
-/**
- * Returns the active migration mode from config, defaulting to "legacy".
- */
-export function getMigrationMode(config: { migration?: { mode?: MigrationMode } }): MigrationMode {
-  return config.migration?.mode ?? "legacy"
-}
-
-/**
- * Adapts a legacy `AuditState` into canonical `CanonicalFinding[]`.
- *
- * In legacy mode: returns the raw findings as-is (backward compatible).
- * In dual mode: normalizes findings to canonical AND returns both.
- * In strict mode: normalizes to canonical, rejects payloads missing required canonical fields.
- */
-export function adaptLegacyFindings(
-  state: AuditState,
-  mode: MigrationMode,
-  runId: string,
-): {
-  legacyFindings: Finding[]
-  canonicalFindings: CanonicalFinding[]
-  diagnostics: ReturnType<DropDiagnosticsCollector["getDiagnostics"]>
-} {
-  const legacyFindings = state.findings
-
-  if (mode === "legacy") {
-    return {
-      legacyFindings,
-      canonicalFindings: [],
-      diagnostics: [],
-    }
-  }
-
-  const policy = mode === "strict" ? "strict-fail" : "warn"
-  const diag = createDropDiagnosticsCollector(policy, "migration-adapter")
-
-  const { findings: canonicalFindings, diagnostics: adapterDiags } = normalizeLegacyFindingsArray(
-    legacyFindings as unknown as unknown[],
-    runId,
-  )
-
-  for (const d of adapterDiags) {
-    if (d.level === "error") {
-      diag.error(d.code, d.message, d.field)
-    } else {
-      diag.warn(d.code, d.message, d.field)
-    }
-  }
-
-  // In strict mode, validate that all legacy findings survived normalization
-  if (mode === "strict" && canonicalFindings.length < legacyFindings.length) {
-    const dropped = legacyFindings.length - canonicalFindings.length
-    diag.error(
-      "STRICT_FINDINGS_DROPPED",
-      `${dropped} legacy finding(s) could not be normalized to canonical format`,
-    )
-  }
-
-  // Throws DropDiagnosticsError in strict mode if errors exist
-  diag.throwIfStrict()
-
-  return {
-    legacyFindings,
-    canonicalFindings,
-    diagnostics: diag.getDiagnostics(),
-  }
-}
-
-/**
- * Adapts a legacy `AuditState` into a canonical `ReportInput`.
- *
- * Maps legacy AuditState fields to the canonical ReportInput contract.
- */
-export function adaptLegacyStateToReportInput(
-  state: AuditState,
-  mode: MigrationMode,
-  runId: string,
-): {
-  reportInput: ReportInput
-  diagnostics: ReturnType<DropDiagnosticsCollector["getDiagnostics"]>
-} {
-  const { canonicalFindings, diagnostics } = adaptLegacyFindings(
-    state,
-    mode === "legacy" ? "dual" : mode,
-    runId,
-  )
-
-  const reportInput: ReportInput = {
-    run_id: runId,
-    seq: 0,
-    session_id: state.sessionId,
-    tool_call_id: "",
-    source: "migration-adapter",
-    schema_version: SCHEMA_VERSION,
-    projectDir: state.projectDir,
-    findings: canonicalFindings,
-    toolsExecuted: state.toolsExecuted.map((t) => ({
-      ...t,
-      run_id: runId,
-      schema_version: SCHEMA_VERSION,
-    })),
-    scope: state.scope,
-    soloditResults: state.soloditResults,
-    fuzzCounterexamples: state.fuzzCounterexamples,
-    coverageReport: state.coverageReport,
-    gasHotspots: state.gasHotspots,
-    proxyContracts: state.proxyContracts,
-  }
-
-  return { reportInput, diagnostics }
-}
-
-/**
- * Validates that a legacy AuditState is compatible with strict mode.
- * Returns true if ALL findings can be normalized without errors.
- */
-export function validateStrictCompatibility(
-  state: AuditState,
-  runId: string,
-): { compatible: boolean; errors: string[] } {
-  const errors: string[] = []
-
-  for (const [index, finding] of state.findings.entries()) {
-    const result = normalizeToCanonicalFinding(
-      finding as unknown as Record<string, unknown>,
-      runId,
-      index + 1,
-    )
-    const hasErrors = result.diagnostics.some((d) => d.level === "error")
-    if (hasErrors) {
-      errors.push(
-        ...result.diagnostics
-          .filter((d) => d.level === "error")
-          .map((d) => `[finding:${index}] ${d.message}`),
-      )
-    }
-  }
-
-  return { compatible: errors.length === 0, errors }
-}

package/src/features/migration/parity-telemetry.ts

@@ -1,133 +0,0 @@
-import { stableHash } from "../../state/projectors"
-import type { CanonicalFinding } from "../../state/schemas"
-import type { Finding, FindingSeverity } from "../../state/types"
-
-const SEVERITIES: readonly FindingSeverity[] = [
-  "Critical",
-  "High",
-  "Medium",
-  "Low",
-  "Informational",
-] as const
-
-export interface SeverityDistribution {
-  Critical: number
-  High: number
-  Medium: number
-  Low: number
-  Informational: number
-}
-
-export interface ParityMetrics {
-  legacyFindingCount: number
-  canonicalFindingCount: number
-  findingCountDiff: number
-  legacySeverityDistribution: SeverityDistribution
-  canonicalSeverityDistribution: SeverityDistribution
-  severityDiffs: Partial<Record<FindingSeverity, number>>
-  legacyContentHash: string
-  canonicalContentHash: string
-  hashMatch: boolean
-  onlyInLegacy: string[]
-  onlyInCanonical: string[]
-  timestamp: number
-}
-
-function computeSeverityDistribution(
-  findings: Array<{ severity: FindingSeverity }>,
-): SeverityDistribution {
-  const dist: SeverityDistribution = {
-    Critical: 0,
-    High: 0,
-    Medium: 0,
-    Low: 0,
-    Informational: 0,
-  }
-  for (const f of findings) {
-    if (f.severity in dist) {
-      dist[f.severity]++
-    }
-  }
-  return dist
-}
-
-function findingIds(findings: Array<{ id: string }>): Set<string> {
-  return new Set(findings.map((f) => f.id))
-}
-
-export function computeParityMetrics(
-  legacyFindings: Finding[],
-  canonicalFindings: CanonicalFinding[],
-): ParityMetrics {
-  const legacySeverity = computeSeverityDistribution(legacyFindings)
-  const canonicalSeverity = computeSeverityDistribution(canonicalFindings)
-
-  const severityDiffs: Partial<Record<FindingSeverity, number>> = {}
-  for (const sev of SEVERITIES) {
-    const diff = canonicalSeverity[sev] - legacySeverity[sev]
-    if (diff !== 0) {
-      severityDiffs[sev] = diff
-    }
-  }
-
-  const legacyIds = findingIds(legacyFindings)
-  const canonicalIds = findingIds(canonicalFindings)
-
-  const onlyInLegacy = [...legacyIds].filter((id) => !canonicalIds.has(id))
-  const onlyInCanonical = [...canonicalIds].filter((id) => !legacyIds.has(id))
-
-  const legacyContentHash = stableHash(
-    legacyFindings.map((f) => ({ id: f.id, check: f.check, severity: f.severity, file: f.file })),
-  )
-  const canonicalContentHash = stableHash(
-    canonicalFindings.map((f) => ({
-      id: f.id,
-      check: f.check,
-      severity: f.severity,
-      file: f.file,
-    })),
-  )
-
-  return {
-    legacyFindingCount: legacyFindings.length,
-    canonicalFindingCount: canonicalFindings.length,
-    findingCountDiff: canonicalFindings.length - legacyFindings.length,
-    legacySeverityDistribution: legacySeverity,
-    canonicalSeverityDistribution: canonicalSeverity,
-    severityDiffs,
-    legacyContentHash,
-    canonicalContentHash,
-    hashMatch: legacyContentHash === canonicalContentHash,
-    onlyInLegacy,
-    onlyInCanonical,
-    timestamp: Date.now(),
-  }
-}
-
-export function formatParityReport(metrics: ParityMetrics): string {
-  const lines: string[] = [
-    "=== Migration Parity Report ===",
-    `Finding count: legacy=${metrics.legacyFindingCount} canonical=${metrics.canonicalFindingCount} diff=${metrics.findingCountDiff}`,
-    `Content hash match: ${metrics.hashMatch}`,
-  ]
-
-  const sevDiffs = Object.entries(metrics.severityDiffs)
-  if (sevDiffs.length > 0) {
-    lines.push(
-      `Severity diffs: ${sevDiffs.map(([k, v]) => `${k}=${v > 0 ? "+" : ""}${v}`).join(", ")}`,
-    )
-  }
-
-  if (metrics.onlyInLegacy.length > 0) {
-    lines.push(
-      `Only in legacy (${metrics.onlyInLegacy.length}): ${metrics.onlyInLegacy.join(", ")}`,
-    )
-  }
-  if (metrics.onlyInCanonical.length > 0) {
-    lines.push(
-      `Only in canonical (${metrics.onlyInCanonical.length}): ${metrics.onlyInCanonical.join(", ")}`,
-    )
-  }
-
-  return lines.join("\n")
-}