solidity-argus 0.2.0 → 0.3.2

package/src/managers/types.ts

@@ -1,4 +1,4 @@
-import type { AuditState } from "../state/types";
+import type { AuditState } from "../state/types"
 
 /**
  * BackgroundManager interface
@@ -12,32 +12,32 @@ export interface BackgroundManager {
    * @param options - Optional configuration (priority, timeout, etc.)
    * @returns taskId - Unique identifier for tracking this task
    */
-  dispatch(agentName: string, prompt: string, options?: { priority?: number }): string;
+  dispatch(agentName: string, prompt: string, options?: { priority?: number }): string
 
   /**
    * Cancel a running background task
    * @param taskId - The task ID to cancel
    */
-  cancel(taskId: string): void;
+  cancel(taskId: string): void
 
   /**
    * Get the result of a completed background task
    * @param taskId - The task ID to retrieve results for
    * @returns Promise resolving to the task result
    */
-  getResult(taskId: string): Promise<unknown>;
+  getResult(taskId: string): Promise<unknown>
 
   /**
    * Register a callback to be invoked when a task completes
    * @param callback - Function called with (taskId, result) when task finishes
    */
-  onComplete(callback: (taskId: string, result: unknown) => void): void;
+  onComplete(callback: (taskId: string, result: unknown) => void): void
 
   /**
    * Get the number of currently active/running tasks
    * @returns Number of active tasks
    */
-  getActiveCount(): number;
+  getActiveCount(): number
 }
 
 /**
@@ -49,30 +49,35 @@ export interface AuditStateManager {
    * Load audit state from persistent storage
    * @returns Promise resolving to AuditState or null if not found
    */
-  load(): Promise<AuditState | null>;
+  load(): Promise<AuditState | null>
 
   /**
    * Save audit state to persistent storage
    * @param state - The AuditState to persist
    */
-  save(state: AuditState): Promise<void>;
+  save(state: AuditState): Promise<void>
 
   /**
    * Get the current in-memory audit state
    * @returns The current AuditState or null if not loaded
    */
-  get(): AuditState | null;
+  get(): AuditState | null
 
   /**
    * Update the audit state with a partial patch
    * @param patch - Partial AuditState object with fields to update
    */
-  update(patch: Partial<AuditState>): Promise<void>;
+  update(patch: Partial<AuditState>): Promise<void>
 
   /**
    * Reset the audit state (clear all data)
    */
-  reset(): Promise<void>;
+  reset(): Promise<void>
+
+  /**
+   * Archive current state (if meaningful) then reset
+   */
+  archive(): Promise<void>
 }
 
 /**
@@ -80,6 +85,6 @@ export interface AuditStateManager {
  * Container for all manager instances
  */
 export type Managers = {
-  backgroundManager: BackgroundManager;
-  auditStateManager: AuditStateManager;
-};
+  backgroundManager: BackgroundManager
+  auditStateManager: AuditStateManager
+}

package/src/plugin-interface.ts

