opencode-resolve 0.1.7 → 0.1.9

package/opencode-resolve.reference.jsonc

@@ -17,10 +17,50 @@
 // permission values, and wrong types throw an error at load time.
 
 {
+  // -----------------------------------------------------------------------
+  // profile ("mix" | "glm" | "gpt")
+  // Activates provider-specific agent configurations.
+  // Set automatically by postinstall based on detected providers.
+  //
+  // "mix" — explicit mixed/default profile. Uses standard resolver prompts,
+  //         DEFAULT_ENABLED, and whatever model aliases you configure.
+  // "glm" — GLM-only, optimized for ZAI coding-plan: reduced maxSteps,
+  //         token-efficient prompts, no hard concurrency cap by default.
+  //         No deep-reviewer by default.
+  // "gpt" — GPT-only, high-performance: parallel coder dispatch, full agent
+  //         roster, higher maxSteps.
+  //
+  // When omitted, the plugin defaults to "mix".
+  // -----------------------------------------------------------------------
+  "profile": "mix",
+
+  // -----------------------------------------------------------------------
+  // tier ("bronze" | "silver" | "gold")
+  // Agent roster preset. Overrides the default enabled list when set.
+  //
+  // "bronze" — Minimum agents: coder + resolver only. Maximum token savings.
+  // "silver" — Standard: coder, resolver, explorer, reviewer, planner.
+  //            No deep-reviewer. Best balance for most projects.
+  // "gold"   — Full power: all 8 agents including debugger and researcher.
+  //            Maximum capability for complex tasks.
+  //
+  // Postinstall sets this automatically:
+  //   GLM → silver, GPT → gold, Mix/unknown → no tier (DEFAULT_ENABLED applies).
+  //
+  // Explicit `enabled` array always wins over tier.
+  // -----------------------------------------------------------------------
+  // "tier": "silver",
+
   // -----------------------------------------------------------------------
   // enabled (string[])
-  // Which resolve agents to inject.
-  // Default: ["coder", "resolver", "explorer", "reviewer", "deep-reviewer"].
+  // Which resolve agents to inject. When omitted, the tier or profile default
+  // is used. Explicit `enabled` wins over both tier and profile defaults.
+  //
+  // Mix/default (no tier): ["coder", "resolver", "explorer", "reviewer",
+  //   "deep-reviewer", "planner"].
+  //
+  // GLM profile default: ["coder", "resolver", "explorer", "reviewer",
+  //   "planner"] — deep-reviewer omitted to save tokens.
   //
   // Core path: resolver + coder form the fixed-role verified resolve loop.
   // Internal specialists: explorer, reviewer, deep-reviewer are injected as
@@ -30,7 +70,7 @@
   // Native OpenCode agents (plan, build) are always preserved and never
   // touched by this list. Per-agent `agents.<name>.enabled` overrides this.
   // -----------------------------------------------------------------------
-  "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer"],
+  // "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer", "planner"],
 
   // -----------------------------------------------------------------------
   // preserveNative (boolean)
@@ -55,20 +95,23 @@
 
   // -----------------------------------------------------------------------
   // autoApprove (boolean)
-  // When true, every default `"ask"` permission on enabled agents is flipped
-  // to `"allow"`. Never touches `"deny"`. Never overrides a permission key
-  // you set explicitly under `agents.<name>.permission`. Default: true.
-  //
-  // Set to false for the conservative ask-every-time behavior.
+  // Documentary flag. The plugin's permission.ask hook automatically
+  // classifies bash commands as safe (allow) / dangerous (deny) / unknown (ask).
+  // Base agent permissions are already set to the correct defaults (allow for
+  // edit/webfetch, ask for bash on write agents, deny for read-only agents).
+  // Changing this flag has no effect on behavior — it exists for config
+  // readability and future compatibility. Default: true.
   // -----------------------------------------------------------------------
   "autoApprove": true,
 
   // -----------------------------------------------------------------------
   // maxParallelSubagents (positive integer)
