@caoscompanybr/merlin 3.5.0

package/.merlin-core/tools/commands/lib/preserve.js

@@ -0,0 +1,232 @@
+/**
+ * Preserve/restore for project-owned data during upgrade/convert/install.
+ *
+ * Three exports:
+ *   - preserveProjectData()   Copies thoughts + domain skills + project-config
+ *                             to a temp dir; verifies thought-count integrity.
+ *   - restoreDomainSkills()   Restores skills from temp to dst with:
+ *                               - Bug B defense (rm -rf target before cp -r)
+ *                               - Opt-in bug C flatten action (skip nested subdirs)
+ *                               - Additive merge (source-only skills also copied)
+ *   - restoreThoughts()       Restores thoughts from temp to dst; throws on count regression.
+ *
+ * These functions are pure (no logging/printing) — caller wires them into its
+ * own progress output. Throws are how they signal "ABORT" to caller.
+ *
+ * Bug class B (commit c59cfe3, 2026-05-17): bare `cp -r src dst/` when `dst`
+ * is an existing dir creates `dst/src/` nesting instead of overwriting.
+ * Defense: rm -rf target before each cp.
+ *
+ * Bug class C (commit 27ab717, 2026-05-17): legacy nested skill dirs from
+ * pre-c59cfe3 upgrades persist across new upgrades. Defense: opt-in
+ * --flatten-nesting flag removes them from temp before restore.
+ *
+ * @module tools/commands/lib/preserve
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { copyDirSync, rmDirSync, countRealThoughts } = require("./fs-safe");
+
+/**
+ * Copy project-owned data (thoughts, domain skills, project-config) to a temp
+ * directory. Cross-drive safe (uses copy, never rename — see EXDEV note in fs-safe).
+ *
+ * Throws ABORT-class error if thought-count verification fails after copy.
+ *
+ * @param {object} opts
+ * @param {string} opts.projectMerlinDir Absolute path to project's .merlin-core/
+ * @param {string} opts.tempDir          Absolute path to use as temp staging area
+ * @param {number} opts.thoughtCount     Pre-copy thought count (for verification)
+ * @returns {{ projectConfigBackup: string|null, thoughtsCopied: number, domainSkillsCopied: string[] }}
+ */
+function preserveProjectData(opts) {
+  const { projectMerlinDir, tempDir, thoughtCount } = opts;
+
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  const result = {
+    projectConfigBackup: null,
+    thoughtsCopied: 0,
+    domainSkillsCopied: [],
+  };
+
+  // 1. Project-config to memory (small file, in-memory is fine)
+  const projectConfigPath = path.join(projectMerlinDir, "project-config.yaml");
+  if (fs.existsSync(projectConfigPath)) {
+    result.projectConfigBackup = fs.readFileSync(projectConfigPath, "utf8");
+  }
+
+  // 2. Thoughts to temp/thoughts — verify count after copy
+  const srcThoughts = path.join(projectMerlinDir, "thoughts");
+  if (fs.existsSync(srcThoughts)) {
+    const dstThoughts = path.join(tempDir, "thoughts");
+    copyDirSync(srcThoughts, dstThoughts);
+    const copiedCount = countRealThoughts(dstThoughts);
+    if (copiedCount < thoughtCount) {
+      throw new Error(
+        `ABORT: Thought backup verification failed. ` +
+          `Expected >= ${thoughtCount}, copied ${copiedCount}. ` +
+          `Original thoughts untouched at: ${srcThoughts}`,
+      );
+    }
+    result.thoughtsCopied = copiedCount;
+  }
+
+  // 3. Domain skills to temp/domain
+  const srcDomain = path.join(projectMerlinDir, "skills", "domain");
+  if (fs.existsSync(srcDomain)) {
+    const dstDomain = path.join(tempDir, "domain");
+    copyDirSync(srcDomain, dstDomain);
+    result.domainSkillsCopied = fs
+      .readdirSync(dstDomain, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name);
+  }
+
+  return result;
+}
+
+/**
+ * Restore domain skills from temp to destination with bug B + bug C defenses.
+ *
+ * Semantics (project wins on conflict):
+ *   1. If flattenNesting && nestedSkills includes a skill, REMOVE that skill's
+ *      nested subdir from temp BEFORE restore (bug C action).
+ *   2. For each skill in temp/domain:
+ *        a. rm -rf <dst>/<skill_name>        (bug B defense — prevents nesting)
+ *        b. cp -r <temp>/<skill_name> <dst>/<skill_name>
+ *   3. Additive merge: for each skill in SOURCE's domain that wasn't in project's
+ *      preserved temp dir, copy it from source into dst (new skills from framework).
+ *
+ * @param {object} opts
+ * @param {string} opts.tempDomainDir          temp/domain/ (project's preserved skills)
+ * @param {string} opts.dstDomainDir           dst .merlin-core/skills/domain/ (where source already lives)
+ * @param {string} opts.srcDomainDir           src .merlin-core/skills/domain/ (for additive merge of new skills)
+ * @param {boolean} [opts.flattenNesting=false]
+ * @param {Array<{name: string}>} [opts.nestedSkills=[]] from preflight.scanNestedSkills()
+ * @returns {{ restored: string[], addedFromSource: string[], flattened: string[] }}
+ */
+function restoreDomainSkills(opts) {
+  const {
+    tempDomainDir,
+    dstDomainDir,
+    srcDomainDir,
+    flattenNesting = false,
+    nestedSkills = [],
+  } = opts;
+
+  const result = {
+    restored: [],
+    addedFromSource: [],
+    flattened: [],
+  };
+
+  fs.mkdirSync(dstDomainDir, { recursive: true });
+
+  // 1. Bug C action: optionally flatten nested subdirs in temp BEFORE restore
+  if (flattenNesting && nestedSkills.length > 0) {
+    for (const ns of nestedSkills) {
+      const nestedPath = path.join(tempDomainDir, ns.name, ns.name);
+      if (fs.existsSync(nestedPath)) {
+        rmDirSync(nestedPath);
+        result.flattened.push(ns.name);
+      }
+    }
+  }
+
+  // 2. Restore project's preserved skills (bug B defense: rm before cp)
+  if (fs.existsSync(tempDomainDir)) {
+    for (const entry of fs.readdirSync(tempDomainDir, {
+      withFileTypes: true,
+    })) {
+      if (!entry.isDirectory()) continue;
+      const target = path.join(dstDomainDir, entry.name);
+      // BUG B DEFENSE: rm -rf target before cp -r, else cp creates nested dir.
+      // (See commit c59cfe3 — bare `cp -r src dst/` when dst exists creates
+      // dst/src/ instead of overwriting.)
+      rmDirSync(target);
+      copyDirSync(path.join(tempDomainDir, entry.name), target);
+      result.restored.push(entry.name);
+    }
+  }
+
+  // 3. Additive merge: source-only skills get copied (project doesn't have them yet)
+  if (fs.existsSync(srcDomainDir)) {
+    for (const entry of fs.readdirSync(srcDomainDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (result.restored.includes(entry.name)) continue; // project already had it
+      const target = path.join(dstDomainDir, entry.name);
+      copyDirSync(path.join(srcDomainDir, entry.name), target);
+      result.addedFromSource.push(entry.name);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Restore thoughts from temp to destination. Verifies count did not regress.
+ *
+ * NOTE: this `rm -rf` the destination thoughts/ first — that's intentional
+ * because Step 3 (framework copy) brought in source's stale thoughts and we
+ * want to wholesale-replace them with project's preserved set.
+ *
+ * Also ensures all canonical thought subdirs exist after restore (some
+ * projects may not have e.g. `objectives/` yet).
+ *
+ * @param {object} opts
+ * @param {string} opts.tempThoughtsDir
+ * @param {string} opts.dstThoughtsDir
+ * @param {number} opts.thoughtCountBefore  Pre-upgrade count (for regression check)
+ * @returns {{ restoredCount: number, dirsEnsured: string[] }}
+ * @throws ABORT-class error if restoredCount < thoughtCountBefore
+ */
+function restoreThoughts(opts) {
+  const { tempThoughtsDir, dstThoughtsDir, thoughtCountBefore } = opts;
+
+  if (fs.existsSync(tempThoughtsDir)) {
+    rmDirSync(dstThoughtsDir);
+    copyDirSync(tempThoughtsDir, dstThoughtsDir);
+  }
+
+  // Canonical thought subdirs — ensure all exist so future writes don't fail
+  const CANONICAL_SUBDIRS = [
+    "decisions",
+    "handoffs",
+    "learnings",
+    "objectives",
+    "plans",
+    "processes",
+    "reminders",
+    "research",
+    "feedback",
+  ];
+  const dirsEnsured = [];
+  for (const sub of CANONICAL_SUBDIRS) {
+    const dir = path.join(dstThoughtsDir, "shared", sub);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+      dirsEnsured.push(sub);
+    }
+  }
+
+  const restoredCount = countRealThoughts(dstThoughtsDir);
+  if (restoredCount < thoughtCountBefore) {
+    throw new Error(
+      `ABORT: Thought count decreased from ${thoughtCountBefore} to ${restoredCount}. ` +
+        `Restore from temp at: ${tempThoughtsDir} ` +
+        `(or .merlin-backups/latest/)`,
+    );
+  }
+
+  return { restoredCount, dirsEnsured };
+}
+
+module.exports = {
+  preserveProjectData,
+  restoreDomainSkills,
+  restoreThoughts,
+};

package/.merlin-core/tools/commands/lib/project-config.template.yaml

@@ -0,0 +1,69 @@
+# ============================================
+# Merlin Project Configuration (Level 2)
+# ============================================
+# Auto-generated by CONVERSION/INSTALL mode.
+# Customize as needed — values here override framework-config.yaml defaults.
+#
+# Level: L2 (Project)
+# Mutability: Editable by project team
+# Git status: Committed (project-specific)
+# ============================================
+
+# --- Project Identity ---
+project:
+  name: "{{PROJECT_NAME}}"
+  description: "Managed by Merlin Framework"
+  version: "{{SOURCE_VERSION}}"
+  language: "pt-BR"
+
+# --- Team Configuration ---
+team:
+  size: small
+  methodology: agile
+
+# --- Active Agent Configuration ---
+agents:
+  active:
+    - merlin-master
+    - analyst
+    - architect
+    - dev
+    - devops
+    - pm
+    - po
+    - qa
+    - sm
+    - ux
+    - data-engineer
+    - researcher
+    - scout
+    - web-researcher
+    - meta
+
+# --- Active Workflow Configuration ---
+workflows:
+  default: development-cycle
+  available:
+    - development-cycle
+    - spec-pipeline
+    - folloni-funnel
+    - qa-loop
+    - greenfield-fullstack
+    - brownfield-discovery
+
+# --- MCP Servers (project-specific) ---
+mcp:
+  servers: {}
+
+# --- Approval Overrides ---
+approval:
+  high_stake_actions:
+    - production_deploy
+    - database_migration
+    - credential_rotation
+    - repository_deletion
+  medium_stake_actions:
+    - git_push_protected
+    - pr_creation
+    - epic_scope_change
+    - mcp_config_change

package/.merlin-core/tools/commands/lib/report.js

@@ -0,0 +1,231 @@
+/**
+ * Post-run reporting for Merlin install/upgrade/convert operations.
+ *
+ * Three exports:
+ *   - writeUpgradeReport()      → JSON file at .merlin-backups/latest/upgrade-report.json
+ *   - formatWhatChanged()       → human-readable diff block (string)
+ *   - formatRecoveryInstructions() → human-readable rollback guide on failure (string)
+ *
+ * Schema target: matches bash's `merlin-upgrade-report/v1` byte-for-byte where
+ * meaningful (timestamps/paths differ per-run, structure is identical so
+ * diff-reports.js can compare bash vs JS outputs in Phase 9).
+ *
+ * @module tools/commands/lib/report
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+// === ANSI (minimal — matches preflight.js) ===
+
+const ANSI = {
+  RESET: "\x1b[0m",
+  RED: "\x1b[0;31m",
+  GREEN: "\x1b[0;32m",
+  YELLOW: "\x1b[1;33m",
+  BLUE: "\x1b[0;34m",
+  CYAN: "\x1b[0;36m",
+};
+
+function useColor() {
+  return !process.env.NO_COLOR && process.stdout.isTTY;
+}
+
+function c(color, text) {
+  return useColor() ? `${ANSI[color]}${text}${ANSI.RESET}` : String(text);
+}
+
+// === writeUpgradeReport ===
+
+/**
+ * Write the structured upgrade report to .merlin-backups/latest/upgrade-report.json.
+ *
+ * Always called (even on partial failure) so the report captures diagnostic state
+ * for rollback / issue-filing purposes.
+ *
+ * @param {object} opts
+ * @param {string} opts.targetDir     Project being upgraded (the .merlin-backups parent)
+ * @param {string} opts.projectName
+ * @param {string} opts.projectDir    Same as targetDir, here for schema parity with bash
+ * @param {string} opts.merlinSource  Source framework root
+ * @param {string} opts.date          ISO timestamp (or YYYYMMDD-HHMMSS for bash parity)
+ * @param {string} opts.mode          "upgrade" | "convert" | "install"
+ * @param {string} opts.versionFrom
+ * @param {string} opts.versionTo
+ * @param {object} opts.preserved     { thoughts_before, thoughts_after, domain_skills_before, domain_skills_after }
+ * @param {object} opts.installed     { agents, commands }
+ * @param {object} opts.backups       { claude_backup, merlin_core_backup } — paths or "" for n/a
+ * @param {number} opts.errors        Error count
+ * @param {boolean} opts.verified
+ * @returns {string} Absolute path of the report file written
+ */
+function writeUpgradeReport(opts) {
+  const {
+    targetDir,
+    projectName,
+    projectDir,
+    merlinSource,
+    date,
+    mode,
+    versionFrom,
+    versionTo,
+    preserved,
+    installed,
+    backups,
+    errors,
+    verified,
+  } = opts;
+
+  const reportDir = path.join(targetDir, ".merlin-backups", "latest");
+  const reportFile = path.join(reportDir, "upgrade-report.json");
+
+  try {
+    fs.mkdirSync(reportDir, { recursive: true });
+  } catch {
+    // best-effort
+  }
+
+  const report = {
+    schema: "merlin-upgrade-report/v1",
+    project_name: projectName,
+    project_dir: projectDir,
+    merlin_source: merlinSource,
+    date,
+    mode,
+    version_from: versionFrom,
+    version_to: versionTo,
+    preserved: {
+      thoughts_before: preserved.thoughts_before,
+      thoughts_after: preserved.thoughts_after,
+      domain_skills_before: preserved.domain_skills_before,
+      domain_skills_after: preserved.domain_skills_after,
+    },
+    installed: {
+      agents: installed.agents,
+      commands: installed.commands,
+    },
+    backups: {
+      claude_backup: backups.claude_backup || "",
+      merlin_core_backup: backups.merlin_core_backup || "",
+    },
+    errors,
+    verified,
+  };
+
+  try {
+    fs.writeFileSync(
+      reportFile,
+      JSON.stringify(report, null, 2) + "\n",
+      "utf8",
+    );
+    return reportFile;
+  } catch {
+    // best-effort; if write fails we just don't produce the report
+    return null;
+  }
+}
+
+// === formatWhatChanged ===
+
+/**
+ * Format a human-readable "what changed" diff block.
+ *
+ * Style matches bash's WHAT CHANGED section (commit 27ab717 era).
+ *
+ * @param {object} opts
+ * @param {string} opts.versionFrom
+ * @param {string} opts.versionTo
+ * @param {number} opts.thoughtsBefore
+ * @param {number} opts.thoughtsAfter
+ * @param {number} opts.domainBefore
+ * @param {number} opts.domainAfter
+ * @param {number} opts.agentsCount
+ * @param {number} opts.commandsCount
+ * @returns {string} Multi-line formatted block (no trailing newline)
+ */
+function formatWhatChanged(opts) {
+  const {
+    versionFrom,
+    versionTo,
+    thoughtsBefore,
+    thoughtsAfter,
+    domainBefore,
+    domainAfter,
+    agentsCount,
+    commandsCount,
+  } = opts;
+
+  const thoughtsTag =
+    thoughtsAfter >= thoughtsBefore
+      ? c("GREEN", "(preserved)")
+      : c("RED", "(LOSS)");
+  const domainTag =
+    domainAfter >= domainBefore
+      ? c("GREEN", "(preserved)")
+      : c("RED", "(LOSS)");
+
+  const lines = [
+    c("BLUE", "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"),
+    c("CYAN", "  WHAT CHANGED"),
+    c("BLUE", "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"),
+    `  Version:    v${versionFrom} → ${c("GREEN", "v" + versionTo)}`,
+    `  Thoughts:   ${thoughtsBefore} → ${thoughtsAfter} ${thoughtsTag}`,
+    `  Domain:     ${domainBefore} → ${domainAfter} ${domainTag}`,
+    `  Agents:     ${agentsCount} installed (target: 15)`,
+    `  Commands:   ${commandsCount} installed (target: 33)`,
+    "",
+  ];
+  return lines.join("\n");
+}
+
+// === formatRecoveryInstructions ===
+
+/**
+ * Format explicit rollback guide for the error path.
+ *
+ * For JS engine: backups live at .merlin-backups/latest/ in this structure:
+ *   .merlin-backups/latest/
+ *   ├── backup-manifest.json
+ *   ├── thoughts/
+ *   ├── domain-skills/
+ *   ├── project-config.yaml
+ *   └── claude-commands/
+ *
+ * Per-piece restore commands are documented (more granular than bash's
+ * "swap whole .merlin-core dir" — JS preserves project-owned data only).
+ *
+ * @param {object} opts
+ * @param {string} opts.projectDir
+ * @param {string} opts.merlinSource
+ * @param {string} opts.backupDir   Absolute path to .merlin-backups/latest/
+ * @param {string} opts.scriptPath  Path to the script for re-run reference
+ * @returns {string}
+ */
+function formatRecoveryInstructions(opts) {
+  const { projectDir, merlinSource, backupDir, scriptPath } = opts;
+  const lines = [
+    "",
+    `  ${c("YELLOW", "↳ How to recover:")}`,
+    `    1. Read upgrade-report.json: ${path.join(backupDir, "upgrade-report.json")}`,
+    `    2. Read backup manifest:     ${path.join(backupDir, "backup-manifest.json")}`,
+    "    3. To restore project-owned data from backup:",
+    `         cp -r "${path.join(backupDir, "thoughts")}" "${path.join(projectDir, ".merlin-core", "thoughts")}"`,
+    `         cp -r "${path.join(backupDir, "domain-skills")}"/* "${path.join(projectDir, ".merlin-core", "skills", "domain")}/"`,
+    `         cp "${path.join(backupDir, "project-config.yaml")}" "${path.join(projectDir, ".merlin-core", "project-config.yaml")}"`,
+    `         cp -r "${path.join(backupDir, "claude-commands")}"/* "${path.join(projectDir, ".claude", "commands")}/"`,
+    "    4. Then re-run with --dry-run first to see what would change:",
+    `         ${c("CYAN", `node "${scriptPath}" upgrade "${projectDir}" --dry-run`)}`,
+    "    5. If the failure recurs, file an issue with upgrade-report.json attached.",
+    `    Source for re-run: ${merlinSource}`,
+    "",
+  ];
+  return lines.join("\n");
+}
+
+module.exports = {
+  writeUpgradeReport,
+  formatWhatChanged,
+  formatRecoveryInstructions,
+};

package/.merlin-core/tools/commands/lib/settings-merge.js

@@ -0,0 +1,134 @@
+/**
+ * Intelligent merge for .claude/settings.local.json hook registrations.
+ *
+ * Port of the bash convert-to-merlin.sh inline `node -e` script (lines ~795-845).
+ *
+ * Why a merge instead of overwrite:
+ *   - settings.local.json contains the OPERATOR'S machine-local permissions
+ *     (filesystem access patterns, MCP server allowances, etc.) — must NOT be
+ *     overwritten by source's settings.
+ *   - But source may add NEW hook registrations (e.g., a new auto-summarize hook)
+ *     that should be picked up automatically.
+ *
+ * Merge semantics (additive, dedupe-by-command):
+ *   - For each event in src.hooks (PostToolUse, SessionStart, Stop, etc.):
+ *     - If tgt has no matching event entry → copy src's wholesale
+ *     - Else for each matcher in src:
+ *       - If tgt has a matcher with the same `matcher` field → dedupe-merge the
+ *         hook commands inside it (exact-string match on `command`)
+ *       - Else push the whole matcher into tgt
+ *   - All other keys in tgt (permissions, env, etc.) are PRESERVED untouched.
+ *
+ * @module tools/commands/lib/settings-merge
+ */
+
+"use strict";
+
+const fs = require("fs");
+
+/**
+ * Merge source's settings.local.json:hooks into target's, preserving all other
+ * target keys (especially permissions).
+ *
+ * Modes:
+ *   - If target doesn't exist: write a new file containing only the source's hooks (no permissions).
+ *   - If target exists with malformed JSON: throws — caller should catch + log non-fatal.
+ *   - If target exists with valid JSON: in-place merge, write back with 2-space indent + trailing newline.
+ *
+ * @param {object} opts
+ * @param {string} opts.srcSettingsPath  Source settings.local.json path
+ * @param {string} opts.dstSettingsPath  Target settings.local.json path
+ * @returns {{ created: boolean, merged: boolean, eventsAdded: string[], commandsAdded: number }}
+ */
+function mergeSettingsLocal(opts) {
+  const { srcSettingsPath, dstSettingsPath } = opts;
+
+  const result = {
+    created: false,
+    merged: false,
+    eventsAdded: [],
+    commandsAdded: 0,
+  };
+
+  if (!fs.existsSync(srcSettingsPath)) {
+    return result; // no source = nothing to do
+  }
+
+  const src = JSON.parse(fs.readFileSync(srcSettingsPath, "utf8"));
+
+  // CASE 1: target doesn't exist — write source's hooks only (strip everything else)
+  if (!fs.existsSync(dstSettingsPath)) {
+    const tgt = src.hooks ? { hooks: src.hooks } : {};
+    fs.writeFileSync(dstSettingsPath, JSON.stringify(tgt, null, 2) + "\n");
+    result.created = true;
+    if (src.hooks) {
+      result.eventsAdded = Object.keys(src.hooks);
+      result.commandsAdded = countAllCommands(src.hooks);
+    }
+    return result;
+  }
+
+  // CASE 2: target exists — in-place merge preserving target's other keys
+  const tgt = JSON.parse(fs.readFileSync(dstSettingsPath, "utf8"));
+
+  if (!src.hooks) {
+    return result; // source has nothing to merge
+  }
+
+  if (!tgt.hooks) tgt.hooks = {};
+
+  for (const [event, srcMatchers] of Object.entries(src.hooks)) {
+    if (!tgt.hooks[event]) {
+      // Whole event missing in target — copy wholesale
+      tgt.hooks[event] = srcMatchers;
+      result.eventsAdded.push(event);
+      result.commandsAdded += countMatchersCommands(srcMatchers);
+      continue;
+    }
+
+    // Event exists in both — merge matcher-by-matcher
+    for (const srcMatcher of srcMatchers) {
+      const tgtMatcher = tgt.hooks[event].find(
+        (m) => m.matcher === srcMatcher.matcher,
+      );
+      if (tgtMatcher) {
+        // Dedupe-merge the hook commands
+        const existing = new Set(tgtMatcher.hooks.map((h) => h.command));
+        for (const hook of srcMatcher.hooks) {
+          if (!existing.has(hook.command)) {
+            tgtMatcher.hooks.push(hook);
+            result.commandsAdded++;
+          }
+        }
+      } else {
+        // Matcher missing in target — push whole matcher
+        tgt.hooks[event].push(srcMatcher);
+        result.commandsAdded += (srcMatcher.hooks || []).length;
+      }
+    }
+  }
+
+  fs.writeFileSync(dstSettingsPath, JSON.stringify(tgt, null, 2) + "\n");
+  result.merged = true;
+  return result;
+}
+
+function countMatchersCommands(matchers) {
+  let n = 0;
+  for (const m of matchers || []) {
+    n += (m.hooks || []).length;
+  }
+  return n;
+}
+
+function countAllCommands(hooks) {
+  let n = 0;
+  for (const event of Object.keys(hooks)) {
+    n += countMatchersCommands(hooks[event]);
+  }
+  return n;
+}
+
+module.exports = {
+  mergeSettingsLocal,
+};