solidity-argus 0.2.0 → 0.3.2

package/src/knowledge/retry.ts

@@ -1,47 +1,47 @@
 export interface RetryOptions<T> {
-  maxAttempts: number;
-  baseDelayMs: number;
-  shouldRetry: (error: unknown) => boolean;
-  onRetry?: (attempt: number, error: unknown) => void;
-  _valueType?: T;
+  maxAttempts: number
+  baseDelayMs: number
+  shouldRetry: (error: unknown) => boolean
+  onRetry?: (attempt: number, error: unknown) => void
+  _valueType?: T
 }
 
 export interface RetryResult<T> {
-  success: boolean;
-  value?: T;
-  error?: unknown;
-  attempts: number;
+  success: boolean
+  value?: T
+  error?: unknown
+  attempts: number
 }
 
 function sleep(delayMs: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, delayMs));
+  return new Promise((resolve) => setTimeout(resolve, delayMs))
 }
 
 export async function withRetry<T>(
   fn: () => Promise<T>,
-  options: RetryOptions<T>
+  options: RetryOptions<T>,
 ): Promise<RetryResult<T>> {
-  const maxAttempts = options.maxAttempts > 0 ? options.maxAttempts : 1;
-  let lastError: unknown;
+  const maxAttempts = options.maxAttempts > 0 ? options.maxAttempts : 1
+  let lastError: unknown
 
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     try {
-      const value = await fn();
-      return { success: true, value, attempts: attempt };
+      const value = await fn()
+      return { success: true, value, attempts: attempt }
     } catch (error) {
-      lastError = error;
-      const canRetry = attempt < maxAttempts && options.shouldRetry(error);
+      lastError = error
+      const canRetry = attempt < maxAttempts && options.shouldRetry(error)
 
       if (!canRetry) {
-        return { success: false, error, attempts: attempt };
+        return { success: false, error, attempts: attempt }
       }
 
       if (options.onRetry) {
-        options.onRetry(attempt, error);
+        options.onRetry(attempt, error)
       }
 
-      const delay = options.baseDelayMs * 2 ** (attempt - 1);
-      await sleep(delay);
+      const delay = options.baseDelayMs * 2 ** (attempt - 1)
+      await sleep(delay)
     }
   }
 
@@ -49,5 +49,5 @@ export async function withRetry<T>(
     success: false,
     error: lastError,
     attempts: maxAttempts,
-  };
+  }
 }

package/src/knowledge/scvd-client.ts

@@ -1,79 +1,79 @@
 export interface ScvdFinding {
-  scvd_id: string;
-  doc_id: string;
-  title: string;
-  description_md: string;
-  severity: "Critical" | "High" | "Medium" | "Low" | "Informational";
-  taxonomy: { swc: string[]; cwe: string[] };
-  repo: { url: string; commit?: string; lines?: [number, number] };
-  sections: { recommendation_md?: string; poc_md?: string };
+  scvd_id: string
+  doc_id: string
+  title: string
+  description_md: string
+  severity: "Critical" | "High" | "Medium" | "Low" | "Informational"
+  taxonomy: { swc: string[]; cwe: string[] }
+  repo: { url: string; commit?: string; lines?: [number, number] }
+  sections: { recommendation_md?: string; poc_md?: string }
 }
 
 export interface ScvdStats {
-  total: number;
-  by_severity: Record<string, number>;
-  last_updated: string;
+  total: number
+  by_severity: Record<string, number>
+  last_updated: string
 }
 
-const DEFAULT_PAGE_SIZE = 100;
+const DEFAULT_PAGE_SIZE = 100
 
 function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