-  // Maximum number of subagents of the SAME ROLE the resolver may dispatch
-  // concurrently. Default: 2 — at most two coders in parallel.
+  // Optional prompt-level cap for how many subagents of the SAME ROLE the
+  // resolver may dispatch concurrently. When omitted, the resolver uses soft
+  // fan-out guidance and backs off on rate-limit errors. GLM profile does not
+  // impose a hard cap unless you set one.
   //   1 = strict per-role serial
-  //   2 = default
+  //   2 = up to two coders in parallel
   //   N = up to N of each role
   // -----------------------------------------------------------------------
   "maxParallelSubagents": 2,
@@ -76,9 +119,12 @@
   // -----------------------------------------------------------------------
   // models (object)
   // Alias map. Keys are either an agent name (coder, reviewer, resolver,
-  // architect, gpt-coder, debugger, researcher, explorer, deep-reviewer)
+  // codex, glm, architect, gpt-coder, debugger, researcher, explorer,
+  // deep-reviewer, planner)
   // OR one of the well-known aliases (`glm`, `gpt`, `quick`, `deep`,
-  // `fast`, `strong`, `mini`, `codex`).
+  // `fast`, `strong`, `mini`, `codex`, `bronze`, `silver`, `gold`,
+  // `gpt-bronze`, `gpt-silver`, `gpt-gold`, `glm-bronze`, `glm-silver`,
+  // `glm-gold`).
   // Values are model identifiers OR another alias.
   //
   // Resolution order for a given agent:
@@ -94,11 +140,17 @@
   // When resolve.json is created for the first time by postinstall, the
   // plugin inspects your OpenCode model config and writes an adaptive
   // preset:
-  //   - GLM/ZAI detected → mixed GLM + GPT aliases
-  //   - OpenAI/GPT detected → single-provider GPT aliases using your model
-  //   - Other or no model → empty (model-neutral inheritance)
-  // Existing resolve.json files are never overwritten. Delete resolve.json
-  // and reinstall to regenerate the preset.
+  //   - interactive terminal → always prompts for mix/gpt/glm, three-tier models,
+  //     and optional dedicated codex/glm primary agents
+  //   - non-interactive install → no guessed model pinning; profile mix,
+  //     models {}, and resolver/codex/glm primary routes enabled
+  //   - OPENCODE_RESOLVE_AUTO_PRESET=1 → legacy non-interactive
+  //     provider-adapted presets
+  // Existing resolve.json files are never overwritten without consent.
+  // Interactive reinstall asks whether to update or back up and run fresh
+  // setup. Non-interactive automation can set:
+  //   OPENCODE_RESOLVE_REINSTALL=fresh
+  //   OPENCODE_RESOLVE_REINSTALL=update
   //
   // Example — one efficient model for everything (recommended default):
   //   "models": {}
@@ -111,17 +163,22 @@
   //     "resolver": "strong"
   //   }
   //
-  // Example — GLM + GPT mixed preset (auto-generated for GLM/ZAI users):
+  // Example — GLM-only three-tier preset (auto-generated for GLM/ZAI users):
+  //   GLM fills all tiers — no GPT dependency, so token exhaustion on
+  //   third-party providers never blocks agent execution.
   //   "models": {
   //     "glm": "zai-coding-plan/glm-5.1",
-  //     "gpt": "openai/gpt-5.5",
-  //     "fast": "glm",
-  //     "strong": "gpt",
-  //     "coder": "glm",
-  //     "resolver": "gpt",
-  //     "reviewer": "gpt",
-  //     "deep-reviewer": "gpt",
-  //     "explorer": "fast"
+  //     "bronze": "zai-coding-plan/glm-5.1",
+  //     "silver": "zai-coding-plan/glm-5.1",
+  //     "gold": "zai-coding-plan/glm-5.1",
+  //     "fast": "bronze",
+  //     "strong": "gold",
+  //     "coder": "silver",
+  //     "resolver": "gold",
+  //     "reviewer": "gold",
+  //     "deep-reviewer": "gold",
+  //     "explorer": "bronze",
+  //     "planner": "gold"
   //   }
   //
   // Legacy aliases (glm, gpt, quick, deep) remain supported for backward
