chainlesschain 0.162.35 → 0.162.37

package/src/lib/permission-rules.cjs

@@ -0,0 +1,325 @@
+"use strict";
+
+/**
+ * permission-rules — Claude-Code `permissions.{allow,ask,deny}` rule engine.
+ *
+ * A rule is a string `Tool(pattern)` (or a bare `Tool` matching every call of
+ * that tool). `Tool` may be written with the Claude-Code umbrella name (Bash,
+ * Read, Write, Edit, WebFetch, Task, …) or this CLI's own tool name (run_shell,
+ * read_file, write_file, …) — both resolve to the same family.
+ *
+ *   Bash(git push:*)      → run_shell whose command starts with "git push"
+ *   Bash(npm run test:*)  → run_shell starting with "npm run test"
+ *   Read(./src/**)        → read_file/list_dir on a path under <cwd>/src
+ *   Edit(//etc/**)        → edit_file on an absolute path under /etc
+ *   WebFetch(domain:example.com) → web_fetch of https://example.com/…
+ *   Bash                  → every run_shell call
+ *
+ * Pure + self-contained (no glob dependency — `globToRegExp` is built in, the
+ * repo avoids pulling minimatch/picomatch). Decision precedence is
+ * deny > ask > allow; no match returns `{ decision: null }` so callers fall
+ * back to the existing risk-tier / shell-policy logic unchanged.
+ *
+ * This module only *decides*; wiring it into the agent tool loop is a separate
+ * step (so it can ship + be unit-tested in isolation).
+ */
+
+const path = require("node:path");
+const os = require("node:os");
+
+const DECISIONS = Object.freeze({
+  DENY: "deny",
+  ASK: "ask",
+  ALLOW: "allow",
+});
+
+/**
+ * Umbrella (Claude-Code) tool name → the concrete CLI tool names it covers.
+ * A rule written with either side resolves to the same family.
+ */
+const TOOL_GROUPS = Object.freeze({
+  bash: ["run_shell"],
+  read: ["read_file", "list_dir"],
+  grep: ["search_files"],
+  glob: ["search_files"],
+  write: ["write_file"],
+  edit: ["edit_file", "edit_file_hashed"],
+  webfetch: ["web_fetch"],
+  websearch: ["web_search"],
+  task: ["spawn_sub_agent"],
+  skill: ["run_skill", "list_skills"],
+  runcode: ["run_code"],
+  git: ["git"],
+  todowrite: ["todo_write"],
+});
+
+/** Tools whose match target is a shell/command string (prefix-style matching). */
+const COMMAND_TOOLS = new Set(["run_shell", "run_code", "git"]);
+/** Tools whose match target is a filesystem path. */
+const PATH_TOOLS = new Set([
+  "read_file",
+  "list_dir",
+  "search_files",
+  "write_file",
+  "edit_file",
+  "edit_file_hashed",
+]);
+/** Tools whose match target is a URL. */
+const URL_TOOLS = new Set(["web_fetch"]);
+
+/**
+ * Does a rule's tool token apply to the concrete tool being evaluated?
+ * `Bash` → run_shell; `read_file` → read_file only; unknown tokens (e.g.
+ * `mcp__srv__do`) fall back to a case-insensitive exact match.
+ */
+function toolMatches(ruleTool, actualTool) {
+  const r = String(ruleTool || "").toLowerCase();
+  const a = String(actualTool || "");
+  if (Object.prototype.hasOwnProperty.call(TOOL_GROUPS, r)) {
+    return TOOL_GROUPS[r].includes(a);
+  }
+  return r === a.toLowerCase();
+}
+
+/**
+ * Parse a rule string into `{ raw, tool, pattern }` (pattern null = bare tool
+ * rule). Returns null for a malformed/empty rule so callers can skip it.
+ */
+function parseRule(rule) {
+  const raw = String(rule || "").trim();
+  if (!raw) return null;
+  const m = raw.match(/^([A-Za-z_][\w-]*)\s*(?:\(([\s\S]*)\))?$/);
+  if (!m) return null;
+  const tool = m[1];
+  const pattern = m[2] === undefined ? null : m[2].trim();
+  return { raw, tool, pattern };
+}
+
+/** Convert a glob (`*`, `**`, `?`) into an anchored RegExp. Slash-normalized. */
+function globToRegExp(glob) {
+  const s = String(glob || "");
+  let re = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === "*") {
+      if (s[i + 1] === "*") {
+        re += ".*";
+        i++;
+        if (s[i + 1] === "/") i++; // `**/` also matches zero segments
+      } else {
+        re += "[^/]*";
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+    } else {
+      re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp("^" + re + "$");
+}
+
+/** Normalize a filesystem path to forward slashes for glob comparison. */
+function toSlash(p) {
+  return String(p || "").replace(/\\/g, "/");
+}
+
+/**
+ * Resolve the concrete value a path-pattern should be matched against, and the
+ * pattern itself, both as absolute slash-normalized strings.
+ *   ./x or x   → relative to cwd
+ *   //abs/x    → absolute (leading `//` is Claude-Code's absolute marker)
+ *   ~/x        → home
+ */
+function resolvePathPattern(pattern, cwd) {
+  let pat = String(pattern || "");
+  if (pat.startsWith("//")) {
+    pat = pat.slice(1); // `//etc/**` → `/etc/**`
+  } else if (pat.startsWith("~/") || pat === "~") {
+    pat = path.join(os.homedir(), pat.slice(1));
+  } else {
+    pat = path.resolve(cwd || process.cwd(), pat);
+  }
+  return toSlash(pat);
+}
+
+/** Extract the match target (command / path / url) for a tool's args. */
+function extractTarget(actualTool, args, cwd) {
+  const a = args || {};
+  if (COMMAND_TOOLS.has(actualTool)) {
+    return { kind: "command", value: String(a.command || "").trim() };
+  }
+  if (PATH_TOOLS.has(actualTool)) {
+    const raw = a.path || a.file_path || a.dir || a.directory || "";
+    if (!raw) return { kind: "path", value: null };
+    return {
+      kind: "path",
+      value: toSlash(path.resolve(cwd || process.cwd(), String(raw))),
+    };
+  }
+  if (URL_TOOLS.has(actualTool)) {
+    return { kind: "url", value: String(a.url || "").trim() };
+  }
+  return { kind: "none", value: null };
+}
+
+/** Match a shell command against a Claude-Code Bash-style pattern. */
+function matchCommand(pattern, command) {
+  const cmd = String(command || "").trim();
+  // `prefix:*` → starts-with prefix (CC idiom: Bash(git push:*))
+  if (pattern.endsWith(":*")) {
+    const prefix = pattern.slice(0, -2).trim();
+    return cmd === prefix || cmd.startsWith(prefix);
+  }
+  if (pattern.includes("*")) {
+    return globToRegExp(pattern).test(cmd);
+  }
+  return cmd === pattern;
+}
+
+/** Match a URL against a `domain:host` or plain glob pattern. */
+function matchUrl(pattern, url) {
+  const u = String(url || "");
+  if (pattern.startsWith("domain:")) {
+    const host = pattern.slice("domain:".length).trim();
+    let actualHost = "";
+    try {
+      actualHost = new URL(u).host;
+    } catch {
+      return false;
+    }
+    return globToRegExp(host).test(actualHost);
+  }
+  return globToRegExp(pattern).test(u);
+}
+
+/**
+ * Does `pattern` (the inside of `Tool(...)`, or null for a bare rule) match the
+ * given tool call? `null` pattern always matches.
+ */
+function matchPattern(pattern, actualTool, args, cwd) {
+  if (pattern === null) return true;
+  const target = extractTarget(actualTool, args, cwd);
+  if (target.kind === "command") {
+    return target.value ? matchCommand(pattern, target.value) : false;
+  }
+  if (target.kind === "url") {
+    return target.value ? matchUrl(pattern, target.value) : false;
+  }
+  if (target.kind === "path") {
+    if (!target.value) return false;
+    return globToRegExp(resolvePathPattern(pattern, cwd)).test(target.value);
+  }
+  // Tool has no match target but the rule specified a pattern → no match.
+  return false;
+}
+
+/**
+ * Evaluate a tool call against a ruleset.
+ *
+ * @param {object} input
+ * @param {string} input.tool            concrete tool name (run_shell, …)
+ * @param {object} [input.args]          tool arguments
+ * @param {string} [input.cwd]           base dir for relative path patterns
+ * @param {object} input.rules           { allow:[], ask:[], deny:[] } of strings
+ * @returns {{ decision: 'deny'|'ask'|'allow'|null, rule: string|null }}
+ */
+function evaluatePermissionRules({ tool, args = {}, cwd, rules } = {}) {
+  const set = rules || {};
+  const order = [
+    [DECISIONS.DENY, set.deny],
+    [DECISIONS.ASK, set.ask],
+    [DECISIONS.ALLOW, set.allow],
+  ];
+  for (const [decision, list] of order) {
+    if (!Array.isArray(list)) continue;
+    for (const entry of list) {
+      const parsed = parseRule(entry);
+      if (!parsed) continue;
+      if (!toolMatches(parsed.tool, tool)) continue;
+      if (matchPattern(parsed.pattern, tool, args, cwd)) {
+        return { decision, rule: parsed.raw };
+      }
+    }
+  }
+  return { decision: null, rule: null };
+}
+
+/** Concrete tool name → the umbrella token a suggested rule should be written
+ *  with (Claude-Code style; what users expect to see in settings.json). */
+const SUGGEST_UMBRELLA = Object.freeze({
+  run_shell: "Bash",
+  run_code: "Bash",
+  git: "git",
+  read_file: "Read",
+  list_dir: "Read",
+  search_files: "Grep",
+  write_file: "Write",
+  edit_file: "Edit",
+  edit_file_hashed: "Edit",
+  web_fetch: "WebFetch",
+  web_search: "WebSearch",
+  spawn_sub_agent: "Task",
+  run_skill: "Skill",
+  list_skills: "Skill",
+  todo_write: "TodoWrite",
+});
+
+/** Commands whose first token is a dispatcher — keep 2 tokens in the prefix. */
+const MULTI_VERB = new Set([
+  "git", "npm", "npx", "yarn", "pnpm", "docker", "kubectl", "cargo",
+  "go", "pip", "pip3", "python", "python3", "node", "dotnet", "gh", "brew",
+]);
+
+/**
+ * Suggest a sensible `allow` rule string for a tool call, for the interactive
+ * "always allow" / don't-ask-again flow. Commands → `Bash(<1-2 token prefix>:*)`;
+ * paths → `<Umbrella>(<dir>/**)`; urls → `WebFetch(domain:<host>)`; otherwise a
+ * bare tool umbrella. Returns null if nothing meaningful can be derived.
+ */
+function suggestAllowRule(tool, args = {}) {
+  const umbrella = SUGGEST_UMBRELLA[tool] || tool;
+  if (COMMAND_TOOLS.has(tool)) {
+    const cmd = String(args.command || "").trim();
+    if (!cmd) return umbrella;
+    const tokens = cmd.split(/\s+/);
+    const keep = MULTI_VERB.has(tokens[0]) && tokens.length > 1 ? 2 : 1;
+    const prefix = tokens.slice(0, keep).join(" ");
+    return `${umbrella}(${prefix}:*)`;
+  }
+  if (PATH_TOOLS.has(tool)) {
+    const raw = args.path || args.file_path || args.dir || args.directory || "";
+    if (!raw) return umbrella;
+    const slash = String(raw).replace(/\\/g, "/");
+    const dir = slash.includes("/") ? slash.slice(0, slash.lastIndexOf("/")) : ".";
+    const base = dir === "" ? "/" : dir;
+    const norm = /^(\.|\/|~)/.test(base) ? base : `./${base}`;
+    return `${umbrella}(${norm}/**)`;
+  }
+  if (URL_TOOLS.has(tool)) {
+    try {
+      return `${umbrella}(domain:${new URL(String(args.url || "")).host})`;
+    } catch {
+      return umbrella;
+    }
+  }
+  return umbrella;
+}
+
+module.exports = {
+  DECISIONS,
+  TOOL_GROUPS,
+  COMMAND_TOOLS,
+  PATH_TOOLS,
+  URL_TOOLS,
+  toolMatches,
+  parseRule,
+  globToRegExp,
+  resolvePathPattern,
+  extractTarget,
+  matchCommand,
+  matchUrl,
+  matchPattern,
+  evaluatePermissionRules,
+  suggestAllowRule,
+  SUGGEST_UMBRELLA,
+};

package/src/lib/provider-options.js

@@ -6,12 +6,19 @@
  *   1. PROVIDER_DEFAULTS[provider]      — hand-curated baseline per provider
  *   2. MODEL_INFERENCE(modelId)         — model-specific overrides (e.g. o1
  *                                         disables temperature, claude-opus
- *                                         enables extended thinking)
+ *                                         gets a larger maxTokens)
  *   3. callOverrides                    — whatever the caller passes
  *
  * Later layers win at leaf keys; objects are merged recursively, arrays are
  * replaced (not concatenated) to keep behavior predictable.
  *