+  return typeof value === "object" && value !== null
 }
 
 function toStringArray(value: unknown): string[] {
   if (!Array.isArray(value)) {
-    return [];
+    return []
   }
 
-  return value.filter((item): item is string => typeof item === "string");
+  return value.filter((item): item is string => typeof item === "string")
 }
 
 function toNumberRecord(value: unknown): Record<string, number> {
   if (!isRecord(value)) {
-    return {};
+    return {}
   }
 
-  const output: Record<string, number> = {};
+  const output: Record<string, number> = {}
   for (const [key, rawValue] of Object.entries(value)) {
     if (typeof rawValue === "number" && Number.isFinite(rawValue)) {
-      output[key] = rawValue;
+      output[key] = rawValue
     }
   }
 
-  return output;
+  return output
 }
 
 function parseLines(value: unknown): [number, number] | undefined {
   if (!Array.isArray(value) || value.length !== 2) {
-    return undefined;
+    return undefined
   }
 
-  const start = value[0];
-  const end = value[1];
+  const start = value[0]
+  const end = value[1]
 
   if (typeof start !== "number" || typeof end !== "number") {
-    return undefined;
+    return undefined
   }
 
-  return [start, end];
+  return [start, end]
 }
 
 function parseFinding(raw: unknown): ScvdFinding | null {
   if (!isRecord(raw)) {
-    return null;
+    return null
   }
 
-  const taxonomyRaw = isRecord(raw.taxonomy) ? raw.taxonomy : {};
-  const repoRaw = isRecord(raw.repo) ? raw.repo : {};
-  const sectionsRaw = isRecord(raw.sections) ? raw.sections : {};
+  const taxonomyRaw = isRecord(raw.taxonomy) ? raw.taxonomy : {}
+  const repoRaw = isRecord(raw.repo) ? raw.repo : {}
+  const sectionsRaw = isRecord(raw.sections) ? raw.sections : {}
 
-  const scvdId = raw.scvd_id;
-  const docId = raw.doc_id;
-  const title = raw.title;
-  const description = raw.description_md;
-  const severity = raw.severity;
-  const repoUrl = repoRaw.url;
+  const scvdId = raw.scvd_id
+  const docId = raw.doc_id
+  const title = raw.title
+  const description = raw.description_md
+  const severity = raw.severity
+  const repoUrl = repoRaw.url
 
   if (
     typeof scvdId !== "string" ||
@@ -82,7 +82,7 @@ function parseFinding(raw: unknown): ScvdFinding | null {
     typeof description !== "string" ||
     typeof repoUrl !== "string"
   ) {
-    return null;
+    return null
   }
 
   if (
@@ -92,7 +92,7 @@ function parseFinding(raw: unknown): ScvdFinding | null {
     severity !== "Low" &&
     severity !== "Informational"
   ) {
-    return null;
+    return null
   }
 
   return {
@@ -117,153 +117,146 @@ function parseFinding(raw: unknown): ScvdFinding | null {
           : undefined,
       poc_md: typeof sectionsRaw.poc_md === "string" ? sectionsRaw.poc_md : undefined,
     },
-  };
+  }
 }
 
 function parseFindings(raw: unknown): ScvdFinding[] {
   if (!Array.isArray(raw)) {
     if (isRecord(raw) && Array.isArray(raw.data)) {
-      return raw.data.map(parseFinding).filter((value): value is ScvdFinding => value !== null);
+      return raw.data.map(parseFinding).filter((value): value is ScvdFinding => value !== null)
     }
-    return [];
+    return []
   }
 
-  return raw.map(parseFinding).filter((value): value is ScvdFinding => value !== null);
+  return raw.map(parseFinding).filter((value): value is ScvdFinding => value !== null)
 }
 
 function parseStats(raw: unknown): ScvdStats {
   if (!isRecord(raw)) {
-    throw new Error("Invalid SCVD stats response payload");
+    throw new Error("Invalid SCVD stats response payload")
   }
 
-  const total = raw.total;
-  const lastUpdated = raw.last_updated;
+  const total = raw.total
+  const lastUpdated = raw.last_updated
 
   if (typeof total !== "number" || typeof lastUpdated !== "string") {
-    throw new Error("Invalid SCVD stats fields in response");
+    throw new Error("Invalid SCVD stats fields in response")
   }
 
   return {
     total,
     by_severity: toNumberRecord(raw.by_severity),
     last_updated: lastUpdated,
-  };
+  }
 }
 
 export class ScvdNetworkError extends Error {
-  override readonly name = "ScvdNetworkError" as const;
-
-  constructor(message: string) {
-    super(message);
-  }
+  override readonly name = "ScvdNetworkError" as const
 }
 
 export class ScvdApiError extends Error {
-  override readonly name = "ScvdApiError" as const;
-  readonly httpStatus: number;
+  override readonly name = "ScvdApiError" as const
+  readonly httpStatus: number
 
   constructor(httpStatus: number, message?: string) {
-    super(message ?? `SCVD API error: HTTP ${httpStatus}`);
-    this.httpStatus = httpStatus;
+    super(message ?? `SCVD API error: HTTP ${httpStatus}`)
+    this.httpStatus = httpStatus
   }
 }
 
 export class ScvdClient {
-  private readonly baseUrl: string;
-  private readonly signal?: AbortSignal;
+  private readonly baseUrl: string
+  private readonly signal?: AbortSignal
 
   constructor(apiUrl: string, signal?: AbortSignal) {
-    this.baseUrl = apiUrl.replace(/\/$/, "");
-    this.signal = signal;
+    this.baseUrl = apiUrl.replace(/\/$/, "")
+    this.signal = signal
   }
 
   async fetchStats(): Promise<ScvdStats> {
-    const url = `${this.baseUrl}/stats`;
+    const url = `${this.baseUrl}/stats`
 
-    let response: Response;
+    let response: Response
     try {
-      response = await fetch(url, { signal: this.signal });
+      response = await fetch(url, { signal: this.signal })
     } catch (error) {
-      const message = error instanceof Error ? error.message : "unknown network error";
-      throw new ScvdNetworkError(`Failed to fetch SCVD stats from ${url}: ${message}`);
+      const message = error instanceof Error ? error.message : "unknown network error"
+      throw new ScvdNetworkError(`Failed to fetch SCVD stats from ${url}: ${message}`)
     }
 
     if (!response.ok) {
       throw new ScvdApiError(
         response.status,
-        `Failed to fetch SCVD stats from ${url}: HTTP ${response.status}`
-      );
+        `Failed to fetch SCVD stats from ${url}: HTTP ${response.status}`,
+      )
     }
 
-    const body = (await response.json()) as unknown;
-    return parseStats(body);
+    const body = (await response.json()) as unknown
+    return parseStats(body)
   }
 
   async fetchFindings(params: {
-    severity?: string;
-    limit?: number;
-    offset?: number;
+    severity?: string
+    limit?: number
+    offset?: number
   }): Promise<ScvdFinding[]> {
-    const searchParams = new URLSearchParams();
+    const searchParams = new URLSearchParams()
 
     if (params.severity) {
-      searchParams.set("severity", params.severity);
+      searchParams.set("severity", params.severity)
     }
     if (typeof params.limit === "number") {
-      searchParams.set("limit", String(params.limit));
+      searchParams.set("limit", String(params.limit))
     }
     if (typeof params.offset === "number") {
-      searchParams.set("offset", String(params.offset));
+      searchParams.set("offset", String(params.offset))
     }
 
-    const query = searchParams.toString();
-    const url = `${this.baseUrl}/findings${query.length > 0 ? `?${query}` : ""}`;
+    const query = searchParams.toString()
+    const url = `${this.baseUrl}/findings${query.length > 0 ? `?${query}` : ""}`
 
-    let response: Response;
+    let response: Response
     try {
-      response = await fetch(url, { signal: this.signal });
+      response = await fetch(url, { signal: this.signal })
     } catch (error) {
-      const message = error instanceof Error ? error.message : "unknown network error";
-      throw new ScvdNetworkError(`Failed to fetch SCVD findings from ${url}: ${message}`);
+      const message = error instanceof Error ? error.message : "unknown network error"
+      throw new ScvdNetworkError(`Failed to fetch SCVD findings from ${url}: ${message}`)
     }
 
     if (!response.ok) {
-      throw new ScvdApiError(
-        response.status,
-        `SCVD API error: HTTP ${response.status} for ${url}`
-      );
+      throw new ScvdApiError(response.status, `SCVD API error: HTTP ${response.status} for ${url}`)
     }
 
-    const body = (await response.json()) as unknown;
-    return parseFindings(body);
+    const body = (await response.json()) as unknown
+    return parseFindings(body)
   }
 
   async fetchAllFindings(onProgress?: (count: number) => void): Promise<ScvdFinding[]> {
-    const results: ScvdFinding[] = [];
-    let offset = 0;
+    const results: ScvdFinding[] = []
+    let offset = 0
 
     while (true) {
       const page = await this.fetchFindings({
         limit: DEFAULT_PAGE_SIZE,
         offset,
-      });
+      })
 
       if (page.length === 0) {
-        break;
+        break
       }
 
