@structor-dev/cli 0.1.0

package/scripts/check-template-files.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { exists, failIfErrors, repoRoot } from "./lib.mjs";
+
+const requiredFiles = [
+  "template/AGENTS.md.tpl",
+  "template/CLAUDE.md.tpl",
+  "template/.claude/CLAUDE.md.tpl",
+  "template/.claude/rules/harness-client-surfaces.md.tpl",
+  "template/.claude/settings.json.tpl",
+  "template/.codex/hooks.json.tpl",
+  "template/README.md.tpl",
+  "template/ai/AGENTS.md.tpl",
+  "template/ai/HUB.md.tpl",
+  "template/ai/context.md.tpl",
+  "template/ai/HARNESS.md.tpl",
+  "template/ai/HARNESS-ENGINEERING.md.tpl",
+  "template/ai/READINESS.md.tpl",
+  "template/ai/QUALITY.md.tpl",
+  "template/ai/DECISIONS.md.tpl",
+  "template/ai/PRODUCT-SUMMARY.md.tpl",
+  "template/ai/PRODUCT.md.tpl",
+  "template/ai/ARCHITECTURE.md.tpl",
+  "template/ai/DESIGN.md.tpl",
+  "template/ai/WORKFLOW.md.tpl",
+  "template/ai/VERSIONING.md.tpl",
+  "template/ai/CODEX-HOOKS.md.tpl",
+  "template/ai/RUNNER-SAFETY.md.tpl",
+  "template/ai/RUNNER-READINESS.md.tpl",
+  "template/ai/AGENT-GARBAGE-COLLECTION.md.tpl",
+  "template/ai/knowledge-manifest.json.tpl",
+  "template/ai/workspace/REPOS.md.tpl",
+  "template/ai/workspace/SYSTEM-MAP.md.tpl",
+  "template/ai/workspace/SESSION-BOOTSTRAP.md.tpl",
+  "template/ai/workspace/LOCAL-STACK.md.tpl",
+  "template/ai/workspace/TEST-STRATEGY.md.tpl",
+  "template/ai/model-overlays/openai/AGENTS.md.tpl",
+  "template/ai/model-overlays/anthropic/CLAUDE.md.tpl",
+  "template/consumer/AGENTS.md.tpl",
+  "template/consumer/CLAUDE.md.tpl",
+  "template/consumer/.claude/CLAUDE.md.tpl",
+  "template/workspace/AGENTS.md.tpl",
+  "template/workspace/CLAUDE.md.tpl",
+  "template/workspace/.claude/CLAUDE.md.tpl",
+  "template/workspace/.claude/rules/harness-client-surfaces.md.tpl",
+  "template/workspace/.claude/settings.json.tpl",
+  "template/ai/contracts/README.md.tpl",
+  "template/ai/contracts/repo-boundaries.md.tpl",
+  "template/ai/contracts/app-legibility.md.tpl",
+  "template/ai/contracts/api-boundary.md.tpl",
+  "template/ai/contracts/security-boundary.md.tpl",
+  "template/ai/contracts/repo-boundaries.contract.json.tpl",
+  "template/ai/contracts/app-legibility.contract.json.tpl",
+  "template/ai/contracts/api-boundary.contract.json.tpl",
+  "template/ai/contracts/security-boundary.contract.json.tpl",
+  "template/ai/contracts/codex-hooks.md.tpl",
+  "template/ai/contracts/codex-hooks.contract.json.tpl",
+  "template/ai/contracts/release-flow.md.tpl",
+  "template/ai/contracts/release-flow.contract.json.tpl",
+  "template/ai/contracts/github-safety.md.tpl",
+  "template/ai/contracts/github-safety.contract.json.tpl",
+  "template/ai/templates/README.md.tpl",
+  "template/ai/templates/task-brief-template.md.tpl",
+  "template/ai/templates/issue-template.md.tpl",
+  "template/ai/templates/fixtures/issues/valid-ready.md.tpl",
+  "template/ai/templates/fixtures/issues/invalid-placeholder.md.tpl",
+  "template/ai/templates/fixtures/issues/invalid-protected-surface.md.tpl",
+  "template/ai/specs/README.md.tpl",
+  "template/ai/skills/README.md.tpl",
+  "template/ai/skills/review-architecture.md.tpl",
+  "template/ai/skills/review-security.md.tpl",
+  "template/ai/skills/review-contract-drift.md.tpl",
+  "template/ai/skills/review-governance-drift.md.tpl",
+  "template/ai/plans/README.md.tpl",
+  "template/ai/plans/tech-debt.md.tpl",
+  "template/scripts/validate-governance.mjs.tpl",
+  "template/scripts/check-template-governance.mjs.tpl",
+  "template/scripts/check-readiness.mjs.tpl",
+  "template/scripts/check-task-template.mjs.tpl",
+  "template/scripts/check-issue-template.mjs.tpl",
+  "template/scripts/check-knowledge-manifest.mjs.tpl",
+  "template/scripts/check-plans.mjs.tpl",
+  "template/scripts/check-review-skills.mjs.tpl",
+  "template/scripts/check-garbage-collection.mjs.tpl",
+  "template/scripts/check-contract-manifests.mjs.tpl",
+  "template/scripts/generate-html-views.mjs.tpl",
+  "template/scripts/check-html-views.mjs.tpl",
+  "template/scripts/check-codex-hooks.mjs.tpl",
+  "template/scripts/check-claude-compatibility.mjs.tpl",
+  "template/scripts/check-overlay-drift.mjs.tpl",
+  "template/scripts/bootstrap-codex-worktree.mjs.tpl",
+  "template/scripts/check-worktrees.mjs.tpl",
+  "template/scripts/check-worktree-bootstrap-fixtures.mjs.tpl",
+  "template/scripts/lib/worktree-bootstrap.mjs.tpl",
+  "template/scripts/fixtures/worktrees/README.md.tpl",
+  "template/scripts/bootstrap-workspace.mjs.tpl",
+  "template/scripts/check-workspace.mjs.tpl",
+  "template/scripts/hooks/codex-hook.mjs.tpl",
+  "template/scripts/hooks/lib/codex-hooks-core.mjs.tpl"
+];
+
+const errors = [];
+for (const relativePath of requiredFiles) {
+  if (!(await exists(path.join(repoRoot, relativePath)))) {
+    errors.push(`missing ${relativePath}`);
+  }
+}
+
+failIfErrors("Template file check", errors);

