solidity-argus 0.1.8 → 0.3.0

package/src/cli/cli-program.ts

@@ -1,45 +1,52 @@
-import type { CliCommand } from "./types";
-import { doctorCommand } from "./commands/doctor";
-import { initCommand } from "./commands/init";
-import { installCommand } from "./commands/install";
+import { cliOutput } from "./cli-output"
+import { checkSkillsCommand } from "./commands/check-skills"
+import { doctorCommand } from "./commands/doctor"
+import { initCommand } from "./commands/init"
+import { installCommand } from "./commands/install"
+import { lintSkillsCommand } from "./commands/lint-skills"
+import type { CliCommand } from "./types"
 
 const HELP_TEXT = `argus — Solidity Security Auditor for OpenCode
 
 Commands:
-  doctor   Check Slither/Foundry installation and config health
-  init     Create solidity-argus config file
-  install  Configure argus plugin in opencode config
-`;
+  doctor        Check Slither/Foundry installation and config health
+  init          Create solidity-argus config file
+  install       Configure argus plugin in opencode config
+  lint-skills   Validate SKILL.md files against schema
+  check-skills  Analyze skills for duplicates, near-duplicates, and conflicts
+`
 
 export class CliProgram {
-  private commands: Map<string, CliCommand> = new Map();
+  private commands: Map<string, CliCommand> = new Map()
 
   registerCommand(command: CliCommand): void {
-    this.commands.set(command.name, command);
+    this.commands.set(command.name, command)
   }
 
   async dispatch(args: string[]): Promise<number> {
-    const subcommand = args[0];
+    const subcommand = args[0]
 
     if (!subcommand || subcommand === "--help" || subcommand === "-h") {
-      console.log(HELP_TEXT);
-      return 0;
+      cliOutput.log(HELP_TEXT)
+      return 0
     }
 
-    const command = this.commands.get(subcommand);
+    const command = this.commands.get(subcommand)
     if (!command) {
-      console.error(`Error: Unknown command '${subcommand}'. Run 'argus' for help.`);
-      return 1;
+      cliOutput.error(`Unknown command '${subcommand}'. Run 'argus' for help.`)
+      return 1
     }
 
-    return command.execute(args.slice(1));
+    return command.execute(args.slice(1))
   }
 }
 
 export function createCliProgram(): CliProgram {
-  const program = new CliProgram();
-  program.registerCommand(doctorCommand);
-  program.registerCommand(initCommand);
-  program.registerCommand(installCommand);
-  return program;
+  const program = new CliProgram()
+  program.registerCommand(doctorCommand)
+  program.registerCommand(initCommand)
+  program.registerCommand(installCommand)
+  program.registerCommand(lintSkillsCommand)
+  program.registerCommand(checkSkillsCommand)
+  return program
 }

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

@@ -0,0 +1,135 @@
+import { readdirSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { loadArgusConfig } from "../../config/loader"
+import { createLogger } from "../../shared/logger"
+import {
+  DEFAULT_GATE_CONFIG,
+  formatReportJson,
+  formatReportText,
+  type GateConfig,
+  generateReport,
+  type SkillReport,
+} from "../../skills/analysis/gates"
+import { normalizeSkill, type SkillDoc } from "../../skills/analysis/normalize"
+import { buildTfidfCorpus, computeAllPairs } from "../../skills/analysis/similarity"
+import { resolveSkillRoots } from "../../skills/argus-skill-resolver"
+import { cliOutput } from "../cli-output"
+import type { CliCommand } from "../types"
+
+const logger = createLogger()
+
+function findSkillFiles(dir: string, maxDepth = 8): string[] {
+  const files: string[] = []
+  const stack: Array<{ path: string; depth: number }> = [{ path: dir, depth: 0 }]
+
+  while (stack.length > 0) {
+    const current = stack.pop()
+    if (!current || current.depth > maxDepth) continue
+
+    try {
+      const entries = readdirSync(current.path, { withFileTypes: true })
+      for (const entry of entries) {
+        const fullPath = join(current.path, entry.name)
+        if (entry.isDirectory()) {
+          stack.push({ path: fullPath, depth: current.depth + 1 })
+        } else if (entry.isFile() && entry.name.toUpperCase() === "SKILL.MD") {
+          files.push(fullPath)
+        }
+      }
+    } catch {}
+  }
+
+  return files
+}
+
+function parseFormatArg(args: string[]): "text" | "json" {
+  const formatIdx = args.indexOf("--format")
+  if (formatIdx !== -1 && args[formatIdx + 1] === "json") {
+    return "json"
+  }
+  return "text"
+}
+
+function parseThresholdArg(args: string[], flag: string, fallback: number): number {
+  const idx = args.indexOf(flag)
+  if (idx === -1) return fallback
+  const raw = args[idx + 1]
+  if (!raw) return fallback
+  const parsed = Number.parseFloat(raw)
+  return Number.isFinite(parsed) && parsed >= 0 && parsed <= 1 ? parsed : fallback
+}
+
+export function loadAndNormalizeSkills(cwd: string): SkillDoc[] {
+  let config: ReturnType<typeof loadArgusConfig> | undefined
+  try {
+    config = loadArgusConfig(cwd)
+  } catch {
+    logger.debug("Config load failed, using defaults")
+  }
+
+  const roots = resolveSkillRoots(cwd, config)
+  const docs: SkillDoc[] = []
+
+  for (const root of roots) {
+    const files = findSkillFiles(root.path)
+    for (const file of files) {
+      try {
+        const content = readFileSync(file, "utf8")
+        const doc = normalizeSkill(content)
+        if (doc) {
+          docs.push(doc)
+        }
+      } catch {
+        logger.debug("Skipping unreadable skill file")
+      }
+    }
+  }
+
+  return docs
+}
+
+export function runAnalysis(docs: SkillDoc[], config: GateConfig): SkillReport {
+  const corpus = buildTfidfCorpus(docs)
+  const pairs = computeAllPairs(docs, corpus)
+  return generateReport(docs, pairs, config)
+}
+
+export const checkSkillsCommand: CliCommand = {
+  name: "check-skills",
+  description:
+    "Analyze SKILL.md files for duplicates, near-duplicates, and detection rule conflicts",
+  async execute(args: string[]): Promise<number> {
+    const cwd = process.cwd()
+    const format = parseFormatArg(args)
+
+    const gateConfig: GateConfig = {
+      blockThreshold: parseThresholdArg(
+        args,
+        "--block-threshold",
+        DEFAULT_GATE_CONFIG.blockThreshold,
+      ),
+      warnThreshold: parseThresholdArg(args, "--warn-threshold", DEFAULT_GATE_CONFIG.warnThreshold),
+      infoThreshold: parseThresholdArg(args, "--info-threshold", DEFAULT_GATE_CONFIG.infoThreshold),
+      blockExactRegexConflict: !args.includes("--no-regex-conflict"),
+    }
+
+    const docs = loadAndNormalizeSkills(cwd)
+
+    if (docs.length === 0) {
+      cliOutput.log("No SKILL.md files found.")
+      return 0
+    }
+
+    cliOutput.log(`Analyzing ${docs.length} skills...`)
+
+    const report = runAnalysis(docs, gateConfig)
+
+    if (format === "json") {
+      cliOutput.log(formatReportJson(report))
+    } else {
+      cliOutput.log(formatReportText(report))
+    }
+
+    return report.summary.block > 0 ? 1 : 0
+  },
+}

package/src/cli/commands/doctor.ts

@@ -1,8 +1,22 @@
-import { execSync } from "node:child_process"
-import { existsSync } from "node:fs"
-import { join } from "node:path"
-import type { CliCommand } from "../types"
+import { existsSync, readdirSync, readFileSync } from "node:fs"
+import { basename, dirname, extname, join } from "node:path"
 import { loadArgusConfig } from "../../config/loader"
+import type { ArgusConfig } from "../../config/types"
+import { createLogger } from "../../shared/logger"
+import {
+  getRequiredAuditSkills,
+  normalizeSkillName,
+  type ResolvedSkill,
+  resolveArgusSkills,
+  resolveSkillRoots,
+} 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"
@@ -11,10 +25,15 @@ const RESET = "\x1b[0m"
 
 function checkBinary(name: string): { found: boolean; version: string | null } {
   try {
-    const version = execSync(`${name} --version`, { timeout: 5000 })
-      .toString()
-      .trim()
-      .split("\n")[0] ?? null
+    const result = Bun.spawnSync([name, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe",
+      timeout: 5000,
+    })
+    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 }
@@ -28,54 +47,315 @@ function checkSolidityProject(dir: string): string | null {
   return null
 }
 
+export const ALL_CATEGORIES = [
+  "vulnerability-pattern",
+  "methodology",
+  "protocol-pattern",
+  "checklist",
+  "reference",
+] as const
+
+export const REQUIRED_CATEGORIES: readonly string[] = ["vulnerability-pattern", "methodology"]
+
+export type SkillHealthReport = {
+  categoryBreakdown: Record<string, number>
+  trustTierBreakdown: Record<string, number>
+  duplicates: Array<{ name: string; sources: string[] }>
+  schemaValid: number
+  schemaInvalid: number
+  schemaSkipped: number
+  invalidSkills: Array<{ name: string; error: string }>
+  missingCategories: string[]
+}
+
+export function findDuplicateSkills(
+  entries: Array<{ name: string; source: string }>,
+): Array<{ name: string; sources: string[] }> {
+  const nameToSources = new Map<string, Set<string>>()
+  for (const { name, source } of entries) {
+    if (!nameToSources.has(name)) nameToSources.set(name, new Set())
+    const sources = nameToSources.get(name)
+    if (sources) sources.add(source)
+  }
+  return Array.from(nameToSources)
+    .filter(([, sources]) => sources.size > 1)
+    .map(([name, sources]) => ({ name, sources: Array.from(sources) }))
+}
+
+export function buildSkillHealthReport(
+  resolvedSkills: Map<string, ResolvedSkill>,
+  duplicateEntries?: Array<{ name: string; source: string }>,
+): SkillHealthReport {
+  const categoryBreakdown: Record<string, number> = {}
+  for (const cat of ALL_CATEGORIES) categoryBreakdown[cat] = 0
+
+  const trustTierBreakdown: Record<string, number> = {}
+  let schemaValid = 0
+  let schemaInvalid = 0
+  let schemaSkipped = 0
+  const invalidSkills: Array<{ name: string; error: string }> = []
+
+  for (const [name, skill] of resolvedSkills) {
+    trustTierBreakdown[skill.source] = (trustTierBreakdown[skill.source] ?? 0) + 1
+
+    const fm = parseFrontmatter(skill.content)
+    if (fm) {
+      const validation = validateSkillFrontmatter(fm)
+      if (validation.success) {
+        schemaValid++
+        if (validation.data.category) {
+          categoryBreakdown[validation.data.category] =
+            (categoryBreakdown[validation.data.category] ?? 0) + 1
+        }
+      } else {
+        schemaInvalid++
+        invalidSkills.push({ name, error: validation.errors[0] ?? "unknown error" })
+      }
+    } else {
+      schemaSkipped++
+    }
+  }
+
+  const duplicates = duplicateEntries ? findDuplicateSkills(duplicateEntries) : []
+  const missingCategories = REQUIRED_CATEGORIES.filter((cat) => (categoryBreakdown[cat] ?? 0) === 0)
+
+  return {
+    categoryBreakdown,
+    trustTierBreakdown,
+    duplicates,
+    schemaValid,
+    schemaInvalid,
+    schemaSkipped,
+    invalidSkills,
+    missingCategories,
+  }
+}
+
+function scanMarkdownFiles(dir: string, maxDepth = 8): string[] {
+  if (!existsSync(dir)) return []
+  const files: string[] = []
+  const stack: Array<{ path: string; depth: number }> = [{ path: dir, depth: 0 }]
+  while (stack.length > 0) {
+    const current = stack.pop()
+    if (!current || current.depth > maxDepth) continue
+    try {
+      const entries = readdirSync(current.path, { withFileTypes: true })
+      for (const entry of entries) {
+        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") {
+          files.push(fullPath)
+        }
+      }
+    } catch {
+      logger.debug("Failed to read directory during skill scan")
+    }
+  }
+  return files
+}
+
+function inferSkillName(filePath: string): string {
+  if (basename(filePath) === "SKILL.md") {
+    return basename(dirname(filePath))
+  }
+  return basename(filePath, extname(filePath))
+}
+
+function collectAllSkillNames(
+  projectDir: string,
+  argusConfig?: ArgusConfig,
+): Array<{ name: string; source: string }> {
+  const roots = resolveSkillRoots(projectDir, argusConfig)
+  const entries: Array<{ name: string; source: string }> = []
+  for (const root of roots) {
+    const files = scanMarkdownFiles(root.path)
+    for (const file of files) {
+      try {
+        const content = readFileSync(file, "utf8")
+        const fm = parseFrontmatter(content)
+        const nameFromFm = typeof fm?.name === "string" ? fm.name : null
+        const rawName = nameFromFm || inferSkillName(file)
+        const name = normalizeSkillName(rawName)
+        if (name) entries.push({ name, source: root.source })
+      } catch {
+        logger.debug("Failed to parse skill file frontmatter")
+      }
+    }
+  }
+  return entries
+}
+
 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
 
-    console.log("Argus Doctor\n")
+    cliOutput.log("Argus Doctor\n")
 
     const slither = checkBinary("slither")
     if (slither.found) {
-      console.log(`${GREEN}✓${RESET} Slither: installed (${slither.version})`)
+      cliOutput.log(`${GREEN}✓${RESET} Slither: installed (${slither.version})`)
     } else {
-      console.log(`${RED}✗${RESET} Slither: not found — pip install slither-analyzer`)
+      cliOutput.log(`${RED}✗${RESET} Slither: not found — pip install slither-analyzer`)
       hasFailure = true
     }
 
     const forge = checkBinary("forge")
     if (forge.found) {
-      console.log(`${GREEN}✓${RESET} Forge: installed (${forge.version})`)
+      cliOutput.log(`${GREEN}✓${RESET} Forge: installed (${forge.version})`)
     } else {
-      console.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
     }
 
+    const solcSelect = checkBinary("solc-select")
+    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)`,
+      )
+    }
+
     const projectType = checkSolidityProject(cwd)
     if (projectType) {
-      console.log(`${GREEN}✓${RESET} Project: ${projectType} detected`)
+      cliOutput.log(`${GREEN}✓${RESET} Project: ${projectType} detected`)
     } else {
-      console.log(`${YELLOW}⚠${RESET} Project: no Solidity project detected`)
+      cliOutput.log(`${YELLOW}⚠${RESET} Project: no Solidity project detected`)
+    }
+
+    if (projectType === "foundry" && detectViaIr(cwd)) {
+      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`,
+        )
+        hasFailure = true
+      }
+      if (!solcSelect.found) {
+        cliOutput.log(`${YELLOW}⚠${RESET}   solc-select is recommended for via_ir flatten fallback`)
+      }
     }
 
+    let config: ReturnType<typeof loadArgusConfig> | undefined
     try {
-      const config = loadArgusConfig(cwd)
-      console.log(`${GREEN}✓${RESET} Config: valid`)
+      config = loadArgusConfig(cwd)
+      cliOutput.log(`${GREEN}✓${RESET} Config: valid`)
+
+      const requiredSkills = getRequiredAuditSkills()
+      const resolvedSkills = resolveArgusSkills(cwd, config)
+      const missingSkills = requiredSkills.filter((skillName) => !resolvedSkills.has(skillName))
+
+      if (missingSkills.length === 0) {
+        cliOutput.log(
+          `${GREEN}✓${RESET} Skills: required audit skills resolvable (${requiredSkills.join(", ")})`,
+        )
+      } else {
+        cliOutput.log(
+          `${RED}✗${RESET} Skills: missing required skills (${missingSkills.join(", ")})`,
+        )
+        hasFailure = true
+      }
     } catch {
-      console.log(`${YELLOW}⚠${RESET} Config: using defaults`)
+      cliOutput.log(`${YELLOW}⚠${RESET} Config: using defaults`)
+
+      const requiredSkills = getRequiredAuditSkills()
+      const resolvedSkills = resolveArgusSkills(cwd)
+      const missingSkills = requiredSkills.filter((skillName) => !resolvedSkills.has(skillName))
+
+      if (missingSkills.length === 0) {
+        cliOutput.log(
+          `${GREEN}✓${RESET} Skills: required audit skills resolvable (${requiredSkills.join(", ")})`,
+        )
+      } else {
+        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) {
-        console.log(`${GREEN}✓${RESET} SCVD API: reachable`)
+        cliOutput.log(`${GREEN}✓${RESET} SCVD API: reachable`)
       } else {
-        console.log(`${YELLOW}⚠${RESET} SCVD API: returned ${response.status}`)
+        cliOutput.log(`${YELLOW}⚠${RESET} SCVD API: returned ${response.status}`)
       }
     } catch {
-      console.log(`${YELLOW}⚠${RESET} SCVD API: unreachable`)
+      cliOutput.log(`${YELLOW}⚠${RESET} SCVD API: unreachable`)
+    }
+
+    // Solodit MCP check
+    const soloditConfig = config?.solodit ?? { enabled: true, port: 3000 }
+    const soloditEnabled = soloditConfig.enabled !== false
+    const soloditPort = soloditConfig.port ?? 3000
+
+    if (soloditEnabled) {
+      const health = await checkSoloditHealth(soloditPort, true)
+      if (health.reachable) {
+        cliOutput.log(`${GREEN}✓${RESET} Solodit MCP: reachable on port ${soloditPort}`)
+      } else {
+        cliOutput.log(
+          `${YELLOW}⚠${RESET} Solodit MCP: unreachable on port ${soloditPort} (start with: npx @lyuboslavlyubenov/solodit-mcp)`,
+        )
+      }
+    } else {
+      cliOutput.log(`${YELLOW}⚠${RESET} Solodit MCP: disabled in config`)
+    }
+
+    cliOutput.log("\nSkill Health")
+    try {
+      const healthSkills = resolveArgusSkills(cwd, config)
+      const allEntries = collectAllSkillNames(cwd, config)
+      const report = buildSkillHealthReport(healthSkills, allEntries)
+
+      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(
+        ([tier, count]) => `${tier}: ${count}`,
+      )
+      cliOutput.log(`${GREEN}✓${RESET} Trust tiers: ${tierParts.join(", ")}`)
+
+      if (report.schemaInvalid === 0) {
+        cliOutput.log(
+          `${GREEN}✓${RESET} Schema: ${report.schemaValid} valid, 0 invalid, ${report.schemaSkipped} skipped (no frontmatter)`,
+        )
+      } else {
+        cliOutput.log(
+          `${YELLOW}⚠${RESET} Schema: ${report.schemaValid} valid, ${report.schemaInvalid} invalid, ${report.schemaSkipped} skipped (no frontmatter)`,
+        )
+        for (const inv of report.invalidSkills) {
+          cliOutput.log(`  ${RED}✗${RESET} ${inv.name}: ${inv.error}`)
+        }
+      }
+
+      if (report.duplicates.length > 0) {
+        for (const dup of report.duplicates) {
+          cliOutput.log(
+            `${YELLOW}⚠${RESET} Duplicate skill: "${dup.name}" found in ${dup.sources.join(" and ")}`,
+          )
+        }
+      } else {
+        cliOutput.log(`${GREEN}✓${RESET} No duplicate skills detected`)
+      }
+
+      for (const cat of report.missingCategories) {
+        cliOutput.log(`${YELLOW}⚠${RESET} Required category "${cat}" has 0 skills`)
+      }
+    } catch {
+      cliOutput.log(`${RED}✗${RESET} Could not analyze skill health`)
+      hasFailure = true
     }
 
     return hasFailure ? 1 : 0

package/src/cli/commands/init.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
+import { cliOutput } from "../cli-output"
 import type { CliCommand } from "../types"
 
 const GREEN = "\x1b[32m"
@@ -17,14 +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)) {
-      console.error(`${YELLOW}⚠${RESET} Config already exists: ${configPath}`)
-      console.error("  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
     }
 
@@ -37,9 +39,9 @@ export const initCommand: CliCommand = {
         ? "Hardhat"
         : "unknown"
 
-    console.log(`${GREEN}✓${RESET} Created ${configPath}`)
-    console.log(`  Project type: ${projectType}`)
-    console.log("  Run 'argus doctor' to check dependencies.")
+    cliOutput.log(`${GREEN}✓${RESET} Created ${configPath}`)
+    cliOutput.log(`  Project type: ${projectType}`)
+    cliOutput.log("  Run 'argus doctor' to check dependencies.")
 
     return 0
   },

package/src/cli/commands/install.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs"
-import { join } from "node:path"
 import { homedir } from "node:os"
+import { join } from "node:path"
+import { cliOutput } from "../cli-output"
 import type { CliCommand } from "../types"
 
 const GREEN = "\x1b[32m"
@@ -22,12 +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) {
-      console.error(`${YELLOW}⚠${RESET} opencode.json not found`)
-      console.error("  Create one first, or run: opencode init")
+      cliOutput.error(
+        `${YELLOW}⚠${RESET} opencode.json not found — create one first, or run: opencode init`,
+      )
       return 1
     }
 
@@ -37,7 +39,7 @@ export const installCommand: CliCommand = {
       const plugins: string[] = config.plugin ?? []
 
       if (plugins.includes("solidity-argus")) {
-        console.log(`${GREEN}✓${RESET} solidity-argus already registered in ${configPath}`)
+        cliOutput.log(`${GREEN}✓${RESET} solidity-argus already registered in ${configPath}`)
         return 0
       }
 
@@ -45,10 +47,10 @@ export const installCommand: CliCommand = {
       config.plugin = plugins
       writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`)
 
-      console.log(`${GREEN}✓${RESET} Added solidity-argus to ${configPath}`)
+      cliOutput.log(`${GREEN}✓${RESET} Added solidity-argus to ${configPath}`)
       return 0
-    } catch (error) {
-      console.error(`${YELLOW}⚠${RESET} Failed to update ${configPath}`)
+    } catch (_error) {
+      cliOutput.error(`${YELLOW}⚠${RESET} Failed to update ${configPath}`)
       return 1
     }
   },