@cohortapp/agent-sdk 2.3.0

package/scripts/ci/check-docs-accuracy.test.mjs

@@ -0,0 +1,409 @@
+/**
+ * Tests for check-docs-accuracy.mjs — docs-accuracy guard (P1-3).
+ *
+ * Pure-function level: the count-claim extractors, the teams/workflows
+ * structural parsers, README link extraction, and the dangling-ref +
+ * broken-link finders are exercised against fixtures written to a tmp dir.
+ * The fixture-tree tests prove the guard catches a planted bad count, a
+ * planted dangling teams ref, and a planted broken README link — and that a
+ * clean tree produces zero drift.
+ *
+ * @module scripts/ci/check-docs-accuracy.test
+ */
+
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+import {
+  extractAgentCountClaims,
+  extractToolCountClaims,
+  parseTeamMembers,
+  parseWorkflowAgentRefs,
+  extractRelativeLinks,
+  countAgentDirs,
+  agentIdSet,
+  findDanglingAgentRefs,
+  findBrokenReadmeLinks,
+  analyzeDocsAccuracy,
+  run,
+} from "./check-docs-accuracy.mjs";
+
+// ── count-claim extraction ──────────────────────────────────────────────────
+
+describe("extractAgentCountClaims", () => {
+  it("extracts '34 agent definitions'", () => {
+    assert.deepEqual(
+      extractAgentCountClaims("…and 34 agent definitions with mandates…"),
+      [34],
+    );
+  });
+
+  it("extracts the '34 sub-agent definitions' phrasing", () => {
+    assert.deepEqual(extractAgentCountClaims("agents/ ← 34 sub-agent definitions"), [34]);
+  });
+
+  it("extracts '34 specialist agent definitions' (one adjective)", () => {
+    assert.deepEqual(
+      extractAgentCountClaims("| 34 specialist agent definitions with mandates |"),
+      [34],
+    );
+  });
+
+  it("returns every claim in order when several appear", () => {
+    assert.deepEqual(
+      extractAgentCountClaims("13 agent definitions … later 34 agent definitions"),
+      [13, 34],
+    );
+  });
+
+  it("does not misread unrelated numbers (40-60 generated range, ports)", () => {
+    assert.deepEqual(
+      extractAgentCountClaims("generates 40–60 sub-agents on port 8080"),
+      [],
+    );
+  });
+
+  it("returns [] for non-string", () => {
+    assert.deepEqual(extractAgentCountClaims(null), []);
+  });
+});
+
+describe("extractToolCountClaims", () => {
+  it("extracts '30 tools across'", () => {
+    assert.deepEqual(extractToolCountClaims("30 tools across 6 categories"), [30]);
+  });
+
+  it("ignores per-access-level counts like '29 tools' / '(24 tools)'", () => {
+    assert.deepEqual(
+      extractToolCountClaims("ceo (29 tools), leadership (24 tools)"),
+      [],
+    );
+  });
+});
+
+// ── teams members parser ────────────────────────────────────────────────────
+
+describe("parseTeamMembers", () => {
+  const yaml = [
+    "name: executive-office",
+    "lead: chief-of-staff",
+    "members:",
+    "  - chief-of-staff # lead",
+    "  - ceo-briefing",
+    "  - communications",
+    "responsibilities:",
+    "  - Morning and evening briefs",
+    "  - Follow-up management",
+    "escalation: principal",
+  ].join("\n");
+
+  it("extracts only the members block (not responsibilities)", () => {
+    assert.deepEqual(parseTeamMembers(yaml), [
+      "chief-of-staff",
+      "ceo-briefing",
+      "communications",
+    ]);
+  });
+
+  it("strips trailing comments and whitespace", () => {
+    assert.deepEqual(parseTeamMembers("members:\n  - alpha   # note\n"), ["alpha"]);
+  });
+
+  it("ignores prose list items that are not the members block", () => {
+    const out = parseTeamMembers(
+      "members:\n  - alpha\nprinciples:\n  - All actions are logged\n",
+    );
+    assert.deepEqual(out, ["alpha"]);
+  });
+
+  it("returns [] when there is no members key", () => {
+    assert.deepEqual(parseTeamMembers("name: x\nlead: y\n"), []);
+  });
+});
+
+// ── workflows agent-ref parser ──────────────────────────────────────────────
+
+describe("parseWorkflowAgentRefs", () => {
+  const yaml = [
+    "steps:",
+    "  - id: market-sweep",
+    "    agent: market-research",
+    "    action: x",
+    "  - id: triage",
+    "    agent: gmail-operator",
+    "  - id: notify",
+    "    action: notify",
+    "on_failure:",
+    "  notify: agent-self",
+  ].join("\n");
+
+  it("extracts agent: step values", () => {
+    assert.deepEqual(parseWorkflowAgentRefs(yaml), [
+      "market-research",
+      "gmail-operator",
+    ]);
+  });
+
+  it("excludes the agent-self sentinel", () => {
+    assert.deepEqual(parseWorkflowAgentRefs("  - agent: agent-self\n"), []);
+  });
+
+  it("ignores steps with no agent (action-only)", () => {
+    assert.deepEqual(parseWorkflowAgentRefs("  - action: notify\n"), []);
+  });
+});
+
+// ── README link extraction ──────────────────────────────────────────────────
+
+describe("extractRelativeLinks", () => {
+  it("returns relative links, skipping http/mailto/anchors", () => {
+    const md =
+      "see [docs](docs/a.md) and [site](https://x.com) and [mail](mailto:a@b.c) and [top](#intro)";
+    assert.deepEqual(extractRelativeLinks(md), ["docs/a.md"]);
+  });
+
+  it("strips anchors and query strings from relative links", () => {
+    assert.deepEqual(
+      extractRelativeLinks("[x](docs/a.md#section) [y](docs/b.md?v=1)"),
+      ["docs/a.md", "docs/b.md"],
+    );
+  });
+
+  it("drops a markdown link title", () => {
+    assert.deepEqual(extractRelativeLinks('[x](docs/a.md "Title")'), ["docs/a.md"]);
+  });
+
+  it("de-dupes repeated links", () => {
+    assert.deepEqual(extractRelativeLinks("[a](x.md) [b](x.md)"), ["x.md"]);
+  });
+});
+
+// ── fixture-tree integration ────────────────────────────────────────────────
+
+/** Build a minimal repo fixture under a tmp dir. */
+function makeFixture(opts = {}) {
+  const root = mkdtempSync(path.join(os.tmpdir(), "docs-acc-"));
+  // agents/ — three agent dirs by default
+  for (const a of opts.agents || ["alpha", "beta", "gamma"]) {
+    mkdirSync(path.join(root, "agents", a), { recursive: true });
+    writeFileSync(path.join(root, "agents", a, "agent.md"), "# agent\n");
+  }
+  // lib/tool-definitions.js — exports getAllToolsByCategory returning N tools
+  mkdirSync(path.join(root, "lib"), { recursive: true });
+  const toolCount = opts.tools ?? 2;
+  const toolEntries = Array.from({ length: toolCount }, (_, i) => `{name:"t${i}"}`);
+  writeFileSync(
+    path.join(root, "lib", "tool-definitions.js"),
+    `export function getAllToolsByCategory(){return {communication:[${toolEntries.join(",")}]};}\n`,
+  );
+  // docs
+  if (opts.readme != null) writeFileSync(path.join(root, "README.md"), opts.readme);
+  if (opts.claude != null) writeFileSync(path.join(root, "CLAUDE.md"), opts.claude);
+  // teams + workflows
+  for (const [name, body] of Object.entries(opts.teams || {})) {
+    mkdirSync(path.join(root, "teams"), { recursive: true });
+    writeFileSync(path.join(root, "teams", name), body);
+  }
+  for (const [rel, body] of Object.entries(opts.workflows || {})) {
+    const abs = path.join(root, "workflows", rel);
+    mkdirSync(path.dirname(abs), { recursive: true });
+    writeFileSync(abs, body);
+  }
+  // extra real files for link resolution
+  for (const [rel, body] of Object.entries(opts.files || {})) {
+    const abs = path.join(root, rel);
+    mkdirSync(path.dirname(abs), { recursive: true });
+    writeFileSync(abs, body);
+  }
+  return root;
+}
+
+describe("count helpers on a fixture", () => {
+  let root;
+  before(() => {
+    root = makeFixture({ agents: ["a", "b"], tools: 5 });
+  });
+  after(() => rmSync(root, { recursive: true, force: true }));
+
+  it("countAgentDirs counts agent subdirs", () => {
+    assert.equal(countAgentDirs(root), 2);
+  });
+
+  it("agentIdSet returns the agent dir names", () => {
+    assert.deepEqual([...agentIdSet(root)].sort(), ["a", "b"]);
+  });
+
+  it("analyzeDocsAccuracy reports actual tool count from the module", async () => {
+    const r = await analyzeDocsAccuracy({ cwd: root });
+    assert.equal(r.counts.toolsActual, 5);
+  });
+});
+
+describe("catches a planted bad count", () => {
+  let root;
+  before(() => {
+    root = makeFixture({
+      agents: ["a", "b", "c"], // actual = 3
+      tools: 4,
+      readme: "Ships with 99 agent definitions and 88 tools across categories.\n",
+      claude: "agents/ ← 99 sub-agent definitions\n",
+    });
+  });
+  after(() => rmSync(root, { recursive: true, force: true }));
+
+  it("flags the agent-count drift in README and CLAUDE.md", async () => {
+    const r = await analyzeDocsAccuracy({ cwd: root });
+    assert.equal(r.counts.agentsActual, 3);
+    const files = r.counts.agentDrift.map((d) => d.file).sort();
+    assert.deepEqual(files, ["CLAUDE.md", "README.md"]);
+    for (const d of r.counts.agentDrift) {
+      assert.equal(d.claimed, 99);
+      assert.equal(d.actual, 3);
+    }
+  });
+
+  it("flags the tool-count drift", async () => {
+    const r = await analyzeDocsAccuracy({ cwd: root });
+    assert.equal(r.counts.toolsActual, 4);
+    assert.equal(r.counts.toolDrift.length, 1);
+    assert.equal(r.counts.toolDrift[0].claimed, 88);
+    assert.equal(r.counts.toolDrift[0].actual, 4);
+  });
+
+  it("reports zero count-drift when claims match reality", async () => {
+    const clean = makeFixture({
+      agents: ["a", "b", "c"],
+      tools: 4,
+      readme: "Ships with 3 agent definitions and 4 tools across categories.\n",
+    });
+    try {
+      const r = await analyzeDocsAccuracy({ cwd: clean });
+      assert.equal(r.counts.agentDrift.length, 0);
+      assert.equal(r.counts.toolDrift.length, 0);
+    } finally {
+      rmSync(clean, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("catches a dangling teams ref", () => {
+  let root;
+  before(() => {
+    root = makeFixture({
+      agents: ["alpha", "beta"], // ghost is missing
+      teams: {
+        "core.yaml": [
+          "name: core",
+          "members:",
+          "  - alpha",
+          "  - ghost", // dangling
+          "responsibilities:",
+          "  - do things",
+        ].join("\n"),
+      },
+    });
+  });
+  after(() => rmSync(root, { recursive: true, force: true }));
+
+  it("flags the missing member but not the resolving one", () => {
+    const { teamRefs } = findDanglingAgentRefs({ cwd: root });
+    assert.equal(teamRefs.length, 1);
+    assert.equal(teamRefs[0].agent, "ghost");
+    assert.match(teamRefs[0].file, /core\.yaml$/);
+  });
+
+  it("does not treat responsibilities prose as agent refs", () => {
+    const { teamRefs } = findDanglingAgentRefs({ cwd: root });
+    assert.ok(!teamRefs.some((t) => t.agent === "do"));
+  });
+});
+
+describe("workflow refs are de-duped and WARN-classed", () => {
+  let root;
+  before(() => {
+    root = makeFixture({
+      agents: ["alpha"],
+      workflows: {
+        "daily/x.yaml": [
+          "steps:",
+          "  - agent: alpha", // resolves
+          "  - agent: phantom", // dangling
+          "  - agent: phantom", // duplicate dangling -> deduped
+        ].join("\n"),
+      },
+    });
+  });
+  after(() => rmSync(root, { recursive: true, force: true }));
+
+  it("reports each (file, agent) dangling pair exactly once", () => {
+    const { workflowRefs } = findDanglingAgentRefs({ cwd: root });
+    assert.equal(workflowRefs.length, 1);
+    assert.equal(workflowRefs[0].agent, "phantom");
+  });
+});
+
+describe("catches a broken README link and ratchets it as FAIL", () => {
+  it("findBrokenReadmeLinks flags only the missing target", () => {
+    const root = makeFixture({
+      readme: "see [real](docs/real.md) and [dead](docs/missing.md)\n",
+      files: { "docs/real.md": "# real\n" },
+    });
+    try {
+      const { checked, broken } = findBrokenReadmeLinks({ cwd: root });
+      assert.equal(checked, 2);
+      assert.deepEqual(broken, ["docs/missing.md"]);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("run() exits 1 when a README link is broken", async () => {
+    const root = makeFixture({
+      agents: ["a"],
+      readme: "[dead](docs/missing.md)\n",
+    });
+    try {
+      const code = await run(root);
+      assert.equal(code, 1);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("run() exits 0 when links resolve, even with count/ref WARN drift", async () => {
+    const root = makeFixture({
+      agents: ["a", "b"],
+      readme: "Ships 99 agent definitions. See [ok](docs/ok.md).\n",
+      files: { "docs/ok.md": "# ok\n" },
+      teams: { "t.yaml": "name: t\nmembers:\n  - ghost\n" },
+    });
+    try {
+      const code = await run(root);
+      assert.equal(code, 0); // drift is WARN, not FAIL
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+// ── the live repo: link invariant must hold ─────────────────────────────────
+
+describe("live repo", () => {
+  it("README relative links all resolve (the ratcheted invariant)", async () => {
+    const r = await analyzeDocsAccuracy();
+    assert.deepEqual(
+      r.links.broken,
+      [],
+      `broken README links: ${r.links.broken.join(", ")}`,
+    );
+  });
+
+  it("counts the real agent dirs and tools", async () => {
+    const r = await analyzeDocsAccuracy();
+    assert.ok(r.counts.agentsActual >= 1);
+    assert.ok(r.counts.toolsActual >= 1);
+  });
+});

package/scripts/ci/check-exports-exist.mjs

@@ -0,0 +1,140 @@
+/**
+ * check-exports-exist.mjs — CI guard that fails if any package.json "exports"
+ * subpath points at a file that does not exist on disk.
+ *
+ * Adapted from OpenClaw's scripts/check.mjs packaging guards. Pure,
+ * dependency-light: Node builtins only. ESM module (maestro is "type":"module").
+ *
+ * This guards the exact class of bug just fixed in maestro, where the "./tts"
+ * export pointed at a missing file. The "exports" map is the package's public
+ * API surface; a dangling target means `import "@cohortapp/agent-sdk/<subpath>"`
+ * throws ERR_MODULE_NOT_FOUND at the consumer, which npm publish does not catch.
+ *
+ * Handles both string targets (`"./x": "./lib/x.js"`) and conditional-export
+ * objects (`"./x": { "import": "./lib/x.mjs", "require": "./lib/x.cjs" }`),
+ * recursing into nested condition maps. Only string leaf values that look like
+ * relative file paths (start with ".") are checked; the special `null` "block"
+ * target and bare condition keys are ignored.
+ *
+ * Usage (standalone): `node scripts/ci/check-exports-exist.mjs`
+ *   exit 0 → all targets exist; exit 1 → one or more missing.
+ *
+ * @module scripts/ci/check-exports-exist
+ */
+
+"use strict";
+
+import { readFile } from "node:fs/promises";
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** Repo root: two levels up from scripts/ci/. @type {string} */
+const REPO_ROOT = path.resolve(fileURLToPath(new URL(".", import.meta.url)), "..", "..");
+
+/**
+ * Collect every string leaf from an "exports" value, regardless of whether it
+ * is a plain string, an array of fallbacks, or a nested condition object.
+ *
+ * @param {unknown} value - An exports map value (string | object | array | null).
+ * @param {string} subpath - The export key this value belongs to (for reporting).
+ * @param {Array<{ subpath: string, target: string }>} [out=[]] - Accumulator.
+ * @returns {Array<{ subpath: string, target: string }>}
+ */
+export function collectExportTargets(value, subpath, out = []) {
+  if (value == null) return out; // null is a deliberate "block this subpath".
+  if (typeof value === "string") {
+    out.push({ subpath, target: value });
+    return out;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectExportTargets(item, subpath, out);
+    return out;
+  }
+  if (typeof value === "object") {
+    for (const v of Object.values(value)) collectExportTargets(v, subpath, out);
+    return out;
+  }
+  return out;
+}
+
+/**
+ * Flatten a whole "exports" map into a list of (subpath, target) pairs.
+ *
+ * @param {Record<string, unknown> | string | undefined} exportsField
+ * @returns {Array<{ subpath: string, target: string }>}
+ */
+export function flattenExports(exportsField) {
+  if (exportsField == null) return [];
+  // Sugar form: "exports": "./index.js"
+  if (typeof exportsField === "string") {
+    return [{ subpath: ".", target: exportsField }];
+  }
+  const pairs = [];
+  for (const [subpath, value] of Object.entries(exportsField)) {
+    // A key that is a condition (e.g. "import") rather than a subpath ("./x" or ".")
+    // still resolves to the same kind of leaf values, so treat uniformly.
+    collectExportTargets(value, subpath, pairs);
+  }
+  return pairs;
+}
+
+/**
+ * Check that every relative-path export target resolves to an existing file.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.cwd=REPO_ROOT] - Repo root containing package.json.
+ * @param {object} [opts.pkg] - Pre-parsed package.json (skips disk read).
+ * @returns {Promise<{ ok: boolean, checked: number, missing: Array<{ subpath: string, target: string, resolved: string }> }>}
+ */
+export async function checkExportsExist(opts = {}) {
+  const cwd = opts.cwd || REPO_ROOT;
+  let pkg = opts.pkg;
+  if (!pkg) {
+    const raw = await readFile(path.join(cwd, "package.json"), "utf8");
+    pkg = JSON.parse(raw);
+  }
+  const targets = flattenExports(pkg.exports);
+  const missing = [];
+  let checked = 0;
+  for (const { subpath, target } of targets) {
+    // Only verify relative file targets. Bare specifiers (rare in "exports")
+    // and non-path strings are out of scope for a filesystem existence check.
+    if (typeof target !== "string" || !target.startsWith(".")) continue;
+    checked++;
+    const resolved = path.resolve(cwd, target);
+    const present = existsSync(resolved) && statSync(resolved).isFile();
+    if (!present) missing.push({ subpath, target, resolved });
+  }
+  return { ok: missing.length === 0, checked, missing };
+}
+
+/**
+ * Run the check and print a human report.
+ *
+ * @param {string} [cwd=REPO_ROOT]
+ * @returns {Promise<number>} Process exit code (0 = ok, 1 = missing target).
+ */
+export async function run(cwd = REPO_ROOT) {
+  const { ok, checked, missing } = await checkExportsExist({ cwd });
+  if (ok) {
+    console.log(`check-exports-exist: OK (${checked} export target(s) exist)`);
+    return 0;
+  }
+  console.error("check-exports-exist: FAIL — exports point at missing files:");
+  for (const m of missing) {
+    console.error(`  "${m.subpath}" -> ${m.target}  (not found: ${m.resolved})`);
+  }
+  console.error(`check-exports-exist: ${missing.length} missing of ${checked} checked`);
+  return 1;
+}
+
+// Run when invoked directly (not when imported).
+if (import.meta.url === `file://${process.argv[1]}`) {
+  run()
+    .then((code) => process.exit(code))
+    .catch((err) => {
+      console.error("check-exports-exist: ERROR", err && err.message ? err.message : err);
+      process.exit(2);
+    });
+}

package/scripts/ci/check-files-exist.mjs

@@ -0,0 +1,107 @@
+/**
+ * check-files-exist.mjs — CI guard that fails if any entry in package.json
+ * "files" does not exist on disk.
+ *
+ * Adapted from OpenClaw's scripts/check.mjs packaging guards. Pure,
+ * dependency-light: Node builtins only. ESM module (maestro is "type":"module").
+ *
+ * The "files" array is the allowlist npm uses to decide what ends up in the
+ * published tarball. An entry that points at a deleted/renamed directory
+ * silently ships nothing for that path — consumers then hit missing modules at
+ * runtime. This guard asserts every listed path resolves to an existing file
+ * or directory in the working tree.
+ *
+ * Entries are treated as literal paths (the common maestro case: "lib/",
+ * "agents/", "README.md"). npm also allows glob patterns in "files"; a bare
+ * glob ("*", "?", "[", "{") is reported as "skipped (glob)" rather than failed,
+ * since resolving globs here would add a dependency.
+ *
+ * Usage (standalone): `node scripts/ci/check-files-exist.mjs`
+ *   exit 0 → all entries exist (or are skipped globs); exit 1 → one missing.
+ *
+ * @module scripts/ci/check-files-exist
+ */
+
+"use strict";
+
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** Repo root: two levels up from scripts/ci/. @type {string} */
+const REPO_ROOT = path.resolve(fileURLToPath(new URL(".", import.meta.url)), "..", "..");
+
+/**
+ * True if a "files" entry contains npm/glob metacharacters and so cannot be
+ * checked with a plain existence test.
+ *
+ * @param {string} entry
+ * @returns {boolean}
+ */
+export function isGlob(entry) {
+  return /[*?[\]{}!]/.test(entry);
+}
+
+/**
+ * Check that every literal entry in the "files" array exists on disk.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.cwd=REPO_ROOT] - Repo root containing package.json.
+ * @param {object} [opts.pkg] - Pre-parsed package.json (skips disk read).
+ * @returns {Promise<{ ok: boolean, checked: number, skipped: string[], missing: Array<{ entry: string, resolved: string }> }>}
+ */
+export async function checkFilesExist(opts = {}) {
+  const cwd = opts.cwd || REPO_ROOT;
+  let pkg = opts.pkg;
+  if (!pkg) {
+    const raw = await readFile(path.join(cwd, "package.json"), "utf8");
+    pkg = JSON.parse(raw);
+  }
+  const entries = Array.isArray(pkg.files) ? pkg.files : [];
+  const missing = [];
+  const skipped = [];
+  let checked = 0;
+  for (const entry of entries) {
+    if (typeof entry !== "string" || entry.length === 0) continue;
+    if (isGlob(entry)) {
+      skipped.push(entry);
+      continue;
+    }
+    checked++;
+    const resolved = path.resolve(cwd, entry);
+    if (!existsSync(resolved)) missing.push({ entry, resolved });
+  }
+  return { ok: missing.length === 0, checked, skipped, missing };
+}
+
+/**
+ * Run the check and print a human report.
+ *
+ * @param {string} [cwd=REPO_ROOT]
+ * @returns {Promise<number>} Process exit code (0 = ok, 1 = missing entry).
+ */
+export async function run(cwd = REPO_ROOT) {
+  const { ok, checked, skipped, missing } = await checkFilesExist({ cwd });
+  const skipNote = skipped.length ? ` (${skipped.length} glob(s) skipped)` : "";
+  if (ok) {
+    console.log(`check-files-exist: OK (${checked} files entry/entries exist)${skipNote}`);
+    return 0;
+  }
+  console.error("check-files-exist: FAIL — files[] entries missing on disk:");
+  for (const m of missing) {
+    console.error(`  "${m.entry}"  (not found: ${m.resolved})`);
+  }
+  console.error(`check-files-exist: ${missing.length} missing of ${checked} checked${skipNote}`);
+  return 1;
+}
+
+// Run when invoked directly (not when imported).
+if (import.meta.url === `file://${process.argv[1]}`) {
+  run()
+    .then((code) => process.exit(code))
+    .catch((err) => {
+      console.error("check-files-exist: ERROR", err && err.message ? err.message : err);
+      process.exit(2);
+    });
+}