package/scripts/init-harness.mjs

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { assertSafeOutputRoot, exists, validateConfigShape } from "./lib.mjs";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+const configFileDefault = "harness.config.json";
+const configArg = "--config";
+const outputArg = "--output";
+const dryRunArg = "--dry-run";
+const forceArg = "--force";
+const installConsumerEntrypointsArg = "--install-consumer-entrypoints";
+const allowAbsoluteOutputArg = "--allow-absolute-output";
+
+const consumerPathPrefix = "consumer/";
+const anthropicPathPrefix = ".claude/";
+const codexHookPathPrefix = ".codex/";
+const scriptRulesPath = "scripts/check-claude-compatibility.mjs.tpl";
+const scriptCodexPath = "scripts/check-codex-hooks.mjs.tpl";
+const scriptHooksPath = "scripts/hooks/";
+
+function parseArgs(argv) {
+  const options = {
+    config: configFileDefault,
+    output: null,
+    dryRun: false,
+    force: false,
+    installConsumerEntrypoints: false,
+    allowAbsoluteOutput: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === configArg) options.config = argv[++index];
+    else if (arg === outputArg) options.output = argv[++index];
+    else if (arg === dryRunArg) options.dryRun = true;
+    else if (arg === forceArg) options.force = true;
+    else if (arg === installConsumerEntrypointsArg) options.installConsumerEntrypoints = true;
+    else if (arg === allowAbsoluteOutputArg) options.allowAbsoluteOutput = true;
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+}
+
+function render(content, values) {
+  return content.replace(/\{\{([A-Z0-9_]+)\}\}/g, (_, key) => {
+    if (!(key in values)) {
+      throw new Error(`No value provided for template placeholder {{${key}}}`);
+    }
+    return values[key];
+  });
+}
+
+function consumerList(consumers) {
+  return consumers.map((consumer) => `- ${consumer.name}: ${consumer.purpose}`).join("\n");
+}
+
+function validationList(validation) {
+  const entries = Object.entries(validation ?? {});
+  if (entries.length === 0) return "- No local validation commands documented yet.";
+  return entries.map(([name, command]) => `- ${name}: \`${command}\``).join("\n");
+}
+
+function consumerNames(consumers) {
+  return JSON.stringify(consumers.map((consumer) => consumer.name));
+}
+
+function consumerConfig(consumers, configDir, outputRoot) {
+  const workspaceRoot = path.dirname(outputRoot);
+  const normalizedConsumers = consumers.map((consumer) => {
+    const consumerRoot = path.resolve(configDir, consumer.path);
+    return {
+      ...consumer,
+      workspacePath: path.relative(workspaceRoot, consumerRoot).replaceAll(path.sep, "/") || ".",
+    };
+  });
+  return JSON.stringify(normalizedConsumers, null, 2);
+}
+
+function booleanLiteral(value) {
+  return value ? "true" : "false";
+}
+
+function clientSupport(config) {
+  return {
+    codexHooks: config.models.openai && (config.clientSupport?.codex?.hooks ?? true),
+    claudeRules: config.models.anthropic && (config.clientSupport?.claude?.rules ?? true),
+    claudeHooks: config.models.anthropic && (config.clientSupport?.claude?.hooks ?? false),
+    claudeSkills: config.models.anthropic && (config.clientSupport?.claude?.skills ?? false),
+  };
+}
+
+function shouldRenderTemplate(sourceRelative, config) {
+  const support = clientSupport(config);
+  const claudePath = "workspace/.claude/";
+  const openaiWorkspacePath = "workspace/AGENTS.md.tpl";
+  const claudeWorkspacePath = "workspace/CLAUDE.md.tpl";
+
+  if (sourceRelative.startsWith(consumerPathPrefix)) return false;
+  if (!config.models.anthropic && sourceRelative.startsWith(anthropicPathPrefix)) return false;
+  if (!support.claudeRules && sourceRelative.startsWith(`${anthropicPathPrefix}rules/`)) return false;
+  if (!support.claudeHooks && sourceRelative.startsWith(`${anthropicPathPrefix}hooks/`)) return false;
+  if (!support.claudeSkills && sourceRelative.startsWith(`${anthropicPathPrefix}skills/`)) return false;
+  if (!support.codexHooks && sourceRelative.startsWith(codexHookPathPrefix)) return false;
+  if (!support.codexHooks && sourceRelative.startsWith(scriptHooksPath)) return false;
+  if (!support.codexHooks && sourceRelative === scriptCodexPath) return false;
+  if (!support.codexHooks && sourceRelative === "ai/contracts/codex-hooks.contract.json.tpl") return false;
+  if (!config.models.anthropic && sourceRelative === scriptRulesPath) return false;
+  if (!config.models.openai && sourceRelative === openaiWorkspacePath) return false;
+  if (!config.models.anthropic && sourceRelative === claudeWorkspacePath) return false;
+  if (!config.models.anthropic && sourceRelative.startsWith(claudePath)) return false;
+  if (!support.claudeRules && sourceRelative.startsWith(`${claudePath}rules/`)) return false;
+  if (!config.models.openai && sourceRelative === "AGENTS.md.tpl") return false;
+  if (!config.models.anthropic && sourceRelative === "CLAUDE.md.tpl") return false;
+  if (!config.models.openai && sourceRelative.startsWith("ai/model-overlays/openai/")) return false;
+  if (!config.models.anthropic && sourceRelative.startsWith("ai/model-overlays/anthropic/")) return false;
+  return true;
+}
+
+async function collectTemplateFiles() {
+  const basePath = path.join(repoRoot, "template");
+  const files = [];
+
+  async function walk(currentPath) {
+    const entries = await readdir(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolute = path.join(currentPath, entry.name);
+      const relative = path.relative(basePath, absolute).replaceAll(path.sep, "/");
+      if (entry.isDirectory()) {
+        await walk(absolute);
+      } else if (entry.isFile() && entry.name.endsWith(".tpl")) {
+        files.push(relative);
+      }
+    }
+  }
+
+  await walk(basePath);
+  return files.sort();
+}
+
+async function writeRenderedFile(sourceRelative, targetRoot, values, options) {
+  const sourcePath = path.join(repoRoot, "template", sourceRelative);
+  const targetRelative = sourceRelative.replace(/\.tpl$/, "");
+  const targetPath = path.join(targetRoot, targetRelative);
+  const content = render(await readFile(sourcePath, "utf8"), values);
+
+  if (options.dryRun) {
+    console.log(`would create ${targetPath}`);
+    return;
+  }
+
+  if ((await exists(targetPath)) && !options.force) {
+    console.log(`skipped existing ${targetPath}`);
+    return;
+  }
+
+  const existed = await exists(targetPath);
+  await mkdir(path.dirname(targetPath), { recursive: true });
+  await writeFile(targetPath, content);
+  console.log(`${existed ? "wrote" : "created"} ${targetPath}`);
+}
+
+async function installConsumerEntrypoints(config, harnessRoot, options) {
+  for (const consumer of config.consumers) {
+    const consumerRoot = path.resolve(path.dirname(path.resolve(options.config)), consumer.path);
+    if (!(await exists(consumerRoot))) {
+      throw new Error(`Consumer repo path does not exist: ${consumerRoot}`);
+    }
+
+    const harnessRelativePath = path.relative(consumerRoot, harnessRoot).replaceAll(path.sep, "/") || ".";
+    const values = {
+      PROJECT_NAME: config.project.name,
+      CONSUMER_NAME: consumer.name,
+      CONSUMER_PURPOSE: consumer.purpose,
+      CONSUMER_VALIDATION_LIST: validationList(consumer.validation),
+      HARNESS_RELATIVE_PATH: harnessRelativePath,
+    };
+
+    const entrypoints = [];
+    if (config.models.openai) entrypoints.push(["AGENTS.md", "AGENTS.md.tpl"]);
+    if (config.models.anthropic) {
+      entrypoints.push(["CLAUDE.md", "CLAUDE.md.tpl"]);
+      entrypoints.push([path.join(".claude", "CLAUDE.md"), path.join(".claude", "CLAUDE.md.tpl")]);
+    }
+
+    for (const [targetRelative, sourceRelative] of entrypoints) {
+      const sourcePath = path.join(repoRoot, "template", "consumer", sourceRelative);
+      const targetPath = path.join(consumerRoot, targetRelative);
+      const content = render(await readFile(sourcePath, "utf8"), values);
+
+      if (options.dryRun) {
+        console.log(`would create consumer entrypoint ${targetPath}`);
+        continue;
+      }
+      if ((await exists(targetPath)) && !options.force) {
+        console.log(`skipped existing consumer entrypoint ${targetPath}`);
+        continue;
+      }
+
+      await mkdir(path.dirname(targetPath), { recursive: true });
+      await writeFile(targetPath, content);
+      console.log(`wrote consumer entrypoint ${targetPath}`);
+    }
+  }
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const configPath = path.resolve(options.config);
+  const config = JSON.parse(await readFile(configPath, "utf8"));
+  const errors = await validateConfigShape(config, options.config);
+  if (errors.length > 0) {
+    throw new Error(errors.join("\n"));
+  }
+
+  const configDir = path.dirname(configPath);
+  const outputPath = options.output ?? config.output.path;
+  const outputRoot = path.resolve(configDir, outputPath);
+  const consumerRepos = config.consumers.map((consumer) => path.resolve(configDir, consumer.path));
+  assertSafeOutputRoot({
+    outputPath,
+    outputRoot,
+    repoRoot,
+    workspaceRoot: configDir,
+    consumerRepos,
+    allowAbsoluteOutput: options.allowAbsoluteOutput,
+  });
+  const support = clientSupport(config);
+  const values = {
+    PROJECT_NAME: config.project.name,
+    PROJECT_SLUG: config.project.slug,
+    HARNESS_REPO_NAME: config.project.harnessRepoName,
+    CONSUMER_REPOS_LIST: consumerList(config.consumers),
+    CONSUMER_REPO_NAMES_JSON: consumerNames(config.consumers),
+    CONSUMER_CONFIG_JSON: consumerConfig(config.consumers, configDir, outputRoot),
+    PRIMARY_CONSUMER_NAME: config.consumers[0].name,
+    MODEL_OPENAI_ENABLED: booleanLiteral(config.models.openai),
+    MODEL_ANTHROPIC_ENABLED: booleanLiteral(config.models.anthropic),
+    CLIENT_CODEX_HOOKS_ENABLED: booleanLiteral(support.codexHooks),
+    CLIENT_CLAUDE_RULES_ENABLED: booleanLiteral(support.claudeRules),
+    CLIENT_CLAUDE_HOOKS_ENABLED: booleanLiteral(support.claudeHooks),
+    CLIENT_CLAUDE_SKILLS_ENABLED: booleanLiteral(support.claudeSkills),
+  };
+
+  for (const sourceRelative of await collectTemplateFiles()) {
+    if (!shouldRenderTemplate(sourceRelative, config)) continue;
+    await writeRenderedFile(sourceRelative, outputRoot, values, options);
+  }
+
+  if (!options.dryRun) {
+    execFileSync(process.execPath, [path.join(outputRoot, "scripts/generate-html-views.mjs")], {
+      cwd: outputRoot,
+      stdio: "inherit",
+    });
+  }
+
+  if (options.installConsumerEntrypoints) {
+    await installConsumerEntrypoints(config, outputRoot, { ...options, config: configPath });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/scripts/lib.mjs

@@ -0,0 +1,190 @@
+import { access, readdir, readFile, stat } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+export async function exists(filePath) {
+  try {
+    await access(filePath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readJson(relativePath) {
+  return JSON.parse(await readFile(path.join(repoRoot, relativePath), "utf8"));
+}
+
+export async function collectFiles(baseRelativePath, predicate = () => true) {
+  const basePath = path.join(repoRoot, baseRelativePath);
+  const files = [];
+
+  async function walk(currentPath) {
+    const entries = await readdir(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolute = path.join(currentPath, entry.name);
+      const relative = path.relative(repoRoot, absolute).replaceAll(path.sep, "/");
+      if (entry.isDirectory()) {
+        await walk(absolute);
+      } else if (entry.isFile() && predicate(relative)) {
+        files.push(relative);
+      }
+    }
+  }
+
+  if (await exists(basePath)) {
+    const info = await stat(basePath);
+    if (info.isDirectory()) {
+      await walk(basePath);
+    }
+  }
+
+  return files.sort();
+}
+
+export function pathContainsSegment(targetPath, segment) {
+  return path.resolve(targetPath).split(path.sep).includes(segment);
+}
+
+export function isSameOrInsidePath(candidate, root) {
+  const resolvedCandidate = path.resolve(candidate);
+  const resolvedRoot = path.resolve(root);
+  const relative = path.relative(resolvedRoot, resolvedCandidate);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+export function assertSafeOutputRoot({
+  outputPath,
+  outputRoot,
+  repoRoot: templateRepoRoot,
+  workspaceRoot,
+  consumerRepos,
+  allowAbsoluteOutput = false,
+}) {
+  const rejectedPath = path.resolve(outputRoot);
+  if (path.isAbsolute(outputPath) && !allowAbsoluteOutput) {
+    throw new Error(`Unsafe output path ${rejectedPath}: absolute output paths require --allow-absolute-output.`);
+  }
+  if (isSameOrInsidePath(outputRoot, templateRepoRoot)) {
+    throw new Error(`Unsafe output path ${rejectedPath}: output must not equal or be inside the template repo ${templateRepoRoot}.`);
+  }
+  if (path.resolve(outputRoot) === path.resolve(workspaceRoot)) {
+    throw new Error(`Unsafe output path ${rejectedPath}: output must not equal the workspace root ${workspaceRoot}.`);
+  }
+  for (const consumerRoot of consumerRepos) {
+    if (isSameOrInsidePath(outputRoot, consumerRoot)) {
+      throw new Error(
+        `Unsafe output path ${rejectedPath}: output must not equal or be inside configured consumer repo ${consumerRoot}.`,
+      );
+    }
+  }
+  if (pathContainsSegment(outputRoot, ".git")) {
+    throw new Error(`Unsafe output path ${rejectedPath}: output path must not contain a .git path segment.`);
+  }
+}
+
+export function failIfErrors(title, errors) {
+  if (errors.length === 0) {
+    console.log(`${title} passed.`);
+    return;
+  }
+
+  console.error(`${title} failed.`);
+  for (const error of errors) {
+    console.error(`- ${error}`);
+  }
+  process.exit(1);
+}
+
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function typeName(value) {
+  if (Array.isArray(value)) return "array";
+  if (value === null) return "null";
+  return typeof value;
+}
+
+function validateJsonSchema(value, schema, label, errors) {
+  const expectedType = schema.type;
+  if (expectedType) {
+    const validType =
+      expectedType === "object" ? isPlainObject(value) :
+      expectedType === "array" ? Array.isArray(value) :
+      typeof value === expectedType;
+    if (!validType) {
+      errors.push(`${label} must be ${expectedType}; got ${typeName(value)}.`);
+      return;
+    }
+  }
+
+  if (Object.hasOwn(schema, "const") && value !== schema.const) {
+    errors.push(`${label} must be ${JSON.stringify(schema.const)}.`);
+  }
+
+  if (typeof value === "string") {
+    if (schema.minLength !== undefined && value.length < schema.minLength) {
+      errors.push(`${label} must be at least ${schema.minLength} character(s).`);
+    }
+    if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
+      errors.push(`${label} must match pattern ${schema.pattern}.`);
+    }
+  }
+
+  if (Array.isArray(value)) {
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+      errors.push(`${label} must contain at least ${schema.minItems} item(s).`);
+    }
+    if (schema.items) {
+      for (const [index, item] of value.entries()) {
+        validateJsonSchema(item, schema.items, `${label}[${index}]`, errors);
+      }
+    }
+  }
+
+  if (isPlainObject(value)) {
+    const properties = schema.properties ?? {};
+    for (const requiredKey of schema.required ?? []) {
+      if (!Object.hasOwn(value, requiredKey)) {
+        errors.push(`${label}.${requiredKey} is required.`);
+      }
+    }
+    if (schema.additionalProperties === false) {
+      for (const key of Object.keys(value)) {
+        if (!Object.hasOwn(properties, key)) {
+          errors.push(`${label}.${key} is not allowed.`);
+        }
+      }
+    }
+    for (const [key, propertySchema] of Object.entries(properties)) {
+      if (Object.hasOwn(value, key)) {
+        validateJsonSchema(value[key], propertySchema, `${label}.${key}`, errors);
+      }
+    }
+  }
+}
+
+export async function validateConfigShape(config, label) {
+  const errors = [];
+  const schema = await readJson("schemas/harness-config.schema.json");
+  validateJsonSchema(config, schema, label, errors);
+
+  if (isPlainObject(config.models) && config.models.openai === false && config.models.anthropic === false) {
+    errors.push("Invalid harness config: at least one model provider must be enabled.");
+  }
+
+  const names = new Set();
+  if (Array.isArray(config.consumers)) {
+    for (const [index, consumer] of config.consumers.entries()) {
+      const prefix = `${label}.consumers[${index}]`;
+      if (names.has(consumer.name)) errors.push(`${prefix}.name is duplicated.`);
+      names.add(consumer.name);
+    }
+  }
+
+  return errors;
+}