solidity-argus 0.3.7 → 0.5.7

package/src/cli/commands/install.ts

@@ -1,57 +1,98 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { homedir } from "node:os"
-import { join } from "node:path"
+import { dirname, join } from "node:path"
 import { cliOutput } from "../cli-output"
+import { confirm } from "../tui-prompts"
 import type { CliCommand } from "../types"
 
 const GREEN = "\x1b[32m"
 const YELLOW = "\x1b[33m"
 const RESET = "\x1b[0m"
 
+function resolveHome(homeOverride?: string): string {
+  if (homeOverride && homeOverride.length > 0) return homeOverride
+  const envHome = process.env.HOME ?? process.env.USERPROFILE
+  if (envHome && envHome.length > 0) return envHome
+  return homedir()
+}
+
+function localConfigPath(): string {
+  return join(process.cwd(), "opencode.json")
+}
+
+function globalConfigPath(homeOverride?: string): string {
+  return join(resolveHome(homeOverride), ".config", "opencode", "opencode.json")
+}
+
 export function findOpencodeConfig(homeOverride?: string): string | null {
-  const cwd = process.cwd()
-  const localPath = join(cwd, "opencode.json")
-  if (existsSync(localPath)) return localPath
+  const local = localConfigPath()
+  if (existsSync(local)) return local
 
-  const home = homeOverride ?? homedir()
-  const globalPath = join(home, ".config", "opencode", "opencode.json")
-  if (existsSync(globalPath)) return globalPath
+  const global = globalConfigPath(homeOverride)
+  if (existsSync(global)) return global
 
   return null
 }
 
