solidity-argus 0.2.0 → 0.3.2

package/src/cli/commands/doctor.ts

@@ -1,20 +1,22 @@
-import { execSync } from "node:child_process"
 import { existsSync, readdirSync, readFileSync } from "node:fs"
 import { basename, dirname, extname, join } from "node:path"
-import type { CliCommand } from "../types"
-import type { ArgusConfig } from "../../config/types"
 import { loadArgusConfig } from "../../config/loader"
+import type { ArgusConfig } from "../../config/types"
+import { createLogger } from "../../shared/logger"
 import {
   getRequiredAuditSkills,
   normalizeSkillName,
+  type ResolvedSkill,
   resolveArgusSkills,
   resolveSkillRoots,
-  type ResolvedSkill,
 } from "../../skills/argus-skill-resolver"
 import { parseFrontmatter, validateSkillFrontmatter } from "../../skills/skill-schema"
 import { detectViaIr } from "../../tools/slither-tool"
 import { checkSoloditHealth } from "../../utils/solodit-health"
 import { cliOutput } from "../cli-output"
+import type { CliCommand } from "../types"
+
+const logger = createLogger()
 
 const GREEN = "\x1b[32m"
 const RED = "\x1b[31m"
@@ -23,13 +25,15 @@ const RESET = "\x1b[0m"
 
 function checkBinary(name: string): { found: boolean; version: string | null } {
   try {
-    const version = execSync(`${name} --version`, {
+    const result = Bun.spawnSync([name, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe",
       timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"],
     })
-      .toString()
-      .trim()
-      .split("\n")[0] ?? null
+    if (result.exitCode !== 0) {
+      return { found: false, version: null }
+    }
+    const version = new TextDecoder().decode(result.stdout).trim().split("\n")[0] ?? null
     return { found: true, version }
   } catch {
     return { found: false, version: null }
@@ -70,7 +74,8 @@ export function findDuplicateSkills(
   const nameToSources = new Map<string, Set<string>>()
   for (const { name, source } of entries) {
     if (!nameToSources.has(name)) nameToSources.set(name, new Set())
-    nameToSources.get(name)!.add(source)
+    const sources = nameToSources.get(name)
+    if (sources) sources.add(source)
   }
   return Array.from(nameToSources)
     .filter(([, sources]) => sources.size > 1)
@@ -112,9 +117,7 @@ export function buildSkillHealthReport(
   }
 
   const duplicates = duplicateEntries ? findDuplicateSkills(duplicateEntries) : []
-  const missingCategories = REQUIRED_CATEGORIES.filter(
-    (cat) => (categoryBreakdown[cat] ?? 0) === 0,
-  )
+  const missingCategories = REQUIRED_CATEGORIES.filter((cat) => (categoryBreakdown[cat] ?? 0) === 0)
 
   return {
     categoryBreakdown,
@@ -146,6 +149,7 @@ function scanMarkdownFiles(dir: string, maxDepth = 8): string[] {
         }
       }
     } catch {
+      logger.debug("Failed to read directory during skill scan")
     }
   }
   return files
@@ -175,6 +179,7 @@ function collectAllSkillNames(
         const name = normalizeSkillName(rawName)
         if (name) entries.push({ name, source: root.source })
       } catch {
+        logger.debug("Failed to parse skill file frontmatter")
       }
     }
   }
@@ -184,7 +189,7 @@ function collectAllSkillNames(
 export const doctorCommand: CliCommand = {
   name: "doctor",
   description: "Check tool dependencies and configuration",
-  async execute(args: string[]): Promise<number> {
+  async execute(_args: string[]): Promise<number> {
     const cwd = process.cwd()
     let hasFailure = false
 
@@ -202,7 +207,9 @@ export const doctorCommand: CliCommand = {
     if (forge.found) {
       cliOutput.log(`${GREEN}✓${RESET} Forge: installed (${forge.version})`)
     } else {
-      cliOutput.log(`${RED}✗${RESET} Forge: not found — curl -L https://foundry.paradigm.xyz | bash`)
+      cliOutput.log(
+        `${RED}✗${RESET} Forge: not found — curl -L https://foundry.paradigm.xyz | bash`,
+      )
       hasFailure = true
     }
 
@@ -210,7 +217,9 @@ export const doctorCommand: CliCommand = {
     if (solcSelect.found) {
       cliOutput.log(`${GREEN}✓${RESET} solc-select: installed (${solcSelect.version})`)
     } else {
-      cliOutput.log(`${YELLOW}⚠${RESET} solc-select: not found — pipx install solc-select (needed for via_ir flatten fallback)`)
+      cliOutput.log(
+        `${YELLOW}⚠${RESET} solc-select: not found — pipx install solc-select (needed for via_ir flatten fallback)`,
+      )
     }
 
     const projectType = checkSolidityProject(cwd)
@@ -221,9 +230,13 @@ export const doctorCommand: CliCommand = {
     }
 
     if (projectType === "foundry" && detectViaIr(cwd)) {
-      cliOutput.log(`${YELLOW}⚠${RESET} via_ir: enabled in foundry.toml — Slither will use flatten fallback`)
+      cliOutput.log(
+        `${YELLOW}⚠${RESET} via_ir: enabled in foundry.toml — Slither will use flatten fallback`,
+      )
       if (!forge.found) {
-        cliOutput.log(`${RED}✗${RESET}   forge is required for via_ir flatten fallback but is missing`)
+        cliOutput.log(
+          `${RED}✗${RESET}   forge is required for via_ir flatten fallback but is missing`,
+        )
         hasFailure = true
       }
       if (!solcSelect.found) {
@@ -241,9 +254,13 @@ export const doctorCommand: CliCommand = {
       const missingSkills = requiredSkills.filter((skillName) => !resolvedSkills.has(skillName))
 
       if (missingSkills.length === 0) {
-        cliOutput.log(`${GREEN}✓${RESET} Skills: required audit skills resolvable (${requiredSkills.join(", ")})`)
+        cliOutput.log(
+          `${GREEN}✓${RESET} Skills: required audit skills resolvable (${requiredSkills.join(", ")})`,
+        )
       } else {
-        cliOutput.log(`${RED}✗${RESET} Skills: missing required skills (${missingSkills.join(", ")})`)
+        cliOutput.log(
+          `${RED}✗${RESET} Skills: missing required skills (${missingSkills.join(", ")})`,
+        )
         hasFailure = true
       }
     } catch {
@@ -254,15 +271,21 @@ export const doctorCommand: CliCommand = {
       const missingSkills = requiredSkills.filter((skillName) => !resolvedSkills.has(skillName))
 
       if (missingSkills.length === 0) {
-        cliOutput.log(`${GREEN}✓${RESET} Skills: required audit skills resolvable (${requiredSkills.join(", ")})`)
+        cliOutput.log(
+          `${GREEN}✓${RESET} Skills: required audit skills resolvable (${requiredSkills.join(", ")})`,
+        )
       } else {
-        cliOutput.log(`${RED}✗${RESET} Skills: missing required skills (${missingSkills.join(", ")})`)
+        cliOutput.log(
+          `${RED}✗${RESET} Skills: missing required skills (${missingSkills.join(", ")})`,
+        )
         hasFailure = true
       }
     }
 
     try {
-      const response = await fetch("https://api.scvd.dev/stats", { signal: AbortSignal.timeout(5000) })
+      const response = await fetch("https://api.scvd.dev/stats", {
+        signal: AbortSignal.timeout(5000),
+      })
       if (response.ok) {
         cliOutput.log(`${GREEN}✓${RESET} SCVD API: reachable`)
       } else {
@@ -296,9 +319,7 @@ export const doctorCommand: CliCommand = {
       const allEntries = collectAllSkillNames(cwd, config)
       const report = buildSkillHealthReport(healthSkills, allEntries)
 
-      const catParts = ALL_CATEGORIES.map(
-        (cat) => `${cat}: ${report.categoryBreakdown[cat] ?? 0}`,
-      )
+      const catParts = ALL_CATEGORIES.map((cat) => `${cat}: ${report.categoryBreakdown[cat] ?? 0}`)
       cliOutput.log(`${GREEN}✓${RESET} Categories: ${catParts.join(", ")}`)
 
       const tierParts = Object.entries(report.trustTierBreakdown).map(
@@ -334,6 +355,7 @@ export const doctorCommand: CliCommand = {
       }
     } catch {
       cliOutput.log(`${RED}✗${RESET} Could not analyze skill health`)
+      hasFailure = true
     }
 
     return hasFailure ? 1 : 0

package/src/cli/commands/init.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
-import type { CliCommand } from "../types"
 import { cliOutput } from "../cli-output"
+import type { CliCommand } from "../types"
 
 const GREEN = "\x1b[32m"
 const YELLOW = "\x1b[33m"
@@ -18,13 +18,15 @@ const DEFAULT_CONFIG = {
 export const initCommand: CliCommand = {
   name: "init",
   description: "Initialize Argus configuration for this project",
-  async execute(args: string[]): Promise<number> {
+  async execute(_args: string[]): Promise<number> {
     const cwd = process.cwd()
     const configDir = join(cwd, ".opencode")
     const configPath = join(configDir, "solidity-argus.json")
 
     if (existsSync(configPath)) {
-      cliOutput.error(`${YELLOW}⚠${RESET} Config already exists: ${configPath} — remove it first if you want to reinitialize.`)
+      cliOutput.error(
+        `${YELLOW}⚠${RESET} Config already exists: ${configPath} — remove it first if you want to reinitialize.`,
+      )
       return 1
     }
 

package/src/cli/commands/install.ts

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs"
-import { join } from "node:path"
 import { homedir } from "node:os"
-import type { CliCommand } from "../types"
+import { join } from "node:path"
 import { cliOutput } from "../cli-output"
+import type { CliCommand } from "../types"
 
 const GREEN = "\x1b[32m"
 const YELLOW = "\x1b[33m"
@@ -23,11 +23,13 @@ export function findOpencodeConfig(homeOverride?: string): string | null {
 export const installCommand: CliCommand = {
   name: "install",
   description: "Register solidity-argus in your OpenCode config",
-  async execute(args: string[]): Promise<number> {
+  async execute(_args: string[]): Promise<number> {
     const configPath = findOpencodeConfig()
 
     if (!configPath) {
-      cliOutput.error(`${YELLOW}⚠${RESET} opencode.json not found — create one first, or run: opencode init`)
+      cliOutput.error(
+        `${YELLOW}⚠${RESET} opencode.json not found — create one first, or run: opencode init`,
+      )
       return 1
     }
 
@@ -47,7 +49,7 @@ export const installCommand: CliCommand = {
 
       cliOutput.log(`${GREEN}✓${RESET} Added solidity-argus to ${configPath}`)
       return 0
-    } catch (error) {
+    } catch (_error) {
       cliOutput.error(`${YELLOW}⚠${RESET} Failed to update ${configPath}`)
       return 1
     }

package/src/cli/commands/lint-skills.ts

@@ -1,16 +1,20 @@
-import { readFileSync, readdirSync } from "node:fs"
-import { extname, join } from "node:path"
+import { readdirSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { createLogger } from "../../shared/logger"
 import type { CliCommand } from "../types"
+
+const logger = createLogger()
+
+import { loadArgusConfig } from "../../config/loader"
 import { resolveSkillRoots } from "../../skills/argus-skill-resolver"
 import { parseFrontmatter, validateSkillFrontmatter } from "../../skills/skill-schema"
-import { loadArgusConfig } from "../../config/loader"
 import { cliOutput } from "../cli-output"
 
 const GREEN = "\x1b[32m"
 const RED = "\x1b[31m"
 const RESET = "\x1b[0m"
 
-function findMarkdownFiles(dir: string, maxDepth = 8): string[] {
+function findSkillFiles(dir: string, maxDepth = 8): string[] {
   const files: string[] = []
   const stack: Array<{ path: string; depth: number }> = [{ path: dir, depth: 0 }]
 
@@ -24,13 +28,11 @@ function findMarkdownFiles(dir: string, maxDepth = 8): string[] {
         const fullPath = join(current.path, entry.name)
         if (entry.isDirectory()) {
           stack.push({ path: fullPath, depth: current.depth + 1 })
-        } else if (entry.isFile() && extname(entry.name).toLowerCase() === ".md") {
+        } else if (entry.isFile() && entry.name.toUpperCase() === "SKILL.MD") {
           files.push(fullPath)
         }
       }
-    } catch {
-      continue
-    }
+    } catch {}
   }
 
   return files
@@ -77,26 +79,28 @@ export const lintSkillsCommand: CliCommand = {
     try {
       config = loadArgusConfig(cwd)
     } catch {
-      // fallback to undefined, resolveSkillRoots handles this
+      logger.debug("Config load failed, using defaults")
     }
 
     const roots = resolveSkillRoots(cwd, config)
     const skillFiles: Array<{ path: string; content: string }> = []
 
     for (const root of roots) {
-      const files = findMarkdownFiles(root.path)
+      const files = findSkillFiles(root.path)
       for (const file of files) {
         try {
           skillFiles.push({ path: file, content: readFileSync(file, "utf8") })
         } catch {
-          // continue on read errors
+          logger.debug("Skipping unreadable skill file")
         }
       }
     }
 
     const result = lintSkillFiles(skillFiles)
 
-    cliOutput.log(`Skill Lint: ${result.valid} valid, ${result.invalid} invalid, ${result.skipped} skipped (no frontmatter)`)
+    cliOutput.log(
+      `Skill Lint: ${result.valid} valid, ${result.invalid} invalid, ${result.skipped} skipped (no frontmatter)`,
+    )
 
     if (result.errors.length > 0) {
       for (const { file, errors } of result.errors) {

package/src/cli/index.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env bun
-import { createCliProgram } from "./cli-program";
+import { createCliProgram } from "./cli-program"
 
-const program = createCliProgram();
-const args = Bun.argv.slice(2);
-const exitCode = await program.dispatch(args);
+const program = createCliProgram()
+const args = Bun.argv.slice(2)
+const exitCode = await program.dispatch(args)
 
 // Set exit code without process.exit() so stdout flushes before termination
-process.exitCode = exitCode;
+process.exitCode = exitCode

package/src/cli/types.ts

@@ -3,7 +3,7 @@
  * Defines the contract for all CLI subcommands
  */
 export interface CliCommand {
-  name: string;
-  description: string;
-  execute: (args: string[]) => Promise<number>;
+  name: string
+  description: string
+  execute: (args: string[]) => Promise<number>
 }

package/src/config/index.ts

@@ -1,3 +1,3 @@
+export { loadArgusConfig } from "./loader"
 export { ArgusConfigSchema } from "./schema"
 export type { ArgusConfig } from "./types"
-export { loadArgusConfig } from "./loader"

package/src/config/loader.ts

@@ -1,10 +1,10 @@
 import { homedir } from "node:os"
 import { join } from "node:path"
-import { ArgusConfigSchema } from "./schema"
-import type { ArgusConfig } from "./types"
-import { detectConfigFile, readJsoncFile } from "../shared/file-utils"
 import { deepMerge } from "../shared/deep-merge"
+import { detectConfigFile, readJsoncFile } from "../shared/file-utils"
 import { createLogger } from "../shared/logger"
+import { ArgusConfigSchema } from "./schema"
+import type { ArgusConfig } from "./types"
 
 export function _mergeConfigs(
   userRaw: Record<string, unknown> | null,
@@ -28,9 +28,7 @@ export function loadArgusConfig(projectDir: string): ArgusConfig {
   const userRaw = userConfigInfo.path ? readJsoncFile(userConfigInfo.path) : null
 
   const projectConfigInfo = detectConfigFile(projectDir)
-  const projectRaw = projectConfigInfo.path
-    ? readJsoncFile(projectConfigInfo.path)
-    : null
+  const projectRaw = projectConfigInfo.path ? readJsoncFile(projectConfigInfo.path) : null
 
   return _mergeConfigs(userRaw, projectRaw)
 }

package/src/config/schema.ts

@@ -2,6 +2,7 @@ import { z } from "zod"
 
 const AgentConfigSchema = z.object({
   model: z.string().optional(),
+  steps: z.number().positive().optional(),
   permission: z.record(z.string(), z.any()).optional(),
   tools: z.record(z.string(), z.boolean()).optional(),
 })
@@ -28,13 +29,12 @@ const KnowledgeConfigSchema = z.object({
 
 const ReportingConfigSchema = z.object({
   format: z.enum(["markdown"]).default("markdown"),
-  severityThreshold: z
-    .enum(["critical", "high", "medium", "low", "informational"])
-    .default("low"),
+  severityThreshold: z.enum(["critical", "high", "medium", "low", "informational"]).default("low"),
   gasAnalysis: z.boolean().default(false),
+  output_dir: z.string().default(".opencode/reports/"),
 })
 
-const SolditConfigSchema = z.object({
+const SoloditConfigSchema = z.object({
   enabled: z.boolean().default(true),
   port: z.number().default(3000),
 })
@@ -70,8 +70,9 @@ export const ArgusConfigSchema = z.object({
     format: "markdown",
     severityThreshold: "low",
     gasAnalysis: false,
+    output_dir: ".opencode/reports/",
   }),
-  solodit: SolditConfigSchema.default({
+  solodit: SoloditConfigSchema.default({
     enabled: true,
     port: 3000,
   }),

package/src/config/types.ts

@@ -1,4 +1,4 @@
-import { z } from "zod"
-import { ArgusConfigSchema } from "./schema"
+import type { z } from "zod"
+import type { ArgusConfigSchema } from "./schema"
 
 export type ArgusConfig = z.infer<typeof ArgusConfigSchema>

package/src/constants/defaults.ts

@@ -4,3 +4,5 @@ export const DEFAULT_MODELS = {
   pythia: "anthropic/claude-sonnet-4-6",
   scribe: "anthropic/claude-sonnet-4-6",
 } as const
+
+export const DEFAULT_STEPS = 50 as const