solidity-argus 0.1.8 → 0.3.0

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,36 +1,110 @@
+import { appendFileSync, existsSync, mkdirSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
 export interface LoggerConfig {
-  debug?: boolean;
+  debug?: boolean
 }
 
 export interface Logger {
-  info(...args: any[]): void;
-  debug(...args: any[]): void;
-  error(...args: any[]): void;
-  warn(...args: any[]): void;
+  info(...args: unknown[]): void
+  debug(...args: unknown[]): void
+  error(...args: unknown[]): void
+  warn(...args: unknown[]): void
 }
 
-export function createLogger(config: LoggerConfig = {}): Logger {
-  const { debug = false } = config;
+type LogSink = (line: string) => void
+
+const LOG_DIR = join(homedir(), ".cache", "solidity-argus")
+const LOG_FILE = join(LOG_DIR, "argus.log")
+
+function ensureLogDir(): void {
+  if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true })
+  }
+}
+
+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(safeStringify).join(" ")
+  return `${ts} [${level}] ${msg}\n`
+}
+
+function createFileSink(): LogSink {
+  let dirReady = false
+  return (line: string) => {
+    if (!dirReady) {
+      ensureLogDir()
+      dirReady = true
+    }
+    try {
+      appendFileSync(LOG_FILE, line)
+    } catch {
+      // if we can't write logs, we don't crash the plugin
+    }
+  }
+}
 
-  const prefix = "[argus]";
+function createStderrSink(): LogSink {
+  return (line: string) => {
+    process.stderr.write(line)
+  }
+}
+
+function resolveSink(): LogSink {
+  const mode = process.env.ARGUS_LOG
+  if (mode === "stderr") return createStderrSink()
+  return createFileSink()
+}
+
+let sharedSink: LogSink | null = null
+
+function getSink(): LogSink {
+  if (!sharedSink) {
+    sharedSink = resolveSink()
+  }
+  return sharedSink
+}
+
+export function createLogger(config: LoggerConfig = {}): Logger {
+  const { debug = false } = config
 
   return {
-    info(...args: any[]): void {
-      console.error(prefix, ...args);
+    info(...args: unknown[]): void {
+      getSink()(formatLine("INFO", args))
     },
 
-    debug(...args: any[]): void {
+    debug(...args: unknown[]): void {
       if (debug) {
-        console.error(prefix, ...args);
+        getSink()(formatLine("DEBUG", args))
       }
     },
 
-    error(...args: any[]): void {
-      console.error(prefix, ...args);
+    error(...args: unknown[]): void {
+      getSink()(formatLine("ERROR", args))
     },
 
-    warn(...args: any[]): void {
-      console.error(prefix, ...args);
+    warn(...args: unknown[]): void {
+      getSink()(formatLine("WARN", args))
     },
-  };
+  }
 }
+
+export function resetLoggerSink(): void {
+  sharedSink = null
+}
+
+export { LOG_FILE, LOG_DIR }

package/src/shared/project-utils.ts

@@ -0,0 +1,30 @@
+import { existsSync } from "node:fs"
+import { dirname, join } from "node:path"
+
+/**
+ * Resolve the project directory from tool execution context.
+ * Provides a consistent fallback chain: directory → worktree → cwd.
+ */
+export function resolveProjectDir(context: { directory?: string; worktree?: string }): string {
+  return context.directory ?? context.worktree ?? process.cwd()
+}
+
+/**
+ * Walk up from a file path to find the nearest directory containing foundry.toml.
+ * Returns the file's parent directory if no foundry.toml is found.
+ */
+export 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
+  }
+}