-      results.push(...page);
-      offset += page.length;
+      results.push(...page)
+      offset += page.length
 
       if (onProgress) {
-        onProgress(results.length);
+        onProgress(results.length)
       }
 
       if (page.length < DEFAULT_PAGE_SIZE) {
-        break;
+        break
       }
     }
 
-    return results;
+    return results
   }
 }

package/src/knowledge/scvd-errors.ts

@@ -1,38 +1,38 @@
 export type SyncError = {
-  status: "error";
-  success: false;
-  reason: "network" | "api" | "parse";
-  message: string;
-  error: string;
-  httpStatus?: number;
-  newFindings: 0;
-  totalIndexed: 0;
-  lastSync: string;
-  attempts?: number;
-};
+  status: "error"
+  success: false
+  reason: "network" | "api" | "parse"
+  message: string
+  error: string
+  httpStatus?: number
+  newFindings: 0
+  totalIndexed: 0
+  lastSync: string
+  attempts?: number
+}
 
 export type SyncSuccess = {
-  status: "success";
-  success: true;
-  newFindings: number;
-  totalIndexed: number;
-  lastSync: string;
-  error?: undefined;
-  attempts?: number;
-};
+  status: "success"
+  success: true
+  newFindings: number
+  totalIndexed: number
+  lastSync: string
+  error?: undefined
+  attempts?: number
+}
 
 export type SyncStale = {
-  status: "stale";
-  success: false;
-  newFindings: 0;
-  totalIndexed: 0;
-  lastSync: string;
-  error?: undefined;
-  daysSinceSync: number;
-  attempts?: number;
-};
+  status: "stale"
+  success: false
+  newFindings: 0
+  totalIndexed: 0
+  lastSync: string
+  error?: undefined
+  daysSinceSync: number
+  attempts?: number
+}
 