+function addPluginToConfig(configPath: string): { added: boolean; ok: boolean } {
+  try {
+    let config: Record<string, unknown>
+    if (existsSync(configPath)) {
+      const content = readFileSync(configPath, "utf-8")
+      config = JSON.parse(content)
+    } else {
+      mkdirSync(dirname(configPath), { recursive: true })
+      config = {}
+    }
+
+    const plugins = Array.isArray(config.plugin) ? (config.plugin as string[]) : []
+    if (plugins.includes("solidity-argus")) {
+      cliOutput.log(`${GREEN}✓${RESET} solidity-argus already registered in ${configPath}`)
+      return { added: false, ok: true }
+    }
+
+    plugins.push("solidity-argus")
+    config.plugin = plugins
+    writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`)
+    cliOutput.log(`${GREEN}✓${RESET} Added solidity-argus to ${configPath}`)
+    return { added: true, ok: true }
+  } catch (_error) {
+    cliOutput.error(`${YELLOW}⚠${RESET} Failed to update ${configPath}`)
+    return { added: false, ok: false }
+  }
+}
+
 export const installCommand: CliCommand = {
   name: "install",
-  description: "Register solidity-argus in your OpenCode config",
-  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`,
-      )
-      return 1
-    }
+  description: "Register solidity-argus in your OpenCode config (use --global for ~/.config/opencode)",
+  async execute(args: string[]): Promise<number> {
+    const isGlobal = args.includes("--global") || args.includes("-g")
+    const local = localConfigPath()
 
-    try {
-      const content = readFileSync(configPath, "utf-8")
-      const config = JSON.parse(content)
-      const plugins: string[] = config.plugin ?? []
+    if (existsSync(local) && !isGlobal) {
+      return addPluginToConfig(local).ok ? 0 : 1
+    }
 
-      if (plugins.includes("solidity-argus")) {
-        cliOutput.log(`${GREEN}✓${RESET} solidity-argus already registered in ${configPath}`)
-        return 0
-      }
+    if (isGlobal) {
+      return addPluginToConfig(globalConfigPath()).ok ? 0 : 1
+    }
 
-      plugins.push("solidity-argus")
-      config.plugin = plugins
-      writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`)
+    const global = globalConfigPath()
+    cliOutput.warn(
+      `${YELLOW}⚠${RESET} No opencode.json found in current directory (${process.cwd()}).`,
+    )
+    cliOutput.warn(
+      `  Installing globally would write to ${global} and load solidity-argus in EVERY OpenCode session.`,
+    )
+    cliOutput.warn(`  To install globally on purpose, re-run with: argus install --global`)
+    cliOutput.warn(`  To install for this project, first create an opencode.json in this directory.`)
 
-      cliOutput.log(`${GREEN}✓${RESET} Added solidity-argus to ${configPath}`)
+    const proceed = await confirm("Install globally anyway?", false)
+    if (!proceed) {
+      cliOutput.log("Aborted. No changes made.")
       return 0
-    } catch (_error) {
-      cliOutput.error(`${YELLOW}⚠${RESET} Failed to update ${configPath}`)
-      return 1
     }
+
+    return addPluginToConfig(global).ok ? 0 : 1
   },
 }

package/src/config/loader.ts

@@ -1,5 +1,6 @@
 import { homedir } from "node:os"
 import { join } from "node:path"
+import type { z } from "zod"
 import { deepMerge } from "../shared/deep-merge"
 import { detectConfigFile, readJsoncFile } from "../shared/file-utils"
 import { createLogger } from "../shared/logger"
@@ -11,15 +12,38 @@ export function _mergeConfigs(
   projectRaw: Record<string, unknown> | null,
 ): ArgusConfig {
   const logger = createLogger()
-  const merged = deepMerge(userRaw ?? {}, projectRaw ?? {})
+  const merged = deepMerge(userRaw ?? {}, projectRaw ?? {}) as Record<string, unknown>
 
   const result = ArgusConfigSchema.safeParse(merged)
-  if (!result.success) {
-    logger.warn("Invalid argus config, using defaults:", result.error.message)
-    return ArgusConfigSchema.parse({})
+  if (result.success) {
+    return result.data
   }
 
-  return result.data
+  // Warn about unknown keys (typos like 'disbled_hooks' instead of 'disabled_hooks')
+  const knownKeys = new Set(Object.keys(ArgusConfigSchema.shape))
+  for (const key of Object.keys(merged)) {
+    if (!knownKeys.has(key)) {
+      logger.warn(`Unknown config key '${key}' — did you mean a known field? Ignoring.`)
+    }
+  }
+
+  const invalidFields: string[] = []
+  const sanitized: Record<string, unknown> = {}
+
+  for (const [key, fieldSchema] of Object.entries(ArgusConfigSchema.shape)) {
+    if (key in merged) {
+      const fieldResult = (fieldSchema as z.ZodTypeAny).safeParse(merged[key])
+      if (fieldResult.success) {
+        sanitized[key] = fieldResult.data
+      } else {
+        invalidFields.push(key)
+        const issues = fieldResult.error.issues.map((i) => i.message).join(", ")
+        logger.error(`Invalid config field '${key}': ${issues}. Using default.`)
+      }
+    }
+  }
+
+  return ArgusConfigSchema.parse(sanitized)
 }
 
 export function loadArgusConfig(projectDir: string): ArgusConfig {

package/src/config/schema.ts

@@ -3,8 +3,9 @@ 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(),
+  permission: z.record(z.string(), z.unknown()).optional(),
   tools: z.record(z.string(), z.boolean()).optional(),
+  temperature: z.number().min(0).max(2).optional(),
 })
 
 const ToolsConfigSchema = z.object({
@@ -36,55 +37,54 @@ const ReportingConfigSchema = z.object({
 
 const SoloditConfigSchema = z.object({
   enabled: z.boolean().default(true),
-  port: z.number().default(3000),
+  port: z.number().default(54173),
 })
 
 const BackgroundConfigSchema = z.object({
   max_concurrent: z.number().positive().default(3),
 })
 
-const MigrationConfigSchema = z.object({
-  mode: z.enum(["legacy", "dual", "strict"]).default("legacy"),
-})
-
-export const ArgusConfigSchema = z.object({
-  agents: z
-    .object({
-      argus: AgentConfigSchema.default({}),
-      sentinel: AgentConfigSchema.default({}),
-      pythia: AgentConfigSchema.default({}),
-      scribe: AgentConfigSchema.default({}),
-    })
-    .default({
-      argus: {},
-      sentinel: {},
-      pythia: {},
-      scribe: {},
+export const ArgusConfigSchema = z
+  .object({
+    agents: z
+      .object({
+        argus: AgentConfigSchema.default({}),
+        sentinel: AgentConfigSchema.default({}),
+        pythia: AgentConfigSchema.default({}),
+        scribe: AgentConfigSchema.default({}),
+        themis: AgentConfigSchema.optional().default({}),
+      })
+      .default({
+        argus: {},
+        sentinel: {},
+        pythia: {},
+        scribe: {},
+        themis: {},
+      }),
+    tools: ToolsConfigSchema.default({}),
+    knowledge: KnowledgeConfigSchema.default({
+      scvd: {
+        enabled: true,
+        apiUrl: "https://api.scvd.dev",
+      },
+      autoSync: true,
+      skillPrecedence: "bundled-first",
+    }),
+    reporting: ReportingConfigSchema.default({
+      format: "markdown",
+      severityThreshold: "low",
+      gasAnalysis: false,
+      output_dir: ".argus/reports/",
     }),
-  tools: ToolsConfigSchema.default({}),
-  knowledge: KnowledgeConfigSchema.default({
-    scvd: {
+    solodit: SoloditConfigSchema.default({
       enabled: true,
-      apiUrl: "https://api.scvd.dev",
-    },
-    autoSync: true,
-    skillPrecedence: "bundled-first",
-  }),
-  reporting: ReportingConfigSchema.default({
-    format: "markdown",
-    severityThreshold: "low",
-    gasAnalysis: false,
-    output_dir: ".argus/reports/",
-  }),
-  solodit: SoloditConfigSchema.default({
-    enabled: true,
-    port: 3000,
-  }),
-  disabled_hooks: z.array(z.string()).default([]),
-  hooks: z.record(z.string(), z.any()).default({}),
-  cli: z.record(z.string(), z.any()).default({}),
-  background: BackgroundConfigSchema.default({
-    max_concurrent: 3,
-  }),
-  migration: MigrationConfigSchema.optional(),
-})
+      port: 54173,
+    }),
+    disabled_hooks: z.array(z.string()).default([]),
+    hooks: z.record(z.string(), z.unknown()).default({}),
+    cli: z.record(z.string(), z.unknown()).default({}),
+    background: BackgroundConfigSchema.default({
+      max_concurrent: 3,
+    }),
+  })
+  .strict()

package/src/constants/defaults.ts

@@ -3,6 +3,7 @@ export const DEFAULT_MODELS = {
   sentinel: "anthropic/claude-sonnet-4-6",
   pythia: "anthropic/claude-sonnet-4-6",
   scribe: "anthropic/claude-sonnet-4-6",
+  themis: "openai/gpt-5.4",
 } as const
 
 export const DEFAULT_STEPS = 50 as const