@@ -164,6 +221,15 @@
       }
     },
 
+    // codex — Codex-optimized primary resolver (selectable in agent picker)
+    // Same verified resolve-loop style as resolver, with a Codex-specific
+    // system prompt. Enabled by GPT/mix first-install presets when selected.
+    "codex": {
+      "enabled": false,
+      "mode": "all",
+      "maxSteps": 35
+    },
+
     // Internal specialist subagents — enabled by default as subagents only.
     // Core path is resolver→coder. These are dispatched only when justified.
 
@@ -229,6 +295,20 @@
       "enabled": false,
       "mode": "subagent",
       "maxSteps": 8
+    },
+
+    // -----------------------------------------------------------------
+    // glm — GLM-optimized orchestrator (selectable in agent picker)
+    // Disabled by default. Enable to get a standalone GLM agent with
+    // coding-plan optimized prompts: session limit handling,
+    // token-efficient execution, no hard concurrency cap unless configured.
+    // Users pick this from OpenCode's agent picker as an alternative
+    // to the default resolver.
+    // -----------------------------------------------------------------
+    "glm": {
+      "enabled": false,
+      "mode": "all",
+      "maxSteps": 30
     }
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-resolve",
-  "version": "0.1.7",
-  "description": "OpenCode plugin that adds a small coder/reviewer agent set while preserving native plan/build behavior.",
+  "version": "0.1.9",
+  "description": "OpenCode plugin that adds a lightweight resolver/coder harness for continuous agentic coding.",
   "type": "module",
   "homepage": "https://github.com/jshsakura/opencode-resolve#readme",
   "bugs": {
@@ -25,13 +25,18 @@
     "opencode-resolve.example.json",
     "opencode-resolve.reference.jsonc",
     "README.md",
+    "README.ko.md",
     "LICENSE"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "coverage": "npm run build && node --experimental-test-coverage --test-coverage-lines=79 --test-coverage-branches=69 --test-coverage-functions=85 --test test/*.mjs",
+    "hooks:install": "node scripts/install-git-hooks.mjs",
     "install:local": "npm run build && node scripts/install-local.mjs",
     "postinstall": "node scripts/postinstall.mjs",
     "prepack": "npm test",
+    "precommit": "npm run typecheck && npm test && npm run coverage",
+    "prepush": "npm run precommit && npm pack --dry-run",
     "test": "npm run build && node --test test/*.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
@@ -39,6 +44,9 @@
     "opencode",
     "opencode-plugin",
     "agents",
+    "agentic-coding",
+    "autonomous-coding",
+    "harness",
     "taskflow",
     "resolve",
     "task-resolution",

package/scripts/install-git-hooks.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process"
+import { chmodSync, existsSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)))
+const hooksDir = join(root, ".githooks")
+
+if (!existsSync(join(root, ".git"))) {
+  console.error("[opencode-resolve] not a git checkout; cannot install hooks")
+  process.exit(1)
+}
+
+for (const hook of ["pre-commit", "pre-push"]) {
+  chmodSync(join(hooksDir, hook), 0o755)
+}
+
+const result = spawnSync("git", ["config", "core.hooksPath", ".githooks"], {
+  cwd: root,
+  stdio: "inherit",
+})
+
+if (result.status !== 0) {
+  process.exit(result.status ?? 1)
+}
+
+console.log("[opencode-resolve] git hooks installed: core.hooksPath=.githooks")

package/scripts/install-local.mjs

@@ -2,6 +2,7 @@ import { constants } from "node:fs"
 import { access, mkdir, readFile, symlink, unlink, writeFile } from "node:fs/promises"
 import { homedir } from "node:os"
 import { dirname, join, resolve } from "node:path"
