@toolu/opencode 6.8.0

package/plugins/toolu/hooks/lib/config.sh

@@ -0,0 +1,355 @@
+#!/usr/bin/env bash
+# Toolu runtime config loader.
+#
+# Reads two layers of JSON config and merges them (project override wins):
+#   1. <agent-config-dir>/toolu.config.json
+#   2. <project-root>/<project-config-dir>/toolu.config.json
+#
+# Defaults are Claude Code-compatible (~/.claude + .claude/); callers can point
+# them elsewhere via TOOLU_CONFIG_DIR and TOOLU_PROJECT_CONFIG_DIRNAME.
+#
+# Public API:
+#   toolu_load_config          - load + cache the merged config
+#   toolu_enabled CAT NAME     - 0 if enabled (default), 1 if disabled
+#   toolu_config_exists        - 0 if any config file is on disk (cheap stat-only check)
+#   toolu_model CLASS          - print the model alias routed to a work class
+#   toolu_string PATH DEF A... - print a config string at dotted PATH if it's in A..., else DEF
+#
+# Defaults: missing key = enabled. Malformed JSON or missing jq = all enabled
+# with a single stderr warning.
+
+_TOOLU_CONFIG_LIB_DIR="$(cd "${BASH_SOURCE%/*}" && pwd)"
+# shellcheck source=host.sh
+. "$_TOOLU_CONFIG_LIB_DIR/host.sh"
+
+# Merged config is held in memory, not a temp file: hooks are short-lived
+# processes, and a per-PID cache file under $TMPDIR was never cleaned up —
+# one leaked file per hook invocation. $(...) subshells inherit the variable
+# exactly like they inherited the file path, so load-once semantics hold.
+TOOLU_CFG_JSON='{}'
+TOOLU_CFG_LOADED=0
+_TOOLU_HAS_JQ=""
+
+_toolu_warn() {
+  printf 'toolu-config: %s\n' "$1" >&2
+}
+
+_toolu_agent_dir() {
+  toolu_config_root | tr -d '\n'
+}
+
+_toolu_project_cfg_dirname() {
+  toolu_project_dirname | tr -d '\n'
+}
+
+_toolu_user_cfg() {
+  local agent_dir
+  agent_dir=$(_toolu_agent_dir)
+  printf '%s/toolu.config.json' "$agent_dir"
+}
+
+_toolu_project_cfg() {
+  toolu_project_config | tr -d '\n'
+}
+
+toolu_load_config() {
+  [ "$TOOLU_CFG_LOADED" = "1" ] && return 0
+  TOOLU_CFG_LOADED=1
+
+  if command -v jq >/dev/null 2>&1; then
+    _TOOLU_HAS_JQ=1
+  else
+    _TOOLU_HAS_JQ=0
+    _toolu_warn "jq missing; all components enabled"
+    TOOLU_CFG_JSON='{}'
+    return 0
+  fi
+
+  local user_cfg project_cfg user_json='{}' project_json='{}'
+  user_cfg=$(_toolu_user_cfg)
+  project_cfg=$(_toolu_project_cfg)
+
+  if [ -f "$user_cfg" ]; then
+    if ! user_json=$(jq -e . "$user_cfg" 2>/dev/null); then
+      _toolu_warn "malformed JSON in $user_cfg; ignoring"
+      user_json='{}'
+    fi
+  fi
+
+  if [ -n "$project_cfg" ] && [ -f "$project_cfg" ]; then
+    if ! project_json=$(jq -e . "$project_cfg" 2>/dev/null); then
+      _toolu_warn "malformed JSON in $project_cfg; ignoring"
+      project_json='{}'
+    fi
+  fi
+
+  TOOLU_CFG_JSON=$(jq -cn --argjson u "$user_json" --argjson p "$project_json" \
+    '$u * $p' 2>/dev/null) || TOOLU_CFG_JSON='{}'
+}
+
+toolu_enabled() {
+  local category="$1" name="$2"
+  toolu_load_config
+  [ "$_TOOLU_HAS_JQ" = "1" ] || return 0
+  local val
+  val=$(jq -r --arg c "$category" --arg n "$name" \
+    'if (.[$c]? // {}) | has($n) then .[$c][$n] | tostring else "missing" end' \
+    <<< "$TOOLU_CFG_JSON" 2>/dev/null)
+  [ "$val" = "false" ] && return 1
+  return 0
+}
+
+# Default-OFF inverse of toolu_enabled: 0 only when .<cat>.<name> is boolean
+# `true`; absent/false/non-true/malformed/no-jq -> 1. Stricter than
+# toolu_enabled_explicit below, which also accepts the string "true" — use this
+# for machine-written markers (e.g. comemory.setup_done) where only the JSON
+# boolean is ever valid.
+toolu_flag_true() {
+  local category="$1" name="$2"
+  toolu_load_config
+  [ "$_TOOLU_HAS_JQ" = "1" ] || return 1
+  local val
+  val=$(jq -r --arg c "$category" --arg n "$name" \
+    'if (.[$c]? // {}) | has($n) then (.[$c][$n] == true) else false end' \
+    <<< "$TOOLU_CFG_JSON" 2>/dev/null)
+  [ "$val" = "true" ] && return 0
+  return 1
+}
+
+# Mirror of toolu_flag_true for explicit opt-outs: 0 only when .<cat>.<name>
+# is boolean `false`; absent/true/non-false/malformed/no-jq -> 1. Separates
+# "user explicitly said no" from "user never set the flag" — e.g. session-start
+# suppresses the /comemory:setup nudge when setup_done is explicitly false.
+toolu_flag_false() {
+  local category="$1" name="$2"
+  toolu_load_config
+  [ "$_TOOLU_HAS_JQ" = "1" ] || return 1
+  local val
+  val=$(jq -r --arg c "$category" --arg n "$name" \
+    'if (.[$c]? // {}) | has($n) then (.[$c][$n] == false) else false end' \
+    <<< "$TOOLU_CFG_JSON" 2>/dev/null)
+  [ "$val" = "true" ] && return 0
+  return 1
+}
+
+# Like toolu_enabled but DEFAULT OFF: returns 0 only when the key is
+# explicitly `true` (boolean, or the string "true" — laxer than
+# toolu_flag_true above). For hand-edited opt-in components (e.g. the
+# session-end comemory reminder) where the default-enabled opt-out semantics
+# are wrong. Missing jq or a missing/non-true value -> 1 (disabled).
+toolu_enabled_explicit() {
+  local category="$1" name="$2"
+  toolu_load_config
+  [ "$_TOOLU_HAS_JQ" = "1" ] || return 1
+  local val
+  val=$(jq -r --arg c "$category" --arg n "$name" \
+    '(.[$c]? // {})[$n]? | tostring' <<< "$TOOLU_CFG_JSON" 2>/dev/null)
+  [ "$val" = "true" ] && return 0
+  return 1
+}
+
+# ── Model-tier routing ──────────────────────────────────────────────────────
+# Which model runs a delegated task is a function of the WORK CLASS, not of the
+# task's prose. Callers name the class; this resolves it to a Claude Code model
+# alias to hand the Agent tool's `model:` field.
+#
+# Aliases, not version ids, are the contract: `sonnet` keeps meaning "the
+# current mid tier" across model releases, so routing survives a new model
+# generation with zero edits. `inherit` is accepted as an override value and
+# means "whatever the lead thread is running".
+#
+# Precedence: `.models.<class>` in config -> built-in default. An unrecognized
+# value is REJECTED (warn + fall back to the default): routing must never emit
+# a model name the Agent tool would refuse, which would fail the delegation
+# instead of just mis-tiering it.
+#
+# The alias list is duplicated inside the plan-ledger step validator
+# (hooks/lib/plan-ledger-parse.sh), which is a jq-only lib that must not drag
+# the config loader in. Parity between the two is enforced by
+# hooks/lib/__tests__/plan-ledger-model.bats.
+TOOLU_MODEL_ALIASES="haiku sonnet opus fable inherit"
+TOOLU_MODEL_CLASSES="mechanical exploration implementation review synthesis architecture"
+
+# _toolu_model_default CLASS -> built-in alias for CLASS; returns 1 if unknown.
+_toolu_model_default() {
+  case "$1" in
+    mechanical)     printf 'haiku' ;;
+    exploration)    printf 'sonnet' ;;
+    implementation) printf 'sonnet' ;;
+    review)         printf 'sonnet' ;;
+    synthesis)      printf 'opus' ;;
+    architecture)   printf 'opus' ;;
+    *) return 1 ;;
+  esac
+}
+
+# toolu_model CLASS -> print the model alias for CLASS.
+# Unknown class: warn, print nothing, return 1 (a caller typo must be loud, not
+# silently routed to some default tier). Missing jq: the built-in default.
+toolu_model() {
+  local class="$1" def val
+  if ! def=$(_toolu_model_default "$class"); then
+    _toolu_warn "unknown model class '$class' (known: $TOOLU_MODEL_CLASSES)"
+    return 1
+  fi
+  toolu_load_config
+  if [ "$_TOOLU_HAS_JQ" != "1" ]; then
+    printf '%s' "$def"
+    return 0
+  fi
+  val=$(jq -r --arg c "$class" \
+    '((.models? // {})[$c]? // "") | tostring' <<< "$TOOLU_CFG_JSON" 2>/dev/null)
+  [ -n "$val" ] || { printf '%s' "$def"; return 0; }
+  case " $TOOLU_MODEL_ALIASES " in
+    *" $val "*) printf '%s' "$val" ;;
+    *)
+      _toolu_warn "models.$class: '$val' is not a model alias ($TOOLU_MODEL_ALIASES); using $def"
+      printf '%s' "$def"
+      ;;
+  esac
+}
+
+# ── Codex model + effort routing ───────────────────────────────────────────
+# Claude keeps the long-standing `.models.<class>` alias contract above.
+# Codex uses a separate nested namespace because its model slugs and reasoning
+# effort are independent values:
+#   .models.codex.<class>.model
+#   .models.codex.<class>.reasoningEffort
+#
+# toolu_codex_model CLASS prints two tab-separated fields followed by a newline:
+# `<model>\t<reasoning-effort>`. Callers can consume them safely with IFS/read.
+TOOLU_CODEX_REASONING_EFFORTS="low medium high xhigh max ultra"
+
+_toolu_codex_model_default() {
+  case "$1" in
+    mechanical)     printf 'gpt-5.6-luna\tmedium' ;;
+    exploration)    printf 'gpt-5.6-terra\tmedium' ;;
+    implementation) printf 'gpt-5.6-terra\tmedium' ;;
+    review)         printf 'gpt-5.6-terra\thigh' ;;
+    synthesis)      printf 'gpt-5.6-sol\thigh' ;;
+    architecture)   printf 'gpt-5.6-sol\thigh' ;;
+    *) return 1 ;;
+  esac
+}
+
+toolu_codex_model() {
+  local class="$1" defaults def_model def_effort model_type model effort_type effort
+  if ! defaults=$(_toolu_codex_model_default "$class"); then
+    _toolu_warn "unknown model class '$class' (known: $TOOLU_MODEL_CLASSES)"
+    return 1
+  fi
+  IFS=$'\t' read -r def_model def_effort <<<"$defaults"
+  toolu_load_config
+  if [ "$_TOOLU_HAS_JQ" != 1 ]; then
+    printf '%s\t%s\n' "$def_model" "$def_effort"
+    return 0
+  fi
+
+  model_type=$(jq -r --arg c "$class" \
+    '((.models?.codex? // {})[$c]?.model? // null) | type' \
+    <<<"$TOOLU_CFG_JSON" 2>/dev/null)
+  model=$(jq -r --arg c "$class" \
+    '((.models?.codex? // {})[$c]?.model? // "") | if type == "string" then . else "" end' \
+    <<<"$TOOLU_CFG_JSON" 2>/dev/null)
+  case "$model_type" in
+    null) model="$def_model" ;;
+    string)
+      if [ -z "$model" ]; then
+        _toolu_warn "models.codex.$class.model: value is not a non-empty string; using $def_model"
+        model="$def_model"
+      fi
+      ;;
+    *)
+      _toolu_warn "models.codex.$class.model: value is not a non-empty string; using $def_model"
+      model="$def_model"
+      ;;
+  esac
+
+  effort_type=$(jq -r --arg c "$class" \
+    '((.models?.codex? // {})[$c]?.reasoningEffort? // null) | type' \
+    <<<"$TOOLU_CFG_JSON" 2>/dev/null)
+  effort=$(jq -r --arg c "$class" \
+    '((.models?.codex? // {})[$c]?.reasoningEffort? // "") | if type == "string" then . else "" end' \
+    <<<"$TOOLU_CFG_JSON" 2>/dev/null)
+  case "$effort_type" in
+    null) effort="$def_effort" ;;
+    string)
+      case " $TOOLU_CODEX_REASONING_EFFORTS " in
+        *" $effort "*) ;;
+        *)
+          _toolu_warn "models.codex.$class.reasoningEffort: '$effort' is not supported ($TOOLU_CODEX_REASONING_EFFORTS); using $def_effort"
+          effort="$def_effort"
+          ;;
+      esac
+      ;;
+    *)
+      _toolu_warn "models.codex.$class.reasoningEffort: value is not a string; using $def_effort"
+      effort="$def_effort"
+      ;;
+  esac
+
+  printf '%s\t%s\n' "$model" "$effort"
+}
+
+# ── Generic string-enum reader ──────────────────────────────────────────────
+# toolu_string PATH DEFAULT ALLOWED...
+# PATH is a dotted jq path into the merged config (e.g. "agentTier.mode").
+# Prints the value at PATH if it is a JSON string AND is one of ALLOWED;
+# otherwise falls back to DEFAULT.
+#
+# Same warn-and-fall-back shape as toolu_model: a key that is simply absent
+# falls back to DEFAULT silently (an unset key is not a mistake); a key that
+# IS present but doesn't qualify (wrong type, or a string outside ALLOWED)
+# warns once on stderr before falling back — that is very likely a typo the
+# author should see.
+toolu_string() {
+  local path="$1" def="$2"
+  shift 2
+  local allowed=("$@")
+  toolu_load_config
+  if [ "$_TOOLU_HAS_JQ" != "1" ]; then
+    printf '%s' "$def"
+    return 0
+  fi
+  local out vtype vval
+  out=$(jq -r --arg p "$path" '
+    ($p | split(".")) as $ks
+    | (getpath($ks)) as $v
+    | [($v | type), (if ($v | type) == "string" then $v else "" end)]
+    | @tsv
+  ' <<< "$TOOLU_CFG_JSON" 2>/dev/null)
+  IFS=$'\t' read -r vtype vval <<< "$out"
+
+  case "$vtype" in
+    null|'')
+      printf '%s' "$def"
+      ;;
+    string)
+      local a
+      for a in "${allowed[@]}"; do
+        if [ "$vval" = "$a" ]; then
+          printf '%s' "$vval"
+          return 0
+        fi
+      done
+      _toolu_warn "$path: '$vval' is not an allowed value (${allowed[*]}); using $def"
+      printf '%s' "$def"
+      ;;
+    *)
+      _toolu_warn "$path: value is not a string; using $def"
+      printf '%s' "$def"
+      ;;
+  esac
+}
+
+# Return 0 if any config file is on disk. Stat-only; no jq, no load. Used by
+# hot-path hooks (e.g. mcp-blocker) to skip config-load entirely when no
+# user has opted in.
+toolu_config_exists() {
+  local user_cfg project_cfg
+  user_cfg=$(_toolu_user_cfg)
+  [ -f "$user_cfg" ] && return 0
+  project_cfg=$(_toolu_project_cfg)
+  [ -n "$project_cfg" ] && [ -f "$project_cfg" ] && return 0
+  return 1
+}