-export type SyncOutcome = SyncSuccess | SyncError | SyncStale;
+export type SyncOutcome = SyncSuccess | SyncError | SyncStale
 
 export function createNetworkError(message: string): SyncError {
   return {
@@ -44,7 +44,7 @@ export function createNetworkError(message: string): SyncError {
     newFindings: 0,
     totalIndexed: 0,
     lastSync: new Date().toISOString(),
-  };
+  }
 }
 
 export function createApiError(httpStatus: number, message: string): SyncError {
@@ -58,7 +58,7 @@ export function createApiError(httpStatus: number, message: string): SyncError {
     newFindings: 0,
     totalIndexed: 0,
     lastSync: new Date().toISOString(),
-  };
+  }
 }
 
 export function createParseError(message: string): SyncError {
@@ -71,19 +71,19 @@ export function createParseError(message: string): SyncError {
     newFindings: 0,
     totalIndexed: 0,
     lastSync: new Date().toISOString(),
-  };
+  }
 }
 
 export function createSyncSuccess(
-  data: Omit<SyncSuccess, "status" | "success" | "error"> & { attempts?: number }
+  data: Omit<SyncSuccess, "status" | "success" | "error"> & { attempts?: number },
 ): SyncSuccess {
   return {
     status: "success",
     success: true,
     ...data,
-  };
+  }
 }
 
 export function isRetryableError(outcome: SyncOutcome): boolean {
-  return outcome.status === "error" && outcome.reason === "network";
+  return outcome.status === "error" && outcome.reason === "network"
 }