+import { createInterface } from "node:readline/promises"
 import { fileURLToPath } from "node:url"
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..")
@@ -25,11 +26,58 @@ await symlink(pluginTarget, pluginLink)
 
 if (!(await exists(resolveConfigPath))) {
   await createAdaptiveResolveConfig()
+} else {
+  await handleExistingResolveConfig()
 }
 
 console.log(`Linked plugin: ${pluginLink} -> ${pluginTarget}`)
 console.log(`Resolve config: ${resolveConfigPath}`)
 
+async function handleExistingResolveConfig() {
+  const action = await chooseExistingResolveConfigAction()
+  if (action !== "fresh") {
+    console.log(`Existing resolve config preserved: ${resolveConfigPath}`)
+    return
+  }
+
+  await backupResolveConfig()
+  await createAdaptiveResolveConfig()
+}
+
+async function chooseExistingResolveConfigAction() {
+  const requested = (process.env.OPENCODE_RESOLVE_REINSTALL ?? "").trim().toLowerCase()
+  if (["fresh", "reset", "recreate", "new"].includes(requested)) return "fresh"
+  if (["update", "keep", "migrate", "preserve"].includes(requested)) return "update"
+  if (requested) {
+    console.warn(`Ignoring unknown OPENCODE_RESOLVE_REINSTALL=${JSON.stringify(requested)}; use "fresh" or "update".`)
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.log(`Existing resolve config found; preserving it. Set OPENCODE_RESOLVE_REINSTALL=fresh for a fresh reinstall.`)
+    return "update"
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    console.log("")
+    console.log(`Existing resolve config found: ${resolveConfigPath}`)
+    console.log("  1. update existing config — preserve your settings")
+    console.log("  2. fresh reinstall — back up resolve.json and create a new config")
+    const raw = await rl.question("Existing config [1=update, 2=fresh reinstall, default 1]: ")
+    return raw.trim() === "2" ? "fresh" : "update"
+  } finally {
+    rl.close()
+  }
+}
+
+async function backupResolveConfig() {
+  const raw = await readFile(resolveConfigPath, "utf8")
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-")
+  const backupPath = `${resolveConfigPath}.bak.${stamp}`
+  await writeFile(backupPath, raw)
+  console.log(`Backed up existing resolve config to ${backupPath}`)
+}
+
 async function createAdaptiveResolveConfig() {
   const raw = await readFile(exampleConfig, "utf8")
   const example = JSON.parse(raw)
@@ -42,10 +90,20 @@ async function createAdaptiveResolveConfig() {
     // opencode.json not found or unreadable — use empty config
   }
 
-  const currentModel = detectOpenCodeModel(opencodeConfig)
-  const preset = buildModelPreset(currentModel)
-
   const resolveConfig = { ...example }
+  let preset = {}
+  if (process.env.OPENCODE_RESOLVE_AUTO_PRESET === "1") {
+    const currentModel = detectOpenCodeModel(opencodeConfig)
+    preset = buildModelPreset(currentModel)
+  } else {
+    resolveConfig.profile = "mix"
+    resolveConfig.models = {}
+    resolveConfig.agents = {
+      ...resolveConfig.agents,
+      codex: { ...(resolveConfig.agents?.codex ?? {}), enabled: true },
+      glm: { ...(resolveConfig.agents?.glm ?? {}), enabled: true },
+    }
+  }
   if (preset && Object.keys(preset).length > 0) {
     resolveConfig.models = preset
   }
@@ -53,7 +111,9 @@ async function createAdaptiveResolveConfig() {
   await mkdir(configDir, { recursive: true })
   await writeFile(resolveConfigPath, `${JSON.stringify(resolveConfig, null, 2)}\n`)
 
-  const label = getPresetLabel(currentModel)
+  const label = process.env.OPENCODE_RESOLVE_AUTO_PRESET === "1"
+    ? getPresetLabel(detectOpenCodeModel(opencodeConfig))
+    : "prompt-required"
   console.log(`Created ${resolveConfigPath} (preset: ${label})`)
 }