+ * NOTE: extended *thinking* is NOT decided here. It is opt-in via the agent's
+ * `--thinking` flag and resolved, model-aware, by `_anthropicThinkingParams`
+ * in agent-core.js — the single source of truth. This module contributes only
+ * `maxTokens` to the Anthropic request (chatWithTools destructures just that
+ * from the merge); a stray `anthropic.thinking` here was a second, divergent
+ * config that was never read, so it has been removed.
+ *
  * @module provider-options
  */
 
@@ -21,7 +28,6 @@ export const PROVIDER_DEFAULTS = Object.freeze({
   anthropic: {
     maxTokens: 8192,
     temperature: 1.0,
-    anthropic: { thinking: { type: "disabled" } },
   },
   openai: {
     maxTokens: 4096,
@@ -66,12 +72,10 @@ export function inferModelOverrides(modelId) {
     return { temperature: undefined, reasoning: { effort: "medium" } };
   }
 
-  // Claude Opus — enable extended thinking by default (users can turn off).
+  // Claude Opus — larger default output budget. (Extended thinking is opt-in
+  // via `--thinking`, decided by `_anthropicThinkingParams`, not here.)
   if (id.includes("opus-4") || id.includes("opus-3")) {
-    return {
-      maxTokens: 16384,
-      anthropic: { thinking: { type: "enabled", budgetTokens: 8000 } },
-    };
+    return { maxTokens: 16384 };
   }
 
   // Claude Haiku — cheaper, smaller output by default.

package/src/lib/settings-hook-events.cjs

@@ -0,0 +1,102 @@
+"use strict";
+
+/**
+ * settings-hook-events — fire non-tool `.claude/settings.json` hooks
+ * (UserPromptSubmit, SessionStart, and generic observe events) that live
+ * outside the executeTool seam.
+ *
+ * Reuses the same loader (collectHooks) + JSON protocol (hook-runner). Tool
+ * hooks (PreToolUse/PostToolUse) are dispatched inline in agent-core; this is
+ * the prompt/session lifecycle half. DB-backed session hooks (session-hooks.js
+ * `fireUserPromptSubmit`) stay separate + observe-only; these settings hooks
+ * are decision-capable (block) and can inject `additionalContext`.
+ *
+ * A hook's non-block stdout becomes context to inject: a JSON
+ * `{ "additionalContext": "..." }` field, or — for convenience — plain
+ * (non-JSON) stdout text. Exit 2 / `{decision:block}` aborts the turn.
+ */
+
+const { collectHooks } = require("./settings-hooks.cjs");
+const { runHooks } = require("./hook-runner.cjs");
+
+/** Join the context emitted by the hooks that ran (additionalContext / plain stdout). */
+function aggregateContext(results) {
+  const parts = [];
+  for (const r of results || []) {
+    if (r.additionalContext) {
+      parts.push(String(r.additionalContext));
+    } else if (r.exitCode === 0 && r.stdout) {
+      const s = String(r.stdout).trim();
+      if (s && s[0] !== "{") parts.push(s); // plain stdout = context to inject
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+
+/**
+ * UserPromptSubmit settings hooks. A `block`/`ask` decision aborts the turn;
+ * otherwise any emitted context is returned for the caller to inject.
+ * @returns {{ blocked:boolean, reason?:string, hook?:string, additionalContext:string|null }}
+ */
+function runUserPromptSubmitHooks(settingsHooks, { prompt, cwd, sessionId } = {}) {
+  if (!settingsHooks) return { blocked: false, additionalContext: null };
+  const matched = collectHooks(settingsHooks, "UserPromptSubmit", "");
+  if (matched.length === 0) return { blocked: false, additionalContext: null };
+  const payload = {
+    hook_event_name: "UserPromptSubmit",
+    prompt: String(prompt || ""),
+    cwd,
+    session_id: sessionId || null,
+  };
+  const outcome = runHooks(matched, payload, { cwd, event: "UserPromptSubmit" });
+  if (outcome.decision === "block" || outcome.decision === "ask") {
+    return {
+      blocked: true,
+      reason: outcome.reason,
+      hook: outcome.hook,
+      additionalContext: null,
+    };
+  }
+  return { blocked: false, additionalContext: aggregateContext(outcome.results) };
+}
+
+/**
+ * SessionStart settings hooks (observe + context injection). The `source`
+ * (startup / resume / clear) is the matcher target.
+ * @returns {{ additionalContext:string|null }}
+ */
+function runSessionStartHooks(settingsHooks, { source, cwd, sessionId } = {}) {
+  if (!settingsHooks) return { additionalContext: null };
+  const matched = collectHooks(settingsHooks, "SessionStart", source || "");
+  if (matched.length === 0) return { additionalContext: null };
+  const payload = {
+    hook_event_name: "SessionStart",
+    source: source || "startup",
+    cwd,
+    session_id: sessionId || null,
+  };
+  const outcome = runHooks(matched, payload, { cwd, event: "SessionStart" });
+  return { additionalContext: aggregateContext(outcome.results) };
+}
+
+/**
+ * Generic observe-only fire (SessionEnd / Stop / PreCompact). Returns the raw
+ * runHooks outcome so callers can read a block reason; never gates flow here.
+ */
+function runObserveHooks(settingsHooks, event, payload = {}, { cwd, matchTarget } = {}) {
+  if (!settingsHooks) return { decision: "continue", results: [] };
+  const matched = collectHooks(settingsHooks, event, matchTarget || "");
+  if (matched.length === 0) return { decision: "continue", results: [] };
+  return runHooks(
+    matched,
+    { hook_event_name: event, cwd, ...payload },
+    { cwd, event },
+  );
+}
+
+module.exports = {
+  runUserPromptSubmitHooks,
+  runSessionStartHooks,
+  runObserveHooks,
+  aggregateContext,
+};

package/src/lib/settings-hooks.cjs

@@ -0,0 +1,163 @@
+"use strict";
+
+/**
+ * settings-hooks — load Claude-Code `hooks` blocks from `.claude/settings.json`
+ * and resolve which command hooks fire for a given event + tool.
+ *
+ * Schema (Claude-Code parity):
+ *   {
+ *     "hooks": {
+ *       "PreToolUse":  [ { "matcher": "Bash", "hooks": [ { "type": "command",
+ *                          "command": "./guard.sh", "timeout": 60 } ] } ],
+ *       "PostToolUse": [ ... ]
+ *     }
+ *   }
+ *
+ * Hook arrays are **concatenated** across the settings hierarchy (user <
+ * project < .local < --settings) — order is significant and there is no dedup
+ * (unlike permission rules, which union). Distinct from the DB-backed
+ * `cc hook add` registry: those stay observe-only; only these settings hooks
+ * get the stdin-JSON decision protocol (see hook-runner.cjs) + blocking power.
+ *
+ * Pure + self-contained (`compileMatcher` is inlined rather than imported from
+ * the ESM hook-manager, which a .cjs cannot `require`). `_deps.fs/homedir`
+ * injection follows the CLI testing convention.
+ */
+
+const path = require("node:path");
+const os = require("node:os");
+const fsDefault = require("node:fs");
+const { SUGGEST_UMBRELLA } = require("./permission-rules.cjs");
+
+const _deps = { fs: fsDefault, homedir: () => os.homedir() };
+
+/** Events this loader understands (PreToolUse/PostToolUse are wired first). */
+const HOOK_EVENTS = Object.freeze([
+  "PreToolUse",
+  "PostToolUse",
+  "UserPromptSubmit",
+  "Stop",
+  "SessionStart",
+  "SessionEnd",
+  "PreCompact",
+  "Notification",
+]);
+
+/** Same hierarchy as settings-loader (user < project < .local < --settings). */
+function settingsFiles(cwd, explicitFile) {
+  const home = _deps.homedir();
+  const list = [
+    path.join(home, ".claude", "settings.json"),
+    path.join(cwd, ".claude", "settings.json"),
+    path.join(cwd, ".claude", "settings.local.json"),
+  ];
+  if (explicitFile) list.push(path.resolve(cwd, explicitFile));
+  return list;
+}
+
+function readJson(file, onWarn) {
+  try {
+    if (!_deps.fs.existsSync(file)) return null;
+    const parsed = JSON.parse(_deps.fs.readFileSync(file, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch (err) {
+    const msg = `hooks: ignoring malformed ${file} (${err.message})`;
+    if (typeof onWarn === "function") onWarn(msg);
+    else process.stderr.write(msg + "\n");
+    return null; // fail-open
+  }
+}
+
+/**
+ * Load + concatenate the `hooks` blocks across the hierarchy.
+ * @returns {{ hooks: Record<string, Array<{matcher:string|null, hooks:Array<{type,command,timeout}>}>>, files:string[] }}
+ */
+function loadHooks({ cwd = process.cwd(), settingsFile, onWarn } = {}) {
+  const merged = {};
+  const files = [];
+  for (const file of settingsFiles(cwd, settingsFile)) {
+    const data = readJson(file, onWarn);
+    const block =
+      data && data.hooks && typeof data.hooks === "object" ? data.hooks : null;
+    if (!block) continue;
+    let contributed = false;
+    for (const [event, groups] of Object.entries(block)) {
+      if (!Array.isArray(groups)) continue;
+      for (const g of groups) {
+        if (!g || typeof g !== "object" || !Array.isArray(g.hooks)) continue;
+        const cmds = g.hooks.filter(
+          (h) => h && h.type === "command" && h.command,
+        );
+        if (cmds.length === 0) continue;
+        if (!merged[event]) merged[event] = [];
+        merged[event].push({ matcher: g.matcher ?? null, hooks: cmds });
+        contributed = true;
+      }
+    }
+    if (contributed) files.push(file);
+  }
+  return { hooks: merged, files };
+}
+
+/**
+ * Compile a matcher into a test fn (pipe / wildcard / regex). Inlined twin of
+ * hook-manager.compileMatcher so this .cjs has no ESM dependency.
+ */
+function compileMatcher(pattern) {
+  if (!pattern || pattern === "*") return () => true;
+  if (pattern.startsWith("/") && pattern.lastIndexOf("/") > 0) {
+    const i = pattern.lastIndexOf("/");
+    try {
+      const re = new RegExp(pattern.slice(1, i), pattern.slice(i + 1));
+      return (v) => re.test(v);
+    } catch {
+      /* fall through to wildcard */
+    }
+  }
+  if (pattern.includes("|")) {
+    const ms = pattern.split("|").map((p) => compileMatcher(p.trim()));
+    return (v) => ms.some((m) => m(v));
+  }
+  const esc = pattern
+    .replace(/[.+^${}()[\]\\]/g, "\\$&")
+    .replace(/\*/g, ".*")
+    .replace(/\?/g, ".");
+  const re = new RegExp(`^${esc}$`);
+  return (v) => re.test(v);
+}
+
+/** Concrete tool name → Claude-Code umbrella token (Bash, Read, …). */
+function umbrellaFor(tool) {
+  return SUGGEST_UMBRELLA[tool] || tool;
+}
+
+/**
+ * Ordered command hooks for an event whose matcher matches the tool. The
+ * matcher is tested against BOTH the CC umbrella (`Bash`) and the raw tool
+ * name (`run_shell`), so settings written either way fire.
+ *
+ * @returns {Array<{command:string, timeout?:number}>}
+ */
+function collectHooks(hooksBlock, event, toolName) {
+  const groups = (hooksBlock && hooksBlock[event]) || [];
+  const umbrella = umbrellaFor(toolName);
+  const raw = String(toolName || "");
+  const out = [];
+  for (const g of groups) {
+    const fn = compileMatcher(g.matcher);
+    if (fn(umbrella) || (raw && fn(raw))) {
+      for (const h of g.hooks) out.push({ command: h.command, timeout: h.timeout });
+    }
+  }
+  return out;
+}
+
+module.exports = {
+  loadHooks,
+  collectHooks,
+  compileMatcher,
+  umbrellaFor,
+  settingsFiles,
+  HOOK_EVENTS,
+  _deps,
+};