@@ -11,12 +11,12 @@ export function createPluginInterface(args: {
 }): PluginReturn {
   const { tools, hooks } = args
 
-   const result: PluginReturn = {
-     tool: tools,
-     config: hooks.config,
-   }
+  const result: PluginReturn = {
+    tool: tools,
+    config: hooks.config,
+  }
 
-   if (hooks["chat.params"]) {
+  if (hooks["chat.params"]) {
     result["chat.params"] = hooks["chat.params"]
   }
 
@@ -25,13 +25,11 @@ export function createPluginInterface(args: {
   }
 
   if (hooks["experimental.chat.system.transform"]) {
-    result["experimental.chat.system.transform"] =
-      hooks["experimental.chat.system.transform"]
+    result["experimental.chat.system.transform"] = hooks["experimental.chat.system.transform"]
   }
 
   if (hooks["experimental.session.compacting"]) {
-    result["experimental.session.compacting"] =
-      hooks["experimental.session.compacting"]
+    result["experimental.session.compacting"] = hooks["experimental.session.compacting"]
   }
 
   if (hooks["tool.execute.after"]) {

package/src/shared/binary-utils.ts

@@ -1,64 +1,73 @@
-import { execSync } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { existsSync } from "node:fs"
+import { join } from "node:path"
+import { createLogger } from "./logger"
+
+const logger = createLogger()
 
 export function hasBinary(name: string): boolean {
   try {
-    execSync(`which ${name}`, { stdio: "ignore", timeout: 3_000 });
-    return true;
+    const result = Bun.spawnSync(["which", name], {
+      stdout: "ignore",
+      stderr: "ignore",
+      timeout: 5_000,
+    })
+    return result.exitCode === 0
   } catch (_e) {
-    return false;
+    return false
   }
 }
 
-export function parseSolcVersion(target: string): string | undefined {
-  const foundryToml = join(target, "foundry.toml");
-  if (existsSync(foundryToml)) {
-    const content = readFileSync(foundryToml, "utf-8");
-    const match = content.match(/solc\s*=\s*["']([^"']+)["']/);
-    if (match?.[1]) return match[1];
+export async function parseSolcVersion(target: string): Promise<string | undefined> {
+  const foundryToml = join(target, "foundry.toml")
+  if (await Bun.file(foundryToml).exists()) {
+    const content = await Bun.file(foundryToml).text()
+    const match = content.match(/solc\s*=\s*["']([^"']+)["']/)
+    if (match?.[1]) return match[1]
   }
 
-  const solFiles = [target];
-  if (existsSync(target) && target.endsWith(".sol")) {
-    solFiles.push(target);
+  const solFiles: string[] = []
+  if (target.endsWith(".sol") && (await Bun.file(target).exists())) {
+    solFiles.push(target)
   } else {
-    const srcDir = join(target, "src");
+    const srcDir = join(target, "src")
     if (existsSync(srcDir)) {
       try {
-        const files = execSync(`find "${srcDir}" -name "*.sol" -maxdepth 3`, {
-          encoding: "utf-8",
-          timeout: 5_000,
-          stdio: ["pipe", "pipe", "pipe"],
+        const proc = Bun.spawn(["find", srcDir, "-maxdepth", "3", "-name", "*.sol"], {
+          stdout: "pipe",
+          stderr: "pipe",
+          signal: AbortSignal.timeout(10_000),
         })
-          .trim()
-          .split("\n")
-          .filter(Boolean);
-        solFiles.push(...files);
+        const exitCode = await proc.exited
+        if (exitCode === 0) {
+          const output = await new Response(proc.stdout).text()
+          solFiles.push(...output.trim().split("\n").filter(Boolean))
+        }
       } catch (_findErr) {
+        logger.debug("find command failed for .sol files")
       }
     }
   }
 
   for (const file of solFiles) {
-    if (!existsSync(file) || !file.endsWith(".sol")) continue;
+    if (!file.endsWith(".sol") || !(await Bun.file(file).exists())) continue
     try {
-      const content = readFileSync(file, "utf-8");
-      const pragma = content.match(/pragma\s+solidity\s+[\^~>=<]*\s*([\d.]+)/);
-      if (pragma?.[1]) return pragma[1];
+      const content = await Bun.file(file).text()
+      const pragma = content.match(/pragma\s+solidity\s+[\^~>=<]*\s*([\d.]+)/)
+      if (pragma?.[1]) return pragma[1]
     } catch (_readErr) {
+      logger.debug("Failed to read .sol file for pragma detection")
     }
   }
-  return undefined;
+  return undefined
 }
 
-export function extractContractNames(filePath: string): string[] {
-  if (!existsSync(filePath)) return [];
+export async function extractContractNames(filePath: string): Promise<string[]> {
+  if (!(await Bun.file(filePath).exists())) return []
   try {
-    const content = readFileSync(filePath, "utf-8");
-    const matches = content.matchAll(/\b(?:contract|library|interface)\s+(\w+)/g);
-    return Array.from(matches, (m) => m[1]).filter(Boolean) as string[];
+    const content = await Bun.file(filePath).text()
+    const matches = content.matchAll(/\b(?:contract|library|interface)\s+(\w+)/g)
+    return Array.from(matches, (m) => m[1]).filter(Boolean) as string[]
   } catch (_e) {
-    return [];
+    return []
   }
 }

package/src/shared/deep-merge.ts

@@ -1,49 +1,74 @@
-export function deepMerge(target: any, source: any): any {
-  // If source is undefined, return target as-is
+const deduplicateObjectIds = new WeakMap<object, number>()
+let nextDeduplicateObjectId = 1
+
+function getDeduplicateObjectKey(obj: object): string {
+  let id = deduplicateObjectIds.get(obj)
+  if (id === undefined) {
+    id = nextDeduplicateObjectId++
+    deduplicateObjectIds.set(obj, id)
+  }
+  return `object:${id}`
+}
+
+function deduplicateArray(arr: unknown[]): unknown[] {
+  const seen = new Set<string>()
+  const result: unknown[] = []
+
+  for (const item of arr) {
+    let key: string
+    if (typeof item === "object" && item !== null) {
+      try {
+        key = `object:${JSON.stringify(item)}`
+      } catch {
+        key = getDeduplicateObjectKey(item)
+      }
+    } else {
+      key = `${typeof item}:${String(item)}`
+    }
+
+    if (!seen.has(key)) {
+      seen.add(key)
+      result.push(item)
+    }
+  }
+
+  return result
+}
+
+export function deepMerge(target: unknown, source: unknown): unknown {
   if (source === undefined) {
-    return target;
+    return target
   }
 
-  // If either is not an object, return source (override)
   if (
     typeof target !== "object" ||
     target === null ||
     typeof source !== "object" ||
     source === null
   ) {
-    return source;
+    return source
   }
 
-  // If both are arrays, concatenate and deduplicate
   if (Array.isArray(target) && Array.isArray(source)) {
-    const merged = [...target, ...source];
-    // Deduplicate by filtering unique values
-    return Array.from(new Set(merged));
-  }
-
-  // If target is array but source is not, return source
-  if (Array.isArray(target) && !Array.isArray(source)) {
-    return source;
+    return deduplicateArray([...target, ...source])
   }
 
-  // If source is array but target is not, return source
-  if (!Array.isArray(target) && Array.isArray(source)) {
-    return source;
+  if (Array.isArray(target) || Array.isArray(source)) {
+    return source
   }
 
-  // Both are plain objects, merge recursively
-  const result = { ...target };
+  const tgt = target as Record<string, unknown>
+  const src = source as Record<string, unknown>
+  const result: Record<string, unknown> = { ...tgt }
 
-  for (const key in source) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      const sourceValue = source[key];
+  for (const key in src) {
+    if (Object.hasOwn(src, key)) {
+      const sourceValue = src[key]
 
-      // Skip undefined values from source
       if (sourceValue === undefined) {
-        continue;
+        continue
       }
 
-      // If both are objects (and not arrays), recurse
       if (
         typeof result[key] === "object" &&
         result[key] !== null &&
@@ -52,20 +77,14 @@ export function deepMerge(target: any, source: any): any {
         sourceValue !== null &&
         !Array.isArray(sourceValue)
       ) {
-        result[key] = deepMerge(result[key], sourceValue);
-      } else if (
-        Array.isArray(result[key]) &&
-        Array.isArray(sourceValue)
-      ) {
-        // Both are arrays, concatenate and deduplicate
-        const merged = [...result[key], ...sourceValue];
-        result[key] = Array.from(new Set(merged));
+        result[key] = deepMerge(result[key], sourceValue)
+      } else if (Array.isArray(result[key]) && Array.isArray(sourceValue)) {
+        result[key] = deduplicateArray([...(result[key] as unknown[]), ...sourceValue])
       } else {
-        // Override with source value
-        result[key] = sourceValue;
+        result[key] = sourceValue
       }
     }
   }
 
-  return result;
+  return result
 }

package/src/shared/file-utils.ts

@@ -1,12 +1,12 @@
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { stripJsoncComments } from "./jsonc-parser";
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { stripJsoncComments } from "./jsonc-parser"
 
-export type ConfigFormat = "json" | "jsonc" | "none";
+export type ConfigFormat = "json" | "jsonc" | "none"
 
 export interface ConfigFileInfo {
-  path: string | null;
-  format: ConfigFormat;
+  path: string | null
+  format: ConfigFormat
 }
 
 export function detectConfigFile(basePath: string): ConfigFileInfo {
@@ -15,42 +15,44 @@ export function detectConfigFile(basePath: string): ConfigFileInfo {
     { path: join(basePath, ".opencode", "solidity-argus.json"), format: "json" as const },
     { path: join(basePath, "solidity-argus.jsonc"), format: "jsonc" as const },
     { path: join(basePath, "solidity-argus.json"), format: "json" as const },
-    { path: join(basePath, "config.jsonc"), format: "jsonc" as const },
-    { path: join(basePath, "config.json"), format: "json" as const },
-  ];
+  ]
 
   for (const candidate of candidates) {
     if (existsSync(candidate.path)) {
       return {
         path: candidate.path,
         format: candidate.format,
-      };
+      }
     }
   }
 
   return {
     path: null,
     format: "none",
-  };
+  }
 }
 
-export function readJsoncFile(filePath: string): Record<string, any> | null {
+export function readJsoncFile(filePath: string): Record<string, unknown> | null {
   try {
     if (!existsSync(filePath)) {
-      return null;
+      return null
     }
 
-    const content = readFileSync(filePath, "utf-8");
+    const content = readFileSync(filePath, "utf-8")
 
     if (!content.trim()) {
-      return null;
+      return null
     }
 
-    const stripped = stripJsoncComments(content);
-    const parsed = JSON.parse(stripped);
+    const stripped = stripJsoncComments(content)
+    const parsed: unknown = JSON.parse(stripped)
+
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return null
+    }
 
-    return parsed;
+    return parsed as Record<string, unknown>
   } catch (_error) {
-    return null;
+    return null
   }
 }

package/src/shared/index.ts

@@ -1,5 +1,11 @@
-export { createLogger, type Logger, type LoggerConfig } from "./logger";
-export { deepMerge } from "./deep-merge";
-export { stripJsoncComments } from "./jsonc-parser";
-export { detectConfigFile, readJsoncFile, type ConfigFormat, type ConfigFileInfo } from "./file-utils";
-export { hasBinary, parseSolcVersion, extractContractNames } from "./binary-utils";
+export { extractContractNames, hasBinary, parseSolcVersion } from "./binary-utils"
+export { deepMerge } from "./deep-merge"
+export {
+  type ConfigFileInfo,
+  type ConfigFormat,
+  detectConfigFile,
+  readJsoncFile,
+} from "./file-utils"
+export { stripJsoncComments } from "./jsonc-parser"
+export { createLogger, type Logger, type LoggerConfig } from "./logger"
+export { findFoundryProjectDir, resolveProjectDir } from "./project-utils"

package/src/shared/jsonc-parser.ts

@@ -1,39 +1,134 @@
 export function stripJsoncComments(jsonc: string): string {
-  let result = jsonc;
+  let inString = false
+  let escaped = false
+  let inLineComment = false
+  let blockCommentDepth = 0
+  const chars: string[] = []
 
-  result = result.replace(/\/\*[\s\S]*?\*\//g, "");
+  for (let i = 0; i < jsonc.length; i++) {
+    const ch = jsonc.charAt(i)
+    const next = jsonc.charAt(i + 1)
 
-  const lines = result.split("\n");
-  result = lines
-    .map((line) => {
-      let inString = false;
-      let escaped = false;
-      let lastCommentIndex = -1;
+    if (inLineComment) {
+      if (ch === "\n" || ch === "\r") {
+        inLineComment = false
+        chars.push(ch)
+      }
+      continue
+    }
 
-      for (let i = 0; i < line.length; i++) {
-        if (escaped) {
-          escaped = false;
-          continue;
-        }
-        if (line[i] === "\\") {
-          escaped = true;
-          continue;
-        }
-        if (line[i] === '"') {
-          inString = !inString;
+    if (blockCommentDepth > 0) {
+      if (ch === "/" && next === "*") {
+        blockCommentDepth++
+        i++
+        continue
+      }
+
+      if (ch === "*" && next === "/") {
+        blockCommentDepth--
+        i++
+        continue
+      }
+
+      if (ch === "\n" || ch === "\r") {
+        chars.push(ch)
+      }
+      continue
+    }
+
+    if (escaped) {
+      escaped = false
+      chars.push(ch)
+      continue
+    }
+
+    if (inString) {
+      if (ch === "\\") {
+        escaped = true
+      } else if (ch === '"') {
+        inString = false
+      }
+      chars.push(ch)
+      continue
+    }
+
+    if (ch === '"') {
+      inString = true
+      chars.push(ch)
+      continue
+    }
+
+    if (ch === "/" && next === "/") {
+      inLineComment = true
+      i++
+      continue
+    }
+
+    if (ch === "/" && next === "*") {
+      blockCommentDepth = 1
+      i++
+      continue
+    }
+
+    chars.push(ch)
+  }
+
+  const result = chars.join("")
+  const out: string[] = []
+  let inString2 = false
+  let escaped2 = false
+
+  for (let i = 0; i < result.length; i++) {
+    const ch = result.charAt(i)
+
+    if (escaped2) {
+      escaped2 = false
+      out.push(ch)
+      continue
+    }
+
+    if (inString2) {
+      if (ch === "\\") {
+        escaped2 = true
+      } else if (ch === '"') {
+        inString2 = false
+      }
+      out.push(ch)
+      continue
+    }
+
+    if (ch === '"') {
+      inString2 = true
+      out.push(ch)
+      continue
+    }
+
+    if (ch === ",") {
+      let j = i + 1
+      while (j < result.length) {
+        const lookahead = result.charAt(j)
+        if (lookahead === " " || lookahead === "\t" || lookahead === "\n" || lookahead === "\r") {
+          j++
+          continue
         }
-        if (!inString && line[i] === "/" && line[i + 1] === "/") {
-          lastCommentIndex = i;
-          break;
+
+        if (lookahead === "}" || lookahead === "]") {
+          break
         }
+
+        out.push(ch)
+        break
+      }
+
+      if (j >= result.length) {
+        out.push(ch)
       }
 
-      if (lastCommentIndex === -1) return line;
-      return line.substring(0, lastCommentIndex);
-    })
-    .join("\n");
+      continue
+    }
 
-  result = result.replace(/,(\s*[}\]])/g, "$1");
+    out.push(ch)
+  }
 
-  return result;
+  return out.join("")
 }

package/src/shared/logger.ts

@@ -1,6 +1,6 @@
-import { appendFileSync, mkdirSync, existsSync } from "node:fs"
-import { join } from "node:path"
+import { appendFileSync, existsSync, mkdirSync } from "node:fs"
 import { homedir } from "node:os"
+import { join } from "node:path"
 
 export interface LoggerConfig {
   debug?: boolean
@@ -24,9 +24,22 @@ function ensureLogDir(): void {
   }
 }
 
+function safeStringify(a: unknown): string {
+  if (typeof a === "string") return a
+  try {
+    return JSON.stringify(a)
+  } catch {
+    try {
+      return String(a)
+    } catch {
+      return "[Unserializable value]"
+    }
+  }
+}
+
 function formatLine(level: string, args: unknown[]): string {
   const ts = new Date().toISOString()
-  const msg = args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" ")
+  const msg = args.map(safeStringify).join(" ")
   return `${ts} [${level}] ${msg}\n`
 }